JSON-LD API 1.0

3.2.1 Methods

compact

Compacts the given input using the context according to the steps in the Compaction Algorithm. The input must be copied, compacted and returned if there are no errors. If the compaction fails, an appropriate exception must be thrown.

INVALID_SYNTAX

A general syntax error was detected in the @context. For example, if a @type key maps to anything other than @id or an absolute IRI, this exception would be raised.

LOAD_ERROR

There was a problem encountered loading a remote context.

LOSSY_COMPACTION

The compaction would lead to a loss of information, such as a @language value.

CONFLICTING_DATATYPES

The target datatype specified in the coercion rule and the datatype for the typed literal do not match.

LIST_OF_LISTS_DETECTED

A list of lists was detected. This is not supported in this version of JSON-LD.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or IRI	✘	✘	The JSON-LD object or array of JSON-LD objects to perform the compaction upon or an IRI referencing the JSON-LD document to compact.
context	object or IRI	✘	✘	The context to use when compacting the input; either in the form of an JSON object or as IRI.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✔	✔	A set of options that may affect the expansion algorithm such as, e.g., the input document's base IRI. This also includes optimize, which if set will cause processor-specific optimization.

Return type: void

expand

Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned if there are no errors. If the expansion fails, an appropriate exception must be thrown.

INVALID_SYNTAX

A general syntax error was detected in the @context. For example, if a @type key maps to anything other than @id or an absolute IRI, this exception would be raised.

LOAD_ERROR

There was a problem encountered loading a remote context.

LIST_OF_LISTS_DETECTED

A list of lists was detected. This is not supported in this version of JSON-LD.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or IRI	✘	✘	The JSON-LD object or array of JSON-LD objects to perform the expansion upon or an IRI referencing the JSON-LD document to expand.
context	object or IRI	✔	✘	An optional external context to use additionally to the context embedded in input when expanding the input.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✔	✔	A set of options that may affect the expansion algorithm such as, e.g., the input document's base IRI.

Return type: void

flatten

Flattens the given input according to the steps in the Flattening Algorithm. The input must be flattened and returned if there are no errors. If the flattening fails, an appropriate exception must be thrown.

Issue

It is still being discussed if the flatten() method should be added or not. See ISSUE-109.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or IRI	✘	✘	The JSON-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
graph	string or IRI	✘	✘	The graph in the document that should be flattened. To return the default graph @default has to be passed, for the merged graph @merged and for any other graph the IRI identifying the graph has to be passed. The default value is @merged.
context	object or IRI	✔	✘	An optional external context to use additionally to the context embedded in input when expanding the input.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✔	✔	A set of options that may affect the expansion algorithm such as, e.g., the input document's base IRI.

Return type: void

fromRDF

Creates a JSON-LD document given an set of Quads.

Parameter	Type	Nullable	Optional	Description
input	Quad[]	✘	✘	A dataset represented as an array of Quads.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✔	✔	A set of options that will affect the algorithm. This includes notType, which if set to true causes the resulting document to use rdf:type as a property, instead of @type.

Return type: void

toRDF

Processes the input according to the Convert to RDF Algorithm, calling the provided callback for each Quad generated.

INVALID_SYNTAX

A general syntax error was detected in the @context. For example, if a @type key maps to anything other than @id or an absolute IRI, this exception would be raised.

LOAD_ERROR

There was a problem encountered loading a remote context.

LIST_OF_LISTS_DETECTED

A list of lists was detected. This is not supported in this version of JSON-LD.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or IRI	✘	✘	The JSON-LD object or array of JSON-LD objects to convert to RDF or a IRI referencing the JSON-LD document to convert to RDF.
callback	QuadCallback	✘	✘	A callback that is called when a Quad is created from processing the given input.
options	JsonLdOptions	✔	✔	A set of options that may affect the conversion to RDF such as, e.g., the input document's base IRI.

Return type: void

3.3.1 JsonLdCallback

The JsonLdCallback is used to return a processed JSON-LD representation as the result of processing an API method.

[NoInterfaceObject Callback]
interface JsonLdCallback {
    void jsonLd (object or object[] jsonld);
};

3.3.2 QuadCallback

The QuadCallback is called whenever the processor generates a quad during the quad() call.

[NoInterfaceObject Callback]
interface QuadCallback {
    void quad (Quad quad);
};

3.4.1 IRI

The IRI datatype is a string representation of an IRI.

typedef DOMString IRI;

3.4.2 JsonLdOptions

The JsonLdOptions type is used to pass various options to the JsonLdProcessor methods.

dictionary JsonLdOptions {
    IRI?    base;
    boolean compactArrays = true;
    boolean optimize = false;
    boolean useRdfType = false;
    boolean useNativeTypes = true;
};

3.4.3 Quad

The Quad interface represents an RDF Quad. See [RDF-CONCEPTS] definition for RDF triple, which most closely aligns to Quad.

[NoInterfaceObject]
interface Quad {
    readonly attribute Node  subject;
    readonly attribute Node  property;
    readonly attribute Node  object;
    readonly attribute Node? graphName;
};

3.4.4 Node

Node is the base class of IRI, BlankNode, and Literal. It is the IDL representation of a linked data graph node.

[NoInterfaceObject]
interface Node {
};

3.4.5 IRI

A node that is an IRI.

[NoInterfaceObject]
interface IRI : Node {
    readonly attribute DOMString value;
};

3.4.6 Blank Node

A node in the linked data graph that does not contain a de-reference-able identifier because it is either ephemeral in nature or does not contain information that needs to be linked to from outside of the linked data graph. A blank node is assigned an identifier starting with the prefix _: and an implementation dependent, auto-generated suffix that is unique to all information associated with the particular blank node.

[NoInterfaceObject]
interface BlankNode : Node {
    readonly attribute DOMString identifier;
};

3.4.7 Literal

Literals represent values such as numbers, dates and strings in RDF data. A Literal is comprised of three attributes:

• a lexical form of the value
• an optional language tag
• a datatype specified by an IRI

Literals representing plain text in a natural language may have a language tag specified by a string token, as specified in [BCP47], normalized to lowercase (e.g., 'en', 'fr', 'en-gb'). They also have a datatype attribute such as xsd:string. If unspecified, the datatype defaults to xsd:string.

Literals representing values with a specific datatype, such as the integer 72, may have a datatype attribute specified in the form of a IRI (e.g., xsd:integer).

See[RDF-CONCEPTS] definition for literal.

[NoInterfaceObject]
interface Literal : Node {
    readonly attribute DOMString  value;
    readonly attribute DOMString? language;
    readonly attribute IRI?       datatype;
};

4.4.1 IRI Compaction Algorithm

The algorithm for generating a compact IRI is:

1. Create an empty list of terms terms that will be populated with terms that are ranked according to how closely they match value. Initialize highest rank to 0, and set a flag list container to false.
2. For each term in the active context:
   1. If the term's IRI is not a complete match against iri, continue to the next term.
   2. If value is a JSON object containing only the property @list:
      1. If term has a @container set to @set, continue to the next term.
      2. If list container is true and term does not have a container set to @list and value is null, continue to the next term.
   3. Otherwise, if term has a container set to @list, continue to the next term.
   4. Set rank to the term rank of value by passing passing term, value, and active context to the Term Rank Algorithm.
   5. If rank is greater than 0:
      1. If term has a container set to @set, then add 1 to rank.
      2. If value is a JSON object containing only the property @list and list container is false and term has a container set to @list, then set list container to true, clear terms, set highest rank to rank, and add term to terms.
      3. Otherwise, if rank is greater than or equal to highest rank:
         1. If rank is greater than highest rank, clear terms and set highest rank to rank.
         2. Add term to terms.
3. If terms is empty, and the active context has a @vocab which is a prefix of iri where the resulting relative IRI is not a term in the active context. The resulting relative IRI is the unmatched part of iri.
4. If terms is empty, add a compact IRI representation of iri for each term in the active context which maps to an IRI which is a prefix for iri where the resulting compact IRI is not a term in the active context. The resulting compact IRI is the term associated with the partially matched IRI in the active context concatenated with a colon (:) character and the unmatched part of iri.
5. If terms is empty, the IRI being processed is a property or the value of @type and @vocab is not null and matches the beginning of iri, return the unmatched portion of iri. Otherwise return iri.
6. Otherwise, return the shortest and lexicographically least value in terms.

4.4.2 Term Rank Algorithm

When selecting among multiple possible terms for a given property, it may be that multiple terms are defined with the same IRI, but differ in @type, @container or @language. The purpose of this algorithm is to take a term and a value and give it a term rank. The selection can then be based, partly, on the term having the highest term rank.

Given a term term, value, and active context determine the term rank using the following steps:

1. If value is null, term rank is 3.
2. Otherwise, if value is a JSON object containing only the property @list:
   1. If the @list property is an empty array, if term has @container set to @list, term rank is 1, otherwise 0.
   2. Otherwise, return the sum of the term ranks for every entry in the list.
3. Otherwise, value must be a node definition, node reference, or a JSON object having a @value.
   1. If value has a @value property:
      1. If value has a @type property matching a @type coercion for term, term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
      2. Otherwise, if @value is not a string, if term has no @type or @language it is 2, otherwise 1.
      3. Otherwise, if value has no @language property, if term has @language null, or term has no @type or @language and the active context has no @language, term rank is 3, otherwise 0.
      4. Otherwise, if value has a @language property matching a @language definition for term (or term has no @type or @language definition and @language in the active context matches the value @language), term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
   2. Otherwise, if term has @type coerced to @id, term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
4. Return term rank.

4.7.1 Expansion Algorithm

The algorithm takes three input variables: an active context, an active property, and an element to be expanded. To begin, the active context is set to the result of performing, Context Processing on the passed context, or empty if context is null, active property is set to null, and element is set to the JSON-LD input.

1. If element is an array, process each entry in element recursively using this algorithm, passing copies of the active context and active property. If has a @container set to @list and any entry in element is an array, or is a JSON object containing a @list property, throw an exception, as lists of lists are not allowed. If the expanded entry is null, drop it. If it's an array, merge its entries with element's entries.
2. Otherwise, if element is an object
   1. If element has a @context property, update the active context according to the steps outlined in Context Processing and remove the @context property.
   2. Then, proceed and process each property and value in element as follows:
      1. Remove property from element, expand property according to the steps outlined in IRI Expansion. Set the active property to the original un-expanded property if property is not a keyword.
      2. If property does not expand to a keyword or an absolute IRI (i.e., it doesn't contain a colon), continue with the next property from element.
      3. If value is null and property is not @value, continue with the next property from element.
      4. If the property is @id the value must be a string. Expand the value according to IRI Expansion.
      5. Otherwise, if the property is @type:
         1. If value is a string, expand according to IRI Expansion.
         2. Otherwise, if value is a JSON Object, it must be empty (used for Framing).
         3. Otherwise, if value is an array, all elements must be strings. Expand value for each of its entries according to IRI Expansion.
      6. Otherwise, if the property is @value or @language the value must not be a JSON object or an array.
      7. Otherwise, if the property is @list or @set expand value recursively using this algorithm, passing copies of the active context and active property. If the expanded value is not an array, convert it to an array. If property is @list and any entry in value is a JSON object containing an @list property, throw an exception, as lists of lists are not supported.
      8. Otherwise, expand value recursively using this algorithm, passing copies of the active context and active property.
      9. If property is not a keyword and active property has a @container @list and the expanded value is not null, convert value to an object with an @list property whose value is set to value (unless value is already in that form).
      10. Convert value to array form unless value is null or property is @id, @type, @value, or @language.
      11. If value is not null, either merge value into an existing property property of element or create a new property property with value as value.
   3. If the processed element has an @value property
      1. element must not have more than one other property, which can either be @language or @type with a string value.
      2. if the value of @value equals null, replace element with the value of @value.
   4. Otherwise, if element has an @type property and its value is not in the form of an array, convert it to an array.
   5. If element has an @set or @list property, it must be the only property. Set element to the value of @set; leave @list untouched.
   6. If element has just a @language property, set element to null.
3. Otherwise, expand element according to the Value Expansion rules, passing copies of the active context and active property.

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

4.8.1 Compaction Algorithm

The algorithm takes three input variables: an active context, an active property, and an element to be compacted. To begin, the active context is set to the result of performing Context Processing on the passed context, active property is set to null, and element is set to the result of performing the Expansion Algorithm on the JSON-LD input. This removes any existing context to allow the given active context to be cleanly applied.

1. If element is an array, process each entry in element recursively using this algorithm, passing a copy of the active context and the active property. If element has a single item and the compactArrays option is set to true, the compacted value is that item; otherwise the compacted value is element.
2. Otherwise, if element is an object:
   1. If element has an @value property or element is a node reference, return the result of performing Value Compaction on element using active property.
   2. Otherwise, if the active property has a @container mapping to @list and element has a corresponding @list property, recursively compact that property's value passing a copy of the active context and the active property ensuring that the result is an array with all null values removed. If there already exists a value for active property in element and the full IRI of property is also coerced to @list, throw an exception. Otherwise store the resulting array as value of active property if empty or property otherwise.
   3. Otherwise, construct output as a new JSON object used for returning the result of compacting element. For each property and value in element:
      1. If property is @id or @type
         1. Set active property to the result of performing IRI Compaction on property.
         2. If value is a string, the compacted value is the result of performing IRI Compaction on value.
         3. Otherwise, value must be an array. Perform IRI Compaction on every entry of value. If value contains just one entry and the compactArrays option is set to true, value is set to that entry.
         4. Add active property and the compacted value to output.
      2. Otherwise, value must be an array.
      3. If value is empty:
         1. Set active property to the result of performing IRI Compaction on property.
         2. Create an entry in output for active property and value.
      4. For each item in value:
         1. Set active property to the result of performing IRI Compaction for property and item using the active context.
         2. Compact item by recursively performing this algorithm passing a copy of the active context and the active property.
         3. If an entry already exists in output for active property, convert it to an array if necessary, and append the compacted value.
         4. Otherwise, if the compacted value is not an array and active property has a @container mapping to @set or if the compactArrays option is set to false, convert value to an array.
         5. Create an entry in output for active property and value.
3. Otherwise, return element as the compacted element.
   Issue

   Perhaps this should also call Value Compaction on native types and strings, which could consolidate potential transformation in one place.

If, after the algorithm outlined above is run, the resulting element is an array, put element into the @graph property of a new JSON object and then set element to that JSON object. Finally, add a @context property to element and set it to the initially passed context.

4.9.1 Flattening Algorithm

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

1. Expand element according the Expansion Algorithm.
2. Generate a nodeMap according the Node Map Generation Algorithm.
3. Initialize an empty array result.
4. If nodeMap has no property graph, return result, otherwise set definitions to its value.
5. Foreach property and value of of definitions:
   1. Add value to result.
6. Return result.

4.9.2 Node Map Generation

The Node Map Generation algorithm takes as input an expanded JSON-LD document and results in a JSON object nodeMap holding a flat representation of the graphs and nodes represented in the document. All nodes that are not uniquely identified by an IRI get assigned a (new) blank node identifier. The resulting nodeMap document will have a property for every graph in the document whose value is another object with a property for every node represented in the document. While the default graph is stored under the @default property and the merged graph under the @merged property, all other graphs are stored under their respective IRIs.

The algorithm takes as input the expanded JSON-LD document as element, the initially empty nodeMap, @default as graph, and null as list.

1. If element is an array, process each entry in element recursively, using this algorithm and return.
2. If element is not a JSON object or if it has a @value property, then if list is not null, append element to list and return.
3. If the @id property exists and is an IRI, set id to its value, otherwise set it to a blank node identifier created by the Generate Blank Node Identifier algorithm.
4. If list is not null, append a new node reference to list using id at the value for @id.
5. Let nodes be the value in nodeMap where the key is graph; if no such value exists, insert a new JSON object for the key graph. If id is not in nodes, create a new JSON object node with id as the value for @id. Let node be the value of id in nodes.
6. For each property that is not @id and each value in element ordered by property:
   1. If property is @graph, recursively call this algorithm passing value for element, nodeMap, null for list and if graph is @merged use graph, otherwise use id for graph and then continue.
   2. If property is not @type and is a keyword, merge property and value into node and then continue.
   3. For each value v in the array value:
      1. If v is a node definition or node reference:
         1. If the property @id is not an IRI or it does not exist, map v to a new blank node identifier to avoid collisions. If one does not already exist, add a node reference for v into node for property.
         2. Recursively call this algorithm passing v for value, nodeMap, graph, and null for list.
      2. Otherwise if v has the property @list then recursively call this algorithm with the value of @list as element, nodeMap, graph, and a new array flattenedList as list. Create a new JSON object with the property @list set to flattenedList and add it to node for property.
      3. Otherwise, if property is @type and v is not an IRI, generate a new blank node identifier and add it to node for property.
      4. Otherwise, add v to node for property.

After the above outlined algorithm has been executed, the node map for all graphs including the default graph are contained in nodeMap. To also create the node map for the merged graph, execute the algorithm again, but pass @merged for graph.

4.9.3 Generate Blank Node Identifier

This algorithm is used by the Node Map Generation Algorithm to deterministically name blank node identifiers. It uses a identifier map and prefix and takes a possibly null identifier and returns a new identifier based on prefix.

The variable next identifier is initialized to prefix appended with 0. The default value of prefix is _:t.

1. If the old identifier is not null and is in the identifier map, return the mapped identifier.
2. Otherwise, if the old identifier is not null, create a new entry in identifier map initialized to the current value of next identifier. Increment next identifier by adding one to the integer suffix. Return the mapped identifier.
3. Otherwise, increment next identifier by adding one to the integer suffix and return its original value.

4.10.3 Convert to RDF Algorithm

The algorithm below is designed for in-memory implementations with random access to JSON object elements.

A conforming JSON-LD processor implementing RDF conversion must implement a processing algorithm that results in the same set of RDF Quads that the following algorithm generates:

The algorithm takes five input variables: a element to be converted, an active subject, active property and graph name. To begin, the active subject, active property and graph name are set to null, and element is set to the result of performing the Expansion Algorithm on the JSON-LD input. This removes any existing context to allow the given context to be cleanly applied.

1. If element is a JSON object, perform the following steps:
   1. Set active object to null.
   2. If element has a @value property:
      1. If the value of @value is a number, set the active object to a typed literal using a string representation of the value as defined in the section Data Round Tripping. Set datatype to the value of the @type property if it exists, otherwise either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
         Issue 150

         It is being discussed if the automatic mapping of JSON-native types to the XSD type system should be configurable or not.

      2. Otherwise, if the value of @value is true or false, set the active object to a typed literal created from the string representation of the value. Set datatype to the value of the @type property if it exists, otherwise xsd:boolean.
      3. Otherwise, if element contains a @type property, set the active object to a typed literal.
      4. Otherwise, if element contains a @language property, set the active object to a language-tagged string.
      5. Otherwise, set the active object to a typed literal using xsd:string as the datatype.
   3. If element has a @list property the value must be an array. Process its value as a list as described in List Conversion using the return value as the active object
   4. If active object is not null:
      1. If neither active subject nor active property are null, generate a Quad representing active subject, active property, active object, and graph name.
      2. Return active object.
   5. If element has a @id property, the value must be a string, set the active subject to the previously expanded value (either a blank node or an IRI).
   6. Otherwise, if element does not have a @id property, set the active subject to newly generated blank node.
   7. Process each property and value in element, ordered by property, as follows:
      1. If property is @type, set the active property to rdf:type.
      2. Otherwise, if property is @graph, process value algorithm recursively, using active subject as graph name and null values for active subject and active property and then proceed to next property.
      3. Otherwise, if property is a keyword, skip this step.
      4. Otherwise, set active property to the IRI value of property.
      5. Process value recursively using this algorithm, passing copies of active subject, active property and graph name.
   8. Set active object to active subject.
2. Otherwise, if element is an array, process each value in the array as follows, process element recursively using this algorithm, using copies of active subject, active property, and graph name.
3. Otherwise, if element is a string, then the active property must be rdf:type so set the active object to an IRI.
4. If any of these steps created an active object and neither active subject nor active property are null, generate a Quad using active subject,active property, active object and graph name.
5. Return active object.

4.10.4 List Conversion

List Conversion is the process of taking an array of values and adding them to a newly created RDF Collection (see [RDF-SCHEMA]) by linking each element of the list using rdf:first and rdf:next, terminating the list with rdf:nil using the following sequence:

The algorithm is invoked with an array array, the active property and returns a value to be used as an active object in the calling location.

1. If array is empty return rdf:nil.
2. Otherwise, generate a Quad using using the active subject, active property and a newly generated blank node identified as first blank node.
3. For each element in array other than the last element:
   1. Create a processor state using first blank node as the active subject, and rdf:first as the active property.
      1. Process the value starting at Step 1.
      2. Proceed using the previous processor state.
   2. Unless this is the last element in array, generate a new blank node identified as rest blank node, otherwise use rdf:nil.
   3. Generate a new Quad using first blank node, rdf:rest and rest blank node.
   4. Set first blank node to rest blank node.
   5. Return first blank node.

4.10.5 Convert from RDF Algorithm

In some cases, data exists natively in Triples or Quads form; for example, if the data was originally represented in an RDF graph or triple/quad store. This algorithm is designed to simply translate an array of Quads into a JSON-LD document.

When expanding typed literal values having a datatype of xsd:string, the @type must not be set to xsd:string and the resulting value must have only a @value property.

The conversion algorithm takes a single parameter input in the form of an array of Quad representations.

1. Construct defaultGraph as a JSON object containing nodes and listMap, each an empty JSON object.
2. Construct graphs as a JSON object containing defaultGraph identified by an empty string.
3. For each quad in input:
   1. Set graph to the entry in graphs identified by name, initializing it to a new entry using the mechanism described in Step 1.
   2. If property is rdf:first, use the entry in graph.listMap indexed by subject, initializing it to a new JSON object if nesessary. Represent object in expanded form, as described in Value Expansion. Add the resulting object representation to the entry indexed by first, and skip to the next quad.
   3. If property is rdf:rest:
      1. If object is a blank node, use the entry in graph.listMap indexed by subject, initializing it to a new JSON object if necessary. Add the nominalValue of object to the entry indexed by rest.
      2. Skip to the next quad.
   4. If name is not null, and defaultGraph.nodes does not contain an entry for name, create a new entry for name from a new JSON object with key/value pair of @id and a string representation of name.
   5. Set value as the entry from graph.nodes for subject, initializing it to a new JSON object with key/value pair of @id and a string representation of subject if necessary.
   6. If property is rdf:type and the useRdfType option is not present or false:
      1. Append the string representation of object to the array value for the key @type, creating an entry in value if necessary.
   7. If object is a typed literal and the useNativeTypes option is set to true:
      1. Generate a converted value:
         1. If the literal's type is xsd:boolean, the converted value is true if the literal matches the value true or false if the literal matches the value false.
         2. If the literal's type is xsd:integer or xsd:double, try to convert the literal to a JSON number. If the conversion is successful, store the result in converted value, otherwise set converted value to value.
         3. Otherwise, do not perform a conversion. Set the converted value to the value.
      2. Append the converted value to the array value for the key, creating an entry in value if necessary.
   8. Otherwise, if object is rdf:nil:
      1. Let key be the string representation of property.
      2. Append an empty @list representation to the array value for key, creating an entry in value if necessary.
   9. Otherwise,
      1. Let key be the string representation of property and let object representation be object represented in expanded form as described in Value Expansion.
      2. If object is a blank node, use the entry in graph.listMap indexed by object, initializing it to a new JSON object if nesessary. Add an entry for head with object representation.
      3. Append object representation to the array value for key, creating an entry in value if necessary.
4. For each name and graph in graphs:
   1. For each subject and entry in graph where entry has both head and first keys:
      1. Set value to the value of head in entry.
      2. Remove the entry for @id in value.
      3. Add an entry to value for @list initialized to a new array containing the value of first from entry.
      4. While entry has a key for rest:
         1. Set entry to the value of graph.listMap for entry.rest.
         2. Add the value for entry.first to the list array.
5. Create array as an empty array.
6. For each subject and entry in defaultGraph.nodes ordered by subject:
   1. Add entry to array.
   2. If graphs has an entry for subject, add a property @graph in entry containing the ordered entries from graphs[subject].nodes.
7. Return array as the result.