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 input variables: an active context, a local context, and an array remote contexts which is used to detect cyclical context inclusions. If remote contexts is not passed, it is initialized to an empty array.

1. Initialize result to the result of cloning active context.
2. If local context is not an array, set it to an array containing only local context.
3. For each item context in local context:
   1. If context is null, set result to a newly-initialized active context and continue with the next context. In JSON-LD 1.0, the base IRI was given a default value here; this is now described conditionally in section 9. The Application Programming Interface.
   2. If context is a string,
      1. Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. 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].
      2. If context is in the remote contexts array, a recursive context inclusion error has been detected and processing is aborted; otherwise, add context to remote contexts.
      3. If context was previously dereferenced, then the processor MUST NOT do a further dereference, and context is set to the previously established internal representation.
      4. Otherwise, dereference context, transforming into the internal representation. If context cannot be dereferenced, or cannot be transformed into the internal representation, a loading remote context failed error has been detected and processing is aborted. If the dereferenced document has no top-level dictionary with an @context member, an invalid remote context has been detected and processing is aborted; otherwise, set context to the value of that member.
      5. Set result to the result of recursively calling this algorithm, passing result for active context, context for local context, and a copy of remote contexts.
      6. Continue with the next context.
   3. If context is not a dictionary, an invalid local context error has been detected and processing is aborted.
   4. If context has an @base key 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 key.
      2. If value is null, remove the base IRI of result.
      3. Otherwise, if value is an absolute IRI, the base IRI of result is set to value.
      4. Otherwise, if value is a relative IRI 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.
   5. If context has an @version key:
      1. If the associated value is not 1.1, an invalid @version value has been detected, and processing is aborted.
      2. If processing mode is set to json-ld-1.0, a processing mode conflict error has been detected and processing is aborted.
      3. Set processing mode, to json-ld-1.1, if not already set.
   6. If context has an @vocab key:
      1. Initialize value to the value associated with the @vocab key.
      2. If value is null, remove any vocabulary mapping from result.
      3. Otherewise, if value the empty string (""), the effective value is the current base IRI.
      4. Otherwise, if value is an absolute IRI or blank node identifier, the vocabulary mapping of result is set to value. If it is not an absolute IRI, or a blank node identifier, an invalid vocab mapping error has been detected and processing is aborted.
   7. If context has an @language key:
      1. Initialize value to the value associated with the @language key.
      2. If value is null, remove any default language from result.
      3. Otherwise, if value is string, the default language of result is set to lowercased value. If it is not a string, an invalid default language error has been detected and processing is aborted.
   8. Create a dictionary defined to use to keep track of whether or not a term has already been defined or currently being defined during recursion.
   9. For each key-value pair in context where key is not @base, @vocab, or @language, invoke the Create Term Definition algorithm, passing result for active context, context for local context, key, and defined.
4. Return result.

4.2.2 Algorithm §

The algorithm has four required inputs which are: an active context, a local context, a term, and a map defined.

1. If defined contains the key 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. Set the value associated with defined's term key to false. This indicates that the term definition is now being created but is not yet complete.
3. Since keywords cannot be overridden, term must not be a keyword. Otherwise, a keyword redefinition error has been detected and processing is aborted.
4. Remove any existing term definition for term in active context.
5. Initialize value to a copy of the value associated with the key term in local context.
6. If value is null or value is a dictionary containing the key-value pair @id-null, set the term definition in active context to null, set the value associated with defined's key term to true, and return.
7. Otherwise, if value is a string, convert it to a dictionary consisting of a single member whose key is @id and whose value is value. Set simple term to true.
8. Otherwise, value must be a dictionary, if not, an invalid term definition error has been detected and processing is aborted. Set simple term to false.
9. Create a new term definition, definition.
10. If value contains the key @type:
    1. Initialize type to the value associated with the @type key, 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 using the IRI Expansion algorithm, passing active context, type for value, true for vocab, local context, and defined. If the expanded type is neither @id, nor @vocab, nor an absolute IRI, an invalid type mapping error has been detected and processing is aborted.
    3. Set the type mapping for definition to type.
11. If value contains the key @reverse:
    1. If value contains @id or @nest, members, an invalid reverse property error has been detected and processing is aborted.
    2. If the value associated with the @reverse key is not a string, an invalid IRI mapping error has been detected and processing is aborted.
    3. Otherwise, set the IRI mapping of definition to the result of using the IRI Expansion algorithm, passing active context, the value associated with the @reverse key for value, true for vocab, local context, and defined. If the result is neither an absolute IRI nor a blank node identifier, i.e., it contains no colon (:), an invalid IRI mapping error has been detected and processing is aborted.
    4. If value contains an @container member, set the container mapping of definition to 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.
    5. Set the reverse property flag of definition to true.
    6. Set the term definition of term in active context to definition and the value associated with defined's key term to true and return.
12. Set the reverse property flag of definition to false.
13. If value contains the key @id and its value does not equal term:
    1. If the value associated with the @id key is not a string, an invalid IRI mapping error has been detected and processing is aborted.
    2. Otherwise, set the IRI mapping of definition to the result of using the IRI Expansion algorithm, passing active context, the value associated with the @id key for value, true for vocab, local context, and defined. If the resulting IRI mapping is neither a keyword, nor an absolute 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.
    3. If term does not contain a colon (:), simple term is true, and the, IRI mapping of definition ends with a URI gen-delim character, set the prefix flag in definition to true.
14. Otherwise if the term contains a colon (:):
    1. If term is a compact IRI with a prefix that is a key 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 absolute IRI or blank node identifier. Set the IRI mapping of definition to term.
15. 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.
16. If value contains the key @container:
    1. Initialize container to the value associated with the @container key, which must be either @graph, @id, @index, @language, @list, @set, or @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, @id, @type, @language in any order . Otherwise, an invalid container mapping has been detected and processing is aborted.
    2. If processingMode is json-ld-1.0 and the container value is @graph, @id, or @type, or is otherwise not a string, an invalid container mapping has been detected and processing is aborted.
    3. Set the container mapping of definition to container.
17. If value contains the key @context:
    1. If processingMode 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 key, which is treated as a local context.
    3. Invoke the Context Processing algorithm using the active context and context as local context. If any error is detected, an invalid scoped context error has been detected and processing is aborted.
    4. Set the local context of definition to context.
18. If value contains the key @language and does not contain the key @type:
    1. Initialize language to the value associated with the @language key, which must be either null or a string. Otherwise, an invalid language mapping error has been detected and processing is aborted.
    2. If language is a string set it to lowercased language. Set the language mapping of definition to language.
19. If value contains the key @nest:
    1. If processingMode is json-ld-1.0, an invalid term definition has been detected and processing is aborted.
    2. Initialize nest value in defined to the value associated with the @nest key, 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.
20. If value contains the key @prefix:
    1. If processingMode is json-ld-1.0, or if term contains a colon (:), an invalid term definition has been detected and processing is aborted.
    2. Initialize the prefix flag to the value associated with the @prefix key, which must be a boolean. Otherwise, an invalid @prefix value error has been detected and processing is aborted.
21. If the value contains any key other than @id, @reverse, @container, @context, @nest, @prefix, or @type, an invalid term definition error has been detected and processing is aborted.
22. Set the term definition of term in active context to definition and set the value associated with defined's key term to true.

5.1.2 Algorithm §

The algorithm takes three required and one optional input variables. The required inputs are an active context, an active property, and an element to be expanded. The optional input is the flag frame expansion the allows special forms of input used for frame expansion. To begin, the active property is set to null, and element is set to the JSON-LD input. If not passed, the frame expansion flag is set to false.

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

1. If element is null, return null.
2. If active property is @default, set the frame expansion flag to false.
3. If element is a scalar,
   1. If active property is null or @graph, drop the free-floating scalar by returning null.
   2. Return the result of the Value Expansion algorithm, passing the active context, active property, and element as value.
4. 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, and the frame expansion flag.
      2. If the active property is @list or its container mapping includes @list, the expanded item must not be an array or a list object, otherwise a list of lists error has been detected and processing is aborted.
      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.
5. Otherwise element is a dictionary.
6. If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
7. For each key/value pair in element where key expands to @type using the IRI Expansion algorithm, passing active context, key for value, and true for vocab:
   1. For each term which is a value of value ordered lexicographically, if term's term definition in active context has a local context, set active context to the result to the result of the Context Processing algorithm, passing active context and the value of the term's local context as local context.
8. Initialize an empty dictionary, result.
9. For each key and value in element, ordered lexicographically by key:
   1. If key is @context, continue to the next key.
   2. Set expanded property to the result of using the IRI Expansion algorithm, passing active context, key for value, and true for vocab.
   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 has already an expanded property member, a colliding keywords error has been detected and processing is aborted.
      3. If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative. When the frame expansion flag is set, value may be an empty dictionary, or an array of one or more strings. expanded value will be an array of one or more of these, with string values expanded using the IRI Expansion Algorithm.
      4. If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items. When the frame expansion flag is set, value may also be an empty dictionary.
      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, and the frame expansion flag, ensuring that expanded value is an array of one or more dictionaries.
      6. If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member 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 member depends on the existence of an @value member. When the frame expansion flag is set, value may also be an empty dictionary or an array of scalar values. expanded value will be null, or an array of one or more scalar values.
      7. If expanded property is @language and value is not a string, an invalid language-tagged string error has been detected and processing is aborted. Otherwise, set expanded value to lowercased value. When the frame expansion flag is set, value may also be an empty dictionary or an array of zero or strings. expanded value will be an array of one or more string values converted to lower case.
      8. If expanded property is @index and value is not a string, an invalid @index value error has been detected and processing is aborted. Otherwise, set expanded value to value.
      9. 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, and the frame expansion flag.
         3. If expanded value is a list object, a list of lists error has been detected and processing is aborted.
      10. If expanded property is @set, set expanded value to the result of using this algorithm recursively, passing active context, active property, value for element, and the frame expansion flag.
      11. If expanded property is @reverse and value is not a dictionary, an invalid @reverse value error has been detected and processing is aborted. Otherwise
          1. Initialize expanded value to the result of using this algorithm recursively, passing active context, @reverse as active property, value as element, and the frame expansion flag.
          2. If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
             1. If result does not have a property member, create one and set its value to an empty array.
             2. Append item to the value of the property member of result.
          3. If expanded value contains members other than @reverse:
             1. If result does not have an @reverse member, create one and set its value to an empty dictionary.
             2. Reference the value of the @reverse member in result using the variable reverse map.
             3. 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. If reverse map has no property member, create one and initialize its value to an empty array.
                   3. Append item to the value of the property member in reverse map.
          4. Continue with the next key from element.
      12. If expanded property is @nest, add key to nests, initializing it to an empty array, if necessary. Continue with the next key from element.
      13. When the frame expansion flag is set, if expanded property is any other framing keyword (@explicit, @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, and the frame expansion flag.
      14. Unless expanded value is null, set the expanded property member of result to expanded value.
      15. Continue with the next key from element.
   5. If key's term definition in active context has a local context, set term context to the result of the Context Processing algorithm, passing active context and the value of the key's local context as local context. Otherwise, set term context to active context.
   6. Set container mapping to key's container mapping in term context.
   7. If container mapping includes @language and value is a dictionary then value is expanded from a language map as follows:
      1. Initialize expanded value to an empty array.
      2. For each key-value pair language-language value in value, ordered lexicographically by language:
         1. If language value is not an array set it to an array containing only language value.
         2. For each item in language value:
            1. item must be a string or null, otherwise an invalid language map value error has been detected and processing is aborted.
            2. Append a dictionary to expanded value that consists of two key-value pairs: (@value-item) and (@language-lowercased language), unless item is null. If language is @none, or expands to @none, do not set the @language member.
   8. Otherwise, if container mapping includes @index, @type, or @id and value is a dictionary then value is expanded from an map as follows:
      1. Initialize expanded value to an empty array.
      2. For each key-value pair index-index value in value, ordered lexicographically by index:
         1. If container mapping includes @type, and index's term definition in term context has a local context, set map context to the result of the Context Processing algorithm, passing term context as active context and the value of the index's local context as local context. Otherwise, set map context to term context.
         2. Set expanded index to the result of using the IRI Expansion algorithm, passing active context, index, and true for vocab.
         3. If index value is not an array set it to an array containing only index value.
         4. 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, and the frame expansion flag.
         5. For each item in index value:
            1. If container mapping includes @graph and if item is not a graph object, set item to a new dictionary containing the key-value pair @graph-item, ensuring that the value is represented using an array.
            2. If container mapping includes @index and item does not have the key @index and expanded index is not @none, add the key-value pair (@index-index) to item.
            3. Otherwise, if container mapping includes @id and item does not have the key @id, add the key-value pair (@id-expanded index) to item, where expanded index is set to the result of using the IRI Expansion algorithm, passing active context, index, and true for document relative, unless expanded index is already set to @none.
            4. Otherwise, if container mapping includes @type set types to the concatenation of expanded index with any existing values of @type in item. If expanded index is @none, do not concatenate expanded index to types. Add the key-value pair (@type-types) to item.
            5. Append item to expanded value.
   9. Otherwise, initialize expanded value to the result of using this algorithm recursively, passing term context as active context, key for active property, value for element, and the frame expansion flag.
   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 dictionary containing the key-value pair @list-expanded value.
   12. If container mapping includes @graph, convert expanded value into an array, if necessary, then convert each value ev in expanded value into a graph object:
       1. If ev is not a graph object, convert it into one by creating a dictionary containing the key-value pair @graph-ev where ev is represented as an array.
   13. Otherwise, if the term definition associated to key indicates that it is a reverse property
       1. If result has no @reverse member, create one and initialize its value to an empty dictionary.
       2. Reference the value of the @reverse member 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 member, create one and initialize its value to an empty array.
          3. Append item to the value of the expanded property member of reverse map.
   14. Otherwise, if key is not a reverse property:
       1. If result does not have an expanded property member, create one and initialize its value to an empty array.
       2. Append expanded value to value of the expanded property member of result.
   15. For each key nesting-key in nests
       1. Set 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 dictionary, or any key within nested value expands to @value, an invalid @nest value error has been detected and processing is aborted.
          2. Recursively repeat step 7 using nested value for element.
10. If result contains the key @value:
    1. The result must not contain any keys other than @value, @language, @type, and @index. It must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
    2. If the value of result's @value key is null, then set result to null.
    3. Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
    4. Otherwise, if the result has an @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
11. Otherwise, if result contains the key @type and its associated value is not an array, set it to an array containing only the associated value.
12. Otherwise, if result contains the key @set or @list:
    1. The result must contain at most one other key and that key must be @index. Otherwise, an invalid set or list object error has been detected and processing is aborted.
    2. If result contains the key @set, then set result to the key's associated value.
13. If result contains only the key @language, set result to null.
14. If active property is null or @graph, drop free-floating values as follows:
    1. If result is an empty dictionary or contains the keys @value or @list, set result to null.
    2. Otherwise, if result is a dictionary whose only key is @id, set result to null. When the frame expansion flag is set, a dictionary containing only the @id key is retained.
15. Return result.

If, after the above algorithm is run, the result is a dictionary that contains only an @graph key, set the result to the value of @graph's value. Otherwise, if the result is null, set it to an empty array. Finally, if the result is not an array, then set the result to an array containing only the result.

5.2.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 dictionary containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
2. If active property has a type mapping in active context that is @vocab, and the value is a string, return a new dictionary containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, true for vocab, and true for document relative.
3. Otherwise, initialize result to a dictionary with an @value member whose value is set to value.
4. If active property has a type mapping in active context, other than @id or @vocab, add an @type member to result and set its value to the value associated with the type mapping.
5. Otherwise, if value is a string:
   1. If a language mapping is associated with active property in active context, add an @language to result and set its value to the language code associated with the language mapping; unless the language mapping is set to null in which case no member is added.
   2. Otherwise, if the active context has a default language, add an @language to result and set its value to the default language.
6. Return result.

6.1.2 Algorithm §

The algorithm takes five required input variables: an active context, an inverse context, an active property, an element to be compacted, and a flag compactArrays To begin, the active context is set to the result of performing Context Processing on the passed context, the inverse context is set to the result of performing the Inverse Context Creation algorithm on active context, the active property is set to null, element is set to the result of performing the Expansion algorithm on the JSON-LD input, and, if not passed, compactArrays is set to true.

1. If the term definition for active property has a local context:
   1. Set active context to the result of the Context Processing algorithm, passing active context and the value of the active property's local context as local context.
   2. Set inverse context using the Inverse Context Creation algorithm using active 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, inverse context, active property, and item for element.
      2. If compacted item is not null, then append it to result.
   3. If result contains only one item (it has a length of 1), active property is not @graph or @set, or the container mapping for active property in active context does not include @list or @set, and compactArrays is true, set result to its only item.
   4. Return result.
4. Otherwise element is a dictionary. If element has an @value or @id member and the result of using the Value Compaction algorithm, passing active context, inverse context, active property,and element as value is a scalar, return that result.
5. Initialize inside reverse to true if active property equals @reverse, otherwise to false.
6. Initialize result to an empty dictionary.
7. If element has a @type member, create a new array compacted types initialized by transforming each expanded type of that member into it's compacted form using the IRI Compaction algorithm, passing active context, inverse context, expanded type for var, and true for vocab. Then, for each term in compacted types ordered lexicographically:
   1. If the term definition for term has a local context:
      1. Set active context to the result of the Context Processing algorithm, passing active context and the value of term's local context as local context.
      2. Set inverse context using the Inverse Context Creation algorithm using active context.
8. For each key expanded property and value expanded value in element, ordered lexicographically by expanded property:
   1. If expanded property is @id or @type:
      1. If expanded value is a string, then initialize compacted value to the result of using the IRI Compaction algorithm, passing active context, inverse context, expanded value for var, and true for vocab if expanded property is @type, false otherwise.
      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 to the result of of using the IRI Compaction algorithm, passing active context, inverse context, expanded type for var, and true for vocab.
            2. Append term, to compacted value.
         3. If compacted value contains only one item (it has a length of 1), then set compacted value to its only item.
      3. Initialize alias to the result of using the IRI Compaction algorithm, passing active context, inverse context, expanded property for var, and true for vocab.
      4. Add a member alias to result whose value is set to compacted value and continue to the next expanded property.
   2. If expanded property is @reverse:
      1. Initialize compacted value to the result of using this algorithm recursively, passing active context, inverse context, @reverse for active property, and expanded value for element.
      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. If the term definition for property in the active context has a container mapping including @set or compactArrays is false, and value is not an array, set value to a new array containing only value.
            2. If property is not a member of result, add one and set its value to value.
            3. Otherwise, if the value of the property member of result is not an array, set it to a new array containing only the value. Then append value to its value if value is not an array, otherwise append each of its items.
            4. Remove the property member from compacted value.
      3. If compacted value has some remaining members, i.e., it is not an empty dictionary:
         1. Initialize alias to the result of using the IRI Compaction algorithm, passing active context, inverse context, @reverse for var, and true for vocab.
         2. Set the value of the alias member of result to compacted value.
      4. Continue with the next expanded property from element.
   3. If expanded property is @preserve then:
      1. Initialize compacted value to the result of using this algorithm recursively, passing active context, inverse context, property for active property, and expanded value for element.
      2. Add expanded value as the value of @preserve in result unless expanded value is an empty array.
   4. 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 property by continuing to the next expanded property.
   5. Otherwise, if expanded property is @index, @value, or @language:
      1. Initialize alias to the result of using the IRI Compaction algorithm, passing active context, inverse context, expanded property for var, and true for vocab.
      2. Add a member alias to result whose value is set to expanded value and continue with the next expanded property.
   6. If expanded value is an empty array:
      1. Initialize item active property to the result of using the IRI Compaction algorithm, passing active context, inverse context, expanded property for var, expanded value for value, true for vocab, and inside reverse.
      2. If the term definition for item active property in the active context has a nest value, that value (nest term) must be @nest, or a term in the active context that expands to @nest, otherwise an invalid @nest value error has been detected, and processing is aborted. If result does not have the key that equals nest term, initialize it to an empty JSON object (nest object). If nest object does not have the key that equals item active property, set this key's value in nest object to an empty array.Otherwise, if the key's value is not an array, then set it to one containing only the value.
      3. Otherwise, if result does not have the key that equals item active property, set this key's value in result to an empty array. Otherwise, if the key's value is not an array, then set it to one containing only the value.
   7. 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 to the result of using the IRI Compaction algorithm, passing active context, inverse context, expanded property for var, expanded item for value, true for vocab, and inside reverse.
      2. If the term definition for item active property in the active context has a nest value member, that value (nest term) must be @nest, or a term in the active context that expands to @nest, otherwise an invalid @nest value error has been detected, and processing is aborted. Set nest result to the value of nest term in result, initializing it to a new dictionary, if necessary; otherwise set nest result to result.
      3. Initialize container to null. If there is a container mapping for item active property in active context, set container to the first such value other than @set.
      4. Initialize as array to true or false depending on if the container mapping for item active property in active context includes @set or if item active property is @graph or @list.
      5. Initialize compacted item to the result of using this algorithm recursively, passing active context, inverse context, item active property for active property, expanded item for element if it does not contain the key @list and is not a graph object containing @list, otherwise pass the key's associated value for element.
      6. If expanded item is a list object:
         1. If compacted item is not an array, then set it to an array containing only compacted item.
         2. If container is not @list:
            1. Convert compacted item to a list object by setting it to a dictionary containing key-value pair where the key is the result of the IRI Compaction algorithm, passing active context, inverse context, @list for var, and compacted item for value and the value is the original compacted item.
            2. If expanded item contains the key @index, then add a key-value pair to compacted item where the key is the result of the IRI Compaction algorithm, passing active context, inverse context, @index as var, and the value associated with the @index key in expanded item as value.
         3. Otherwise, item active property must not be a key in nest result because there cannot be two list objects associated with an active property that has a container mapping; a compaction to list of lists error has been detected and processing is aborted.
      7. 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.
            2. Initialize map key to the result of calling the IRI Compaction algorithm passing active context and the value of @id in expanded item or @none if no such value exists as var, with vocab set to true if there is no @id member in expanded item.
            3. If compacted item is not an array and as array is true, set compacted item to an array containing that value.
            4. If map key is not a key in map object, then set this key's value in map object to compacted item. Otherwise, if the value is not an array, then set it to one containing only the value and then append compacted item to it.
         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.
            2. Initialize map key the value of @index in expanded item or @none, if no such value exists.
            3. If compacted item is not an array and as array is true, set compacted item to an array containing that value.
            4. If map key is not a key in map object, then set this key's value in map object to compacted item. Otherwise, if the value is not an array, then set it to one containing only the value and then append compacted item to it.
         3. Otherwise, if container includes @graph and expanded item is a simple graph object the value cannot be represented as a map object. If compacted item is not an array and as array is true, set compacted item to an array containing that value. If the value associated with the key that equals item active property in nest result is not an array, set it to a new array containing only the value. Then append compacted item to the value if compacted item is not an array, otherwise, concatenate it.
         4. Otherwise, container does not include @graph or otherwise does not match one of the previous cases, redo compacted item.
            1. Set compacted item to a new dictionary containing the key resulting from calling the IRI Compaction algorithm passing active context, @graph as var, and true for vocab using the original compacted item as a value.
            2. If expanded item contains the key @id, add the key resulting from calling the IRI Compaction algorithm passing active context, @id as var, and true for vocab using the value resulting from calling the IRI Compaction algorithm passing active context, the value of @id in expanded item as var.
            3. If expanded item contains the key @index, add the key resulting from calling the IRI Compaction algorithm passing active context, @index as var, and true for vocab using the value of @index in expanded item.
            4. If as array is true, set compacted item to an array containing that value.
            5. Then append compacted item to the value if compacted item is not an array, otherwise, concatenate it.
      8. Otherwise, if container includes @language, @index, @id, or @type and container does not include @graph:
         1. If item active property is not a key in nest result, initialize it to an empty dictionary. Initialize map object to the value of item active property in nest result.
         2. Set container key to the result of calling the IRI Compaction algorithm passing active context, either @language, @index, @id, or @type based on the contents of container, as var, and true for vocab.
         3. If container includes @language and expanded item contains the key @value, then set compacted item to the value associated with its @value key. Set map key to the value of @language in expanded item, if any.
         4. If container includes @index set map key to the value of @index in expanded item, if any, and remove container key from compacted item.
         5. If container includes @id, set map key to the value of container key in compacted item and remove container key from compacted item.
         6. If container is @type, set map key to the first value of container key in compacted item, if any. If there are remaining values in compacted item for compacted container, set the value of compacted container in compacted value to those remaining values. Otherwise, remove that key-value pair from compacted item.
         7. If compacted item is not an array and as array is true, set compacted item to an array containing that value.
         8. If map key is null, set it to the result of calling the IRI Compaction algorithm passing active context, @none as var, and true for vocab.
         9. If map key is not a key in map object, then set this key's value in map object to compacted item. Otherwise, if the value is not an array, then set it to one containing only the value and then append compacted item to it.
      9. Otherwise,
         1. If compactArrays is false, as array is true and compacted item is not an array, set it to a new array containing only compacted item.
         2. If item active property is not a key in result then add the key-value pair, (item active property-compacted item), to nest result.
         3. Otherwise, if the value associated with the key that equals item active property in nest result is not an array, set it to a new array containing only the value. Then append compacted item to the value if compacted item is not an array, otherwise, concatenate it.
9. Return result.

If, after the algorithm outlined above is run, result is an empty array, replace it with a new dictionary. Otherwise, if result is an array, replace it with a new dictionary with a single member whose key is the result of using the IRI Compaction algorithm, passing active context, inverse context, and @graph as var and whose value is the array result.

Finally, if a non-empty context has been passed, add an @context member to result and set its value to the passed context.

6.2.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 dictionary.
2. Initialize default language to @none. If the active context has a default language, set default language to it.
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 lexicographically order .
   3. Initialize var to the value of the IRI mapping for the term definition.
   4. If var is not a key in result, add a key-value pair where the key is var and the value is an empty dictionary to result.
   5. Reference the value associated with the var member in result using the variable container map.
   6. If container map has no container member, create one and set its value to a new dictionary with three members. The first member is @language and its value is a new empty dictionary, the second member is @type and its value is a new empty dictionary, and the third member is @any and its value is a new dictionary with the member @none set to the term being processed.
   7. Reference the value associated with the container member in container map using the variable type/language map.
   8. If the term definition indicates that the term represents a reverse property:
      1. Reference the value associated with the @type member in type/language map using the variable type map.
      2. If type map does not have an @reverse member, create one and set its value to the term being processed.
   9. Otherwise, if term definition has a type mapping:
      1. Reference the value associated with the @type member in type/language map using the variable type map.
      2. If type map does not have a member corresponding to the type mapping in term definition, create one and set its value to the term being processed.
   10. Otherwise, if term definition has a language mapping (might be null):
       1. Reference the value associated with the @language member in type/language map using the variable language map.
       2. If the language mapping equals null, set language to @null; otherwise set it to the language code in language mapping.
       3. If language map does not have a language member, create one and set its value to the term being processed.
   11. Otherwise:
       1. Reference the value associated with the @language member in type/language map using the variable language map.
       2. If language map does not have a default language member, create one and set its value to the term being processed.
       3. If language map does not have an @none member, create one and set its value to the term being processed.
       4. Reference the value associated with the @type member in type/language map using the variable type map.
       5. If type map does not have an @none member, create one and set its value to the term being processed.
4. Return result.

6.3.2 Algorithm §

This algorithm takes three required inputs and three optional inputs. The required inputs are an active context, an inverse 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 vocab and reverse are both set to false.

1. If var is null, return null.
2. If vocab is true and var is a key in inverse context:
   1. Initialize default language to active context's default language, if it has one, otherwise to @none.
   2. If value is a dictionary containing the property @preserve, 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.
   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 dictionary, that contains the key @index, 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 a not key in value, then append @list to containers.
      2. Initialize list to the array associated with the key @list 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 the key @value:
            1. If item contains the key @language, then set item language to its associated value.
            2. Otherwise, if item contains the key @type, set item type to its associated value.
            3. Otherwise, set item language to @null.
         3. Otherwise, set item type to @id.
         4. If common language is null, set it to item language.
         5. Otherwise, if item language does not equal common language and item contains the key @value, then set common language to @none because list items have conflicting languages.
         6. If common type is null, set it 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 it to @none.
      6. If common type is null, set it 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 the key @index, append the values @graph@index and @graph@index@set to containers.
      2. If the value contains the key @id, 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 the key @index, append the values @graph@index and @graph@index@set to containers.
      5. If the value does not contain the key @id, append the values @graph@id and @graph@id@set to containers.
      6. Append the values @index and @index@set to containers.
   9. Otherwise:
      1. If value is a value object:
         1. If value contains the key @language and does not contain the key @index, then set type/language value to its associated value and, append @language and @language@set to containers.
         2. Otherwise, if value contains the key @type, 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 json-ld-1.1 and value does not contain the key @index, append @index and @index@set to containers.
   12. If processing mode is json-ld-1.1 and value contains only the key @value, append @language and @language@set to containers.
   13. If type/language value is null, set it 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 has an @id member:
       1. If the result of using the IRI compaction algorithm, passing active context, inverse context, the value associated with the @id key in value for var, and true for vocab has a term definition in the active context with an IRI mapping that equals the value associated with the @id key 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 an empty list object, set type/language to @any.
   18. Initialize term to the result of the Term Selection algorithm, passing inverse context, var, containers, type/language, and preferred values.
   19. If term is not null, return term.
3. 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.
4. 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 tore the created compact IRI, if any.
5. For each key term and value term definition in the active context:
   1. If the term definition is null, its IRI mapping equals var, its IRI mapping is not a substring at the beginning of var, or the term definition does not contain the prefix flag having a value of true, the term cannot be used as a prefix. Continue with the next term.
   2. Initialize candidate by concatenating term, a colon (:), and the substring of var that follows after the value of the term 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 the term definition has an IRI mapping that equals var and value is null, set compact IRI to candidate.
6. If compact IRI is not null, return compact IRI.
7. If vocab is false, transform var to a relative IRI using the base IRI from active context, if it exists.
8. Finally, return var as is.

6.4.2 Algorithm §

This algorithm has five required inputs. They are: an inverse 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. Initialize container map to the value associated with var in the inverse context.
2. For each item container in containers:
   1. If container is not a key in 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 member in container map.
   3. Initialize value map to the value associated with type/language member in type/language map.
   4. For each item in preferred values:
      1. If item is not a key in 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 member in value map.
3. No matching term has been found. Return null.

6.5.2 Algorithm §

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

1. Initialize number members to the number of members value contains.
2. If value has an @index member and the container mapping associated to active property includes @index, decrease number members by 1.
3. If number members is greater than 2, return value as it cannot be compacted.
4. If value has an @id member:
   1. If number members is 1 and the type mapping of active property is set to @id, return the result of using the IRI compaction algorithm, passing active context, inverse context, and the value of the @id member for var.
   2. Otherwise, if number members is 1 and the type mapping of active property is set to @vocab, return the result of using the IRI compaction algorithm, passing active context, inverse context, the value of the @id member for var, and true for vocab.
   3. Otherwise, return value as is.
5. Otherwise, if value has an @type member whose value matches the type mapping of active property, return the value associated with the @value member of value.
6. Otherwise, if value has an @language member whose value matches the language mapping of active property, return the value associated with the @value member of value.
7. Otherwise, if number members equals 1 and either the value of the @value member is not a string, or the active context has no default language, or the language mapping of active property is set to null,, return the value associated with the @value member.
8. Otherwise, return value as is.

7.1.2 Algorithm §

The algorithm takes two input variables, an element to flatten and an optional context used to compact the flattened document. If not passed, context is set to null.

This algorithm generates new blank node identifiers and relabels existing blank node identifiers. The Generate Blank Node Identifier algorithm keeps an identifier map and a counter to ensure consistent relabeling and avoid collisions. Thus, before this algorithm is run, the identifier map is reset and the counter is initialized to 0.

1. Initialize node map to a dictionary consisting of a single member whose key is @default and whose value is an empty dictionary.
2. Perform the Node Map Generation algorithm, passing element and node map.
3. Initialize default graph to the value of the @default member of node map, which is a dictionary representing the default graph.
4. For each key-value pair graph name-graph in node map where graph name is not @default, perform the following steps:
   1. If default graph does not have a graph name member, create one and initialize its value to a dictionary consisting of an @id member whose value is set to graph name.
   2. Reference the value associated with the graph name member in default graph using the variable entry.
   3. Add an @graph member to entry and set it to an empty array.
   4. For each id-node pair in graph ordered by id, add node to the @graph member of entry, unless the only member of node is @id.
5. Initialize an empty array flattened.
6. For each id-node pair in default graph ordered by id, add node to flattened, unless the only member of node is @id.
7. If context is null, return flattened.
8. Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result has only the @graph keyword (or its alias) at the top-level other than @context, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.

7.2.2 Algorithm §

The algorithm takes as input an expanded JSON-LD document element and a reference to a dictionary node map. Furthermore it has the optional parameters active graph (which defaults to @default), an active subject, active property, and a reference to a dictionary 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 dictionary. Reference the dictionary which is the value of the active graph member of node map using the variable graph. If the active subject is null, set node to null otherwise reference the active subject member of graph using the variable node.
3. If element has an @type member, perform for each item the following steps:
   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 member, perform the following steps:
   1. If list is null:
      1. If node does not have an active property member, 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 member of node. If there is no item equivalent to element, append element to the array. Two dictionaries are considered equal if they have equivalent key-value pairs.
   2. Otherwise, append element to the @list member of list.
5. Otherwise, if element has an @list member, perform the following steps:
   1. Initialize a new dictionary result consisting of a single member @list whose value is initialized to an empty array.
   2. Recursively call this algorithm passing the value of element's @list member for element, active graph, active subject, active property, and result for list.
   3. Append result to the value of the active property member of node.
6. Otherwise element is a node object, perform the following steps:
   1. If element has an @id member, set id to its value and remove the member 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 a member id, create one and initialize its value to a dictionary consisting of a single member @id whose value is id.
   4. Reference the value of the id member of graph using the variable node.
   5. If active subject is a dictionary, a reverse property relationship is being processed. Perform the following steps:
      1. If node does not have an active property member, 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 member of node. If there is no item equivalent to active subject, append active subject to the array. Two dictionaries are considered equal if they have equivalent key-value pairs.
   6. Otherwise, if active property is not null, perform the following steps:
      1. Create a new dictionary reference consisting of a single member @id whose value is id.
      2. If list is null:
         1. If node does not have an active property member, 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 member of node. If there is no item equivalent to reference, append reference to the array. Two dictionaries are considered equal if they have equivalent key-value pairs.
      3. Otherwise, append reference to the @list member of list.
   7. If element has an @type key, append each item of its associated array to the array associated with the @type key of node unless it is already in that array. Finally remove the @type member from element.
   8. If element has an @index member, set the @index member of node to its value. If node has already an @index member with a different value, a conflicting indexes error has been detected and processing is aborted. Otherwise, continue by removing the @index member from element.
   9. If element has an @reverse member:
      1. Create a dictionary referenced node with a single member @id whose value is id.
      2. Set reverse map to the value of the @reverse member 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 dictionary for active subject indicates to the algorithm that a reverse property relationship is being processed.
      4. Remove the @reverse member from element.
   10. If element has an @graph member, recursively invoke this algorithm passing the value of the @graph member for element, node map, and id for active graph before removing the @graph member from element.
   11. 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.
       2. If node does not have a property member, 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.3.2 Algorithm §

The algorithm takes a single input variable identifier which may be null. Between its executions, the algorithm needs to keep an identifier map to relabel existing blank node identifiers consistently and a counter to generate new blank node identifiers. The counter is initialized to 0 by default.

1. If identifier is not null and has an entry in the identifier map, return the mapped identifier.
2. Otherwise, generate a new blank node identifier by concatenating the string _:b and counter.
3. Increment counter by 1.
4. If identifier is not null, create a new entry for identifier in identifier map and set its value to the new blank node identifier.
5. Return the new blank node identifier.

8.1.2 Algorithm §

The algorithm takes a JSON-LD document element and returns an RDF dataset. Unless the produceGeneralizedRdf option is set to true, RDF triple containing a blank node predicate are excluded from output.

This algorithm generates new blank node identifiers and relabels existing blank node identifiers. The Generate Blank Node Identifier algorithm keeps an identifier map and a counter to ensure consistent relabeling and avoid collisions. Thus, before this algorithm is run, the identifier map is reset and the counter is initialized to 0.

1. Expand element according to the Expansion algorithm.
2. Generate a node map according to the Node Map Generation algorithm.
3. Initialize an empty RDF dataset dataset.
4. For each graph name and graph in node map ordered by graph name:
   1. If graph name is a relative IRI, continue with the next graph name-graph pair.
   2. Initialize triples as an empty array.
   3. For each subject and node in graph ordered by subject:
      1. If subject is a relative IRI, 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, append a triple composed of subject, rdf:type, and type to triples.
         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.
         4. Otherwise, if property is a relative IRI, continue with the next property-values pair.
         5. Otherwise, property is an absolute IRI or blank node identifier. For each item in values:
            1. If item is a list object, initialize list triples as an empty array and list head to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list triples. Append first a triple composed of subject, property, and list head to triples and finally append all triples from list triples to triples.
            2. Otherwise, item is a value object or a node object. Append a triple composed of subject, property, and the result of using the Object to RDF Conversion algorithm passing item to triples, unless the result is null, indicating a relative IRI that has to be ignored.
   4. If graph name is @default, add triples to the default graph in dataset.
   5. Otherwise, create a named graph in dataset composed of graph name and add triples.
5. Return dataset.

8.2.2 Algorithm §

The algorithm takes as its sole argument item which MUST be either a value object or node object.

1. If item is a node object and the value of its @id member is a relative IRI, return null.
2. If item is a node object, return the IRI or blank node identifier associated with its @id member.
3. Otherwise, item is a value object. Initialize value to the value associated with the @value member in item.
4. Initialize datatype to the value associated with the @type member of item or null if item does not have such a member.
5. If value is true or false, set value to the string true or false which is the canonical lexical form as described in section 8.6 Data Round Tripping If datatype is null, set it to xsd:boolean.
6. Otherwise, if value is a number with a non-zero fractional part (the result of a modulo‑1 operation) 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 section 8.6 Data Round Tripping. If datatype is null, set it to xsd:double.
7. Otherwise, if value is a number with no non-zero fractional part (the result of a modulo‑1 operation) or value is a number and datatype equals xsd:integer, convert value to a string in canonical lexical form of an xsd:integer as defined in [XMLSCHEMA11-2] and described in section 8.6 Data Round Tripping. If datatype is null, set it to xsd:integer.
8. Otherwise, if datatype is null, set it to xsd:string or rdf:langString, depending on if item has an @language member.
9. Initialize literal as an RDF literal using value and datatype. If item has an @language member, add the value associated with the @language key as the language tag of literal.
10. Return literal.

8.3.2 Algorithm §

The algorithm takes two inputs: an array list and an empty array list triples used for returning the generated triples.

1. If list is empty, return rdf:nil.
2. Otherwise, create an array bnodes composed of a newly generated blank node identifier for each entry in list.
3. Initialize an empty array list triples.
4. For each pair of subject from bnodes and item from list:
   1. Initialize object to the result of using the Object to RDF Conversion algorithm passing item to list triples.
   2. Unless object is null, append a triple composed of subject, rdf:first, and object.
   3. Set rest as the next entry in bnodes, or if that does not exist, rdf:nil. Append a triple composed of subject, rdf:rest, and rest to list triples.
5. Return the first blank node from bnodes or rdf:nil if bnodes is empty.

8.4.2 Algorithm §

The algorithm takes one required and two optional inputs: an RDF dataset dataset and the two flags use native types and use rdf:type that both default to false.

1. Initialize default graph to an empty dictionary.
2. Initialize graph map to a dictionary consisting of a single member @default whose value references default graph.
3. Initialize node usage map to an empty dictionary.
4. For each graph in dataset:
   1. If graph is the default graph, set name to @default, otherwise to the graph name associated with graph.
   2. If graph map has no name member, create one and set its value to an empty dictionary.
   3. If graph is not the default graph and default graph does not have a name member, create such a member and initialize its value to a new dictionary with a single member @id whose value is name.
   4. Reference the value of the name member in graph map using the variable node map.
   5. For each RDF triple in graph consisting of subject, predicate, and object:
      1. If node map does not have a subject member, create one and initialize its value to a new dictionary consisting of a single member @id whose value is set to subject.
      2. Reference the value of the subject member in node map using the variable node.
      3. If object is an IRI or blank node identifier, and node map does not have an object member, create one and initialize its value to a new dictionary consisting of a single member @id whose value is set to object.
      4. If predicate equals rdf:type, the use rdf:type flag is not true, and object is an IRI or blank node identifier, append object to the value of the @type member of node; unless such an item already exists. If no such member exists, create one and initialize it to an array whose only item is object. Finally, continue to the next RDF triple.
      5. Set value to the result of using the RDF to Object Conversion algorithm, passing object and use native types.
      6. If node does not have an predicate member, create one and initialize its value to an empty array.
      7. If there is no item equivalent to value in the array associated with the predicate member of node, append a reference to value to the array. Two JSON objects are considered equal if they have equivalent key-value pairs.
      8. If object is a blank node identifier or IRI, it might represent the list node:
         1. If the object member of node usage map does not exist, initialize it to a new empty array.
         2. Append the value of the @id member of node to the object member of node usage map.
         3. If the object member of node map has no usages member, create one and initialize it to an empty array.
         4. Reference the usages member of the object member of node map using the variable usages.
         5. Append a new dictionary consisting of three members, node, property, and value to the usages array. The node member is set to a reference to node, property to predicate, and value to a reference to value.
5. For each name and graph object in graph map:
   1. If graph object has no rdf:nil member, continue with the next name-graph object pair as the graph does not contain any lists that need to be converted.
   2. Initialize nil to the value of the rdf:nil member of graph object.
   3. For each item usage in the usages member of nil, perform the following steps:
      1. Initialize node to the value of the value of the node member of usage, property to the value of the property member of usage, and head to the value of the value member of usage.
      2. Initialize two empty arrays list and list nodes.
      3. While property equals rdf:rest, the value of the @id member of node is a blank node identifier, the array value of the member of node usage map associated with the @id member of node has only one member, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Perform the following steps to traverse the list backwards towards its head:
         1. Append the only item of rdf:first member of node to the list array.
         2. Append the value of the @id member of node to the list nodes array.
         3. Initialize node usage to the only item of the usages member of node.
         4. Set node to the value of the node member of node usage, property to the value of the property member of node usage, and head to the value of the value member of node usage.
         5. If the @id member of node is an IRI instead of a blank node identifier, exit the while loop.
      4. If property equals rdf:first, i.e., the detected list is nested inside another list
         1. and the value of the @id of node equals rdf:nil, i.e., the detected list is empty, continue with the next usage item. The rdf:nil node cannot be converted to a list object as it would result in a list of lists, which isn't supported.
         2. Otherwise, the list consists of at least one item. We preserve the head node and transform the rest of the linked list to a list object.
         3. Set head id to the value of the @id member of head.
         4. Set head to the value of the head id member of graph object so that all it's properties can be accessed.
         5. Then, set head to the only item in the value of the rdf:rest member of head.
         6. Finally, remove the last item of the list array and the last item of the list nodes array.
      5. Remove the @id member from head.
      6. Reverse the order of the list array.
      7. Add an @list member to head and initialize its value to the list array.
      8. For each item node id in list nodes, remove the node id member from graph object.
6. Initialize an empty array result.
7. For each subject and node in default graph ordered by subject:
   1. If graph map has a subject member:
      1. Add an @graph member to node and initialize its value to an empty array.
      2. For each key-value pair s-n in the subject member of graph map ordered by s, append n to the @graph member of node after removing its usages member, unless the only remaining member of n is @id.
   2. Append node to result after removing its usages member, unless the only remaining member of node is @id.
8. Return result.

8.5.2 Algorithm §

This algorithm takes two required inputs: a value to be converted to a dictionary and a flag use native types.

1. If value is an IRI or a blank node identifier, return a new dictionary consisting of a single member @id whose value is set to value.
2. Otherwise value is an RDF literal:
   1. Initialize a new empty dictionary result.
   2. Initialize converted value to value.
   3. Initialize type to null
   4. If use native types is true
      1. If the datatype IRI of value equals xsd:string, set converted value to the lexical form of value.
      2. Otherwise, if the datatype IRI of value equals xsd:boolean, set converted value to true if the lexical form of value matches true, or false if it matches false. If it matches neither, set type to xsd:boolean.
      3. Otherwise, if the datatype IRI of value equals xsd:integer or xsd:double and its lexical form is a valid xsd:integer or xsd:double according [XMLSCHEMA11-2], set converted value to the result of converting the lexical form to a JSON number.
   5. Otherwise, if value is a language-tagged string add a member @language to result and set its value to the language tag of value.
   6. Otherwise, set type to the datatype IRI of value, unless it equals xsd:string which is ignored.
   7. Add a member @value to result whose value is set to converted value.
   8. If type is not null, add a member @type to result whose value is set to type.
   9. Return result.