JSON-LD 1.1 Processing Algorithms and API

4.1.2 Algorithm

This algorithm specifies how a new active context is updated with a local context. The algorithm takes three required and four optional input variables. The required inputs are an active context, a local context, and a base URL used when resolving relative context URLs. The optional inputs are an array remote contexts, defaulting to a new empty array, which is used to detect cyclical context inclusions, override protected, defaulting to false, which is used to allow changes to protected terms, propagate, defaulting to true to mark term definitions associated with non-propagated contexts, and validate scoped context defaulting to true, which is used to limit recursion when validating possibly recusive scoped contexts..

1. Initialize result to the result of cloning active context, with inverse context set to null..
2. If local context is an object containing the member @propagate, its value MUST be boolean true or false, set propagate to that value.
   Note

   Error handling is performed in step 5.11.
3. If propagate is false, and result does not have a previous context, set previous context in result to active context.
4. If local context is not an array, set local context to an array containing only local context.
5. For each item context in local context:
   1. If context is null:
      1. If override protected is false and active context contains any protected term definitions, an invalid context nullification has been detected and processing is aborted.
      2. Initialize result as a newly-initialized active context, setting both base IRI and original base URL to the value of original base URL in active context, and, if propagate is false, previous context in result to the previous value of result.
      3. Continue with the next context.
   2. If context is a string,
      1. Initialize context to the result of resolving context against base URL. If base URL is not a valid IRI, then context MUST be a valid IRI, otherwise a loading document failed error has been detected and processing is aborted.
         Note

         base URL is often not the same as base or the base IRI of the active context.
      2. If validate scoped context is false, and remote contexts already includes context do not process context further and continue to any next context in local context.
      3. If the number of entries in the remote contexts array exceeds a processor defined limit, a context overflow error has been detected and processing is aborted; otherwise, add context to remote contexts.
      4. If context was previously dereferenced, then the processor MUST NOT do a further dereference, and context is set to the previously established internal representation: set context document to the previously dereferenced document, and set loaded context to the value of the @context entry from the document in context document.
         Note

         Only the @context entry need be retained.
      5. Otherwise, set context document to the RemoteDocument obtained by dereferencing context using the LoadDocumentCallback, passing context for url, and http://www.w3.org/ns/json-ld#context for profile and for requestProfile.
         1. If context cannot be dereferenced, or the document from context document cannot be transformed into the internal representation , a loading remote context failed error has been detected and processing is aborted.
         2. If the document has no top-level map with an @context entry, an invalid remote context has been detected and processing is aborted.
         3. Set loaded context to the value of that entry.
      6. Set result to the result of recursively calling this algorithm, passing result for active context, loaded context for local context, the documentUrl of context document for base URL, a copy of remote contexts, and validate scoped context.
         Note

         If context was previously dereferenced, processors MUST make provisions for retaining the base URL of that context for this step to enable the resolution of any relative context URLs that may be encountered during processing.
      7. Continue with the next context.
   3. If context is not a map, an invalid local context error has been detected and processing is aborted.
   4. Otherwise, context is a context definition.
   5. If context has an @version entry:
      1. If the associated value is not 1.1, an invalid @version value has been detected, and processing is aborted.
         Note

         The use of 1.1 for the value of @version is intended to cause a JSON-LD 1.0 processor to stop processing. Although it is clearly meant to be related to JSON-LD 1.1, it does not otherwise adhere to the requirements for Semantic Versioning. Implementations may require special consideration when comparing the values of numbers with a non-zero fractional part.
      2. If processing mode is set to json-ld-1.0, a processing mode conflict error has been detected and processing is aborted.
   6. If context has an @import entry:
      1. If processing mode is json-ld-1.0, an invalid context entry error has been detected and processing is aborted.
      2. Otherwise, if the value of @import is not a string, an invalid @import value error has been detected and processing is aborted.
      3. Initialize import to the result of resolving the value of @import against base URL.
      4. Dereference import using the LoadDocumentCallback, passing import for url, and http://www.w3.org/ns/json-ld#context for profile and for requestProfile.
      5. If import cannot be dereferenced, or cannot be transformed into the internal representation, a loading remote context failed error has been detected and processing is aborted.
      6. If the dereferenced document has no top-level map with an @context entry, or if the value of @context is not a context definition (i.e., it is not an map), an invalid remote context has been detected and processing is aborted; otherwise, set import context to the value of that entry.
      7. If import context has a @import entry, an invalid context entry error has been detected and processing is aborted.
      8. Set context to the result of merging context into import context, replacing common entries with those from context.
   7. If context has an @base entry and remote contexts is empty, i.e., the currently being processed context is not a remote context:
      1. Initialize value to the value associated with the @base entry.
      2. If value is null, remove the base IRI of result.
      3. Otherwise, if value is an IRI, the base IRI of result is set to value.
      4. Otherwise, if value is a relative IRI reference and the base IRI of result is not null, set the base IRI of result to the result of resolving value against the current base IRI of result.
      5. Otherwise, an invalid base IRI error has been detected and processing is aborted.
   8. If context has an @vocab entry:
      1. Initialize value to the value associated with the @vocab entry.
      2. If value is null, remove any vocabulary mapping from result.
      3. Otherwise, if value is an IRI or blank node identifier, the vocabulary mapping of result is set to the result of IRI expanding value using true for document relative . If it is not an IRI, or a blank node identifier, an invalid vocab mapping error has been detected and processing is aborted.
         Note

         The use of blank node identifiers to value for @vocab is obsolete, and may be removed in a future version of JSON-LD.
   9. If context has an @language entry:
      1. Initialize value to the value associated with the @language entry.
      2. If value is null, remove any default language from result.
      3. Otherwise, if value is a string, the default language of result is set to value. If it is not a string, an invalid default language error has been detected and processing is aborted. If value is not well-formed according to section 2.2.9 of [BCP47], processors SHOULD issue a warning.
         Note

         Processors MAY normalize language tags to lower case.
   10. If context has an @direction entry:
       1. If processing mode is json-ld-1.0, an invalid context entry error has been detected and processing is aborted.
       2. Initialize value to the value associated with the @direction entry.
       3. If value is null, remove any base direction from result.
       4. Otherwise, if value is a string, the base direction of result is set to value. If it is not null, "ltr", or "rtl", an invalid base direction error has been detected and processing is aborted.
   11. If context has an @propagate entry:
       1. If processing mode is json-ld-1.0, an invalid context entry error has been detected and processing is aborted.
       2. Otherwise, if the value of @propagate is not boolean true or false, an invalid @propagate value error has been detected and processing is aborted.
          Note

          The previous context is actually set earlier in this algorithm; the previous two steps exist for error checking only.
   12. Create a map defined to keep track of whether or not a term has already been defined or is currently being defined during recursion.
   13. For each key-value pair in context where key is not @base, @direction, @import, @language, @propagate, @protected, @version, or @vocab, invoke the Create Term Definition algorithm, passing result for active context, context for local context, key, defined, base URL, the value of the @protected entry from context, if any, for protected, override protected, and a copy of remote contexts.
6. Return result.

4.2.2 Algorithm

The algorithm has four required and five optional inputs. The required inputs are an active context, a local context, a term, and a map defined. The optional inputs are base URL defaulting to null, protected which defaults to false, and override protected, defaulting to false, which is used to allow changes to protected terms, an array remote contexts, defaulting to a new empty array, which is used to detect cyclical context inclusions, and validate scoped context defaulting to true, which is used to limit recursion when validating possibly recusive scoped contexts..

1. If defined contains the entry term and the associated value is true (indicating that the term definition has already been created), return. Otherwise, if the value is false, a cyclic IRI mapping error has been detected and processing is aborted.
2. If term is the empty string (""), an invalid term definition error has been detected and processing is aborted. Otherwise, set the value associated with defined's term entry to false. This indicates that the term definition is now being created but is not yet complete.
3. Initialize value to a copy of the value associated with the entry term in local context.
4. If term is @type, and processing mode is json-ld-1.0, a keyword redefinition error has been detected and processing is aborted. At this point, value MUST be a map with only either or both of the following entries:
   • An entry for @container with value @set.
   • An entry for @protected.
   Any other value means that a keyword redefinition error has been detected and processing is aborted.
5. Otherwise, since keywords cannot be overridden, term MUST NOT be a keyword and a keyword redefinition error has been detected and processing is aborted. If term has the form of a keyword (i.e., it matches the ABNF rule "@"1*ALPHA from [RFC5234]), return; processors SHOULD generate a warning.
6. Initialize previous definition to any existing term definition for term in active context, removing that term definition from active context.
7. If value is null, convert it to a map consisting of a single entry whose key is @id and whose value is null.
8. Otherwise, if value is a string, convert it to a map consisting of a single entry whose key is @id and whose value is value. Set simple term to true.
9. Otherwise, value MUST be a map, if not, an invalid term definition error has been detected and processing is aborted. Set simple term to false.
10. Create a new term definition, definition, initializing prefix flag to false, protected to protected, and reverse property to false.
11. If value has an @protected entry, set the protected flag in definition to the value of this entry. If the value of @protected is not a boolean, an invalid @protected value error has been detected and processing is aborted. If processing mode is json-ld-1.0, an invalid term definition has been detected and processing is aborted.
12. If value contains the entry @type:
    1. Initialize type to the value associated with the @type entry, which MUST be a string. Otherwise, an invalid type mapping error has been detected and processing is aborted.
    2. Set type to the result of IRI expanding type, using local context, and defined.
    3. If the expanded type is @json or @none, and processing mode is json-ld-1.0, an invalid type mapping error has been detected and processing is aborted.
    4. Otherwise, if the expanded type is neither @id, nor @json, nor @none, nor @vocab, nor an IRI, an invalid type mapping error has been detected and processing is aborted.
    5. Set the type mapping for definition to type.
13. If value contains the entry @reverse:
    1. If value contains @id or @nest, entries, an invalid reverse property error has been detected and processing is aborted.
    2. If the value associated with the @reverse entry is not a string, an invalid IRI mapping error has been detected and processing is aborted.
    3. If the value associated with the @reverse entry is a string having the form of a keyword (i.e., it matches the ABNF rule "@"1*ALPHA from [RFC5234]), return; processors SHOULD generate a warning.
    4. Otherwise, set the IRI mapping of definition to the result of IRI expanding the value associated with the @reverse entry, using local context, and defined. If the result does not have the form of an IRI or a blank node identifier, an invalid IRI mapping error has been detected and processing is aborted.
    5. If value contains an @container entry, set the container mapping of definition to an array containing its value; if its value is neither @set, nor @index, nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
    6. Set the reverse property flag of definition to true.
    7. Set the term definition of term in active context to definition and the value associated with defined's entry term to true and return.
14. If value contains the entry @id and its value does not equal term:
    1. If the @id entry of value is null, the term is not used for IRI expansion, but is retained to be able to detect future redefinitions of this term.
    2. Otherwise:
       1. If the value associated with the @id entry is not a string, an invalid IRI mapping error has been detected and processing is aborted.
       2. If the value associated with the @id entry is not a keyword, but has the form of a keyword (i.e., it matches the ABNF rule "@"1*ALPHA from [RFC5234]), return; processors SHOULD generate a warning.
       3. Otherwise, set the IRI mapping of definition to the result of IRI expanding the value associated with the @id entry, using local context, and defined. If the resulting IRI mapping is neither a keyword, nor an IRI, nor a blank node identifier, an invalid IRI mapping error has been detected and processing is aborted; if it equals @context, an invalid keyword alias error has been detected and processing is aborted.
       4. If the term contains a colon (:) anywhere but as the first or last character of term, or if it contains a slash (/) anywhere:
          1. Set the value associated with defined's term entry to true.
          2. If the result of IRI expanding term using local context, and defined, is not the same as the IRI mapping of definition, an invalid IRI mapping error has been detected and processing is aborted.
       5. If term contains neither a colon (:) nor a slash (/), simple term is true, and if the IRI mapping of definition is either an IRI ending with a gen-delim character, or a blank node identifier, set the prefix flag in definition to true.
15. Otherwise if the term contains a colon (:) anywhere after the first character:
    1. If term is a compact IRI with a prefix that is an entry in local context a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
    2. If term's prefix has a term definition in active context, set the IRI mapping of definition to the result of concatenating the value associated with the prefix's IRI mapping and the term's suffix.
    3. Otherwise, term is an IRI or blank node identifier. Set the IRI mapping of definition to term.
16. Otherwise if the term contains a slash (/):
    1. Term is a relative IRI reference.
    2. Set the IRI mapping of definition to the result of IRI expanding term. If the resulting IRI mapping is not an IRI, an invalid IRI mapping error has been detected and processing is aborted.
17. Otherwise, if term is @type, set the IRI mapping of definition to @type.
18. Otherwise, if active context has a vocabulary mapping, the IRI mapping of definition is set to the result of concatenating the value associated with the vocabulary mapping and term. If it does not have a vocabulary mapping, an invalid IRI mapping error been detected and processing is aborted.
19. If value contains the entry @container:
    1. Initialize container to the value associated with the @container entry, which MUST be either @graph, @id, @index, @language, @list, @set, @type, or an array containing exactly any one of those keywords, an array containing @graph and either @id or @index optionally including @set, or an array containing a combination of @set and any of @index, @graph, @id, @type, @language in any order . Otherwise, an invalid container mapping has been detected and processing is aborted.
    2. If the container value is @graph, @id, or @type, or is otherwise not a string, generate an invalid container mapping error and abort processing if processing mode is json-ld-1.0.
    3. Set the container mapping of definition to container coercing to an array, if necessary.
    4. If the container mapping of definition includes @type:
       1. If type mapping in definition is undefined, set it to @id.
       2. If type mapping in definition is neither @id nor @vocab, an invalid type mapping error has been detected and processing is aborted.
20. If value contains the entry @index:
    1. If processing mode is json-ld-1.0 or container mapping does not include @index, an invalid term definition has been detected and processing is aborted.
    2. Initialize index to the value associated with the @index entry. If the result of IRI expanding that value is not an IRI, an invalid term definition has been detected and processing is aborted.
    3. Set the index mapping of definition to index
21. If value contains the entry @context:
    1. If processing mode is json-ld-1.0, an invalid term definition has been detected and processing is aborted.
    2. Initialize context to the value associated with the @context entry, which is treated as a local context.
    3. Invoke the Context Processing algorithm using the active context, context as local context, base URL, true for override protected, a copy of remote contexts, and false for validate scoped context. If any error is detected, an invalid scoped context error has been detected and processing is aborted.
       Note

       The result of the Context Processing algorithm is discarded; it is called to detect errors at definition time. If used, the context will be re-processed and applied to the active context as part of expansion or compaction.

    4. Set the local context of definition to context, and base URL to base URL.
22. If value contains the entry @language and does not contain the entry @type:
    1. Initialize language to the value associated with the @language entry, which MUST be either null or a string. If language is not well-formed according to section 2.2.9 of [BCP47], processors SHOULD issue a warning. Otherwise, an invalid language mapping error has been detected and processing is aborted.
    2. Set the language mapping of definition to language.
       Note

       Processors MAY normalize language tags to lower case.
23. If value contains the entry @direction and does not contain the entry @type:
    1. Initialize direction to the value associated with the @direction entry, which MUST be either null, "ltr", or "rtl". Otherwise, an invalid base direction error has been detected and processing is aborted.
    2. Set the direction mapping of definition to direction.
24. If value contains the entry @nest:
    1. If processing mode is json-ld-1.0, an invalid term definition has been detected and processing is aborted.
    2. Initialize nest value in definition to the value associated with the @nest entry, which MUST be a string and MUST NOT be a keyword other than @nest. Otherwise, an invalid @nest value error has been detected and processing is aborted.
25. If value contains the entry @prefix:
    1. If processing mode is json-ld-1.0, or if term contains a colon (:) or slash (/), an invalid term definition has been detected and processing is aborted.
    2. Set the prefix flag to the value associated with the @prefix entry, which MUST be a boolean. Otherwise, an invalid @prefix value error has been detected and processing is aborted.
    3. If the prefix flag of definition is set to true, and its IRI mapping is a keyword, an invalid term definition has been detected and processing is aborted.
26. If value contains any entry other than @id, @reverse, @container, @context, @direction, @index, @language, @nest, @prefix, @protected, or @type, an invalid term definition error has been detected and processing is aborted.
27. If override protected is false and previous definition exists and is protected;
    1. If definition is not the same as previous definition (other than the value of protected), a protected term redefinition error has been detected, and processing is aborted.
    2. Set definition to previous definition to retain the value of protected.
28. Set the term definition of term in active context to definition and set the value associated with defined's entry term to true.

4.3.2 Algorithm

The algorithm takes one required input: the active context that the inverse context is being created for.

1. Initialize result to an empty map.
2. Initialize default language to @none. If the active context has a default language, set default language to the default language from the active context normalized to lower case.
3. For each key term and value term definition in the active context, ordered by shortest term first (breaking ties by choosing the lexicographically least term):
   1. If the term definition is null, term cannot be selected during compaction, so continue to the next term.
   2. Initialize container to @none. If the container mapping is not empty, set container to the concatenation of all values of the container mapping in lexicographical order .
   3. Initialize var to the value of the IRI mapping for the term definition.
   4. If var is not an entry of result, add an entry where the key is var and the value is an empty map to result.
   5. Reference the value associated with the var entry in result using the variable container map.
   6. If container map has no container entry, create one and set its value to a new map with three entries. The first entry is @language and its value is a new empty map, the second entry is @type and its value is a new empty map, and the third entry is @any and its value is a new map with the entry @none set to the term being processed.
   7. Reference the value associated with the container entry in container map using the variable type/language map.
   8. Reference the value associated with the @type entry in type/language map using the variable type map.
   9. Reference the value associated with the @language entry in type/language map using the variable language map.
   10. If the term definition indicates that the term represents a reverse property:
       1. If type map does not have an @reverse entry, create one and set its value to the term being processed.
   11. Otherwise, if term definition has a type mapping which is @none:
       1. If language map does not have an @any entry, create one and set its value to the term being processed.
       2. If type map does not have an @any entry, create one and set its value to the term being processed.
   12. Otherwise, if term definition has a type mapping:
       1. If type map does not have an entry corresponding to the type mapping in term definition, create one and set its value to the term being processed.
   13. Otherwise, if term definition has both a language mapping and a direction mapping:
       1. Create a new variable lang dir.
       2. If neither the language mapping nor the direction mapping are null, set lang dir to the concatenation of language mapping and direction mapping separated by an underscore ("_") normalized to lower case.
       3. Otherwise, if language mapping is not null, set lang dir to the language mapping, normalized to lower case.
       4. Otherwise, if direction mapping is not null, set lang dir to direction mapping preceded by an underscore ("_").
       5. Otherwise, set lang dir to @null.
       6. If language map does not have a lang dir entry, create one and set its value to the term being processed.
   14. Otherwise, if term definition has a language mapping (might be null):
       1. If the language mapping equals null, set language to @null; otherwise to the language mapping, normalized to lower case.
       2. If language map does not have a language entry, create one and set its value to the term being processed.
   15. Otherwise, if term definition has a direction mapping (might be null):
       1. If the direction mapping equals null, set direction to @none; otherwise to direction mapping preceded by an underscore ("_").
       2. If language map does not have a direction entry, create one and set its value to the term being processed.
   16. Otherwise, if active context has a default base direction:
       1. Initialize a variable lang dir with the concatenation of default language and default base direction, separate by an underscore ("_"), normalized to lower case.
       2. If language map does not have a lang dir entry, create one and set its value to the term being processed.
       3. If language map does not have an @none entry, create one and set its value to the term being processed.
       4. If type map does not have an @none entry, create one and set its value to the term being processed.
   17. Otherwise:
       1. If language map does not have a default language entry (after being normalized to lower case), create one and set its value to the term being processed.
       2. If language map does not have an @none entry, create one and set its value to the term being processed.
       3. If type map does not have an @none entry, create one and set its value to the term being processed.
4. Return result.

4.4.2 Algorithm

This algorithm has five required inputs. They are: an active context, a keyword or IRI var, an array containers that represents an ordered list of preferred container mapping, a string type/language that indicates whether to look for a term with a matching type mapping or language mapping, and an array representing an ordered list of preferred values for the type mapping or language mapping to look for.

1. If the active context has a null inverse context, set inverse context in active context to the result of calling the Inverse Context Creation algorithm using active context.
2. Initialize inverse context to the value of inverse context in active context.
3. Initialize container map to the value associated with var in the inverse context.
4. For each item container in containers:
   1. If container is not an entry of container map, then there is no term with a matching container mapping for it, so continue to the next container.
   2. Initialize type/language map to the value associated with the container entry in container map.
   3. Initialize value map to the value associated with type/language entry in type/language map.
   4. For each item in preferred values:
      1. If item is not an entry of value map, then there is no term with a matching type mapping or language mapping, so continue to the next item.
      2. Otherwise, a matching term has been found, return the value associated with the item entry in value map.
5. No matching term has been found. Return null.

5.1.2 Algorithm

The algorithm takes four required and three optional input variables. The required inputs are an active context, an active property, an element to be expanded, and a base URL associated with the documentUrl of the original document to expand. The optional inputs are the frameExpansion flag allowing special forms of input used for frame expansion, the ordered flag, used to order map entry keys lexicographically, where noted, and the from map flag, used to control reverting previous term definitions in the active context associated with non-propagated contexts. If not passed, the optional flags are set to false.

The algorithm also performs processing steps specific to expanding a JSON-LD Frame. For a frame, the @id and @type entries can accept an array of IRIs or an empty map. The entries of a value object can also accept an array of strings, or an empty map. Framing also uses additional keyword entries: (@explicit, @default, @embed, @explicit, @omitDefault, or @requireAll) which are preserved through expansion. Special processing for a JSON-LD Frame is invoked when the frameExpansion flag is set to true.

1. If element is null, return null.
2. If active property is @default, initialize the frameExpansion flag to false.
3. If active property has a term definition in active context with a local context, initialize property-scoped context to that local context.
4. If element is a scalar,
   1. If active property is null or @graph, drop the free-floating scalar by returning null.
   2. If property-scoped context is defined, set active context to the result of the Context Processing algorithm, passing active context, property-scoped context as local context, and base URL from the term definition for active property in active context.
   3. Return the result of the Value Expansion algorithm, passing the active context, active property, and element as value.
5. If element is an array,
   1. Initialize an empty array, result.
   2. For each item in element:
      1. Initialize expanded item to the result of using this algorithm recursively, passing active context, active property, item as element, base URL, the frameExpansion ordered, and from map flags.
      2. If the container mapping of active property includes @list, and expanded item is an array, set expanded item to a new map containing the entry @list where the value is the original expanded item.
      3. If expanded item is an array, append each of its items to result. Otherwise, if expanded item is not null, append it to result.
   3. Return result.
6. Otherwise element is a map.
7. If active context has a previous context, the active context is not propagated. If from map is undefined or false, and element does not contain an entry expanding to @value, and element does not consist of a single entry expanding to @id (where entries are IRI expanded, set active context to previous context from active context, as the scope of a term-scoped context does not apply when processing new node objects.
8. If property-scoped context is defined, set active context to the result of the Context Processing algorithm, passing active context, property-scoped context as local context, base URL from the term definition for active property, in active context and true for override protected.
9. If element contains the entry @context, set active context to the result of the Context Processing algorithm, passing active context, the value of the @context entry as local context and base URL.
10. Initialize type-scoped context to active context. This is used for expanding values that may be relevant to any previous type-scoped context.
11. For each key and value in element ordered lexicographically by key where key IRI expands to @type:
    1. Convert value into an array, if necessary.
    2. For each term which is a value of value ordered lexicographically, if term is a string, and term's term definition in type-scoped context has a local context, set active context to the result Context Processing algorithm, passing active context, the value of the term's local context as local context, base URL from the term definition for value in active context, and false for propagate.
12. Initialize two empty maps, result and nests. Initialize input type to expansion of the last value of the first entry in element expanding to @type (if any), ordering entries lexicographically by key. Both the key and value of the matched entry are IRI expanded.
13. For each key and value in element, ordered lexicographically by key if ordered is true:
    1. If key is @context, continue to the next key.
    2. Initialize expanded property to the result of IRI expanding key.
    3. If expanded property is null or it neither contains a colon (:) nor it is a keyword, drop key by continuing to the next key.
    4. If expanded property is a keyword:
       1. If active property equals @reverse, an invalid reverse property map error has been detected and processing is aborted.
       2. If result already has an expanded property entry, other than @included or @type (unless processing mode is json-ld-1.0), a colliding keywords error has been detected and processing is aborted.
       3. If expanded property is @id:
          1. If value is not a string, an invalid @id value error has been detected and processing is aborted. When the frameExpansion flag is set, value MAY be an empty map, or an array of one or more strings.
          2. Otherwise, set expanded value to the result of IRI expanding value using true for document relative and false for vocab. When the frameExpansion flag is set, expanded value will be an array of one or more of the values, with string values expanded using the IRI Expansion algorithm as above.
       4. If expanded property is @type:
          1. If value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. When the frameExpansion flag is set, value MAY be an empty map, or a default object where the value of @default is restricted to be an IRI. All other values mean that invalid type value error has been detected and processing is aborted.
          2. If value is an empty map, set expanded value to value.
          3. Otherwise, if value is a default object, set expanded value to a new default object with the value of @default set to the result of IRI expanding value using type-scoped context for active context, and true for document relative.
          4. Otherwise, set expanded value to the result of IRI expanding each of its values using type-scoped context for active context, and true for document relative.
          5. If result already has an entry for @type, prepend the value of @type in result to expanded value, transforming it into an array, if necessary.
             Note

             No transformation from a string value to an array expanded value is implied, and the form or value should be preserved in expanded value.
       5. If expanded property is @graph, set expanded value to the result of using this algorithm recursively passing active context, @graph for active property, value for element, base URL, and the frameExpansion and ordered flags, ensuring that expanded value is an array of one or more maps.
       6. If expanded property is @included:
          1. If processing mode is json-ld-1.0, continue with the next key from element.
          2. Set expanded value to the result of using this algorithm recursively passing active context, null for active property, value for element, base URL, and the frameExpansion and ordered flags, ensuring that the result is an array.
          3. If any element of expanded value is not a node object, an invalid @included value error has been detected and processing is aborted.
          4. If result already has an entry for @included, prepend the value of @included in result to expanded value.
       7. If expanded property is @value:
          1. If input type is @json, set expanded value to value. If processing mode is json-ld-1.0, an invalid value object value error has been detected and processing is aborted.
          2. Otherwise, if value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. When the frameExpansion flag is set, value MAY be an empty map or an array of scalar values.
          3. Otherwise, set expanded value to value. When the frameExpansion flag is set, expanded value will be an array of one or more string values or an array containing an empty map.
          4. If expanded value is null, set the @value entry of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type entry depends on the existence of an @value entry.
       8. If expanded property is @language:
          1. If value is not a string, an invalid language-tagged string error has been detected and processing is aborted. When the frameExpansion flag is set, value MAY be an empty map or an array of zero or more strings.
          2. Otherwise, set expanded value to value. If value is not well-formed according to section 2.2.9 of [BCP47], processors SHOULD issue a warning. When the frameExpansion flag is set, expanded value will be an array of one or more string values or an array containing an empty map.
             Note

             Processors MAY normalize language tags to lower case.
       9. If expanded property is @direction:
          1. If processing mode is json-ld-1.0, continue with the next key from element.
          2. If value is neither "ltr" nor "rtl", an invalid base direction error has been detected and processing is aborted. When the frameExpansion flag is set, value MAY be an empty map or an array of zero or more strings.
          3. Otherwise, set expanded value to value. When the frameExpansion flag is set, expanded value will be an array of one or more string values or an array containing an empty map.
       10. If expanded property is @index:
           1. If value is not a string, an invalid @index value error has been detected and processing is aborted.
           2. Otherwise, set expanded value to value.
       11. If expanded property is @list:
           1. If active property is null or @graph, continue with the next key from element to remove the free-floating list.
           2. Otherwise, initialize expanded value to the result of using this algorithm recursively passing active context, active property, value for element, base URL, and the frameExpansion and ordered flags, ensuring that the result is an array..
       12. If expanded property is @set, set expanded value to the result of using this algorithm recursively, passing active context, active property, value for element, base URL, and the frameExpansion and ordered flags.
       13. If expanded property is @reverse:
           1. If value is not a map, an invalid @reverse value error has been detected and processing is aborted.
           2. Otherwise initialize expanded value to the result of using this algorithm recursively, passing active context, @reverse as active property, value as element, base URL, and the frameExpansion and ordered flags.
           3. If expanded value contains an @reverse entry, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
              1. Use add value to add item to the property entry in result using true for as array.
           4. If expanded value contains an entry other than @reverse:
              1. Set reverse map to the value of the @reverse entry in result, initializing it to an empty map, if necessary.
              2. For each property and items in expanded value other than @reverse:
                 1. For each item in items:
                    1. If item is a value object or list object, an invalid reverse property value has been detected and processing is aborted.
                    2. Use add value to add item to the property entry in reverse map using true for as array.
           5. Continue with the next key from element.
       14. If expanded property is @nest, add key to nests, initializing it to an empty array, if necessary. Continue with the next key from element.
       15. When the frameExpansion flag is set, if expanded property is any other framing keyword (@default, @embed, @explicit, @omitDefault, or @requireAll), set expanded value to the result of performing the Expansion Algorithm recursively, passing active context, active property, value for element, base URL, and the frameExpansion and ordered flags.
       16. Unless expanded value is null, expanded property is @value, and input type is not @json, set the expanded property entry of result to expanded value.
       17. Continue with the next key from element.
    5. Initialize container mapping to key's container mapping in active context.
    6. If key's term definition in active context has a type mapping of @json, set expanded value to a new map, set the entry @value to value, and set the entry @type to @json.
    7. Otherwise, if container mapping includes @language and value is a map then value is expanded from a language map as follows:
       1. Initialize expanded value to an empty array.
       2. Initialize direction to the default base direction from active context.
       3. If key's term definition in active context has a direction mapping, update direction with that value.
       4. For each key-value pair language-language value in value, ordered lexicographically by language if ordered is true:
          1. If language value is not an array set language value to an array containing only language value.
          2. For each item in language value:
             1. If item is null, continue to the next entry in language value.
             2. item must be a string, otherwise an invalid language map value error has been detected and processing is aborted.
             3. Initialize a new map v consisting of two key-value pairs: (@value-item) and (@language-language). If item is neither @none nor well-formed according to section 2.2.9 of [BCP47], processors SHOULD issue a warning.
                Note

                Processors MAY normalize language tags to lower case.
             4. If language is @none, or expands to @none, remove @language from v.
             5. If direction is not null, add an entry for @direction to v with direction.
             6. Append v to expanded value.
    8. Otherwise, if container mapping includes @index, @type, or @id and value is a map then value is expanded from an map as follows:
       1. Initialize expanded value to an empty array.
       2. Initialize index key to the key's index mapping in active context, or @index, if it does not exist.
       3. For each key-value pair index-index value in value, ordered lexicographically by index if ordered is true:
          1. If container mapping includes @id or @type, initialize map context to the previous context from active context if it exists, otherwise, set map context to active context.
          2. If container mapping includes @type and index's term definition in map context has a local context, update map context to the result of the Context Processing algorithm, passing map context as active context the value of the index's local context as local context and base URL from the term definition for index in map context.
          3. Otherwise, set map context to active context.
          4. Initialize expanded index to the result of IRI expanding index.
          5. If index value is not an array set index value to an array containing only index value.
          6. Initialize index value to the result of using this algorithm recursively, passing map context as active context, key as active property, index value as element, base URL, true for from map, and the frameExpansion and ordered flags.
          7. For each item in index value:
             1. If container mapping includes @graph, and item is not a graph object, set item to a new map containing the key-value pair @graph-item, ensuring that the value is represented using an array.
             2. If container mapping includes @index, index key is not @index, and expanded index is not @none:
                1. Initialize re-expanded index to the result of calling the Value Expansion algorithm, passing the active context, index key as active property, and index as value.
                2. Initialize expanded index key to the result of IRI expanding index key.
                3. Initialize index property values to an array consisting of re-expanded index followed by the existing values of the concatenation of expanded index key in item, if any.
                4. Add the key-value pair (expanded index key-index property values) to item.
                5. If item is a value object, it MUST NOT contain any extra properties; an invalid value object error has been detected and processing is aborted.
             3. Otherwise, if container mapping includes @index, item does not have an entry @index, and expanded index is not @none, add the key-value pair (@index-index) to item.
             4. Otherwise, if container mapping includes @id item does not have the entry @id, and expanded index is not @none, add the key-value pair (@id-expanded index) to item, where expanded index is set to the result of IRI expandingindex using true for document relative and false for vocab.
             5. Otherwise, if container mapping includes @type and expanded index is not @none, initialize types to a new array consisting of expanded index followed by any existing values of @type in item. Add the key-value pair (@type-types) to item.
             6. Append item to expanded value.
    9. Otherwise, initialize expanded value to the result of using this algorithm recursively, passing active context, key for active property, value for element, base URL, and the frameExpansion and ordered flags.
    10. If expanded value is null, ignore key by continuing to the next key from element.
    11. If container mapping includes @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a map containing the key-value pair @list-expanded value.
    12. If container mapping includes @graph, and includes neither @id nor @index, convert expanded value into an array, if necessary, then convert each value ev in expanded value into a graph object:
        1. Convert ev into a graph object by creating a map containing the key-value pair @graph-ev where ev is represented as an array.
           Note

           This may lead to a graph object including another graph object, if ev was already in the form of a graph object.
    13. If the term definition associated to key indicates that it is a reverse property
        1. If result has no @reverse entry, create one and initialize its value to an empty map.
        2. Reference the value of the @reverse entry in result using the variable reverse map.
        3. If expanded value is not an array, set it to an array containing expanded value.
        4. For each item in expanded value
           1. If item is a value object or list object, an invalid reverse property value has been detected and processing is aborted.
           2. If reverse map has no expanded property entry, create one and initialize its value to an empty array.
           3. Use add value to add item to the expanded property entry in reverse map using true for as array.
    14. Otherwise, key is not a reverse property use add value to add expanded value to the expanded property entry in result using true for as array.
14. For each key nesting-key in nests, ordered lexicographically if ordered is true:
    1. Initialize nested values to the value of nesting-key in element, ensuring that it is an array.
    2. For each nested value in nested values:
       1. If nested value is not a map, or any key within nested value expands to @value, an invalid @nest value error has been detected and processing is aborted.
       2. Recursively repeat steps 13 and 14 using nested value for element.
          Note

          By invoking steps 13 and 14 on nested value we are able to unfold arbitrary levels of nesting, with results being merged into result. Step 13 iterates through each entry in nested value and expands it, while collecting new nested values found at each level, until all nesting has been extracted.
15. If result contains the entry @value:
    1. The result must not contain any entries other than @direction, @index, @language, @type, and @value. It must not contain an @type entry if it contains either @language or @direction entries. Otherwise, an invalid value object error has been detected and processing is aborted.
    2. If the result's @type entry is @json, then the @value entry may contain any value, and is treated as a JSON literal.
    3. Otherwise, if the value of result's @value entry is null, or an empty array, return null.
    4. Otherwise, if the value of result's @value entry is not a string and result contains the entry @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
    5. Otherwise, if the result has an @type entry and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
16. Otherwise, if result contains the entry @type and its associated value is not an array, set it to an array containing only the associated value.
17. Otherwise, if result contains the entry @set or @list:
    1. The result must contain at most one other entry which must be @index. Otherwise, an invalid set or list object error has been detected and processing is aborted.
    2. If result contains the entry @set, then set result to the entry's associated value.
18. If result is a map that contains only the entry @language, return null.
19. If active property is null or @graph, drop free-floating values as follows:
    1. If result is a map which is empty, or contains only the entries @value or @list, set result to null.
    2. Otherwise, if result is a map whose only entry is @id, set result to null. When the frameExpansion flag is set, a map containing only the @id entry is retained.
20. Return result.

5.2.2 Algorithm

The algorithm takes two required and four optional input variables. The required inputs are an active context and a value to be expanded. The optional inputs are two flags, document relative and vocab, that specifying whether value can be interpreted as a relative IRI reference against the document's base IRI or the active context's vocabulary mapping, respectively, and a local context and a map defined to be used when this algorithm is used during Context Processing. If not passed, the two flags are set to false and local context and defined are initialized to null.

1. If value is a keyword or null, return value as is.
2. If value has the form of a keyword (i.e., it matches the ABNF rule "@"1*ALPHA from [RFC5234]), a processor SHOULD generate a warning and return null.
3. If local context is not null, it contains an entry with a key that equals value, and the value of the entry for value in defined is not true, invoke the Create Term Definition algorithm, passing active context, local context, value as term, and defined. This will ensure that a term definition is created for value in active context during Context Processing.
4. If active context has a term definition for value, and the associated IRI mapping is a keyword, return that keyword.
5. If vocab is true and the active context has a term definition for value, return the associated IRI mapping.
6. If value contains a colon (:) anywhere after the first character, it is either an IRI, a compact IRI, or a blank node identifier:
   1. Split value into a prefix and suffix at the first occurrence of a colon (:).
   2. If prefix is underscore (_) or suffix begins with double-forward-slash (//), return value as it is already an IRI or a blank node identifier.
   3. If local context is not null, it contains a prefix entry, and the value of the prefix entry in defined is not true, invoke the Create Term Definition algorithm, passing active context, local context, prefix as term, and defined. This will ensure that a term definition is created for prefix in active context during Context Processing.
   4. If active context contains a term definition for prefix having a non-null IRI mapping and the prefix flag of the term definition is true, return the result of concatenating the IRI mapping associated with prefix and suffix.
   5. If value has the form of an IRI, return value.
7. If vocab is true, and active context has a vocabulary mapping, return the result of concatenating the vocabulary mapping with value.
8. Otherwise, if document relative is true set value to the result of resolving value against the base IRI from active context. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
9. Return value as is.

5.3.2 Algorithm

The algorithm takes three required inputs: an active context, an active property, and a value to expand.

1. If the active property has a type mapping in active context that is @id, and the value is a string, return a new map containing a single entry where the key is @id and the value is the result IRI expanding value using true for document relative and false for vocab.
2. If active property has a type mapping in active context that is @vocab, and the value is a string, return a new map containing a single entry where the key is @id and the value is the result of IRI expanding value using true for document relative.
3. Otherwise, initialize result to a map with an @value entry whose value is set to value.
4. If active property has a type mapping in active context, other than @id, @vocab, or @none, add @type to result and set its value to the value associated with the type mapping.
5. Otherwise, if value is a string:
   1. Initialize language to the language mapping for active property in active context, if any, otherwise to the default language of active context.
   2. Initialize direction to the direction mapping for active property in active context, if any, otherwise to the default base direction of active context.
   3. If language is not null, add @language to result with the value language.
   4. If direction is not null, add @direction to result with the value direction.
6. Return result.

6.1.2 Algorithm

The algorithm takes three required and two optional input variables. The required inputs are an active context, an active property, and an element to be compacted. The optional inputs are the compactArrays flag and the ordered flag, used to order map entry keys lexicographically, where noted. If not passed, both flags are set to false.

1. Initialize type-scoped context to active context. This is used for compacting values that may be relevant to any previous type-scoped context.
2. If element is a scalar, it is already in its most compact form, so simply return element.
3. If element is an array:
   1. Initialize result to an empty array.
   2. For each item in element:
      1. Initialize compacted item to the result of using this algorithm recursively, passing active context, active property, item for element, and the compactArrays and ordered flags.
      2. If compacted item is not null, then append it to result.
   3. If result is empty or contains more than one value, or compactArrays is false, or active property is either @graph or @set, or container mapping for active property in active context includes either @list or @set, return result.
   4. Otherwise, return the value in result.
4. Otherwise element is a map.
5. If active context has a previous context, the active context is not propagated. If element does not contain an @value entry, and element does not consist of a single @id entry, set active context to previous context from active context, as the scope of a term-scoped context does not apply when processing new node objects.
6. If the term definition for active property in active context has a local context:
   1. Set active context to the result of the Context Processing algorithm, passing active context, the value of the active property's local context as local context, base URL from the term definition for active property in active context, and true for override protected.
7. If element has an @value or @id entry and the result of using the Value Compaction algorithm, passing active context, active property, and element as value is a scalar, or the term definition for active property has a type mapping of @json, return that result.
8. If element is a list object, and the container mapping for active property in active context includes @list, return the result of using this algorithm recursively, passing active context, active property, value of @list in element for element, and the compactArrays and ordered flags.
9. Initialize inside reverse to true if active property equals @reverse, otherwise to false.
10. Initialize result to an empty map.
11. If element has an @type entry, create a new array compacted types initialized by transforming each expanded type of that entry into its compacted form by IRI compacting expanded type. Then, for each term in compacted types ordered lexicographically:
    1. If the term definition for term in type-scoped context has a local context set active context to the result of the Context Processing algorithm, passing active context and the value of term's local context in type-scoped context as local context base URL from the term definition for term in type-scoped context, and false for propagate.
12. For each key expanded property and value expanded value in element, ordered lexicographically by expanded property if ordered is true:
    1. If expanded property is @id:
       1. If expanded value is a string, then initialize compacted value by IRI compacting expanded value with vocab set to false.
       2. Initialize alias by IRI compacting expanded property.
       3. Add an entry alias to result whose value is set to compacted value and continue to the next expanded property.
    2. If expanded property is @type:
       1. If expanded value is a string, then initialize compacted value by IRI compacting expanded value using type-scoped context for active context.
       2. Otherwise, expanded value must be a @type array:
          1. Initialize compacted value to an empty array.
          2. For each item expanded type in expanded value:
             1. Set term by IRI compacting expanded type using type-scoped context for active context.
             2. Append term, to compacted value.
       3. Initialize alias by IRI compacting expanded property.
       4. Initialize as array to true if processing mode is json-ld-1.1 and the container mapping for alias in the active context includes @set, otherwise to the negation of compactArrays.
       5. Use add value to add compacted value to the alias entry in result using as array.
       6. Continue to the next expanded property.
    3. If expanded property is @reverse:
       1. Initialize compacted value to the result of using this algorithm recursively, passing active context, @reverse for active property, expanded value for element, and the compactArrays and ordered flags.
       2. For each property and value in compacted value:
          1. If the term definition for property in the active context indicates that property is a reverse property
             1. Initialize as array to true if the container mapping for property in the active context includes @set, otherwise the negation of compactArrays.
             2. Use add value to add value to the property entry in result using as array.
             3. Remove the property entry from compacted value.
       3. If compacted value has some remaining map entries, i.e., it is not an empty map:
          1. Initialize alias by IRI compacting @reverse.
          2. Set the value of the alias entry of result to compacted value.
       4. Continue with the next expanded property from element.
    4. If expanded property is @preserve then:
       1. Initialize compacted value to the result of using this algorithm recursively, passing active context, active property, expanded value for element, and the compactArrays and ordered flags.
       2. Add compacted value as the value of @preserve in result unless expanded value is an empty array.
    5. If expanded property is @index and active property has a container mapping in active context that includes @index, then the compacted result will be inside of an @index container, drop the @index entry by continuing to the next expanded property.
    6. Otherwise, if expanded property is @direction, @index, @language, or @value:
       1. Initialize alias by IRI compacting expanded property.
       2. Add an entry alias to result whose value is set to expanded value and continue with the next expanded property.
    7. If expanded value is an empty array:
       1. Initialize item active property by IRI compacting expanded property using expanded value for value and inside reverse for reverse.
       2. If the term definition for item active property in the active context has a nest value entry (nest term):
          1. If nest term is not @nest, or a term in the active context that expands to @nest, an invalid @nest value error has been detected, and processing is aborted.
          2. If result does not have a nest term entry, initialize it to an empty map.
          3. Initialize nest result to the value of nest term in result.
       3. Otherwise, initialize nest result to result.
       4. Use add value to add an empty array to the item active property entry in nest result using true for as array.
    8. At this point, expanded value must be an array due to the Expansion algorithm. For each item expanded item in expanded value:
       1. Initialize item active property by IRI compacting expanded property using expanded item for value and inside reverse for reverse.
       2. If the term definition for item active property in the active context has a nest value entry (nest term):
          1. If nest term is not @nest, or a term in the active context that expands to @nest, an invalid @nest value error has been detected, and processing is aborted.
          2. If result does not have a nest term entry, initialize it to an empty map.
          3. Initialize nest result to the value of nest term in result.
       3. Otherwise, initialize nest result to result.
       4. Initialize container to container mapping for item active property in active context, or to a new empty array, if there is no such container mapping.
       5. Initialize as array to true if container includes @set, or if item active property is @graph or @list, otherwise the negation of compactArrays.
       6. Initialize compacted item to the result of using this algorithm recursively, passing active context, item active property for active property, expanded item for element, along with the compactArrays and ordered flags. If expanded item is a list object or a graph object, use the value of the @list or @graph entries, respectively, for element instead of expanded item.
       7. If expanded item is a list object:
          1. If compacted item is not an array, then set compacted item to an array containing only compacted item.
          2. If container does not include @list:
             1. Convert compacted item to a list object by setting it to a map containing an entry where the key is the result of IRI compacting @list and the value is the original compacted item.
             2. If expanded item contains the entry @index-value, then add an entry to compacted item where the key is the result of IRI compacting @index and value is value.
             3. Use add value to add compacted item to the item active property entry in nest result using as array.
          3. Otherwise, set the value of the item active property entry in nest result to compacted item.
       8. If expanded item is a graph object:
          1. If container includes @graph and @id:
             1. Initialize map object to the value of item active property in nest result, initializing it to a new empty map, if necessary.
             2. Initialize map key by IRI compacting the value of @id in expanded item or @none if no such value exists with vocab set to false if there is an @id entry in expanded item.
             3. Use add value to add compacted item to the map key entry in map object using as array.
          2. Otherwise, if container includes @graph and @index and expanded item is a simple graph object:
             1. Initialize map object to the value of item active property in nest result, initializing it to a new empty map, if necessary.
             2. Initialize map key the value of @index in expanded item or @none, if no such value exists.
             3. Use add value to add compacted item to the map key entry in map object using as array.
          3. Otherwise, if container includes @graph and expanded item is a simple graph object the value cannot be represented as a map object.
             1. If compacted item is an array with more than one value, it cannot be directly represented, as multiple objects would be interpreted as different named graphs. Set compacted item to a new map, containing the key from IRI compacting @included and the original compacted item as the value.
             2. Use add value to add compacted item to the item active property entry in nest result using as array.
          4. Otherwise, container does not include @graph or otherwise does not match one of the previous cases.
             1. Set compacted item to a new map containing the key from IRI compacting @graph using the original compacted item as a value.
             2. If expanded item contains an @id entry, add an entry in compacted item using the key from IRI compacting @id using the value of IRI compacting the value of @id in expanded item using false for vocab.
             3. If expanded item contains an @index entry, add an entry in compacted item using the key from IRI compacting @index and the value of @index in expanded item.
             4. Use add value to add compacted item to the item active property entry in nest result using as array.
       9. Otherwise, if container includes @language, @index, @id, or @type and container does not include @graph:
          1. Initialize map object to the value of item active property in nest result, initializing it to a new empty map, if necessary.
          2. Initialize container key by IRI compacting either @language, @index, @id, or @type based on the contents of container.
          3. Initialize index key to the value of index mapping in the term definition associated with item active property in active context, or @index, if no such value exists.
          4. If container includes @language and expanded item contains a @value entry, then set compacted item to the value associated with its @value entry. Set map key to the value of @language in expanded item, if any.
          5. Otherwise, if container includes @index and index key is @index, set map key to the value of @index in expanded item, if any.
          6. Otherwise, if container includes @index and index key is not @index:
             1. Reinitialize container key by IRI compacting index key.
             2. Set map key to the first value of container key in compacted item, if any.
             3. If there are remaining values in compacted item for container key, use add value to add those remaining values to the container key in compacted item. Otherwise, remove that entry from compacted item.
          7. Otherwise, if container includes @id, set map key to the value of container key in compacted item and remove container key from compacted item.
          8. Otherwise, if container includes @type:
             1. Set map key to the first value of container key in compacted item, if any.
             2. If there are remaining values in compacted item for container key, use add value to add those remaining values to the container key in compacted item.
             3. Otherwise, remove that entry from compacted item.
             4. If compacted item contains a single entry with a key expanding to @id, set compacted item to the result of using this algorithm recursively, passing active context, item active property for active property, and a map composed of the single entry for @id from expanded item for element.
          9. If map key is null, set it to the result of IRI compacting @none.
          10. Use add value to add compacted item to the map key entry in map object using as array.
       10. Otherwise, use add value to add compacted item to the item active property entry in nest result using as array.
13. Return result.

6.2.2 Algorithm

This algorithm takes two required inputs and three optional inputs. The required inputs are an active context, and the var to be compacted. The optional inputs are a value associated with the var, a vocab flag which specifies whether the passed var should be compacted using the active context's vocabulary mapping, and a reverse flag which specifies whether a reverse property is being compacted. If not passed, value is set to null and both vocab and reverse are both set to false.

1. If var is null, return null.
2. If the active context has a null inverse context, set inverse context in active context to the result of calling the Inverse Context Creation algorithm using active context.
3. Initialize inverse context to the value of inverse context in active context.
4. If vocab is true and var is an entry of inverse context:
   1. Initialize default language based on the active context's default language, normalized to lower case and default base direction:
      1. If the active context's default base direction is not null, to the concatenation of the active context's default language and default base direction, separated by an underscore ("_"), normalized to lower case.
      2. Otherwise, to the active context's default language, if it has one, normalized to lower case, otherwise to @none.
   2. If value is a map containing an @preserve entry, use the first element from the value of @preserve as value.
   3. Initialize containers to an empty array. This array will be used to keep track of an ordered list of preferred container mapping for a term, based on what is compatible with value.
      Note

      Algorithm steps may append the same value to containers, but the order in which they are added is significant for choosing the most appropriate term.
   4. Initialize type/language to @language, and type/language value to @null. These two variables will keep track of the preferred type mapping or language mapping for a term, based on what is compatible with value.
   5. If value is a map containing an @index entry, and value is not a graph object then append the values @index and @index@set to containers.
   6. If reverse is true, set type/language to @type, type/language value to @reverse, and append @set to containers.
   7. Otherwise, if value is a list object, then set type/language and type/language value to the most specific values that work for all items in the list as follows:
      1. If @index is not an entry in value, then append @list to containers.
      2. Initialize list to the array associated with the @list entry in value.
      3. Initialize common type and common language to null. If list is empty, set common language to default language.
      4. For each item in list:
         1. Initialize item language to @none and item type to @none.
         2. If item contains an @value entry:
            1. If item contains an @direction entry, then set item language to the concatenation of the item's @language entry (if any) the item's @direction, separated by an underscore ("_"), normalized to lower case.
            2. Otherwise, if item contains an @language entry, then set item language to its associated value, normalized to lower case.
            3. Otherwise, if item contains a @type entry, set item type to its associated value.
            4. Otherwise, set item language to @null.
         3. Otherwise, set item type to @id.
         4. If common language is null, set common language to item language.
         5. Otherwise, if item language does not equal common language and item contains a @value entry, then set common language to @none because list items have conflicting languages.
         6. If common type is null, set common type to item type.
         7. Otherwise, if item type does not equal common type, then set common type to @none because list items have conflicting types.
         8. If common language is @none and common type is @none, then stop processing items in the list because it has been detected that there is no common language or type amongst the items.
      5. If common language is null, set common language to @none.
      6. If common type is null, set common type to @none.
      7. If common type is not @none then set type/language to @type and type/language value to common type.
      8. Otherwise, set type/language value to common language.
   8. Otherwise, if value is a graph object, prefer a mapping most appropriate for the particular value.
      1. If value contains an @index entry, append the values @graph@index and @graph@index@set to containers.
      2. If value contains an @id entry, append the values @graph@id and @graph@id@set to containers.
      3. Append the values @graph @graph@set, and @set to containers.
      4. If value does not contain an @index entry, append the values @graph@index and @graph@index@set to containers.
      5. If the value does not contain an @id entry, append the values @graph@id and @graph@id@set to containers.
      6. Append the values @index and @index@set to containers.
      7. Set type/language to @type and set type/language value to @id.
   9. Otherwise:
      1. If value is a value object:
         1. If value contains an @direction entry and does not contain an @index entry, then set type/language value to the concatenation of the value's @language entry (if any) and the value's @direction entry, separated by an underscore ("_"), normalized to lower case. Append @language and @language@set to containers.
         2. Otherwise, if value contains an @language entry and does not contain an @index entry, then set type/language value to the value of @language normalized to lower case, and append @language, and @language@set to containers.
         3. Otherwise, if value contains an @type entry, then set type/language value to its associated value and set type/language to @type.
      2. Otherwise, set type/language to @type and set type/language value to @id, and append @id, @id@set, @type, and @set@type, to containers.
      3. Append @set to containers.
   10. Append @none to containers. This represents the non-existence of a container mapping, and it will be the last container mapping value to be checked as it is the most generic.
   11. If processing mode is not json-ld-1.0 and value is not a map or does not contain an @index entry, append @index and @index@set to containers.
   12. If processing mode is not json-ld-1.0 and value is a map containing only an @value entry, append @language and @language@set to containers.
   13. If type/language value is null, set type/language value to @null. This is the key under which null values are stored in the inverse context entry.
   14. Initialize preferred values to an empty array. This array will indicate, in order, the preferred values for a term's type mapping or language mapping.
   15. If type/language value is @reverse, append @reverse to preferred values.
   16. If type/language value is @id or @reverse and value is a map containing an @id entry:
       1. If the result of IRI compacting the value of the @id entry in value has a term definition in the active context with an IRI mapping that equals the value of the @id entry in value, then append @vocab, @id, and @none, in that order, to preferred values.
       2. Otherwise, append @id, @vocab, and @none, in that order, to preferred values.
   17. Otherwise, append type/language value and @none, in that order, to preferred values. If value is a list object with an empty array as the value of @list, set type/language to @any.
   18. Append @any to preferred values.
   19. If preferred values contains any entry having an underscore ("_"), append the substring of that entry from the underscore to the end of the string to preferred values.
   20. Initialize term to the result of the Term Selection algorithm, passing var, containers, type/language, and preferred values.
   21. If term is not null, return term.
5. At this point, there is no simple term that var can be compacted to. If vocab is true and active context has a vocabulary mapping:
   1. If var begins with the vocabulary mapping's value but is longer, then initialize suffix to the substring of var that does not match. If suffix does not have a term definition in active context, then return suffix.
6. The var could not be compacted using the active context's vocabulary mapping. Try to create a compact IRI, starting by initializing compact IRI to null. This variable will be used to store the created compact IRI, if any.
7. For each term definition definition in active context:
   1. If the IRI mapping of definition is null, its IRI mapping equals var, its IRI mapping is not a substring at the beginning of var, or definition does not have a true prefix flag, definition's key cannot be used as a prefix. Continue with the next definition.
   2. Initialize candidate by concatenating definition key, a colon (:), and the substring of var that follows after the value of the definition's IRI mapping.
   3. If either compact IRI is null, candidate is shorter or the same length but lexicographically less than compact IRI and candidate does not have a term definition in active context, or if that term definition has an IRI mapping that equals var and value is null, set compact IRI to candidate.
8. If compact IRI is not null, return compact IRI.
9. To ensure that the IRI var is not confused with a compact IRI, if the IRI scheme of var matches any term in active context with prefix flag set to true, and var has no IRI authority (preceded by double-forward-slash (//), an IRI confused with prefix error has been detected, and processing is aborted.
10. If vocab is false, transform var to a relative IRI reference using the base IRI from active context, if it exists.
11. Finally, return var as is.

6.3.2 Algorithm

This algorithm has three required inputs: an active context, an active property, and a value to be compacted.

1. Initialize result to a copy of value.
2. If the active context has a null inverse context, set inverse context in active context to the result of calling the Inverse Context Creation algorithm using active context.
3. Initialize inverse context to the value of inverse context in active context.
4. Initialize language to the language mapping for active property in active context, if any, otherwise to the default language of active context.
5. Initialize direction to the direction mapping for active property in active context, if any, otherwise to the default base direction of active context.
6. If value has an @id entry and has no other entries other than @index:
   1. If the type mapping of active property is set to @id, set result to the result of IRI compacting the value associated with the @id entry using false for vocab.
   2. Otherwise, if the type mapping of active property is set to @vocab, set result to the result of IRI compacting the value associated with the @id entry.
7. Otherwise, if value has an @type entry whose value matches the type mapping of active property, set result to the value associated with the @value entry of value.
8. Otherwise, if the type mapping of active property is @none, or value has an @type entry, and the value of @type in value does not match the type mapping of active property, leave value as is, as value compaction is disabled.
   1. Replace any value of @type in result with the result of IRI compacting the value of the @type entry.
9. Otherwise, if the value of the @value entry is not a string:
   1. If value has an @index entry, and the container mapping associated to active property includes @index, or if value has no @index entry, set result to the value associated with the @value entry.
10. Otherwise, if value has an @language entry whose value exactly matches language, using a case-insensitive comparison if it is not null, or is not present, if language is null, and the value has an @direction entry whose value exactly matches direction, if it is not null, or is not present, if direction is null:
    1. If value has an @index entry, and the container mapping associated to active property includes @index, or value has no @index entry, set result to the value associated with the @value entry.
11. If result is a map, replace each key in result with the result of IRI compacting that key.
12. Return result.

7.1.2 Algorithm

The algorithm takes one required and one optional input variables. The required input is an element to flatten. The optional input is the ordered flag, used to order map entry keys lexicographically, where noted. If not passed, the ordered flag is set to false.

This algorithm uses the Generate Blank Node Identifier algorithm to generate new blank node identifiers and relabel existing blank node identifiers. The Generate Blank Node Identifier algorithm maintains an identifier map to ensure that blank node identifiers in the source document are consistently remapped to new blank node identifiers avoiding collisions. Thus, before this algorithm is run, the identifier map is reset.

1. Initialize node map to a map consisting of a single entry whose key is @default and whose value is an empty map.
2. Perform the Node Map Generation algorithm, passing element and node map.
3. Initialize default graph to the value of the @default entry of node map, which is a map representing the default graph.
4. For each key-value pair graph name-graph in node map where graph name is not @default, ordered lexicographically by graph name if ordered is true, perform the following steps:
   1. If default graph does not have a graph name entry, create one and initialize its value to a map consisting of an @id entry whose value is set to graph name.
   2. Reference the value associated with the graph name entry in default graph using the variable entry.
   3. Add an @graph entry to entry and set it to an empty array.
   4. For each id-node pair in graph ordered lexicographically by id if ordered is true, add node to the @graph entry of entry, unless the only entry of node is @id.
5. Initialize an empty array flattened.
6. For each id-node pair in default graph ordered lexicographically by id if ordered is true, add node to flattened, unless the only entry of node is @id.
7. Return flattened.

7.2.2 Algorithm

The algorithm takes as input an expanded JSON-LD document element and a reference to a map node map. Furthermore it has the optional parameters active graph (which defaults to @default), an active subject, active property, and a reference to a map list. If not passed, active subject, active property, and list are set to null.

1. If element is an array, process each item in element as follows and then return:
   1. Run this algorithm recursively by passing item for element, node map, active graph, active subject, active property, and list.
2. Otherwise element is a map. Reference the map which is the value of the active graph entry of node map using the variable graph. If the active subject is null, set node to null otherwise reference the active subject entry of graph using the variable subject node.
3. For each item in the @type entry of element, if any, or for the value of @type, if the value of @type exists and is not an array:
   1. If item is a blank node identifier, replace it with a newly generated blank node identifier passing item for identifier.
4. If element has an @value entry, perform the following steps:
   1. If list is null:
      1. If subject node does not have an active property entry, create one and initialize its value to an array containing element.
      2. Otherwise, compare element against every item in the array associated with the active property entry of subject node. If there is no item equivalent to element, append element to the array. Two maps are considered equal if they have equivalent map entries.
   2. Otherwise, append element to the @list entry of list.
5. Otherwise, if element has an @list entry, perform the following steps:
   1. Initialize a new map result consisting of a single entry @list whose value is initialized to an empty array.
   2. Recursively call this algorithm passing the value of element's @list entry for element, node map, active graph, active subject, active property, and result for list.
   3. If list is null, append result to the value of the active property entry of subject node.
   4. Otherwise, append result to the @list entry of list.
6. Otherwise element is a node object, perform the following steps:
   1. If element has an @id entry, set id to its value and remove the entry from element. If id is a blank node identifier, replace it with a newly generated blank node identifier passing id for identifier.
   2. Otherwise, set id to the result of the Generate Blank Node Identifier algorithm passing null for identifier.
   3. If graph does not contain an entry id, create one and initialize its value to a map consisting of a single entry @id whose value is id.
   4. Reference the value of the id entry of graph using the variable node.
   5. If active subject is a map, a reverse property relationship is being processed. Perform the following steps:
      1. If node does not have a active property entry, create one and initialize its value to an array containing active subject.
      2. Otherwise, compare active subject against every item in the array associated with the active property entry of node. If there is no item equivalent to active subject, append active subject to the array. Two maps are considered equal if they have equivalent map entries.
   6. Otherwise, if active property is not null, perform the following steps:
      1. Create a new map reference consisting of a single entry @id whose value is id.
      2. If list is null:
         1. If subject node does not have an active property entry, create one and initialize its value to an array containing reference.
         2. Otherwise, compare reference against every item in the array associated with the active property entry of subject node. If there is no item equivalent to reference, append reference to the array. Two maps are considered equal if they have equivalent map entries.
      3. Otherwise, append reference to the @list entry of list.
   7. If element has an @type entry, append each item of its associated array to the array associated with the @type entry of node unless it is already in that array. Finally remove the @type entry from element.
   8. If element has an @index entry, set the @index entry of node to its value. If node already has an @index entry with a different value, a conflicting indexes error has been detected and processing is aborted. Otherwise, continue by removing the @index entry from element.
   9. If element has an @reverse entry:
      1. Create a map referenced node with a single entry @id whose value is id.
      2. Initialize reverse map to the value of the @reverse entry of element.
      3. For each key-value pair property-values in reverse map:
         1. For each value of values:
            1. Recursively invoke this algorithm passing value for element, node map, active graph, referenced node for active subject, and property for active property. Passing a map for active subject indicates to the algorithm that a reverse property relationship is being processed.
      4. Remove the @reverse entry from element.
   10. If element has an @graph entry, recursively invoke this algorithm passing the value of the @graph entry for element, node map, and id for active graph before removing the @graph entry from element.
   11. If element has an @included entry, recursively invoke this algorithm passing the value of the @included entry for element, node map, and active graph before removing the @included entry from element.
   12. Finally, for each key-value pair property-value in element ordered by property perform the following steps:
       1. If property is a blank node identifier, replace it with a newly generated blank node identifier passing property for identifier.
          Note

          The use of blank node identifiers to label properties is obsolete, and may be removed in a future version of JSON-LD.
       2. If node does not have a property entry, create one and initialize its value to an empty array.
       3. Recursively invoke this algorithm passing value for element, node map, active graph, id for active subject, and property for active property.

7.4.2 Algorithm

The algorithm takes a single input variable identifier which may be null. The algorithm maintains an identifier map to relabel existing blank node identifiers to new blank node identifiers, which is reset when the invoking algorithm is initialized.

1. If identifier is not null and has an entry in the identifier map, return the mapped identifier.
2. Otherwise, generate a new unique blank node identifier.
3. If identifier is not null, create a new entry for identifier in identifier map and set its value to the new blank node identifier.
4. Return the new blank node identifier.

8.1.2 Algorithm

The algorithm takes a map node map, which is the result of the Node Map Generation algorithm and an RDF dataset dataset into which new graphs and triples are added. It also takes two optional input variables produceGeneralizedRdf and rdfDirection. Unless the produceGeneralizedRdf option is set to true, triple containing a blank node predicate are excluded from output.

1. For each graph name and graph in node map ordered by graph name:
   1. If graph name is not well-formed, continue with the next graph name-graph pair.
   2. If graph name is @default, initialize triples to the value of the defaultGraph attribute of dataset. Otherwise, initialize triples as an empty RdfGraph and add to dataset using its add method along with graph name for graphName.
   3. For each subject and node in graph ordered by subject:
      1. If subject is not well-formed, continue with the next subject-node pair.
      2. For each property and values in node ordered by property:
         1. If property is @type, then for each type in values, create a new RdfTriple composed of subject, rdf:type for predicate, and type for object and add to triples using its add method, unless type is not well-formed.
         2. Otherwise, if property is a keyword continue with the next property-values pair.
         3. Otherwise, if property is a blank node identifier and the produceGeneralizedRdf option is not true, continue with the next property-values pair.
            Note

            The use of blank node identifiers to label properties is obsolete, and may be removed in a future version of JSON-LD, as is the support for generalized RDF Datasets and thus the produceGeneralizedRdf option may be also be removed.
         4. Otherwise, if property is not well-formed, continue with the next property-values pair.
         5. Otherwise, property is an IRI or blank node identifier. For each item in values:
            1. Initialize list triples as an empty array.
               Note

               item is a value object, list object, or a node object.
            2. Add a triple composed of subject, property, and the result of using the Object to RDF Conversion algorithm passing item and list triples to triples using its add method, unless the result is null, indicating a non-well-formed resource that has to be ignored.
            3. Add all RdfTriple instances from list triples to triples using its add method.

8.2.2 Algorithm

The algorithm takes as two arguments item which MUST be either a value object, list object, or node object and list triples, which is an empty array.

1. If item is a node object and the value of its @id entry is not well-formed, return null.
2. If item is a node object, return the IRI or blank node identifier associated with its @id entry.
3. If item is a list object return the result of the List Conversion algorithm, passing the value associated with the @list entry from item and list triples.
4. Otherwise, item is a value object. Initialize value to the value associated with the @value entry in item.
5. Initialize datatype to the value associated with the @type entry of item or null if item does not have such an entry.
6. If datatype is not null and neither a well-formed IRI nor @json, return null.
7. If item has an @language entry which is not well-formed, return null.
8. If datatype is @json, convert value to the canonical lexical form using the result of transforming the internal representation of value to JSON and set datatype to rdf:JSON.
   Issue

   The JSON Canonicalization Scheme [JCS] is an emerging standard for JSON canonicalization not yet ready to be referenced. When a JSON canonicalization standard becomes available, this specification will likely be updated to require such a canonical representation. Users are cautioned from depending on the JSON literal lexical representation as an RDF literal, as the specifics of serialization may change in a future revision of this document.
9. If value is true or false, set value to the string true or false which is the canonical lexical form as described in § 8.6 Data Round Tripping If datatype is null, set datatype to xsd:boolean.
10. Otherwise, if value is a number with a non-zero fractional part (the result of a modulo‑1 operation) or an absolute value greater or equal to 10²¹, or value is a number and datatype equals xsd:double, convert value to a string in canonical lexical form of an xsd:double as defined in [XMLSCHEMA11-2] and described in § 8.6 Data Round Tripping. If datatype is null, set datatype to xsd:double.
11. Otherwise, if value is a number, convert it to a string in canonical lexical form of an xsd:integer as defined in [XMLSCHEMA11-2] and described in § 8.6 Data Round Tripping. If datatype is null, set datatype to xsd:integer.
    Note

    It follows from the previous step that value has no non-zero fractional part.
12. Otherwise, if datatype is null, set datatype to xsd:string or rdf:langString, depending on if item has an @language entry.
13. If item contains an @direction entry and rdfDirection is not null, item is a value object which is serialized using special rules.
    1. Initialize language to the value of @language in item normalized to lower case, or the empty string ("") if there is no such entry.
       Note

       Generally, language tags are not normalized, but when creating an i18n-datatype or compound-literal values are normalized to lower case for improved interoperability.
    2. If rdfDirection is i18n-datatype, set datatype to the result of appending language and the value of @direction in item separated by an underscore ("_") to https://www.w3.org/ns/i18n#. Initialize literal as an RDF literal using value and datatype.
       Note

       Processors MAY normalize language tags to lower case.
       Note

       As @direction may be used without @language, it is possible, and legitimate, to create a datatype IRI such as http://w3.org/ns/i18n#_ltr, which does not encode a language tag.
    3. Otherwise, if rdfDirection is compound-literal:
       1. Initialize literal as a new blank node.
       2. Create a new triple using literal as the subject, rdf:value as the predicate, and the value of @value in item as the object, and add it to list triples.
       3. If the item has an entry for @language, create a new triple using literal as the subject, rdf:language as the predicate, and language as the object, and add it to list triples.
       4. Create a new triple using literal as the subject, rdf:direction as the predicate, and the value of @direction in item as the object, and add it to list triples.
14. Otherwise, initialize literal as an RDF literal using value and datatype. If item has an @language entry, add the value associated with the @language entry as the language tag of literal.
15. Return literal.