JSON-LD Algorithms 1.0 Algorithms for Processing JSON-LD Documents W3C Editor's Draft 25 December 2012 Algorithms and API

Algorithm

This algorithm specifies how a new active property's container mapping context is set to @list updated with a local context . The algorithm takes three input variables: an active context , a local context , and the expanded item is an array or a list object trigger a LIST_OF_LISTS_DETECTED error. remote contexts which is used to detect cyclical context inclusions. If the expanded item remote contexts is null , drop it. Otherwise, if the expanded item not passed, it is initialized to an empty array , merge its entries with result's entries. .

1. Otherwise, append item to Initialize result . Finally, set element to the result and return. of cloning active context .
2. Otherwise, element must be an object. If element has a @context member, update the active local context according is not an array , set it to the steps outlined in Context Processing and remove the @context member. Initialize an empty JSON object array result and containing only local context .
3. then process For each property and value item context in element ordered by property as follows: local context :
   1. If the active context contains a property generator for property set expanded property to its IRIs is null , otherwise set it to the result of expanding property according to the steps outlined in IRI Expansion a newly-initialized active context (passing true for the vocabRelative flag). If expanded property is null , skip the current property - value pair and continue to with the next property - value pair in element . context .
   2. If expanded property context is a keyword string , process it as follows:
      1. If expanded property equals @id , set the @id member of result Set context to the result of expanding resolving value according against the base IRI Expansion algorithm (passing true for the documentRelative flag). If value which is not established as specified in section 5.1 Establishing a string Base URI trigger an INVALID_ID_VALUE error. If expanded property equals @type , set the @type member of result to [ RFC3986 ]. Only the result basic algorithm in section 5.2 of expanding value according the [ IRI Expansion algorithm RFC3986 (passing true for both the documentRelative and the vocabRelative flag). If value ] is used; neither a string Syntax-Based Normalization nor an array Scheme-Based Normalization of strings 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 trigger an INVALID_TYPE_VALUE error. Empty arrays of [ RFC3987 are ignored. ].
      2. If expanded property equals @value , set the @value member of result to value . If value context is neither in the remote contexts array, a scalar nor null trigger an INVALID_VALUE_OBJECT_VALUE recursive context inclusion error. error has been detected and processing is aborted; otherwise, add context to remote contexts .
      3. If expanded property equals @language , set Initialize context no base to the @language member of result to of cloning the lowercased value . If value is not a string , trigger an INVALID_LANGUAGE_VALUE error. active context .
      4. If expanded property equals @annotation , set Remove the @annotation member of result to value . If value is not a string base IRI trigger an INVALID_ANNOTATION_VALUE error. of context no base .
      5. Dereference context . If expanded property equals the dereferenced document has no top-level JSON object with an @set @context or @list , member, an invalid remote context has been detected and processing is aborted; otherwise, set context to the expanded property member value of result that member.
      6. Set context to the result of expanding value by recursively using calling this algorithm, passing copies of the context no base for active context , context for local context , and active property . remote contexts .
      7. If expanded property equals @graph , context has no base IRI but result does, set the @graph member base IRI of result context to the result of expanding value by recursively using this algorithm, passing copies one of the active context and @graph as active property . result .
      8. Continue Overwrite result with context and continue with the next property - value pair from element . context .
   3. If expanded property context is not a JSON object , an absolute IRI ,i.e., it doesn't contain a colon, continue with the next member from element . Otherwise, if property's container mapping invalid local context is set to @language Initialize a new empty array language map values . error has been detected and processing is aborted.
   4. Process each key - val pair of value ordered by key as follows: If val is not context has an array, transform it to one. For each item of val , construct a new JSON object consisting of two members: @value @base set to key:
      Issue 223 : Feature at risk

      This feature is at risk as the currently processed item and fact that a document may have multiple base IRIs is potentially confusing for developers. It is also being discussed whether relative IRIs are allowed as values of @language @base set to or whether the lowercased key . If val is not a empty string , trigger a LANGUAGE_MAP_INVALID_VALUE error. Otherwise append the object to language map values . Set value should be used to language map values . Otherwise, if property's container mapping is set explicitly specify that there isn't a base IRI , which could be used to @annotation ensure that relative IRIs remain relative when expanding.

      1. Initialize a new empty array annotation map values . Process each key - val pair of value ordered by key as follows: If val is not an array, transform it to one. Expand val by recursively using this algorithm, passing copies of the active context and active property . Add to each item of val a member value associated with the @annotation @base set to key if no such member exists yet and append the resulting JSON object to annotation map values . Set value to annotation map values . key.
      2. Otherwise, expand If value by recursively using this algorithm, passing copies of is null , remove the active context base IRI and property as active property . of result .
      3. If the expanded Otherwise, if value equals null is an absolute IRI , continue with the next property - value pair from element . If property's container mapping base IRI of result is set to @list and value . If it is either not an JSON object or a JSON object without absolute IRI , an @list member, replace value with a JSON object invalid base IRI with an @list member whose value is set to value (wrapped in an array if it error has been detected and processing is not already one). aborted.
   5. If expanded property is context has an array , @vocab key:
      1. label all blank nodes in Initialize value to the value associated with blank node identifiers by using the Label Blank Nodes Algorithm . @vocab key.
      2. Then, for each iri of expanded property merge a copy of If value into the iri member of the is null , remove any vocabulary mapping from result JSON object . .
      3. Otherwise, merge if value into is an absolute IRI , the iri member vocabulary mapping of the result JSON object . Set element to result and numProperties is set to the number of members of result . value . If element has it is not an @annotation member, decrease numProperties by 1. If element has absolute IRI , an @value invalid vocab mapping member, decrease numProperties by 1. If element error has an @language member, decrease numProperties by 1 been detected and check that the value of the @value member processing is a string. If not, trigger an INVALID_LANGUAGE_TAGGED_STRING error. aborted.
   6. Otherwise, if element If context has an @type @language member, decrease numProperties by 1 and check that key:
      1. Initialize value to the value of associated with the @type member is a string. If not, trigger an INVALID_TYPED_VALUE @language error. key.
      2. If numProperties value is greater than 0, trigger an INVALID_VALUE_OBJECT error. null , remove any default language from result .
      3. If the Otherwise, if value of the @value member equals null is string , the default language of result is set element to null . Return. If element has an @type member whose lowercased value . If it is not an array a string , transform it to an array . If element has an @list or @set invalid default language member error has been detected and numProperties processing is greater than 1, trigger an INVALID_SET_OR_LIST_OBJECT error. aborted.
   7. Otherwise, if element has an @set member, set element Create a JSON object defined to the value use to keep track of that member. whether or not a term has already been defined or currently being defined during recursion.
   8. Otherwise, if element has just an For each key - value pair in context where key is not @base , @vocab , or @language member, set element to null. , invoke the Create Term Definition algorithm , passing result for active context , context for local context , key , and defined .
4. Return result .

Algorithm

The algorithm takes three input variables: has four required inputs which are: an active context , a local context , a term , and an array of already included remote contexts remoteContexts . To begin, remoteContexts is initialized to an empty array. a map defined .

1. If defined contains the key term and the associated value is true (indicating that the term definition has already been created), return. Otherwise, if the value is false , a cyclic IRI Expansion algorithm mapping pass error has been detected and processing is aborted.
2. Set the value specified in the algorithm along associated with defined 's term key to false . This indicates that the active context , the currently term definition is now being processed local context , and true for the vocabRelative flag. created but is not yet complete.
3. If the local context Since keywords is cannot be overridden, term must not an array, transform it to one. be a keyword . Otherwise, a keyword redefinition error has been detected and processing is aborted.
4. Process each item Remove any existing term definition for term in active context of .
5. Initialize value to the value associated with the key term in local context as follows: .
6. If context equals value is null or value is a JSON object containing the key-value pair @id - null , reset set the term definition in active context and continue with to null , set the next item. value associated with defined 's key term to true , and return.
7. If context Otherwise, if value is a string :
   1. Expand context according value by setting it to the result of using the IRI Expansion . algorithm , passing active context , value , true for vocab , true for document relative , local context , and defined .
   2. If context value is in the remoteContexts array, raise @context , an RECURSIVE_CONTEXT_INCLUSION invalid keyword alias error. Otherwise, add context to remoteContexts . error has been detected and processing is aborted.
   3. Dereference Set the IRI mapping for the term definition for term in active context . to value , set the value associated with defined 's key term to true , and return.
8. If the resulting document is a JSON document consisting of Otherwise, value must be a top-level JSON object , if not, an invalid term definition that has a @context member recursively invoke this algorithm passing error has been detected and processing is aborted.
9. Create a copy of active context new term definition , the definition .
10. If value of contains the key @context member as local context , and a copy of the remoteContexts array. Relative IRIs are expanded using the remote context's IRI . Otherwise raise @reverse :
    1. If value contains an @id , an @type , or an @language , member, an INVALID_REMOTE_CONTEXT invalid reverse property error. error has been detected and processing is aborted.
    2. Continue If the value associated with the next item from context . If context @reverse key is not a JSON object string , raise an INVALID_LOCAL_CONTEXT invalid IRI mapping error. error has been detected and processing is aborted.
    3. Otherwise, if set the IRI mapping of definition to the result of using the IRI Expansion algorithm , passing active context is an JSON object , perform the following steps: If context has a value associated with the @vocab @reverse member: if its key for value , true for vocab , true for document relative , local context , and defined . If the result is neither not an absolute IRI , i.e., it does not contain a contains no colon ( : ), nor null , trigger an INVALID_VOCAB_MAPPING invalid IRI mapping error; otherwise set error has been detected and processing is aborted.
    4. Set the active context's vocabulary type mapping of definition to its value and remove the @vocab member from context . @id .
    5. If context has a @language member: if its value is neither a string nor null , trigger contains an INVALID_DEFAULT_LANGUAGE @container error; otherwise member, set the active context's default language container mapping of definition to its value and remove the @language @index member from context . For each other key - value pair in context perform the following steps: Remove if that is the key - value pair from context . of the @container member; otherwise an invalid reverse property error has been detected (reverse properties only support index-containers) and processing is aborted.
    6. If key is a JSON-LD keyword , continue with Set the next key - value pair. reverse property flag of definition to true .
    7. If value equals null , replace Set the term definition for key of term in the active context to definition and the value associated with an IRI mapping set defined 's key term to null true and continue with return.
11. Set the next key - value pair. reverse property flag of definition to false .
12. If value contains the key @id :
    1. If the value associated with the @id key is not a string , expand it according to the an invalid IRI Expansion algorithm mapping error has been detected and replace the term definition for key in processing is aborted.
    2. Otherwise, set the active context with an IRI mapping set of definition to the expanded result of using the IRI Expansion algorithm , passing active context , the value . Continue associated with the next @id key - for value pair. , true for vocab , true for document relative , local context , and defined .
13. If value is not Otherwise if the term contains a JSON object , trigger an INVALID_TERM_DEFINITION colon ( : error ):
    1. If term definition is a compact IRI for with a prefix that is a key exists in the local context a dependency has been found. Use this algorithm recursively passing active context , remove it. Initialize a new, empty term definition local context , the prefix definition . as term , and defined .
    2. If value term 's prefix has an @id member with a value val : if val is null term definition in active context , set the IRI mapping of definition to val . if val is an array , process each item in the array: if item is a string expand it according result of concatenating the value associated with the prefix 's IRI Expansion algorithm . otherwise, raise an INVALID_PROPERTY_GENERATOR error. if val is an array , lexicographically sort val mapping and set definition to val . the term 's suffix .
    3. Otherwise, if val term is a string , expand it according an absolute IRI . Set the IRI Expansion algorithm mapping and set of definition to val . term .
14. If Otherwise, if active context has a vocabulary mapping , the IRI mapping of definition is set to null or a keyword , store the definition as result of concatenating the term definition for key in value associated with the active context vocabulary mapping and continue with the next key - value pair from context . Otherwise, set the term . If it does not have a vocabulary mapping , an invalid IRI mapping of definition to the result of expanding key according the IRI Expansion algorithm . error been detected and processing is aborted.
15. If value has an contains the key @type member with a :
    1. Initialize type to the value val and val is not associated with the @type key, which must be a string or does not expand to . Otherwise, an absolute IRI invalid type mapping error has been detected and processing is aborted.
    2. Set type to the result of using the IRI Expansion algorithm , raise an INVALID_TYPE_MAPPING error. Otherwise set passing active context , type for value , true for vocab , true for document relative , local context , and defined . If the expanded type is neither @id , nor @vocab , nor an absolute IRI , an invalid type mapping of definition to the expanded val . Otherwise, if value has an @language member with a value val that error has been detected and processing is a string or null , set aborted.
    3. Set the language type mapping of for definition to the lowercased val . If val is neither a string nor null , raise an INVALID_LANGUAGE_MAPPING error. type .
16. f If value has an contains the key @container member with a :
    1. Initialize container to the value val that equals associated with the @container key, which must be either @list , @set , or @annotation @index , set or @language . Otherwise, an invalid container mapping error has been detected and processing is aborted.
    2. Set the container mapping of definition to val . container .
17. If val is value contains the key @language and does not one of those values, raise contain the key @type :
    1. Initialize language to the value associated with the @language key, which must be either null or a string . Otherwise, an INVALID_CONTAINER_MAPPING invalid language mapping error. error has been detected and processing is aborted.
    2. If language is a string set it to lowercased language . Set the language mapping of definition to language .
18. Set the term definition of term in active context to definition and set the value associated with defined 's key term to true .

Algorithm

The algorithm takes two mandatory required and four optional input variables: variables. The required inputs are an active context and a value to be expanded, an active context , expanded. The optional inputs are two flags documentRelative flags, document relative and vocabRelative vocab , that specifying whether value should can be interpreted as a relative IRI against the document's base IRI or the active context's vocabulary mapping , along with an respectively, and a local context passed and a map defined to be used when this algorithm is used in during 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 local context and defined are initialized to an empty array by default. The algorithm for generating an IRI is: null .

1. If value is null or a JSON-LD keyword or null , return value as is.
2. If a local context has been passed and value is in the path array, raise not null , it contains a CYCLIC_IRI_MAPPING error. Otherwise append key that equals value to path . If local context contains an IRI mapping for , and the value associated with the key that equals value in defined is not a property generator return true , invoke the result of recursively calling this Create Term Definition algorithm , passing the IRI of the IRI mapping as new value , the active context and , local context , path , value as term , and true for the vocabRelative flag. If the result is defined . This will ensure that a property generator , raise an PROPERTY_GENERATOR_IN_TERM_DEFINITION error. If an IRI mapping term definition exists is created for value in the active context that during Context Processing .
3. If vocab is not a property generator true return and the active context has a term definition for value of , return the associated IRI mapping .
4. If value contains a colon ( : ), perform the following steps: it is either an absolute IRI or a compact IRI :
   1. Split value into a prefix and suffix at the first occurrence of a colon ( : ).
   2. If prefix is not underscore ( _ ) and suffix begins does not begin with double-forward-slash ( // or prefix equals _ , return value as is. ), it may be a compact IRI :
      1. If a local context has been passed, expand prefix by recursively invoking this algorithm passing is not null , it contains a key that equals prefix as , and the value , associated with the key that equals prefix in defined is not true , invoke the Create Term Definition algorithm , passing active context and , local context , path , and true for the vocabRelative flag. If the expanded prefix contains a colon ( : ) generate as term , and return an IRI defined . This will ensure that a term definition by prepending the expanded is created for prefix to the (possibly empty) suffix using textual concatenation. in active context during Context Processing .
      2. Otherwise, if the If active context contains an IRI mapping a term definition for prefix that is not a property generator , generate and return an the result of concatenating the IRI mapping by prepending the associated with prefix and suffix .
   3. Return value as it is already an absolute IRI mapped to prefix to the (possibly empty) suffix using textual concatenation. .
5. Otherwise, if the vocabRelative flag If vocab is set to true , and the active context contains has a vocabulary mapping , generate and return an IRI by prepending the IRI result of concatenating the vocabulary mapping to the with value using textual concatenation. .
6. Otherwise, if the documentRelative flag document relative is true , set value to true , resolve the result of resolving 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 Scheme-Based Normalization ]) are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [ RFC3987 ] ].
7. Otherwise If local context is not null and value is not an absolute IRI , an invalid IRI mapping error has been detected and processing is aborted.
8. Otherwise, return value as is.

Algorithm

The algorithm for expanding a value takes three input variables: an active context , an active property , and an element to be expanded. To begin, the active context . It is implemented as follows: 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 .

1. If value element is null , return null .
2. If element is a scalar ,
   1. If active property is null or @graph , drop the free-floating scalar by returning null .
   2. Return the result of the Value Expansion algorithm , passing the active context , active property , and element as value .
3. If element is an array ,
   1. Initialize an empty object array, result . .
   2. For each item in element :
      1. Initialize expanded item to the result of using this algorithm recursively, passing active context , active property , and item as element .
      2. If the active property is @graph @list or the active property's type its container mapping is set to @id @list , add the expanded item must not be an array or a key-value pair list object , otherwise a list of lists error has been detected and processing is aborted.
      3. If expanded item is an array , append each of its items to result where . Otherwise, if expanded item is not null, append it to result .
   3. Return result .
4. Otherwise element is a JSON object .
5. If element contains the key is @id @context , set active context to the result of the Context Processing algorithm , passing active context and the value is of the @context key as local context .
6. Initialize an empty JSON object , result of expanding .
7. For each key and value according in element , ordered lexicographically by key :
   1. If key is @context , continue to the next key .
   2. Set expanded property to the result of using the IRI Expansion algorithm , passing active context , key for value , and true for the documentRelative flag. Then return result . vocab .
   3. Add If expanded property is null or it neither contains a key-value pair colon ( : ) nor it is a keyword , drop key by continuing to result where the next key .
   4. If expanded property is a keyword :
      1. If active property equals @value @reverse , an invalid reverse property map error has been detected and the value processing is value . aborted.
      2. If the active result has already an expanded property member, an colliding keywords error has been detected and processing is aborted.
      3. If expanded property is @id and value is not a type mapping string , add a key-value pair an invalid @id value error has been detected and processing is aborted. Otherwise, set expanded value to the result where of using the key IRI Expansion algorithm , passing active context , value , and true for document relative .
      4. If expanded property is @type and the value is neither a string nor an array of strings , an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm , passing active context , true associated with the type mapping for vocab , and true for document relative to expand the value or each of its items.
      5. If expanded property is @graph , set expanded value to the result of using this algorithm recursively passing active context , @graph for active property , and value for element .
      6. If expanded property is @value and value is not a newly generated blank node identifier scalar if the type mapping or null , an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to a blank node identifier . value . If expanded value is null , set the @value member of result to null and continue with the next key from element . Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
      7. Otherwise, if If expanded property is @language and value is not a string , an invalid language-tagged string error has been detected and the active processing is aborted. Otherwise, set expanded value to lowercased value .
      8. If expanded property has is @index and value is not a language mapping or string , an default language invalid @index value error has been detected and processing is aborted. Otherwise, set in expanded value to value .
      9. If expanded property is @list :
         1. If active property is null or @graph , continue with the next key from element to remove the free-floating list..
         2. Otherwise, initialize expanded value to the result of using this algorithm recursively passing active context , add active property , and value for element .
         3. If expanded value is a key-value pair list object , a list of lists error has been detected and processing is aborted.
      10. If expanded property is @set , set expanded value to result where the key result of using this algorithm recursively, passing active context , active property , and value for element .
      11. If expanded property is @language @reverse and the value is the language tag associated with the language mapping not a JSON object , an invalid @reverse value or error has been detected and processing is aborted. Otherwise
          1. Initialize expanded value to the result of using this algorithm recursively, passing active context , @reverse as active property or , and value as element .
          2. If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the default language following steps:
             1. If result does not have a property member, create one and set its value to an empty array .
             2. Return Append item to the value of the property member of result . .
             5.6 Label Blank Nodes Algorithm The algorithm takes a single input variable:
          3. If expanded value contains members other than @reverse :
             1. If result does not have an element @reverse member, create one and set its value to be labeled with blank node identifiers an empty JSON object .
             2. Reference the value of the @reverse member in result using the variable reverse map .
             3. For each property and items in expanded value other than @reverse :
                1. For each item in items :
                   1. If element item is a value object or list object , an invalid reverse property value has been detected and processing is aborted.
                   2. If reverse map has no property member, create one and initialize its value to an empty array .
                   3. Append item to the value of the property member in reverse map .
          4. Continue with the next key from element .
      12. Unless expanded value is null , recursively apply this algorithm set the expanded property member of result to all its items. expanded value .
      13. Continue with the next key from element. .
   5. Otherwise, if element key 's container mapping in active context is @language and value is a JSON object with then value is expanded from a @list language map as follows:
      1. Initialize expanded value to an empty array .
      2. For each key-value pair language - language value in value , ordered lexicographically by language :
         1. If language value is not an array set it to an array containing only language value .
         2. For each item in language value :
            1. item must be a string , otherwise an invalid language map value member, recursively apply this algorithm error has been detected and processing is aborted.
            2. Append a JSON object to all items expanded value that consists of the two key-value pairs: ( @list @value member's value. - item ) and ( @language -lowercased language ).
   6. Otherwise, if element key 's container mapping in active context is @index and value is a JSON object then value is expanded from an index map as follows:
      1. Initialize expanded value to an empty array .
      2. For each key key-value pair index - index value pair in value , ordered lexicographically by key recursively apply index :
         1. If index value is not an array set it to an array containing only index value .
         2. Initialize index value to the result of using this algorithm recursively, passing active context , key as active property , and index value as element .
         3. For each item in index value :
            1. If item does not have the key @index , add the key-value pair ( @index - index ) to item .
            2. Append item to expanded value . .
   7. Otherwise, initialize expanded value to the result of using this algorithm recursively, passing active context , key for active property , and value for element .
   8. If expanded value is null , ignore key by continuing to the next key from element .
   9. If the container mapping associated to key in active context is @list and expanded value is not already a node list object , convert expanded value to a list object without by first setting it to an array containing only expanded value if it is not already an array , and then by setting it to a JSON object containing the key-value pair @id @list - expanded value .
   10. Otherwise, if the term definition associated to key indicates that it is a reverse property
       1. If result has no @reverse member, create a new one and initialize its value to an empty JSON object .
       2. Reference the value of the @id @reverse member and assign in result using the variable reverse map .
       3. If expanded value is not an array , set it to an array containing expanded value .
       4. For each item in expanded value
          1. If item is a new blank node identifier value object according the Generate Blank Node Identifier or list object , an invalid reverse property value algorithm. has been detected and processing is aborted.
          2. If reverse map has no expanded property member, create one and initialize its value to an empty array .
          3. Append item to the value of the expanded property member of reverse map .
       5.7 Generate Blank Node Identifier This algorithm
   11. Otherwise, if key is used to generate new blank node identifiers or to relabel existing blank node identifiers with not a new reverse property :
       1. If result does not have an expanded property member, create one and initialize its value to avoid collision by an empty array .
       2. Append expanded value to value of the introduction expanded property member of new ones. result .
8. If result contains the key @value :
   1. The result must not contain any keys other than @value , @language , @type , and @index . It needs must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
   2. If the value of result 's @value key is null , then set result to keep null .
   3. Otherwise, if the value of result 's @value member is not a string and result contains the key @language , an identifier map , invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
   4. Otherwise, if the result has a counter , @type member and its value is not a prefix between string , an invalid typed value error has been detected and processing is aborted.
9. Otherwise, if result contains the key @type and its executions associated value is not an array , set it to an array containing only the associated value.
10. Otherwise, if result contains the key @set or @list :
    1. The result must contain at most one other key and that key must be able @index . Otherwise, an invalid set or list object error has been detected and processing is aborted.
    2. If result contains the key @set , then set result to generate new blank node identifiers the key's associated value.
11. If result contains only the key @language , set result to null . The counter
12. If active property is initialized null or @graph , drop free-floating values as follows:
    1. If result is an empty JSON object or contains the keys @value or @list , set result to null .
    2. Otherwise, if result is a JSON object whose only key is 0 @id , set result to null .
13. Return result .

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

Algorithm

The algorithm takes three required inputs: an active context , an active property , and a single input variable identifier which might be null . value to expand.

1. If the identifier active property has a type mapping in active context that is not null @id , return a new JSON object containing a single key-value pair where the key is @id and the value is in the identifier map , return result of using the mapped identifier. IRI Expansion algorithm , passing active context , value , and true for document relative .
2. Otherwise, generate If active property has a type mapping in active context that is @vocab , return a new blankNodeIdentifier by concatenating prefix JSON object containing a single key-value pair where the key is @id and counter . the value is the result of using the IRI Expansion algorithm , passing active context , value , true for vocab , and true for document relative .
3. Increment counter by Otherwise, initialize result to a JSON object with an 1 . @value member whose value is set to value .
4. If identifier is not null active property has a type mapping in active context , create add an @type member to result and set its value to the value associated with the type mapping .
5. Otherwise, if value is a new entry string :
   1. If a language mapping is associated with active property in identifier map active context , add an @language to result and set its value to blankNodeIdentifer . the language code associated with the language mapping ; unless the language mapping is set to null in which case no member is added.
   2. Otherwise, if the active context has a default language , add an @language to result and set its value to the default language .
6. Return blankNodeIdentifier . result .

Algorithm

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

1. If element is a scalar , it is already in its most compact form, so simply return element .
2. If element is an array , :
   1. Initialize a new result to an empty array result . .
   2. Process For each item in element recursively :
      1. Initialize compacted item to the result of using this algorithm, algorithm recursively, passing a copy of the active context , inverse context , and the active property . Add each , and em>item for element .
      2. If compacted item to result unless it is not null . , then append it to result .
   3. If result contains only one item (it has a single item length of 1 ), active property has no container mapping in active context , and the compactArrays option is true , set result to true , return that item; otherwise return its only item.
   4. Return result . .
3. If Otherwise element is not a JSON object it is already in compact form, return it as is. .
4. If element has an @value or @id member, replace element with member and the result of using the Value Compaction algorithm . If the updated , passing active context , inverse context , active property ,and element as value is a scalar , return it as it cannot be further compacted. that result.
5. Initialize a new inside reverse to true if active property equals @reverse , otherwise to false .
6. Initialize result to an empty JSON object result. .
7. Process For each key expanded property and value expanded value in element , ordered lexicographically by expanded property as follows: :
   1. If expanded property is a JSON-LD keyword and property equals @id , compact or @type :
      1. If expanded value according is a string , then initialize compacted value to the rules result of using the IRI Compaction algorithm . Otherwise, , passing active context , inverse context , expanded value for iri , and true for vocab if expanded property equals is @type , compact false otherwise.
      2. Otherwise, expanded value (or each item of must be a @type array :
         1. Initialize compacted value if it is to an empty array ) according .
         2. For each item expanded type in expanded value , append the rules result of of using the IRI Compaction algorithm , passing active context , inverse context , expanded type for iri , and true with the vocabRelative flag set for vocab , to true . compacted value .
         3. If compacted value is an array consisting of just contains only one item, replace item (it has a length of 1 ), then set compacted value with that to its only item.
      3. Otherwise, if Initialize alias to the result of using the IRI Compaction algorithm , passing active context , inverse context , and expanded property equals for iri .
      4. Add a member alias to result whose value is set to compacted value and continue to the next expanded property .
   2. If expanded property is @graph , compact @reverse :
      1. Initialize compacted value by recursively invoking to the result of using this algorithm, algorithm recursively, passing a copy of the active context , inverse context , @reverse for active property , and expanded value for element .
      2. For each property as active and value in compacted value :
         1. If the term definition for property in the active context ensuring indicates that property is a reverse property
            1. If compactArrays is false and value is not an array , set value to a new array containing only value .
            2. If property is not a member of result , add one and set its value to value .
            3. Otherwise, if the value of the property member of result is not an array . , set it to a new array containing only the value. Then append value to its value if value is not an array , otherwise append each of its items.
            4. Set active Remove the property member from compacted value .
      3. If compacted value has some remaining members, i.e., it is not an empty JSON object :
         1. Initialize alias to the result of performing using the IRI Compaction on property . algorithm , passing active context , inverse context , and @reverse for iri .
         2. Set the active property value of the alias member of result to compacted value . Continue and continue with the next expanded property - value pair from element . .
   3. If value expanded property is an empty array , set @index and active property has a container mapping in active context that is @index , then the compacted result will be inside of an @index container, drop the @index property by continuing to the next expanded property .
   4. Otherwise, if expanded property is @index , @value , or @language :
      1. Initialize alias to the result of performing using the IRI Compaction on algorithm , passing active context , inverse context , and expanded property with the vocabRelative flag for iri .
      2. Add a member alias to result whose value is set to true . expanded value and continue with the next expanded property .
   5. If active property is a JSON object , i.e., it expanded value is a property generator , set an empty array :
      1. Initialize item active property to the result of performing using the Find and Remove Property Generator Duplicates IRI Compaction algorithm , passing element , property , null for value, the active context , and active inverse context , expanded property . for iri , expanded value for value , true for vocab , and inside reverse .
      2. Ensure that If result has an does not have the key that equals item active property member; if not create it and , set its this key's value in result to an empty array . Continue with Otherwise, if the next property - key's value pair from element . is not an array , then set it to one containing only the value.
   6. Otherwise perform At this point, expanded value must be an array due to the following steps for Expansion algorithm . For each item of expanded item in expanded value : :
      1. Set Initialize item active property to the result of performing using the IRI Compaction algorithm , passing active context , inverse context , expanded property for iri , expanded item for value , true on for vocab , and inside reverse .
      2. Initialize container to null . If there is a container mapping for item active property with the vocabRelative flag in active context , set container to true . its value.
      3. If Initialize compacted item to the result of using this algorithm recursively, passing active context , inverse context , item active property for active property , expanded item for element if it does not contain the key @list , otherwise pass the key's associated value for element .
      4. If expanded item is a JSON list object :
         1. If compacted item is not an array , i.e., then set it to an array containing only compacted item .
         2. If container is not @list :
            1. Convert compacted item to a property generator , set active property list object by setting it to a JSON object containing key-value pair where the key is the result of performing the Find and Remove Property Generator Duplicates IRI Compaction algorithm , passing element , property , item , the active context , inverse context , @list for iri , and active property . compacted item for value .
            2. If expanded item contains the key @index , then add a key-value pair to compacted item where the key is the result of the IRI Compaction algorithm , passing active property's context , inverse context , @index as iri , and the associated with the @index key in expanded item as value .
         3. Otherwise, item active property must not be a key in result because there cannot be two list objects associated with an active property that has a container mapping is set ; a compaction to list of lists error has been detected and processing is aborted.
      5. If container is @language or @annotation @index :
         1. Unless result has already an If item active property member, create one and is a key in result , then initialize map object to its value associated value, otherwise initialize it to an empty JSON object . This object
         2. If container is called mapObject . @language and compacted item contains the key @value , then set compacted item to the value associated with its @value key.
         3. Set index Initialize map key to the value of associated with with the key that equals container in expanded item .
         4. If map key is not a key in map object , then set this key's value in map object to compacted item . Otherwise, if the value is not an array , then set it to one containing only the value and then append compacted item to it.
      6. Otherwise,
         1. If compactArrays is false , container is @language @set or @annotation @list , or expanded property is @list member of or @graph and compacted item (depending on is not an array , set it to a new array containing only compacted item .
         2. If item active property is not a key in result then add the key-value pair, ( item active property - compacted item ), to result .
         3. Otherwise, if the value of associated with the key that equals item active property's container mapping property in result is not an array , set it to a new array ). containing only the value. Then append compacted item to the value if compacted item is not an array , otherwise, concatenate it.
8. First compact item using Return result .

If, after the Value Compaction algorithm passing index as containerValue , then compact outlined above is run, the result result is an array , replace it by recursively invoking this algorithm passing with a copy new JSON object with a single member whose key is the result of using the IRI Compaction algorithm , passing active context , inverse context , and @graph as iri and whose value is the active property . If no index array result . Finally, if a context has been passed, add an @context member exists in the mapObject create one to result and set its value to item ; otherwise append item to the index member (converting passed context .

Algorithm

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

1. Initialize result to an array empty JSON object .
2. Initialize default language to @none . If the active property's container mapping context is has a default language , set default language to @list , set it.
3. For each key term and value term definition in the active property context , ordered by shortest term member of result to first (breaking ties by choosing the value of item's @list member. lexicographically least term ):
   1. If such an member already exists in result, raise an COMPACTION_TO_LIST_OF_LISTS error; otherwise the term definition is null , term cannot be selected during compaction , so continue with to the next property - value pair from element . term .
   2. Initialize container to @none . If item there is a JSON object container mapping in term definition , compact it by recursively invoking this algorithm passing a copy set container to its associated value.
   3. Initialize iri to the value of the active context , inverse context , and IRI mapping for the active property term definition .
   4. If no active property iri is not a key in result , add a key-value pair where the key is iri and the value is an empty JSON object to result .
   5. Reference the value associated with the iri member exists in result using the variable container map .
   6. If container has no container map member, create one and set its value to item ; otherwise append item to the active property a new JSON object with two members. The first member (converting it to an array if it is not one already). @language and its value is a new empty JSON object , the second member is @type and its value is a new empty JSON object .
   7. Reference the value associated with the container member in container map using the variable type/language map .
   8. If the compactArrays term definition indicates that the term represents a reverse property :
      1. Reference the value associated with the @type option is member in type/language map using the variable type map .
      2. If type map does not have a @reverse member, create one and set its value to the term being processed.
   9. Otherwise, if term definition has a type mapping :
      1. Reference the value associated with the false @type or member in type/language map using the active property's container variable type map .
      2. If type map does not have a member corresponding to the type mapping is in term definition , create one and set its value to the term being processed.
   10. Otherwise, if term definition has a language mapping (might be null ):
       1. Reference the value associated with the @list @language or @set , convert member in type/language map using the value of variable language map .
       2. If the active property language mapping member of result equals null , set language to an array if @null ; otherwise set it is to the language code in language mapping .
       3. If language map does not have a language member, create one already. and set its value to the term being processed.
   If, after the algorithm outlined above is run,
   11. Otherwise:
       1. Reference the resulting element is an array replace it value associated with the @language member in type/language map using the variable language map .
       2. If language map does not have a new JSON object default language member, create one and set its value to the term with being processed.
       3. If language map does not have a single member whose name is @none member, create one and set its value to the result of compacting term being processed.
       4. Reference the value associated with the @graph @type with member in type/language map using the IRI Compaction algorithm and whose value is element . Finally, add variable type map .
       5. If type map does not have a @context @none property to element member, create one and set it its value to the initially passed context . term being processed.
4. Return result .

Algorithm

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

1. Initialize a variable result to If iri is null , return null .
2. If an entry for vocab is true and iri exists is a key in the inverse context , perform the following steps: :
   1. If a value Initialize default language to active context's default language , if it has been passed, perform the following steps: one, otherwise to @none .
   2. Initialize queryPath , which containers to an empty array . This array will be used to query the inverse context , to keep track of an empty array ordered list of preferred container mappings for a term , based on what is compatible with value .
   3. Initialize container type/language to @set @language , typeOrLanguage , and typeLanguageValue type/language value to null . @null . These two variables will keep track of the preferred type mapping or language mapping for a term , based on what is compatible with value .
   4. If value is a JSON object and it has an that contains the key @annotation @index , then append the value @index member, set container to @annotation . containers .
   5. If value has an @id member, reverse is true , set typeOrLanguage type/language to @type and typeLanguageValue , type/language value to @id . @reverse , and append @set to containers .
   6. Otherwise, if value has an @value member, is a list object , then set type/language and type/language value to the most specific values that work for all items in the list as follows:
      1. and an If @type @index member, set typeOrLanguage to is a not key in value , then append @type @list and typeLanguageValue to containers .
      2. Initialize list to the value of array associated with the key @type @list member of in value . .
      3. Otherwise, if it has an @language member, Initialize common language to null . If list is empty, set typeOrLanguage common language to default language .
      4. For each item in list :
         1. Initialize item language to @language @none and typeLanguageValue item type to @none .
         2. If item contains the value of the key @language member of value . @value :
            1. If value has no item contains the key @annotation member, @language , then set container item language to @language its associated value.
            2. Otherwise, if item contains the value of value's key @value member is is a string , @type , set typeOrLanguage item type to @language and typeLanguageValue its associated value.
            3. Otherwise, set item language to @null .
         3. Otherwise, if value has an set item type to @list member, @id .
         4. If the @list member has at least one item, update container , typeOrLanguage , and typeLanguageValue by recursively running the steps 2.1.2 common language is null , set it to 2.1.3.4 (which will never be true since list of lists are item language .
         5. Otherwise, if item language does not allowed) of this algorithm passing the first equal common language and item of value's contains the key @list @value , then set common language to @none member as new value . because list items have conflicting languages.
         6. If value has no @annotation member, common type is null , set container it to @list . item type .
         7. Starting from the second Otherwise, if item of value's type does not equal common type , then set common type to @list @none member, recursively run the steps 2.1.2 to 2.1.3.4 (which will never be true since because list of lists are not allowed) of this algorithm passing the item as new value . items have conflicting types.
         8. If common language is @none and common type is @none , then stop processing items in the resulting typeOrLanguage list because it has been detected that there is no common language or typeLanguageValue differ from type amongst the current value of typeOrLanguage or typeLanguageValue , items.
      5. If common language is null , set both it to @none .
      6. If common type is null and stop processing the , set it to @list @none .
      7. If common type is not @none items. then set type/language to @type and type/language value to common type .
      8. Otherwise, set type/language value to common language .
   7. Otherwise:
      1. If value is a value object :
         1. If value contains the container equals key @list @language and does not contain the key @index , then set the first item of queryPath type/language value to an array consisting of the two elements @list its associated value and append null @language ; otherwise set it to an array consisting of three elements where the first element is the containers .
         2. Otherwise, if value of container and contains the other two elements are key @set @type , then set type/language value to its associated value and set type/language to @null @type .
      2. If typeOrLanguage is null , Otherwise, set the second type/language to @type and the the third item of queryPath set type/language value to an array consisting of a single element @null @id .
      3. Otherwise, set the second item of queryPath Append @set to an array consisting containers .
   8. Append @none to containers . This represents the non-existence of two elements where a container mapping , and it will be the first element last container mapping value to be checked as it is the most generic.
   9. If type/language value of typeOrLanguage and the second element is null , set it to @null . Set This is the third item of queryPath key under which null values are stored in the inverse context entry .
   10. Initialize preferred values to an empty array . This array whose first element typeLanguageValue and whose second element will indicate, in order, the preferred values for a term's type mapping or language mapping .
   11. If type/language value is @null . @reverse , append @reverse to preferred values .
   12. Query If type/language value is @id or @reverse and value has an @id member:
       1. If the result of using the IRI compaction algorithm , passing active context , inverse context and store , the result value associated with the @id key in result . If result is a a string value for iri , true or for vocab , and true for document relative has a JSON object term definition in the active context with a an IRI mapping that equals the value associated with the term @id member, return result . key in value , then append @vocab , @id , and @none , in that order, to preferred values .
       2. Otherwise, append @id , @vocab , and @none , in that order, to preferred values .
   13. Otherwise, if the entry for iri append type/language value and @none , in that order, to preferred values .
   14. Initialize term to the result of the Term Selection algorithm , passing inverse context has a , iri , containers , type/language , and preferred values .
   15. If term member, is not null , return its value. term .
3. At this point, there is no simple term that iri can be compacted to. Instead, try to create a compact IRI , starting by initializing compact IRI to null . This variable will be used to store the created compact IRI , if any.
4. For each termIri - termDefinition pair in inverse context key term and value term definition sorted in reverse order by termIri the (longest termIri comes first), perform the following steps: active context :
   1. If termDefinition does not have a the term member, i.e., it is contains a property generator, colon ( : ), then continue with to the next termIri - termDefinition pair from inverse context term because terms with colons can't be used as prefixes .
   2. Otherwise, if iri begins with termIri and If the term definition is longer than termIri , generate a compact null , its IRI mapping equals iri , or its IRI mapping by concatenating is not a substring at the value beginning of iri , the term member of termDefinition cannot be used as a prefix because it is not a partial match with iri . Continue with the next term .
   3. Initialize candidate by concatenating term , a colon ( : ) character ), and the unmatched part substring of iri . that follows after the value of the term definition's IRI mapping .
   4. If either compact IRI is null or candidate is shorter or the resulting same length but lexicographically less than compact IRI and candidate does not have a term definition has an entry in the active context , continue with the next termIri - termDefinition pair from inverse context as or if the term definition has an IRI mapping that equals iri and value is null , set compact IRI cannot be used. to candidate .
5. Otherwise, if result If compact IRI is not null , return the compact IRI ; if it .
6. At this point, there is not null, set the term member of result to the no compact IRI and return result . If the vocabRelative flag that iri can be compacted to, so if vocab is set to true , the and active context has a vocabulary mapping , and :
   1. If iri begins with the IRI of the vocabulary mapping mapping's value but is longer Set vocabIri longer, then initialize suffix to the unmatched part substring of iri . that does not match. If there suffix does not exist an entry for vocabIri have a term definition in the active context , then return vocabIri if result is null ; if it is not null set the term member of result to vocabIri and return result . suffix .
7. If result vocab is null , return false then transform iri as is. to a relative IRI using the document's base IRI .
8. Otherwise set the term member of result to iri and Finally, return result . iri as is.