The JSON-LD API 1.0

2.1.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 appropirate exception must be thrown.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	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 URL	✘	✘	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.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	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	ObjectOrURL	✔	✘	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.

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 URL	✘	✘	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 URL	✘	✘	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	ObjectOrURL	✔	✘	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

frame

Frames the given input using the frame according to the steps in the Framing Algorithm. The input is used to build the framed output and is returned if there are no errors. If there are no matches for the frame, null must be returned. Exceptions must be thrown if there are errors.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	The JSON-LD object or array of JSON-LD objects to perform the framing upon or an IRI referencing the JSON-LD document to frame.
frame	object or URL	✘	✘	The frame to use when re-arranging the data of 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 framing 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[]	✘	✘	An array of RDF 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.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	The JSON-LD object or array of JSON-LD objects to convert to RDF or an 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

2.2.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 (ObjectOrObjectArray jsonld);
};

2.2.2 QuadCallback

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

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

2.3.1 URL

The URL datatype is a string representation of an IRI.

typedef DOMString URL;

2.3.2 JsonLdOptions

The JsonLdOptions type is used to convery a set of options to an interface method.

typedef object JsonLdOptions;

2.3.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? name;
};

2.3.4 Node

Node is the base class of IRI, BlankNode, and Literal.

[NoInterfaceObject]
interface Node {
    readonly attribute DOMString nominalValue;
    readonly attribute DOMString interfaceName;
};

2.3.5 IRI

A node identified by an IRI. IRIs are defined by International Resource Identifier [IRI]. See [RDF-CONCEPTS] definition for IRI.

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

2.3.6 Blank Node

A BlankNode is a reference to an unnamed resource (one for which an IRI may not be known), and may be used in a Quad as a unique reference to that unnamed node. See [RDF-CONCEPTS] definition for blank node.

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

Developers and authors must not assume that the nominalValue of a BlankNode will remain the same between two processing runs. BlankNode nominalValues are only valid for the most recent processing run on the document. BlankNodes nominalValues will often be generated differently by different processors.

Implementers must ensure that BlankNode nominalValues are unique within the current environment, two BlankNodes are considered equal if, and only if, their nominalValues are strictly equal.

2.3.7 Literal

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

• a lexical representation of the nominalValue
• an optional language represented by a string token
• an optional datatype specified by an IRI

Literals representing plain text in a natural language may have a language attribute specified by a text string token, as specified in [BCP47], normalized to lowercase (e.g., 'en', 'fr', 'en-gb'). They may also have a datatype attribute such as 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., <http://www.w3.org/2001/XMLSchema#integer>).

See[RDF-CONCEPTS] definition for literal.

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

3.5.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, 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, 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.
4. If terms is empty, return iri.
5. Otherwise, return the shortest and lexicographically least value in terms.

3.5.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 subject definition, subject 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.

3.9.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 to the initial context 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 subject reference, the expanded value is the result of performing IRI Expansion on the value of @id.
         3. Otherwise, if value is a JSON Object, it must be empty (used for Framing).
         4. Otherwise, if value is an array, all elements must be either a string or subject reference. Expand value for each of its entries using the previous three steps.
      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.

3.10.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, 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 subject 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 and removing null values. Return either the result as an array, as an object with a key of @list (or appropriate alias from active context).
   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, value is set to that entry.
         4. Add active property and the expanded 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, create an entry in output for active property and value as an array.
         5. Otherwise, create an entry in output for active property and value.
3. Otherwise, return element as the compacted element.
   Perhaps this should also call Value Compaction on native types and strings, which could consolodate 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.

3.11.1 Framing Algorithm Terms

input frame

the initial frame provided to the framing algorithm.

framing context

a context containing a map of embeds, the object embed flag, the explicit inclusion flag and the omit default flag.

map of embeds

a map that tracks if a subject is to be embedded in the output of the Framing Algorithm; it maps a subject @id to a parent JSON object and property or parent array.

object embed flag

a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.

explicit inclusion flag

a flag specifying that for properties to be included in the output, they must be explicitly declared in the framing context.

omit default flag

a flag specifying that properties that are missing from the JSON-LD input, but present in the input frame should be omitted from the output.

map of flattened subjects

a map of subjects that is the result of the Subject Map Generation algorithm.

3.11.2 Framing Algorithm

This algorithm is a work in progress. Presently, it only works for documents without named graphs.

The framing algorithm takes an JSON-LD input (expanded input) and an input frame (expanded frame) that have been expanded according to the Expansion Algorithm, and a number of options and produces JSON-LD output.

Create framing context using null for the map of embeds, the object embed flag set to true, the explicit inclusion flag set to false, and the omit default flag set to false along with map of flattened subjects set to the @merged property of the result of performing the Subject Map Generation algorithm on expanded input. Also create results as an empty array.

Invoke the recursive algorithm using framing context (state), the map of flattened subjects (subjects), expanded frame (frame), result as parent, and null as active property.

The following series of steps is the recursive portion of the framing algorithm:

1. Validate frame.
2. Create a set of matched subjects by filtering subjects checking the map of flattened subjects against frame:
   1. If frame has a @type property containing one or more IRIs match any subject definition with a @type property including any of those IRIs.
   2. Otherwise, if frame has a @type property only a empty JSON object, matches any subject definition with a @type property, regardless of the actual values.
   3. Otherwise, match if the subject definition contains all of the non-keyword properties in frame.
3. Get values for embedOn and explicitOn by looking in frame for the keys @embed and @explicit using the current values for object embed flag and explicit inclusion flag from state if not found.
4. For each id and subject from the set of matched subjects, ordered by id:
   1. If the active property is null, set the map of embeds in state to an empty map.
   2. Initialize output with @id and id.
   3. Initialize embed with parent and active property to property.
   4. If embedOn is true, and id is in map of embeds from state:
      1. Set existing to the value of id in map of embeds and set embedOn to false.
      2. If existing has a parent which is an array containing a JSON object with @id equal to id, element has already been embedded and can be overwritten, so set embedOn to true.
      3. Otherwise, existing has a parent which is a subject definition. Set embedOn to true if any of the items in parent property is a subject definition or subject reference for id because the embed can be overwritten.
      4. If embedOn is true, existing is already embedded but can be overwritten, so Remove Embedded Definition for id.
   5. If embedOn is false, add output to parent by either appending to parent if it is an array, or appending to active property in parent otherwise.
   6. Otherwise:
      1. Add embed to map of embeds for id.
      2. Process each property and value in the matched subject, ordered by property:
         1. If property is a keyword, add property and a copy of value to output and continue with the next property from subject.
         2. If property is not in frame:
            1. If explicitOn is false, Embed values from subject in output using subject as element and property as active property.
            2. Continue to next property.
         3. Process each item from value as follows:
            1. If item is a JSON object with the key @list, then create a JSON object named list with the key @list and the value of an empty array. Append list to property in output. Process each listitem in the @list array as follows:
               1. If listitem is a subject reference process listitem recursively using this algorithm passing a new map of subjects that contains the @id of listitem as the key and the subject definition from the original map of flattened subjects as the value. Pass the first value from frame for property as frame, list as parent, and @list as active property.
               2. Otherwise, append a copy of listitem to @list in list.
            2. If item is a subject reference process item recursively using this algorithm passing a new map as subjects that contains the @id of item as the key and the subject definition from the original map of flattened subjects as the value. Pass the first value from frame for property as frame, output as parent, and property as active property.
               Passing a subject reference doesn't work if this map is used recursively. Presently pass subject definition from original map of flattened subjects.
            3. Otherwise, append a copy of item to active property in output.
      3. Process each property and value in frame, where property is not a keyword, ordered by property:
         1. Set property frame to the first item in value or a newly created JSON object if value is empty.
         2. Skip to the next property in frame if property is in output or if property frame contains @omitDefault which is true or if it does not contain @omitDefault but the value of omit default flag true.
         3. Set the value of property in output to a new JSON object with a property @preserve and a value that is a copy of the value of @default in frame if it exists, or the string @null otherwise.
      4. Add output to parent. If parent is an array, append output, otherwise append output to active property in parent.

At the completion of the recursive algorithm, results will contain the top-level subject definitions.

The final two steps of the framing algorithm require results to be compacted according to the Compaction Algorithm by using the context provided in the input frame. If the frame has no context, compaction is performed with an empty context (not a null context). The compaction result must use the @graph keyword at the top-level, even if the context is empty or if there is only one element to put in the @graph array. Subsequently, replace all key-value pairs where the key is @preserve with the value from the key-pair. If the value from the key-pair is @null, replace the value with null. If, after replacement, an array contains only the value null remove the value, leaving an empty array. The resulting value is the final JSON-LD output.

The algorithm needs to be updated to consider @graph. See ISSUE-118 for details.

3.11.3 Subject Map Generation

The Subject Map Generation algorithm takes as input an expanded JSON-LD document and results in a JSON object subjectMap 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 subjectMap 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 subjectMap, @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 identifer created by the Generate Blank Node Identifier algorithm.
4. If list is not null, append a new subject reference to list using id at the value for @id.
5. Let subjects be the value in subjectMap where the key is graph; if no such value exists, insert a new JSON object for the key graph. If id is not in subjects, create a new JSON object subject with id as the value for @id. Let subject be the value of id in subjects.
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, subjectMap, 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 subject and then continue.
   3. For each value v in the array value:
      1. If v is a subject definition or subject 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 subject reference for v into subject for property.
         2. Recursively call this algorithm passing v for value, subjectMap, 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, subjectMap, graph, and a new array flattenedList as list. Create a new JSON object with the property @list set to flattenedList and add it to subject for property.
      3. Otherwise, if property is @type and v is not an IRI, generate a new blank node identifier and add it to subject for property.
      4. Otherwise, add v to subject for property.

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

3.11.4 Remove Embedded Definition

This algorithm replaces an already embedded subject definition with a subject reference. It then recursively removes any entries in the map of embeds that had the removed subject definition in their parent chain.

The algorithm is invoked with a framing context and subject id id.

1. Find embed from map of embeds for id.
2. Let parent and property be from embed.
3. If parent is an array, replace the subject definition that matches id with a subject reference. If parent is a JSON object, replace the subject definition for property that matches id with a subject reference.
4. Remove dependents for id in map of embeds by scanning the map for entries with parent that have an @id of id, removing that definition from the map, and then removing the dependents for the parent id recursively by repeating this step. This step will terminate when there are no more embed entries containing the removed subject definition's @id in their parent chain.

3.11.5 Embed Values

This algorithm recursively embeds property values in subject definition output, given a framing context, input subject definition element, active property, and output.

1. For each item in active property of element:
   1. If item is a JSON object with the key @list, then create a new JSON object with a key @list and a value of an empty array and add it to output, appending if output is an array, and appending to active property otherwise. Recursively call this algorithm passing item as element, @list as active property, and the new array as output. Continue to the next item.
   2. If item is a subject reference:
      1. If map of embeds does not contain an entry for the @id of item:
         1. Initialize embed with output as parent and active property as property and add to map of embeds.
         2. Initialize a new subject definition o to act as the embedded subject definition.
         3. For each property and value in the expanded definition for item in subjects:
            1. Add property and a copy of value to o if property is a keyword.
            2. Otherwise, recursively call this algorithm passing value as element, property as active property and o as output.
      2. Set item to o.
2. If output is an array, append a copy of item, otherwise append a copy of item to active property in output.

3.12.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 subjectMap according the Subject Map Generation Algorithm.
3. Initialize an empty array result.
4. If subjectMap 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.

3.13.2 RDF Conversion Algorithm Terms

graph name

A IRI or BlankNode used to identify quads belonging to a named graph.

3.13.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.
      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, set the active object to a plain literal. If element contains a @language property, use its value to set the language of the plain literal.
   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 BlankNode 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.

3.13.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 BlankNode 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 BlankNode 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.

3.13.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.

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 subjects 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 BlankNode, 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.subjects 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.subjects 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 notType option is present and not true:
      1. Append the string representation of object to the array value for the key @type, creating an entry in value if necessary.
   7. 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.
   8. 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 BlankNode, 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.subjects 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].subjects.
7. Return array as the result.