JSON-LD API Algorithms 1.0

4.1 5.1 Algorithm Terms

active graph

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

active subject

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

active property

the 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 coercion type mappings in the active context .

active object

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

active context

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

compact IRI a compact IRI is has the form of prefix and 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 . local context

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

processor state

the 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

prefix compact IRI

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

language-tagged string node object

A language-tagged string node object is represents zero or more properties of a literal node without a datatype, including in the JSON-LD graph serialized by the JSON-LD document. A JSON object is a language. See languaged-tagged string node object in [ RDF-CONCEPTS 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.

typed literal list object

A typed literal list object is a literal JSON object with an associated that has a @list member.

IRI scalar which indicates the literal's datatype. See

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

literal quad in

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

4.2 5.2 Context Processing Expansion Algorithm

Processing of JSON-LD data structure is managed recursively. During processing, each rule is applied using information provided by the The algorithm takes three input variables: an active context . Processing begins by pushing a new processor state onto , an active property , and an element to be expanded. To begin, the processor state stack. If a local active context is encountered, information from set to the local context result of performing, Context Processing is merged into on the active context . The active context passed expandContext , or empty if expandContext is used for expanding properties and values of a JSON object null , active property (or elements of an array) using a term mapping . It is also used to maintain coercion mapping s from terms to datatypes, language mapping s from terms set to language codes, and list mapping s null , and set mapping s for terms. Processors must element use is set to the lexical form of JSON-LD input . This algorithm expects the property when creating JSON-LD input to be a mapping, well-formed JSON-LD document as lookup is performed on lexical forms, not expanded IRI representations. A local context defined in [ JSON-LD ].

1. If element is identified within a JSON object scalar , expand it according to the Value Expansion having a @context algorithm, passing copies of the active context and active property with a string and return.
2. If element is null , return.
3. If element is an array or a JSON object value. When processing a local context , special processing rules apply:
   1. Create a new, initialize an empty local context . array result .
   2. Let Expand each context item be the value by recursively using this algorithm, passing copies of @context If context equals null , clear the active context and active property .
   3. If the active property's container mapping is set to @list and the expanded context item is an array , process each element as or a list object trigger a LIST_OF_LISTS_DETECTED error.
   4. If the expanded context item in order by starting at Step 2.1 . is null , drop it.
   5. If Otherwise, if the expanded context item is a string an array , it must merge its entries with result's have a lexical form of IRI . entries.
   6. Expand Otherwise, append context item according to IRI Expansion . Dereference context result .
   7. If the resulting document is a JSON document, extract the top-level @context element using the JSON Pointer "/@context" as described in [ JSON-POINTER ]. Set Finally, set context element to the extracted content result and process it by starting at Step 2.1 . return.
4. If Otherwise, context element is a JSON object , perform the following steps: must be an object.
   1. If context element has a @language @context property, it must have a value of a simple string member, update the active context with according to the lexical form described steps outlined in [ BCP47 Context Processing ], or null . Add the language to and remove the local context . @context member.
   2. If Initialize an empty JSON object value has a @vocab key, it must result have a value of a simple string with the lexical form of an absolute IRI , or null . Add the vocabulary mapping to the local context . and
   Otherwise, for
   3. then process each property and value in context element perform the following steps: ordered by property as follows:
      1. If the property's value is active context contains a simple string property generator for property set expanded property to its IRIs , determine otherwise set it to the IRI mapping value by performing result of expanding property according to the steps outlined in IRI Expansion on (passing true for the associated value. vocabRelative flag).
      2. If the result of the IRI mapping is an absolute IRI , merge the property into the local context term mapping , unless the expanded property is a JSON-LD keyword null , in which case return an error. Otherwise, if skip the property's current property - value is null remove mapping, coercion, container pair and language information associated with property from the local context . Otherwise, continue to the next property 's - value must be a JSON object . pair in element .
      3. If the expanded property is a JSON-LD keyword and the value has , process it as follows:
         1. If expanded property equals @id , set the @language or @type @id properties, return an error. Issue member of result to the result of expanding value according the Undecided if @type or IRI Expansion algorithm (passing @graph true can take for the documentRelative flag). If value is not a @container string trigger an INVALID_ID_VALUE with @set . error.
         2. If the expanded property has equals @type , set the form of term , its value must have an @id @type property with a string value which must member of result have to the form result of a term , compact IRI , or absolute IRI . Determine expanding value according the IRI mapping by performing IRI Expansion algorithm on the associated value. If (passing true for both the result of documentRelative and the IRI mapping vocabRelative flag). If value is neither a string nor an absolute IRI , merge the array of strings trigger an INVALID_TYPE_VALUE error. Empty arrays are ignored.
         3. If expanded property into equals @value , set the local context @value member of result to value . If value is neither a scalar term mapping . nor null trigger an INVALID_VALUE_OBJECT_VALUE error.
         4. If the expanded property has equals @language , set the form of @language member of a compact IRI or absolute IRI , result to the lowercased value . If value may have is not a @id string , trigger an INVALID_LANGUAGE_VALUE error.
         5. If expanded property with a string value which must have equals @annotation , set the form @annotation member of result to value . If value is not a term , compact IRI , or absolute IRI . Determine the IRI mapping by performing IRI Expansion string on the associated value. trigger an INVALID_ANNOTATION_VALUE error.
         6. If expanded property equals @set or @list , set the result expanded property member of result to the IRI mapping is an absolute IRI , merge the result of expanding property value into by recursively using this algorithm, passing copies of the local active context term mapping and active property .
         7. If the value expanded property has a equals @type @graph , set the @graph property, its value must member of result have to the form result of expanding value by recursively using this algorithm, passing copies of a term , compact IRI , absolute IRI , or the keyword active context and @id . Determine the IRI by performing IRI Expansion on @graph as active property .
         8. Continue with the associated value. next property - value pair from element .
      4. If the result of the IRI mapping expanded property is not an absolute IRI or @id , merge into the local context coercion mapping using the lexical value of ,i.e., it doesn't contain a colon, continue with the next member from property element .
      5. If the Otherwise, if value has a @container property, its value must property's be @list or @set . Merge the list container mapping or is set mapping into the local context to @language
         1. Initialize a new empty array using the lexical value of the property language map values .
         2. If the Process each key - val pair of value has 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: @language property but no @type @value property, the value of set to the currently processed item and @language property must set to the lowercased key . If val be is not a string or null . Merge , trigger a LANGUAGE_MAP_INVALID_VALUE error. Otherwise append the object to language mapping into the local context using the lexical map values .
         3. Set value of the to property language map values .
      6. Merge the local context Otherwise, if property's container mapping into 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. Repeat Step 2.4.2 until no entries are added Add to each item of val a member @annotation set to key if no such member exists yet and append the local context . resulting JSON object to annotation map values .
         3. Set value to annotation map values .
      Note It can be difficult to distinguish between a compact IRI
      7. Otherwise, expand value by recursively using this algorithm, passing copies of the active context and an absolute IRI , property as a compact IRI may seem to be a valid IRI active property .
      8. If the expanded scheme value equals null , continue with the next property - value pair from element . When performing repeated IRI expansion, a term used as a prefix may not have a valid
      9. If property's container mapping due to dependencies in resolving term definitions. By continuing Step 2.3.2 until no changes are made, mappings to IRIs created using an undefined term prefix will eventually expand is set to an absolute IRI s. 4.3 IRI Expansion Keys @list and some values are evaluated to produce an IRI . This section defines an algorithm for transforming a value representing an IRI into is either not an actual IRI . IRIs JSON object may be represented as an absolute IRI , a term , a compact IRI , or as a value relative to @vocab . An absolute IRI is defined in [ RFC3987 JSON object ] containing a without an @list member, replace scheme value along with a JSON object with an @list member whose value is set to path and optional query value and fragment segments. A relative IRI is (wrapped in an IRI that is relative some other absolute IRI array ; in the case of JSON-LD this if it is not already one).
      10. If expanded property is the base location of the document. The algorithm for generating an IRI is: array ,
          1. If the active context contains a term label all blank nodes mapping for the in value with blank node identifiers by using a case-sensitive comparison, use the mapped Label Blank Nodes Algorithm .
          2. Then, for each iri of expanded property merge a copy of value as an IRI . into the iri member of the result JSON object .
      11. Otherwise, split the merge value into a the prefix iri member of the result JSON object .
   4. Set element to result and suffix numProperties from to the first occurrence number of ':'. members of result .
   5. If the prefix is a '_' (underscore), the value represents a named blank node . element has an @annotation member, decrease numProperties by 1.
   6. If the active context contains a term mapping for prefix element using a case-sensitive comparison, and has an @value member,
      1. decrease suffix numProperties does not does not begin with '//' (i.e., it does not match a by 1.
      2. If hier-part element including has an @language member, decrease authority numProperties (as defined in [ RFC3986 ]), generate an IRI by prepending the mapped prefix to the (possibly empty) suffix using textual concatenation. Note that an empty suffix 1 and no suffix (meaning check that the value contains no ':' string at all) are treated equivalently. of the @value member is a string. If not, trigger an INVALID_LANGUAGE_TAGGED_STRING error.
      3. Otherwise, if the IRI being processed does not contain a colon element has an @type member, decrease numProperties by 1 and is a property, i.e., a key in a JSON object , or check that the value of the @type and the active context has member is a @vocab string. If not, trigger an INVALID_TYPED_VALUE mapping, join error.
      4. If numProperties is greater than 0, trigger an INVALID_VALUE_OBJECT error.
      5. If the mapped value to of the suffix using textual concatenation. @value member equals null , set element to null .
      6. Otherwise, if the IRI being processed does not contain a colon and Return.
   7. If element has an @type member whose value is not a property, i.e., not a key in a JSON object treat an array , transform it as a relative IRI to an array .
   8. If element has an @list or @set member and resolve it against the base IRI as per [ RFC3986 ] using only the basic algorithm in section 5.2. Neither Syntax-Based Normalization numProperties nor is greater than 1, trigger an INVALID_SET_OR_LIST_OBJECT error.
   9. Otherwise, if Scheme-Based Normalization element (described in sections 6.2.2 and 6.2.3 of [ RFC3986 ]) are performed. Characters additionally allowed in IRI references are treated in has an @set member, set element to the same way that unreserved characters are treated in URI references, per section 6.5 value of [ RFC3987 ]. that member.
   10. Otherwise, use the value directly as if element has just an IRI . @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 .

4.4 5.3 IRI Compaction Context Processing

Some keys 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 are expressed using IRI have to be interpreted as well as the current vocabulary mapping and the default language . Each term definition s. This section defines an algorithm for transforming consists of an IRI ( iri ) to mapping and optionally a term type mapping from terms to datatypes or compact 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 using is encountered, information from the term local context s specified in is merged into the active context . A local context using 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 optional active context , a local context , and an array of already included remote contexts value remoteContexts . To begin, remoteContexts is initialized to an empty array.

All calls of the IRI Compaction Algorithm The Expansion algorithm for generating a compact IRI is: 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. Create If the local context is not an empty list of terms array, transform it to one.
2. Process each item terms context that will be populated with term of the local context s that are ranked according to how closely they match value . Initialize as follows:
   1. If highest rank context to 0 , equals null , reset the active context and set continue with the next item.
   2. If context is a flag string :
      1. Expand list container context according to false . IRI Expansion .
      2. For each If term context is in the active 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 term remoteContexts 's array. Relative IRIs are expanded using the remote context's IRI is not a complete match against iri , continue to . Otherwise raise an INVALID_REMOTE_CONTEXT error.
      5. Continue with the next item from term context .
   3. If value context is not a JSON object containing only , raise an INVALID_LOCAL_CONTEXT error.
   4. Otherwise, if context is an JSON object , perform the property @list : following steps:
      1. If term context has a @container @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 @set , continue to its value and remove the next @vocab member from term context .
      2. If list container context is has a true @language and term does not have member: if its value is neither a container string nor null , trigger an INVALID_DEFAULT_LANGUAGE error; otherwise set the active context's default language to its value and remove the @list @language and member from context .
      3. For each other key - value is null , continue to pair in context perform the following steps:
         1. Remove the next term key - value pair from context .
         2. Otherwise, if If term key has is a container set to @list , JSON-LD keyword , continue to with the next term . key - value pair.
         3. Set If rank value to equals null , replace the term rank definition of for value key by passing passing term , value , and in the active context with an IRI mapping set to null and continue with the Term Rank Algorithm . next key - value pair.
         4. If rank value is greater than 0 : If a string , expand it according to the IRI Expansion algorithm and replace the term definition for key has a container in the active context with an IRI mapping set to @set , then add 1 to the expanded rank value . Continue with the next key - value pair.
         5. If value is not a JSON object containing only the property @list , trigger an INVALID_TERM_DEFINITION and error
         6. If term definition for list container key is false and exists in the active context , remove it.
         7. Initialize a new, empty term definition definition .
         8. If value has a an container @id set to @list , then set list container to true , clear member with a value terms , set val :
            1. if highest rank val to rank , and add is null , set term definition to terms val .
            2. Otherwise, if rank val is greater than or equal to an array , process each highest rank : item in the array:
               1. If if rank item is greater than a string expand it according the IRI Expansion algorithm .
               2. otherwise, raise an INVALID_PROPERTY_GENERATOR error.
            3. if highest rank , clear val is an array , lexicographically sort terms val and set highest rank definition to rank val .
            4. Add Otherwise, if term val is a string , expand it according the IRI Expansion algorithm and set definition to terms val .
         9. If the IRI mapping of terms definition is empty, and the active context set to null has a @vocab which is or a prefix of keyword , store the iri definition where as the resulting relative IRI is not a term definition for key in the active context . The resulting relative IRI is and continue with the unmatched part of next iri key - value pair from context .
         10. If terms is empty, add a compact Otherwise, set the IRI mapping representation of iri definition for each term in the active context which maps to an the result of expanding key according the IRI which is Expansion algorithm .
         11. If value has an @type member with a prefix for value iri val and val where the resulting compact IRI is not a term string in the active context . The resulting compact or does not expand to an absolute IRI is the term associated with using the partially matched IRI in Expansion algorithm , raise an INVALID_TYPE_MAPPING error. Otherwise set the active context IRI mapping concatenated with a colon (:) character and the unmatched part of iri definition to the expanded val .
         12. If Otherwise, if terms is empty, the IRI being processed is a property or the value of @type and has an @vocab @language member with a value val that is not a string or null and matches , set the beginning language mapping of iri , return definition to the unmatched portion of lowercased iri val . Otherwise return If iri . val is neither a string nor null , raise an INVALID_LANGUAGE_MAPPING error.
         13. Otherwise, return the shortest and lexicographically least f value has an @container member with a value in terms 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.

4.4.2 5.4 Term Rank Algorithm IRI Expansion

When selecting among multiple possible terms for a given property, it may be that multiple terms In JSON-LD documents keys and some values are defined with the same evaluated to produce an IRI , but differ in @type , @container or @language . The purpose . 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 is are said to take a term be in expanded IRI form , although this may also include blank node identifiers and a value and give it a term rank . The selection can then be based, partly, on the term having the highest term rank JSON-LD keywords .

Given The algorithm takes two mandatory and four optional input variables: a term term , value , and to be expanded, an active context , two flags documentRelative and vocabRelative specifying whether value should be interpreted as relative IRI determine against the term rank document's base IRI or the active context's using 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 following steps: 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 , term rank is 3 . Otherwise, if or a JSON-LD keyword , return value is as is.
2. If a JSON object local context containing only the property @list : has been passed
   1. If the @list property and value is an empty array, if in the term path has @container array, raise a CYCLIC_IRI_MAPPING set error. Otherwise append value to @list , term rank is 1 , otherwise 0 . path .
   2. Otherwise, If local context contains an IRI mapping for value that is not a property generator return the sum result of recursively calling this algorithm passing the term rank IRI s of the IRI mapping as new value , the active context and local context , path , and true for every entry in the list. vocabRelative flag. If the result is a property generator , raise an PROPERTY_GENERATOR_IN_TERM_DEFINITION error.
3. Otherwise, If an IRI mapping exists for value must be a node definition , node reference , or a JSON object in the active context having that is not a @value . property generator return the value of the IRI mapping .
4. If value has contains a @value colon ( : property: ), perform the following steps:
   1. If Split value has a @type property matching into a @type coercion for term , term rank is 3 , otherwise if prefix and term suffix has no @type at the first occurrence of a colon ( : coercion and no @language , term rank is 1 , otherwise 0 . ).
   2. Otherwise, if @value is not a string , if If term suffix has no begins with @type // or prefix equals @language it is 2 _ , otherwise 1 . Otherwise, if return value as is.
   3. If a local context has no @language property, if been passed, expand term prefix has @language null , or by recursively invoking this algorithm passing term prefix has no @type or @language and as value , the active context has no and local context , path , and @language , term rank true for the vocabRelative flag. If the expanded prefix contains a colon ( : ) generate and return an IRI is 3 , otherwise 0 . by prepending the expanded prefix to the (possibly empty) suffix using textual concatenation.
   4. Otherwise, if the active context contains an IRI mapping for value prefix has that is not a @language property matching a @language definition for generator , generate and return an IRI by prepending the IRI mapped to term prefix (or to the (possibly empty) term suffix has no @type or using textual concatenation.
5. Otherwise, if the vocabRelative flag is set to @language true definition and @language in the active context matches contains a vocabulary mapping , generate and return an IRI by prepending the value @language ), term rank IRI is 3 , otherwise if of the vocabulary mapping to the term value has no @type coercion and no @language , term rank is 1 , otherwise 0 . using textual concatenation.
6. Otherwise, if the term documentRelative has @type coerced flag is set to @id true , term rank 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 3 , otherwise if used; neither term Syntax-Based Normalization has no @type coercion nor Scheme-Based Normalization (as described in sections 6.2.2 and no @language , term rank 6.2.3 of [ RFC3986 is 1 , otherwise 0 . ]) 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. Return term rank . 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.

4.5 5.5 Value Expansion

Some values in JSON-LD can be expressed in a compact form. 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 , the return null .
2. Initialize an empty object value is already expanded. result .
3. If active property is @graph or the target of an active property's type mapping is set to @id coercion, expand the value into an object with , add a key-value pair to result where the key is @id and the value is the expanded IRI result of expanding value according to the IRI Expansion algorithm rules. Otherwise, if active property is not a keyword , then expand passing true for the value documentRelative into an object: flag. Then return result .
4. Set the first Add a key-value pair to result where the key is @value and the unexpanded value is value .
5. If the active property is the target of typed literal coercion, set the second has a type mapping , add a key-value pair to result where the key is @type and the associated coercion datatype expanded according to value is the IRI Expansion rules. 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 is the target of has a language tagging, mapping or an default language is set in the second active context , add a key-value pair to result where the key is @language and the value of is the language tagging from tag associated with the language mapping or the active context property or the default language .
7. Otherwise, Return value is already expanded. result .

4.6 5.6 Value Compaction Label Blank Nodes Algorithm

Some values, such as IRIs and typed literals , may be expressed in an expanded form ( expanded value ) in JSON-LD. These values are required to be compacted at times when processing JSON-LD documents. The algorithm for compacting takes a single input variable: an expanded value value element takes an active property and active context to be labeled with blank node identifiers . It is implemented as follows:

1. If value element only has one property and the active context has no default language, then the compacted value is the value of @value . an array , recursively apply this algorithm to all its items.
2. Otherwise, if active property is @graph , the compacted value element is the value associated a JSON object with the a @id @list key, processed according member, recursively apply this algorithm to all items of the IRI Compaction steps. @list member's value.
3. Otherwise, if the active context contains element is a coercion target for the JSON object
   1. For each key that matches the expression of the value, compact the - value using the following steps: pair ordered by key recursively apply this algorithm to value .
   2. If the coercion target element is a node object without an @id , the compacted value is the value associated with the member, create a new @id key, processed member and assign it a new blank node identifier according to the IRI Compaction Generate Blank Node Identifier steps. algorithm.
   If the coercion target

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 typed literal , new one to avoid collision by the compacted value 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 the value associated with the initialized to @value 0 key. Otherwise, if and value prefix contains an is set to @id _:t key, the compacted value is by default.

The algorithm takes a single input variable value identifier with the value of @id processed according to the IRI Compaction steps. which might be null .

1. Otherwise, if If the active context identifier is not null contains a @language , which matches the @language of the value, or the value has only a @value key, the compacted value and is in the value associated with identifier map , return the @value key. mapped identifier.
2. Otherwise, if the value contains generate a @type key, the compacted value is new value blankNodeIdentifier with the by concatenating prefix and counter .
3. Increment counter by @type value processed according to the IRI Compaction steps. 1 .
4. Otherwise, the value If identifier is not modified. null , create a new entry in identifier map set to blankNodeIdentifer .
5. Return blankNodeIdentifier .

4.7 Expansion Expansion is the process of taking a JSON-LD document and applying a context such that all IRI , datatypes, and literal values are expanded so that the context is no longer necessary. JSON-LD document expansion is typically used as a part of other JSON-LD API methods. For example, assume the following JSON-LD input document: { "@context": { "name": "http://xmlns.com/foaf/0.1/name", "homepage": { "@id": "http://xmlns.com/foaf/0.1/homepage", "@type", "@id" } }, "name": "Manu Sporny", "homepage": "http://manu.sporny.org/" } Running the JSON-LD Expansion algorithm against the JSON-LD input document provided above would result in the following output: { "http://xmlns.com/foaf/0.1/name": "Manu Sporny", "http://xmlns.com/foaf/0.1/homepage": { "@id": "http://manu.sporny.org/" } } 4.7.1 5.8 Expansion Compaction Algorithm

The algorithm takes three four input variables: an active context , an inverse context , an active property , and an element to be expanded. compacted. To begin, the active context is set to the result of performing, performing Context Processing on the passed context , or empty if inverse context is null 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 , process
   1. Initialize a new empty array result .
   2. Process each entry item in element recursively using this algorithm, passing copies 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 @container single item and the compactArrays option is set to @list and any entry in true , return that item; otherwise return result .
2. If element is an array , or is not a JSON object containing a @list property, it is already in compact form, return an error, it as lists of lists are not allowed. If the expanded entry is null, drop it. is.
3. If it's an array, merge its entries with element 's entries. Otherwise, if has an @value or @id member, replace element is an object with the result of the Value Compaction algorithm . If the updated element has is a @context property, update the active context according to the steps outlined in Context Processing scalar , return it as it cannot be further compacted.
4. Initialize a new empty JSON object and remove the @context property. result.
5. Then, proceed and process Process each property and value in element ordered by property as follows:
   1. Remove If property from element , expand is a JSON-LD keyword
      1. and property equals @id , compact value according to the steps outlined in rules of the IRI Expansion Compaction algorithm . Set the active property to the original un-expanded
      2. Otherwise, if property if equals @type , compact property value is not a keyword . If (or each item of property value does not expand to a keyword or if it is an absolute array ) according the rules of the IRI Compaction algorithm (i.e., it doesn't contain a colon), continue with the next property from element . vocabRelative flag set to true . If value is null an array and consisting of just one item, replace property value is not @value , continue with the next property from element . that item.
      3. If the Otherwise, if property is equals @id the @graph , compact value must be by recursively invoking this algorithm, passing a string . Expand copy of the active context , inverse context , and value property according as active property ensuring that the result is an array .
      4. Set active property to the result of performing IRI Expansion . Compaction on property .
      5. Otherwise, if Set the active property member of result to value .
      6. Continue with the next property is @type : - value pair from element .
   2. If value is a string an empty array , expand according
      1. set active property to the result of performing IRI Expansion . Otherwise, if Compaction on value property with the vocabRelative flag set to true .
      2. If active property is a JSON Object object , i.e., it must be empty (used for Framing 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. Otherwise, if Ensure that value result is has an active property member; if not create it and set its value to an empty array , all elements must be string s. Expand .
      4. Continue with the next property - value pair from element .
   3. Otherwise perform the following steps for each item of its entries according value :
      1. Set active property to the result of performing IRI Expansion . Compaction on property with the vocabRelative flag set to true .
      2. Otherwise, if 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 @value @language or @language @annotation the
         1. Unless value must not result be a has already an active property member, create one and initialize its value to an empty JSON object or an array . This object is called mapObject .
         2. Otherwise, if the Set property index is to the value of the @list @language or @set @annotation expand member of item (depending on the value of the active property's container mapping ).
         3. First compact item recursively using the Value Compaction algorithm passing index as containerValue , then compact it by recursively invoking this algorithm, algorithm passing copies a copy of the active context , inverse context , and the active property . .
         4. If no index member exists in the expanded mapObject create one and set its value to item is not an array , convert ; otherwise append item to the index member (converting it to an array . If if it is not one already).
         5. Continue with the next property is @list and any entry in - value pair from element .
      4. If item is a JSON object containing an having a @list property, return an error, as lists member,
         1. compact the value of lists are not supported. 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. Otherwise, expand 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 using invoking this algorithm, algorithm passing copies a copy of the active context , inverse context , and the active property .
      6. If no active property member exists in result is not a keyword create one and set its value to item ; otherwise append item to the active property has a member (converting it to an array if it is not one already).
      7. If the compactArrays option is set to @container false or the active property's container mapping is set to @list and or @set , convert the expanded value of the active property member of result to an array if it is not null , convert one already.

   If, after the algorithm outlined above is run, the resulting value element to is an array replace it with a new JSON object with an a single member whose name is the result of compacting the value @list @graph property with the IRI Compaction algorithm and whose value is set element . Finally, add a @context property to value element (unless 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 already in that form). Convert passed it is used to choose the best matching term .

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

The algorithm for generating a compact IRI is:

1. If Initialize a variable value result is not to null .
2. If an entry for iri exists in the inverse context , either merge perform the following steps:
   1. If a value into has been passed, perform the following steps:
      1. Initialize queryPath , which will be used to query the inverse context , to an existing empty array
      2. Initialize property container property of to @set , element typeOrLanguage , and typeLanguageValue or create to null .
      3. If value is a new JSON object
         1. and it has an @annotation member, set property container property with to @annotation .
         2. If value as value. has an @id member, set typeOrLanguage to @type and typeLanguageValue to @id .
         3. If the processed Otherwise, if element value has an @value property member,
            1. and an @type member, set element must not typeOrLanguage have more than one other property, which can either be to @language @type or and typeLanguageValue to the value of the @type with a string value. member of value .
            2. Otherwise, if it has an @language member, set typeOrLanguage to @language and typeLanguageValue to the value of the @value @language equals null , replace member of element value . If value with 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 element value has an @type @list property member,
            1. If the @list member has at least one item, update container , typeOrLanguage , and its value is 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 in allowed) of this algorithm passing the form first item of an array , convert it to an array . value's @list member as new value .
            2. If element value has an no @set @annotation or member, set container to @list property, it must .
            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 only property. Set item as new element value . If the resulting typeOrLanguage to or typeLanguageValue differ from the current value of @set ; leave typeOrLanguage or typeLanguageValue , set both to null and stop processing the @list untouched. items.
      4. If the element container has just a equals @language property, @list , set the first item of element 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, expand set the second item of element queryPath according to the Value Expansion an array rules, passing copies consisting of two elements where the first element is the value of typeOrLanguage and the active context second element is @null . Set the third item of queryPath to an array whose first element typeLanguageValue and active property . whose second element is @null .
      If, after
      7. Query the algorithm outlined above is run, inverse context and store the resulting result in element result .
      8. If result is an a a string or a JSON object with just a @graph term property, member, return element result .
   2. Otherwise, if the entry for iri is set to in the value of inverse context has a @graph term 's member, return its value. Finally, if
3. For each element termIri is - 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 JSON object , term member, i.e., it is wrapped into an array a property generator, continue with the next termIri - termDefinition pair from inverse context . 4.8 Compaction Compaction
   2. Otherwise, if iri begins with termIri and is longer than termIri , generate a compact IRI by concatenating the process value of taking the term member of termDefinition with a JSON-LD document colon ( : ) character and applying a context such that the most compact form unmatched part of iri .
   3. If the document is generated. JSON is typically expressed in a very compact, key-value format. That is, full IRIs are rarely used as keys. At times, a JSON-LD document may be received that is not in its most compact form. JSON-LD, via the API, provides a way to resulting compact a JSON-LD document. For example, assume the following JSON-LD input document: { "http://xmlns.com/foaf/0.1/name": "Manu Sporny", "http://xmlns.com/foaf/0.1/homepage": { "@id": "http://manu.sporny.org/" } } Additionally, assume the following developer-supplied JSON-LD context: { "@context": { "name": "http://xmlns.com/foaf/0.1/name", "homepage": { "@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id" } } } IRI Running has an entry in the JSON-LD Compaction algorithm given active context , continue with the next termIri - termDefinition pair from inverse context supplied above against as the JSON-LD input document provided above would compact IRI cannot be used.
   4. Otherwise, if result in is null , return the following output: { "@context": { "name": "http://xmlns.com/foaf/0.1/name", "homepage": { "@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id" } }, "name": "Manu Sporny", "homepage": "http://manu.sporny.org/" } compact IRI The compaction algorithm also enables the developer to map any expanded format into an application-specific compacted format. While ; if it is not null, set the context provided above mapped http://xmlns.com/foaf/0.1/name term member of result to name , it could have also mapped it to any arbitrary string provided by the developer. compact IRI 4.8.1 Compaction Algorithm The algorithm takes three input variables: an active context , an active property , and an return element result .
4. If the vocabRelative flag is set to be compacted. To begin, true , the active context is set to has a vocabulary mapping , and iri begins with the result IRI of performing Context Processing the vocabulary mapping on but is longer
   1. Set vocabIri to the passed unmatched part of context , iri .
   2. If there does not exist an entry for vocabIri in the active property 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 , and return element iri is as is.
6. Otherwise set to the result term member of performing result to iri and return result .

5.10 Inverse Context Creation

An active context as produced by the Expansion Algorithm Context Processing on algorithm is very efficient for expanding terms and compact IRIs to IRIs but is of limited use for the JSON-LD input opposite operation: IRI compaction . This removes any existing 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 the given to efficiently select a term for a IRI -value pair.

The value takes an active context to be cleanly applied. and returns the corresponding inverse context .

1. If Set element defaultLanguage to active context's default language if there is an array , process one; otherwise set it to @null .
2. For each entry term definition in element recursively using this algorithm, passing a copy of the active context and perform the active property . following steps:
   1. If element has a single item and the compactArrays term's option IRI mapping is set to true , null continue with the compacted value is that item; otherwise next term definition .
   2. Set container to the compacted value is element . of the term's container mapping or @null if no such mapping exists.
   3. Otherwise, if If the term is a property generator , set element termType is an object: to propertyGenerators .
   4. If Otherwise set set element termType has an to @value term property or element is a node reference , return and append the result term to the term member of performing Value Compaction the JSON object on for the term's IRI in inverse context (append element term using active property . 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 active property term has a @container language mapping store the associated language in language , replacing null with @null . Then append the term to @list 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 element has lexicographically least term in each term member in inverse context . The result is thus a corresponding single string value.
4. Finally, sort the array associated with every @list propertyGenerators property, recursively compact member in inverse context lexicographically (shortest terms come first).

5.11 Inverse Context Query Algorithm

It is possible that property's value passing a copy 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 active inverse context and to return either the active best matching term , or a list of potential property generators ensuring that the result is an array along with all null values removed. If there already exists a value for active term to fall back to if none of the property generators in can be applied.

This algorithm takes an element inverseContextSubtree , a queryPath and as generated by the full IRI of Compaction algorithm and a property level parameter which is also coerced initialized to @list , return an error. Otherwise store 0 if nothing else is passed. The algorithm returns either a string representing the resulting best matching term or a JSON object consisting of a propertyGenerators member, containing a sorted array as value of active potential property generators , and an optional term member containing a term to fall back to if empty or none of the property generators can be applied.

1. Initialize result otherwise. to null .
2. Otherwise, construct If output level as 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 used for returning the result of compacting and store that object in element result . For each
   2. If property inverseContextSubtree has a term member and result is null , return the value of that member; otherwise result in is a JSON object , copy the term member into element: result and return result .
3. If Otherwise, for each property entry is @id or of the array in queryPath's level'd position ( @type queryPath[level] ), perform the following steps:
   1. Set active property If inverseContextSubtree has no entry member, continue with the next entry .
   2. Otherwise set tmpResult to the result of performing IRI Compaction on recursively invoking this algorithm passing the property entry member of inverseContextSubtree as new inverseContextSubtree , queryPath , and level + 1 as new level .
   3. If value tmpResult is a string , the compacted and value result is the result of performing IRI Compaction on null , return value . Otherwise, tmpResult ; otherwise, if value result must is not null , transform tmpResult be to a JSON object whose propertyGenerators member is set to an empty array . Perform IRI Compaction on every entry of and whose term member is set to value tmpResult .
   4. If value result contains just one entry and is null , replace it with tmpResult .
   5. Otherwise, append each item of the compactArrays propertyGenerator option is set member of tmpResult to the true , propertyGenerator member of value result unless it is set to that entry. already in result's member. If result has no term member but tmpResult does, copy tmpResult's term member into result .
4. Add Return result .

5.12 Value Compaction

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

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

1. Otherwise, If a value containerValue must has been passed, the active property has a container mapping set to @annotation and value be has an array . @annotation member which equals containerValue , remove that member.
2. If value is empty: Set active property a JSON object to having a single member @id , return the result of performing IRI Compaction on property . that member's value.
3. Create an entry in Otherwise, if output value for is a JSON object having a @value member, perform the following steps:
   1. If the active property has a type mapping and value . For each item in has a corresponding @type member, remove the @type member from value : .
   2. Set Otherwise, if the active property to the result of performing IRI Compaction has a language mapping for property and item using the active context . Compact item value by recursively performing this algorithm passing has a copy of the active context and corresponding @language member, remove the active property . @language member from value .
   3. If an entry already exists in Otherwise, if a output containerValue for has been passed, the active property , convert it to an array if necessary, has a container mapping set to @language , and append value has a @language member which equals containerValue , remove the compacted @language member from value .
   4. Otherwise, if the compacted active context has a default language
      1. and the value is not an array and active property has a corresponding @container mapping to @set @language or if member, remove the compactArrays option is set to false , convert @language member from value to an array. .
      2. Create an entry in Otherwise, or if the value of output value's for active property and @value member is a string , return value .
   5. If value has just a @value member, return the value of that member.
4. Otherwise, return Return element value as the compacted element . is.

Issue 5.13 Perhaps this should also call Value Compaction on native types Find and strings, which could consolidate potential transformation in one place. Remove Property Generator Duplicates

If, after the This algorithm outlined above is run, the resulting 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 is an array , property , value , active context , put active property .

1. For each item element propertyGenerator into of the array which is the value of the @graph propertyGenerators property member of active property perform the following steps:
   1. Check that a new JSON object member exists for each IRI and then set associated with the element propertyGenerator . If value to is not null also check whether each of those members that JSON object . Finally, add a @context property to contains element and set it value . Values are considered to be equal if they are of the initially passed context . 4.9 Flattening Flattening is same type and have the process of taking a JSON-LD document, expanding same value(s); node objects it, labeling are considered to be equal if all members match, except if no @id member exists (i.e., it is an unlabeled nodes with a blank node , in that case node objects identifier, and returning an array of are never considered to be equal.
   2. If that's not the nodes defined in case, continue with the document. For example, assume next propertyGenerator .
   3. Otherwise, remove value from every member. If the following JSON-LD input document: { "@context": { "name": "http://xmlns.com/foaf/0.1/name", "knows": "http://xmlns.com/foaf/0.1/knows" }, "@id": "http://example.com/markus", "name": "Markus Lanthaler", "knows": { "name": "Manu Sporny" } } Running resulting value of a member is an empty array , remove the JSON-LD Flattening algorithm for member altogether from element .
   4. Return propertyGenerator .
2. Return the value of the merged graph ( @merged term ) against the JSON-LD input document provided above would result in the following output: [ { "@id": "http://example.com/markus", "http://xmlns.com/foaf/0.1/knows": [ { "@id": "_:t0" } ], "http://xmlns.com/foaf/0.1/name": [ { "@value": "Markus Lanthaler" } ] }, { "@id": "_:t0", "http://xmlns.com/foaf/0.1/name": [ { "@value": "Manu Sporny" } ] } ] member of active property since no matching property generator has been found.

4.9.1 5.14 Flattening Algorithm

The algorithm takes two input variables, an element to flatten and the graph for which the node definitions should be returned. If a graph context is not set, it will default used to @merged which represents the result of merging all graphs including compact the default graph ( @default ). flattened document.

1. Expand element according the Expansion Algorithm algorithm .
2. Generate a nodeMap according the Node Map Generation Algorithm algorithm .
3. Initialize 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 result nodes ) to the JSON object which is the value of the graphName member of nodeMap .
   3. If For each nodeMap id has no property - node pair in graph , return ordered by result id , otherwise set add definitions node to its value. the nodes array .
5. Foreach Initialize an empty array flattened.
6. For each property id and - value node of of pair in definitions defaultGraph ordered by property : Add id , add value node to result flattened .
7. If context equals null , return flattened .
8. Return 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.

4.9.2 5.15 Node Map Generation

The Node Map Generation This algorithm takes as input an expanded JSON-LD document and results in creates a JSON object nodeMap holding a flat 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. identifier . The resulting nodeMap document will have a property member for every graph in the document whose value is another object with a property member for every node represented in the document. While the The default graph is stored under the @default property and the merged graph under the @merged property, member, all other graphs are stored under their respective IRIs . graph name.

The algorithm takes as input the an expanded JSON-LD document as element , the initially empty and a reference to a JSON object nodeMap , . Furthermore it has the optional parameters active graph (which defaults to @default as graph , null as list , ), an active subject , active property , and null a reference to a JSON object as id 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. If Otherwise element is not a JSON object or if it has a @value property, then if . Let list activeGraph be the JSON object which is not null , append element to the value of the active graph member of list and return. nodeMap .
3. If id is null and if the it has a @id @type property exists and is an IRI , set member, perform for each id item to its value, otherwise set it to a blank node identifier created by the Generate Blank Node Identifier algorithm. following steps:
   1. If list item is not null a blank node identifier , append replace it with a new blank node reference to list using id as the value for @id . identifier .
   2. Let nodes be the value in nodeMap where the key is If graph activeGraph ; if has no such member item , create it and initialize its value exists, insert to a new JSON object for consisting of a single member @id with the key value graph item .
4. If id element has an @value member, perform the following steps:
   1. If active property is not in nodes , create null , generate a new JSON object blank node with identifier id as the value for @id . Let and store node element be the as value of the member id in nodes activeGraph .
      Issue 207

      Handling of free-floating values is still being discussed.

   2. For each property that is not @id and each Otherwise, if no value list in has been passed, merge element ordered by into the active property : member of the active subject in activeGraph .
   3. If Otherwise, append property element is to the @graph , recursively call this algorithm passing value for element , nodeMap , null for @list member of list and .
5. Otherwise, if graph element is has an @merged @list use graph , otherwise use id for graph and then continue. member, perform the following steps:
   1. If Initialize a new JSON object property result is not @type and is having a keyword, merge single member property @list and whose value into node and then continue. is initialized to an empty array .
   2. For each Recursively call this algorithm passing the value of v element's in the array @list member as new value : If element and v result is a node definition or node reference : as list .
   3. If the active property @id is not an IRI or it does not exist, map v to a is null , new generate a blank node identifier name id to avoid collisions. If one does not already exist, add a node reference for and store v result into as value of the member node id for in property activeGraph .
      Issue 207

      Handling of free-floating values is still being discussed.

   4. Recursively call this algorithm passing Otherwise, add v result for to the the value , nodeMap , graph , null of the active property for list , and name for member of the active subject in id activeGraph .
6. Otherwise if v element has is a node object , perform the property following steps:
   1. If element has an @list @id then recursively call this algorithm with the member, store its value of @list as in element , id and remove the member from nodeMap , element . If graph , and id is a blank node identifier , replace it with a new array flattenedList blank node identifier .
   2. Otherwise generate a new blank node identifier and store it as list id . Create
   3. If activeGraph does not contain a member id , create one and initialize it to a new JSON object with the property consisting of a single member @list @id whose value is set to flattenedList and add it to node for property id .
   4. Otherwise, if If active property is @type and v is not an IRI null , generate perform the following steps:
      1. Create a new blank node identifier JSON object and add it to node reference for consisting of a single member @id whose value is property id .
      2. Otherwise, add If no v list to has been passed, merge node element for into the active property member of the active subject in activeGraph .
      3. Otherwise, append element to the @list member of list .
   After the above outlined algorithm
   5. If element has been executed, the node map for all graphs including an @type member, merge each value into the default graph are contained @type of active subject in nodeMap activeGraph . To also create the node map for the merged graph, execute Then remove the algorithm again, but pass @merged @type for member from graph element . 4.9.3 Generate Blank Node Identifier This algorithm is used by
   6. If element has an @annotation member, set the Node Map Generation Algorithm @annotation of active subject in activeGraph to deterministically name blank node its value. If such a member already exists in active subject identifiers. It uses and has a different value, raise a CONFLICTING_ANNOTATION error. Otherwise continue and remove the @annotation from identifier map element .
   7. If element and has an @graph member, recursively invoke this algorithm passing the value of the @graph member as new prefix element and takes a possibly null identifier and returns a id as new identifier based on active subject . Then remove the @graph member from prefix element . The variable
   8. Finally for each next identifier property is initialized to - prefix appended with 0 . The default value of pair in prefix element is _:t . ordered by property perform the following steps:
      1. If no property member exists in the old identifier is not null JSON object and which is in the identifier map , return the mapped identifier. Otherwise, if value of the old identifier is not null , create a new entry in identifier map id initialized to the current value member of next identifier . Increment next identifier activeGraph by adding one to the integer suffix. Return create the mapped identifier. member and initialize its value to an empty array .
      2. Otherwise, increment Recursively invoke this algorithm passing next identifier value by adding one to the integer suffix as new element , id as new active subject , and return its original value. property as new active property .

4.10 5.16 RDF Conversion Algorithms

A JSON-LD document may be converted between other RDF-compatible document formats using the algorithms specified in this section. The JSON-LD Processing Model This specification describes processing rules for extracting RDF from a algorithms to transform JSON-LD document, and for transforming documents to an array of Quad RDF quads retrieved by processing another serialization format into JSON-LD. 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 during the output process and but are not required to implement the algorithm exactly as described.