JSON-LD Algorithms 1.0

5.1 Algorithm Terms

active graph

The name of the currently active graph that the processor should use when processing.

active subject

The currently active subject that the processor should use when processing.

active property

The currently active property that the processor should use when processing. The active property is represented in the original lexical form, which is used for finding type mappings in the active context.

active object

The currently active object that the processor should use when processing.

active context

A context that is used to resolve terms while the processing algorithm is running. The active context is the context contained within the processor state.

local context

A context that is specified within a JSON object, specified via the @context keyword.

processor state

The processor state, which includes the active context, active subject, and active property. The processor state is managed as a stack with elements from the previous processor state copied into a new processor state when entering a new JSON object.

JSON-LD input

The JSON-LD data structure that is provided as input to the algorithm.

JSON-LD output

The JSON-LD data structure that is produced as output by the algorithm.

term

A term is a short word defined in a context that may be expanded to an IRI

compact IRI

A compact IRI is has the form of prefix:suffix and is used as a way of expressing an IRI without needing to define separate term definitions for each IRI contained within a common vocabulary identified by prefix.

node object

A node object represents zero or more properties of a node in the JSON-LD graph serialized by the JSON-LD document. A JSON object is a node object if it exists outside of the JSON-LD context and:

• it does not contain the @value, @list, or @set keywords, or
• it is not the top-level JSON object in the JSON-LD document containing the @graph keyword.

list object

A list object is a JSON object that has a @list member.

scalar

A scalar is either a JSON string, number, true, or false.

quad

An RDF triple as specified by [RDF-CONCEPTS] augmented with a a fourth component, a graph name.

5.2 Expansion Algorithm

The algorithm takes three input variables: an active context, an active property, and an element to be expanded. To begin, the active context is set to the result of performing, Context Processing on the passed expandContext, or empty if expandContext is null, active property is set to null, and element is set to the JSON-LD input. This algorithm expects the JSON-LD input to be a well-formed JSON-LD document as defined in [JSON-LD].

1. If element is a scalar, expand it according to the Value Expansion algorithm, passing copies of the active context and active property and return.
2. If element is null, return.
3. If element is an array,
   1. initialize an empty array result.
   2. Expand each item by recursively using this algorithm, passing copies of the active context and active property.
   3. If the active property's container mapping is set to @list and the expanded item is an array or a list object trigger a LIST_OF_LISTS_DETECTED error.
   4. If the expanded item is null, drop it.
   5. Otherwise, if the expanded item is an array, merge its entries with result's entries.
   6. Otherwise, append item to result.
   7. Finally, set element to result and return.
4. Otherwise, element must be an object.
   1. If element has a @context member, update the active context according to the steps outlined in Context Processing and remove the @context member.
   2. Initialize an empty JSON object result and
   3. then process each property and value in element ordered by property as follows:
      1. If the active context contains a property generator for property set expanded property to its IRIs, otherwise set it to the result of expanding property according to the steps outlined in IRI Expansion (passing true for the vocabRelative flag).
      2. If expanded property is null, skip the current property-value pair and continue to the next property-value pair in element.
      3. If expanded property is a keyword, process it as follows:
         1. If expanded property equals @id, set the @id member of result to the result of expanding value according the IRI Expansion algorithm (passing true for the documentRelative flag). If value is not a string trigger an INVALID_ID_VALUE error.
         2. If expanded property equals @type, set the @type member of result to the result of expanding value according the IRI Expansion algorithm (passing true for both the documentRelative and the vocabRelative flag). If value is neither a string nor an array of strings trigger an INVALID_TYPE_VALUE error. Empty arrays are ignored.
         3. If expanded property equals @value, set the @value member of result to value. If value is neither a scalar nor null trigger an INVALID_VALUE_OBJECT_VALUE error.
         4. If expanded property equals @language, set the @language member of result to the lowercased value. If value is not a string, trigger an INVALID_LANGUAGE_VALUE error.
         5. If expanded property equals @annotation, set the @annotation member of result to value. If value is not a string trigger an INVALID_ANNOTATION_VALUE error.
         6. If expanded property equals @set or @list, set the expanded property member of result to the result of expanding value by recursively using this algorithm, passing copies of the active context and active property.
         7. If expanded property equals @graph, set the @graph member of result to the result of expanding value by recursively using this algorithm, passing copies of the active context and @graph as active property.
         8. Continue with the next property-value pair from element.
      4. If expanded property is not an absolute IRI,i.e., it doesn't contain a colon, continue with the next member from element.
      5. Otherwise, if property's container mapping is set to @language
         1. Initialize a new empty array language map values.
         2. Process each key-val pair of value ordered by key as follows:
            1. If val is not an array, transform it to one.
            2. For each item of val, construct a new JSON object consisting of two members: @value set to the currently processed item and @language set to the lowercased key. If val is not a string, trigger a LANGUAGE_MAP_INVALID_VALUE error. Otherwise append the object to language map values.
         3. Set value to language map values.
      6. Otherwise, if property's container mapping is set to @annotation
         1. Initialize a new empty array annotation map values.
         2. Process each key-val pair of value ordered by key as follows:
            1. If val is not an array, transform it to one.
            2. Expand val by recursively using this algorithm, passing copies of the active context and active property.
            3. Add to each item of val a member @annotation set to key if no such member exists yet and append the resulting JSON object to annotation map values.
         3. Set value to annotation map values.
      7. Otherwise, expand value by recursively using this algorithm, passing copies of the active context and property as active property.
      8. If the expanded value equals null, continue with the next property-value pair from element.
      9. If property's container mapping is set to @list and value is either not an JSON object or a JSON object without an @list member, replace value with a JSON object with an @list member whose value is set to value (wrapped in an array if it is not already one).
      10. If expanded property is an array,
          1. label all blank nodes in value with blank node identifiers by using the Label Blank Nodes Algorithm.
          2. Then, for each iri of expanded property merge a copy of value into the iri member of the result JSON object.
      11. Otherwise, merge value into the iri member of the result JSON object.
   4. Set element to result and numProperties to the number of members of result.
   5. If element has an @annotation member, decrease numProperties by 1.
   6. If element has an @value member,
      1. decrease numProperties by 1.
      2. If element has an @language member, decrease numProperties by 1 and check that the value of the @value member is a string. If not, trigger an INVALID_LANGUAGE_TAGGED_STRING error.
      3. Otherwise, if element has an @type member, decrease numProperties by 1 and check that the value of the @type member is a string. If not, trigger an INVALID_TYPED_VALUE error.
      4. If numProperties is greater than 0, trigger an INVALID_VALUE_OBJECT error.
      5. If the value of the @value member equals null, set element to null.
      6. Return.
   7. If element has an @type member whose value is not an array, transform it to an array.
   8. If element has an @list or @set member and numProperties is greater than 1, trigger an INVALID_SET_OR_LIST_OBJECT error.
   9. Otherwise, if element has an @set member, set element to the value of that member.
   10. Otherwise, if element has just an @language member, set element to null.

If, after the algorithm outlined above is run, the resulting element is an JSON object with just a @graph member, element is set to the value of @graph's value. Finally, if element is a JSON object, it is wrapped into an array.

5.3 Context Processing

Processing of JSON-LD data structure is managed recursively. During processing, each rule is applied using information provided by the active context.

The active context contains the active term definitions which specify how properties and values have to be interpreted as well as the current vocabulary mapping and the default language. Each term definition consists of an IRI mapping and optionally a type mapping from terms to datatypes or language mapping from terms to language codes, and a container mapping. If an IRI mapping maps a term to multiple IRIs it is said to be a property generator.

If a local context is encountered, information from the local context is merged into the active context. A local context is identified within a JSON object having a @context member with a string, array or a JSON object value.

This algorithm specifies how the active context is updated with a local context. The algorithm takes three input variables: an active context, a local context, and an array of already included remote contexts remoteContexts. To begin, remoteContexts is initialized to an empty array.

All calls of the IRI Expansion algorithm pass the value specified in the algorithm along with the active context, the currently being processed local context, and true for the vocabRelative flag.

1. If the local context is not an array, transform it to one.
2. Process each item context of the local context as follows:
   1. If context equals null, reset the active context and continue with the next item.
   2. If context is a string:
      1. Expand context according to IRI Expansion.
      2. If context is in the remoteContexts array, raise an RECURSIVE_CONTEXT_INCLUSION error. Otherwise, add context to remoteContexts.
      3. Dereference context.
      4. If the resulting document is a JSON document consisting of a top-level JSON object that has a @context member recursively invoke this algorithm passing a copy of active context, the value of the @context member as local context, and a copy of the remoteContexts array. Relative IRIs are expanded using the remote context's IRI. Otherwise raise an INVALID_REMOTE_CONTEXT error.
      5. Continue with the next item from context.
   3. If context is not a JSON object, raise an INVALID_LOCAL_CONTEXT error.
   4. Otherwise, if context is an JSON object, perform the following steps:
      1. If context has a @vocab member: if its value is neither an absolute IRI, i.e., it does not contain a colon (:), nor null, trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
      2. If context has a @language member: if its value is neither a string nor null, trigger an INVALID_DEFAULT_LANGUAGE error; otherwise set the active context's default language to its value and remove the @language member from context.
      3. For each other key-value pair in context perform the following steps:
         1. Remove the key-value pair from context.
         2. If key is a JSON-LD keyword, continue with the next key-value pair.
         3. If value equals null, replace the term definition for key in the active context with an IRI mapping set to null and continue with the next key-value pair.
         4. If value is a string, expand it according to the IRI Expansion algorithm and replace the term definition for key in the active context with an IRI mapping set to the expanded value. Continue with the next key-value pair.
         5. If value is not a JSON object, trigger an INVALID_TERM_DEFINITION error
         6. If term definition for key exists in the active context, remove it.
         7. Initialize a new, empty term definition definition.
         8. If value has an @id member with a value val:
            1. if val is null, set definition to val.
            2. if val is an array, process each item in the array:
               1. if item is a string expand it according the IRI Expansion algorithm.
               2. otherwise, raise an INVALID_PROPERTY_GENERATOR error.
            3. if val is an array, lexicographically sort val and set definition to val.
            4. Otherwise, if val is a string, expand it according the IRI Expansion algorithm and set definition to val.
         9. If the IRI mapping of definition is set to null or a keyword, store the definition as the term definition for key in the active context and continue with the next key-value pair from context.
         10. Otherwise, set the IRI mapping of definition to the result of expanding key according the IRI Expansion algorithm.
         11. If value has an @type member with a value val and val is not a string or does not expand to an absolute IRI using the IRI Expansion algorithm, raise an INVALID_TYPE_MAPPING error. Otherwise set the IRI mapping of definition to the expanded val.
         12. Otherwise, if value has an @language member with a value val that is a string or null, set the language mapping of definition to the lowercased val. If val is neither a string nor null, raise an INVALID_LANGUAGE_MAPPING error.
         13. f value has an @container member with a value val that equals @list, @set, or @annotation, set the container mapping of definition to val. If val is not one of those values, raise an INVALID_CONTAINER_MAPPING error.

5.4 IRI Expansion

In JSON-LD documents keys and some values are evaluated to produce an IRI. This section defines an algorithm for transforming strings representing an IRI into an absolute IRI. If IRI expansion occurs during context processing, the local context that is being processed is passed to this algorithm. After application of this algorithm, values processed by this algorithm are said to be in expanded IRI form, although this may also include blank node identifiers and JSON-LD keywords.

The algorithm takes two mandatory and four optional input variables: a value to be expanded, an active context, two flags documentRelative and vocabRelative specifying whether value should be interpreted as relative IRI against the document's base IRI or the active context's vocabulary mapping, along with an local context passed when this algorithm is used in Context Processing, and finally an array path which is used to detect cyclic IRI mappings. If not passed, the two flags are set to false and path is initialized to an empty array by default.

The algorithm for generating an IRI is:

1. If value is null or a JSON-LD keyword, return value as is.
2. If a local context has been passed
   1. and value is in the path array, raise a CYCLIC_IRI_MAPPING error. Otherwise append value to path.
   2. If local context contains an IRI mapping for value that is not a property generator return the result of recursively calling this algorithm passing the IRI of the IRI mapping as new value, the active context and local context, path, and true for the vocabRelative flag. If the result is a property generator, raise an PROPERTY_GENERATOR_IN_TERM_DEFINITION error.
3. If an IRI mapping exists for value in the active context that is not a property generator return the value of the IRI mapping.
4. If value contains a colon (:), perform the following steps:
   1. Split value into a prefix and suffix at the first occurrence of a colon (:).
   2. If suffix begins with // or prefix equals _, return value as is.
   3. If a local context has been passed, expand prefix by recursively invoking this algorithm passing prefix as value, the active context and local context, path, and true for the vocabRelative flag. If the expanded prefix contains a colon (:) generate and return an IRI by prepending the expanded prefix to the (possibly empty) suffix using textual concatenation.
   4. Otherwise, if the active context contains an IRI mapping for prefix that is not a property generator, generate and return an IRI by prepending the IRI mapped to prefix to the (possibly empty) suffix using textual concatenation.
5. Otherwise, if the vocabRelative flag is set to true and the active context contains a vocabulary mapping, generate and return an IRI by prepending the IRI of the vocabulary mapping to the value using textual concatenation.
6. Otherwise, if the documentRelative flag is set to true, resolve value against the base IRI as per [RFC3986] and return the resulting IRI. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization (as described in sections 6.2.2 and 6.2.3 of [RFC3986]) 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]
7. Otherwise return value as is.

If the result of the algorithm above is a blank node identifier, i.e., a string that begins with _:, and no local context has been passed, generated a new blank node identifier before returning the final result.

5.5 Value Expansion

Some values in JSON-LD can be expressed in a compacted form. These values are required to be expanded at times when processing JSON-LD documents. A value is said to be in expanded form after the application of this algorithm.

The algorithm for expanding a value takes an active property and active context. It is implemented as follows:

1. If value is null, return null.
2. Initialize an empty object result.
3. If active property is @graph or the active property's type mapping is set to @id, add a key-value pair to result where the key is @id and the value is the result of expanding value according to the IRI Expansion algorithm passing true for the documentRelative flag. Then return result.
4. Add a key-value pair to result where the key is @value and the value is value.
5. If the active property has a type mapping, add a key-value pair to result where the key is @type and the value is the IRI associated with the type mapping or a newly generated blank node identifier if the type mapping is set to a blank node identifier.
6. Otherwise, if value is a string and the active property has a language mapping or an default language is set in the active context, add a key-value pair to result where the key is @language and the value is the language tag associated with the language mapping or the active property or the default language.
7. Return result.

5.6 Label Blank Nodes Algorithm

The algorithm takes a single input variable: an element to be labeled with blank node identifiers.

1. If element is an array, recursively apply this algorithm to all its items.
2. Otherwise, if element is a JSON object with a @list member, recursively apply this algorithm to all items of the @list member's value.
3. Otherwise, if element is a JSON object
   1. For each key-value pair ordered by key recursively apply this algorithm to value.
   2. If element is a node object without an @id member, create a new @id member and assign it a new blank node identifier according the Generate Blank Node Identifier algorithm.

5.7 Generate Blank Node Identifier

This algorithm is used to generate new blank node identifiers or to relabel existing blank node identifiers with a new one to avoid collision by the introduction of new ones. It needs to keep an identifier map, a counter, and a prefix between its executions to be able to generate new blank node identifiers. The counter is initialized to 0 and prefix is set to _:t by default.

The algorithm takes a single input variable identifier which might be null.

1. If the identifier is not null and is in the identifier map, return the mapped identifier.
2. Otherwise, generate a new blankNodeIdentifier by concatenating prefix and counter.
3. Increment counter by 1.
4. If identifier is not null, create a new entry in identifier map set to blankNodeIdentifer.
5. Return blankNodeIdentifier.

5.8 Compaction Algorithm

The algorithm takes four input variables: an active context, an inverse context, an active property, and an element to be compacted. To begin, the active context is set to the result of performing Context Processing on the passed context, inverse context is set to the result of creating an inverse context from the active context, active property is set to null, and element is set to the result of performing the Expansion Algorithm on the JSON-LD input.

1. If element is an array,
   1. Initialize a new empty array result.
   2. Process each item in element recursively using this algorithm, passing a copy of the active context, inverse context, and the active property. Add each compacted item to result unless it is null.
   3. If result has a single item and the compactArrays option is set to true, return that item; otherwise return result.
2. If element is not a JSON object it is already in compact form, return it as is.
3. If element has an @value or @id member, replace element with the result of the Value Compaction algorithm. If the updated element is a scalar, return it as it cannot be further compacted.
4. Initialize a new empty JSON object result.
5. Process each property and value in element ordered by property as follows:
   1. If property is a JSON-LD keyword
      1. and property equals @id, compact value according the rules of the IRI Compaction algorithm.
      2. Otherwise, if property equals @type, compact value (or each item of value if it is an array) according the rules of the IRI Compaction algorithm with the vocabRelative flag set to true. If value is an array consisting of just one item, replace value with that item.
      3. Otherwise, if property equals @graph, compact value by recursively invoking this algorithm, passing a copy of the active context, inverse context, and property as active property ensuring that the result is an array.
      4. Set active property to the result of performing IRI Compaction on property.
      5. Set the active property member of result to value.
      6. Continue with the next property-value pair from element.
   2. If value is an empty array,
      1. set active property to the result of performing IRI Compaction on property with the vocabRelative flag set to true.
      2. If active property is a JSON object, i.e., it is a property generator, set active property to the result of performing the Find and Remove Property Generator Duplicates algorithm passing element, property, null for value, the active context, and active property.
      3. Ensure that result has an active property member; if not create it and set its value to an empty array.
      4. Continue with the next property-value pair from element.
   3. Otherwise perform the following steps for each item of value:
      1. Set active property to the result of performing IRI Compaction on property with the vocabRelative flag set to true.
      2. If active property is a JSON object, i.e., it is a property generator, set active property to the result of performing the Find and Remove Property Generator Duplicates algorithm passing element, property, item, the active context, and active property.
      3. If the active property's container mapping is set to @language or @annotation
         1. Unless result has already an active property member, create one and initialize its value to an empty JSON object. This object is called mapObject.
         2. Set index to the value of the @language or @annotation member of item (depending on the value of the active property's container mapping).
         3. First compact item using the Value Compaction algorithm passing index as containerValue, then compact it by recursively invoking this algorithm passing a copy of the active context, inverse context, and the active property.
         4. If no index member exists in the mapObject create one and set its value to item; otherwise append item to the index member (converting it to an array if it is not one already).
         5. Continue with the next property-value pair from element.
      4. If item is a JSON object having a @list member,
         1. compact the value of that member by recursively invoking this algorithm passing a copy of the active context, inverse context, and the active property ensuring that the result is an array.
         2. If the active property's container mapping is set to @list, set the active property member of result to the value of item's @list member. If such an member already exists in result, raise an COMPACTION_TO_LIST_OF_LISTS error; otherwise continue with the next property-value pair from element.
      5. If item is a JSON object, compact it by recursively invoking this algorithm passing a copy of the active context, inverse context, and the active property.
      6. If no active property member exists in result create one and set its value to item; otherwise append item to the active property member (converting it to an array if it is not one already).
      7. If the compactArrays option is set to false or the active property's container mapping is set to @list or @set, convert the value of the active property member of result to an array if it is not one already.

   If, after the algorithm outlined above is run, the resulting element is an array replace it with a new JSON object with a single member whose name is the result of compacting the value @graph with the IRI Compaction algorithm and whose value is element. Finally, add a @context property to element and set it to the initially passed context.

5.9 IRI Compaction Algorithm

This section defines an algorithm for transforming an IRI to a term or compact IRI. If a value is passed it is used to choose the best matching term.

This algorithm takes three mandatory and two optional parameters. The mandatory parameters are the iri to be compacted, an active context, and an inverse context. Optionally it is possible to pass a value and a vocabRelative flag which specifies whether the passed iri should be compacted using the active context's vocabulary mapping. If the vocabRelative flag is not set it defaults to false.

The algorithm for generating a compact IRI is:

1. Initialize a variable result to null.
2. If an entry for iri exists in the inverse context, perform the following steps:
   1. If a value has been passed, perform the following steps:
      1. Initialize queryPath, which will be used to query the inverse context, to an empty array
      2. Initialize container to @set, typeOrLanguage, and typeLanguageValue to null.
      3. If value is a JSON object
         1. and it has an @annotation member, set container to @annotation.
         2. If value has an @id member, set typeOrLanguage to @type and typeLanguageValue to @id.
         3. Otherwise, if value has an @value member,
            1. and an @type member, set typeOrLanguage to @type and typeLanguageValue to the value of the @type member of value.
            2. Otherwise, if it has an @language member, set typeOrLanguage to @language and typeLanguageValue to the value of the @language member of value. If value has no @annotation member, set container to @language
            3. Otherwise, if the value of value's @value member is is a string, set typeOrLanguage to @language and typeLanguageValue to @null.
         4. Otherwise, if value has an @list member,
            1. If the @list member has at least one item, update container, typeOrLanguage, and typeLanguageValue by recursively running the steps 2.1.2 to 2.1.3.4 (which will never be true since list of lists are not allowed) of this algorithm passing the first item of value's @list member as new value.
            2. If value has no @annotation member, set container to @list.
            3. Starting from the second item of value's @list member, recursively run the steps 2.1.2 to 2.1.3.4 (which will never be true since list of lists are not allowed) of this algorithm passing the item as new value. If the resulting typeOrLanguage or typeLanguageValue differ from the current value of typeOrLanguage or typeLanguageValue, set both to null and stop processing the @list items.
      4. If the container equals @list, set the first item of queryPath to an array consisting of the two elements @list and null; otherwise set it to an array consisting of three elements where the first element is the value of container and the other two elements are @set and @null.
      5. If typeOrLanguage is null, set the second and the the third item of queryPath to an array consisting of a single element @null.
      6. Otherwise, set the second item of queryPath to an array consisting of two elements where the first element is the value of typeOrLanguage and the second element is @null. Set the third item of queryPath to an array whose first element typeLanguageValue and whose second element is @null.
      7. Query the inverse context and store the result in result.
      8. If result is a a string or a JSON object with a term member, return result.
   2. Otherwise, if the entry for iri in the inverse context has a term member, return its value.
3. For each termIri-termDefinition pair in inverse context sorted in reverse order by termIri the (longest termIri comes first), perform the following steps:
   1. If termDefinition does not have a term member, i.e., it is a property generator, continue with the next termIri-termDefinition pair from inverse context.
   2. Otherwise, if iri begins with termIri and is longer than termIri, generate a compact IRI by concatenating the value of the term member of termDefinition with a colon (:) character and the unmatched part of iri.
   3. If the resulting compact IRI has an entry in the active context, continue with the next termIri-termDefinition pair from inverse context as the compact IRI cannot be used.
   4. Otherwise, if result is null, return the compact IRI; if it is not null, set the term member of result to the compact IRI and return result.
4. If the vocabRelative flag is set to true, the active context has a vocabulary mapping, and iri begins with the IRI of the vocabulary mapping but is longer
   1. Set vocabIri to the unmatched part of iri.
   2. If there does not exist an entry for vocabIri in the active context, return vocabIri if result is null; if it is not null set the term member of result to vocabIri and return result.
5. If result is null, return iri as is.
6. Otherwise set the term member of result to iri and return result.

5.10 Inverse Context Creation

An active context as produced by the Context Processing algorithm is very efficient for expanding terms and compact IRIs to IRIs but is of limited use for the opposite operation: IRI compaction. Hence, this algorithm introduces the notion of an inverse context which brings the same efficiency to IRI compaction. An inverse context a tree of JSON objects which allow to efficiently select a term for a IRI-value pair.

The value takes an active context and returns the corresponding inverse context.

1. Set defaultLanguage to active context'sdefault language if there is one; otherwise set it to @null.
2. For each term definition in the active context perform the following steps:
   1. If the term's IRI mapping is set to null continue with the next term definition.
   2. Set container to the value of the term's container mapping or @null if no such mapping exists.
   3. If the term is a property generator, set termType to propertyGenerators.
   4. Otherwise set set termType to term and append the term to the term member of the JSON object for the term's IRI in inverse context (append term to inverseContext[iri]['term']).
   5. For each iri mapped to the term, perform the following steps:
      1. If the term has a type mapping to type, append the term to inverseContext[iri][container]['@type'][type][termType], e.g., inverseContext['http://...']['@list']['@type']['http://...']['term'].
      2. Otherwise, if the term has a language mapping store the associated language in language, replacing null with @null. Then append the term to inverseContext[iri][container]['@language'][language][termType], e.g., inverseContext['http://...']['@list']['@language']['de']['term'].
      3. Otherwise append the term to inverseContext[iri][container]['@null']['@null'][termType] as well as inverseContext[iri][container]['@language'][defaultLanguage][termType] to take the default language into consideration for terms without explicit language mapping.
3. Remove all but the shortest and lexicographically least term in each term member in inverse context. The result is thus a single string value.
4. Finally, sort the array associated with every propertyGenerators member in inverse context lexicographically (shortest terms come first).

5.11 Inverse Context Query Algorithm

It is possible that multiple terms that differ in their container, type, or language mapping are mapped to the same IRI. The purpose of this algorithm is to query the inverse context to return either the best matching term, or a list of potential property generators along with a term to fall back to if none of the property generators can be applied.

This algorithm takes an inverseContextSubtree, a queryPath as generated by the IRI Compaction algorithm and a level parameter which is initialized to 0 if nothing else is passed. The algorithm returns either a string representing the best matching term or a JSON object consisting of a propertyGenerators member, containing a sorted array of potential property generators, and an optional term member containing a term to fall back to if none of the property generators can be applied.

1. Initialize result to null.
2. If level equals 3, i.e., the deepest nested JSON object in the inverse context has been reached, perform the following steps:
   1. If inverseContextSubtree has a propertyGenerators member, copy that member into a new JSON object and store that object in result.
   2. If inverseContextSubtree has a term member and result is null, return the value of that member; otherwise result is a JSON object, copy the term member into result and return result.
3. Otherwise, for each entry of the array in queryPath's level'd position (queryPath[level]), perform the following steps:
   1. If inverseContextSubtree has no entry member, continue with the next entry.
   2. Otherwise set tmpResult to the result of recursively invoking this algorithm passing the entry member of inverseContextSubtree as new inverseContextSubtree, queryPath, and level + 1 as new level.
   3. If tmpResult is a string and result is null, return tmpResult; otherwise, if result is not null, transform tmpResult to a JSON object whose propertyGenerators member is set to an empty array and whose term member is set to tmpResult.
   4. If result is null, replace it with tmpResult.
   5. Otherwise, append each item of the propertyGenerator member of tmpResult to the propertyGenerator member of result unless it is already in result's member. If result has no term member but tmpResult does, copy tmpResult's term member into result.
4. Return result.

5.12 Value Compaction

Expansion transforms all values into expanded formin JSON-LD. This algorithm does the opposite, it compacts an algorithm according the term definition of the passed active property. After the application of this algorithm a value is said to be in compacted form.

This algorithm takes a value, an active context, an inverse context, an active property, and an optional containerValue.

1. If a containerValue has been passed, the active property has a container mapping set to @annotation and value has an @annotation member which equals containerValue, remove that member.
2. If value is a JSON object having a single member @id, return the result of performing IRI Compaction on that member's value.
3. Otherwise, if value is a JSON object having a @value member, perform the following steps:
   1. If the active property has a type mapping and value has a corresponding @type member, remove the @type member from value.
   2. Otherwise, if the active property has a language mapping and value has a corresponding @language member, remove the @language member from value.
   3. Otherwise, if a containerValue has been passed, the active property has a container mapping set to @language, and value has a @language member which equals containerValue, remove the @language member from value.
   4. Otherwise, if the active context has a default language
      1. and the value has a corresponding @language member, remove the @language member from value.
      2. Otherwise, or if the value of value's @value member is a string, return value.
   5. If value has just a @value member, return the value of that member.
4. Return value as is.

5.13 Find and Remove Property Generator Duplicates

This algorithm checks if a specific value exists for all IRIs associated with a property generator and if so, it removes them. The algorithm takes five parameters: element, property, value, active context, active property.

1. For each item propertyGenerator of the array which is the value of the propertyGenerators member of active property perform the following steps:
   1. Check that a member exists for each IRI associated with the propertyGenerator. If value is not null also check whether each of those members that contains value. Values are considered to be equal if they are of the same type and have the same value(s); node objects are considered to be equal if all members match, except if no @id member exists (i.e., it is an unlabeled blank node, in that case node objects are never considered to be equal.
   2. If that's not the case, continue with the next propertyGenerator.
   3. Otherwise, remove value from every member. If the resulting value of a member is an empty array, remove the member altogether from element.
   4. Return propertyGenerator.
2. Return the value of the term member of active property since no matching property generator has been found.

5.14 Flattening Algorithm

The algorithm takes two input variables, an element to flatten and a context used to compact the flattened document.

1. Expand element according the Expansion algorithm.
2. Generate a nodeMap according the Node Map Generation algorithm.
3. Let defaultGraph be the value of the @default member of nodeMap; a JSON object representing the default graph.
4. For each other graphName-graph pair in nodeMap perform the following steps:
   1. If defaultGraph does not have a graphName member, create one and initialize its value to a JSON object consisting of an @id member whose value is set to graphName.
   2. Add a @graph member set to an empty array (referred to as nodes) to the JSON object which is the value of the graphName member of nodeMap.
   3. For each id-node pair in graph ordered by id, add node to the nodes array.
5. Initialize an empty array flattened.
6. For each id-node pair in defaultGraph ordered by id, add node to flattened.
7. If context equals null, return flattened.
8. Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, 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.

5.15 Node Map Generation

This algorithm creates a JSON object nodeMap holding an indexed representation of the graphs and nodes represented in the passed, expanded document. All nodes that are not uniquely identified by an IRI get assigned a (new) blank node identifier. The resulting nodeMap will have a member for every graph in the document whose value is another object with a member for every node represented in the document. The default graph is stored under the @default member, all other graphs are stored under their graph name.

The algorithm takes as input an expanded JSON-LD document element and a reference to a JSON object nodeMap. Furthermore it has the optional parameters active graph (which defaults to @default), an active subject, active property, and a reference to a JSON object list. The nodeMap must be initialized to a JSON object consisting of a single member whose name corresponds with active graph and whose value is an empty JSON object.

1. If element is an array, process each entry in element recursively, using this algorithm and return.
2. Otherwise element is a JSON object. Let activeGraph be the JSON object which is the value of the active graph member of nodeMap.
3. If it has a @type member, perform for each item the following steps:
   1. If item is a blank node identifier, replace it with a new blank node identifier.
   2. If activeGraph has no member item, create it and initialize its value to a JSON object consisting of a single member @id with the value item.
4. If element has an @value member, perform the following steps:
   1. If active property is null, generate a blank node identifier id and store element as value of the member id in activeGraph.
      Issue 207

      Handling of free-floating values is still being discussed.

   2. Otherwise, if no list has been passed, merge element into the active property member of the active subject in activeGraph.
   3. 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 JSON object result having 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 as new element and result as list.
   3. If active property is null, generate a blank node identifier id and store result as value of the member id in activeGraph.
      Issue 207

      Handling of free-floating values is still being discussed.

   4. Otherwise, add result to the the value of the active property member of the active subject in activeGraph.
6. Otherwise element is a node object, perform the following steps:
   1. If element has an @id member, store its value in id and remove the member from element. If id is a blank node identifier, replace it with a new blank node identifier.
   2. Otherwise generate a new blank node identifier and store it as id.
   3. If activeGraph does not contain a member id, create one and initialize it to a JSON object consisting of a single member @id whose value is set to id.
   4. If active property is not null, perform the following steps:
      1. Create a new JSON object reference consisting of a single member @id whose value is id.
      2. If no list has been passed, merge element into the active property member of the active subject in activeGraph.
      3. Otherwise, append element to the @list member of list.
   5. If element has an @type member, merge each value into the @type of active subject in activeGraph. Then remove the @type member from element.
   6. If element has an @annotation member, set the @annotation of active subject in activeGraph to its value. If such a member already exists in active subject and has a different value, raise a CONFLICTING_ANNOTATION error. Otherwise continue and remove the @annotation from element.
   7. If element has an @graph member, recursively invoke this algorithm passing the value of the @graph member as new element and id as new active subject. Then remove the @graph member from element.
   8. Finally for each property-value pair in element ordered by property perform the following steps:
      1. If no property member exists in the JSON object which is the value of the id member of activeGraph create the member and initialize its value to an empty array.
      2. Recursively invoke this algorithm passing value as new element, id as new active subject, and property as new active property.

5.16 RDF Conversion Algorithms

This specification describes algorithms to transform JSON-LD documents to an array of RDF quads and vice-versa. Note that many uses of JSON-LD may not require generation of RDF.

The processing algorithms described in this section are provided in order to demonstrate how one might implement a JSON-LD to RDF processor. Conformant implementations are only required to produce the same type and number of quads but are not required to implement the algorithm exactly as described.

(value).toFixed(0).toString()

(value).toExponential(15).replace(/(\d)0*e\+?/,'$1E')

6.1 JsonLdProcessor

The JSON-LD processor interface is the high-level programming structure that developers use to access the JSON-LD transformation methods.

The JSON-LD API signatures are the same across all programming languages. Due to the fact that asynchronous programming is uncommon in certain languages, developers may implement a processor with a synchronous interface instead. In that case, the callback parameter must not be included and the result must be returned as a return value instead.

It is important to highlight that conformant JSON-LD processors must not modify the input parameters.

[Constructor]
interface JsonLdProcessor {
    void expand ((object or object[] or DOMString) input, JsonLdCallback callback, optional JsonLdOptions? options);
    void compact ((object or object[] or DOMString) input, (object or DOMString) context, JsonLdCallback callback, optional JsonLdOptions? options);
    void flatten ((object or object[] or DOMString) input, (object or DOMString)? context, JsonLdCallback callback, optional JsonLdOptions? options);
};

6.2 Callbacks

JSON-LD processors utilize callbacks in order to return information in an asynchronous manner to calling applications. This section details the parameters sent to those callbacks.

callback JsonLdCallback = void (JsonLdProcessingError error, object or object[] document);

6.3 Data Structures

This section describes datatype definitions used within the JSON-LD API.

dictionary JsonLdOptions {
    DOMString           base;
    object or DOMString expandContext = null;
    boolean             compactArrays = true;
    boolean             optimize = false;
    boolean             useRdfType = false;
    boolean             useNativeTypes = true;
};

dictionary JsonLdProcessingError {
    JsonLdErrorCode code;
    DOMString?      message;
};

enum JsonLdErrorCode {
    "INVALID_SYNTAX",
    "LOAD_ERROR",
    "LIST_OF_LISTS_DETECTED"
};