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 Statement Quads s. .

Parameter	Type	Nullable	Optional	Description
input	Statement Quad []	✘	✘	An array of RDF statements. 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 Statement 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.
context ObjectOrURL ✔ ✘ An external context to use additionally to the context embedded in input when expanding the input . callback	StatementCallback QuadCallback	✘	✘	A callback that is called when a Statement 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 StatementCallback QuadCallback

The StatementCallback QuadCallback is called whenever the processor generates a statement quad during the statement() 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 JsonLdOptiones JsonLdOptions type is used to convery a set of options to an interface method.

typedef


object



JsonLdOptions

;

2.3.3 Statement Quad

The Statement Quad interface represents an RDF Statement. 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 NamedNode IRI , BlankNode , and LiteralNode Literal .

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

2.3.5 NamedNode IRI

A node identified by an IRI . NamedNodes 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 is may not be known), and may be used in a Statement Quad as a unique reference to that unnamed resource. 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. BlankNode BlankNodes s nominalValues will often be generated differently by different processors.

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

2.3.7 LiteralNode Literal

LiteralNodes Literals represent values such as numbers, dates and strings in RDF data. A LiteralNode 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 a an NamedNode IRI

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

LiteralNodes Literals representing values with a specific datatype, such as the integer 72, may have a datatype attribute specified in the form of a NamedNode 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 term s 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. Return 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 an 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 rank s for every entry in the list.
3. Otherwise, if value is true must be a subject definition , false subject reference , or a number , if JSON object having a @value .
   1. If term value has a @type @value coercion to xsd:boolean , property:
      1. If value has a xsd:integer , or @type property matching a xsd:double @type respectively, coercion for term , term rank is 3 , otherwise if term has no @type or coercion and no @language it , term rank is 2 1 , otherwise 1 0 .
      2. Otherwise, if value @value is not a string , it represents a string value with no @language . If term has @language null , or if term has no @type or @language and the active context has no @language , term rank it is 3 2 , otherwise 0 1 .
      3. Otherwise, value must be a subject definition , subject reference , or a JSON object having a @value . If if value has an no @value @language property, it must have either a @type or a @language : If if value term has a @type property matching a @type @language coercion for term , term rank is 3 , otherwise if null , or term has no @type coersion or @language and the active context has no @language , term rank is 1 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 coersion 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 coersion 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 it's 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 it's 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 , @set , or @graph , @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 @value is the only property or the value of @value equals null , replace element with the value of @value .
   4. Otherwise, if element has an @type property and it's 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 Flattening Algorithm 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 Flattening 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 definition s.

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 . For 1.0, this might not require anything, as the default implementation of Subject Flattening See ISSUE-118 should flatten everything into a single graph. for details.

3.11.3 Subject Flattening Map Generation

The Subject Flattening Map Generation algorithm takes as input an expanded JSON-LD document, document and results in a JSON object subjects subjectMap with holding a mapping from each object flat representation of the graphs and nodes represented in the document to document. All nodes that are not uniquely identified by an IRI get assigned a single entry within the input document, assigning (new) blank node identifiers to objects without identifier. The resulting subjectMap document will have a @id, or property for every graph in the document whose value is another object with an @id that references a blank property for every node identifier. 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 operates on the initially empty subjects and takes as input the current 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. algorithm and return.
2. Otherwise, if element is a JSON object: If element is not a subject definition JSON object or subject reference : if it has a @value property, then if list is not null , append element to list and return.
3. If the property @id property exists and is not an IRI , return set id to its value, otherwise set it to a blank node identifer using created by the Generate Blank Node Identifier as algorithm.
4. If name , otherwise use list is not null , append a new subject reference to list using id at the value of the for @id property as name . .
5. Unless Let subjects as an entry for be the value in name subjectMap create where the key is graph ; if no such value exists, insert a new entry JSON object for the key graph . If id is not in subjects initialized using , create a new JSON object subject with @id set to name id as the value for @id . Let subject . Otherwise, use that existing entrpy as be the value of subject id in subjects .
6. For each property that is not @id and each value in element other than @id : 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, copy merge property and value to into subject . and then continue.
   3. Otherwise, if For each value v in the array value :
      1. If v is a JSON object , subject definition or subject reference :
         1. If the property @id is not an IRI or it must does not exist, map v only have 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 key property @list. @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 containing with the property @list and an array created by performing this algorithm recursively on each item in the list set to flattenedList and add it to subject along with for property .
      3. Otherwise, value must be an array . Add property to if subject property is @type and v is not an array value created by performing this algorithm recursively on each item in the array. Return IRI , generate a new JSON object created as a subject reference blank node identifier and add it to name subject for property .
      4. Otherwise, return add element v to subject for property .
   Otherwise, return element .

After the above outlined algorithm states to set has been executed, the property in subject using the mapped values, but it really should merge, if map for all graphs including the property already exists default graph are contained in subject subjectMap . The algorithm should descend into @graph and To also create a parallel flattened structure of the subject to object within that @graph representation. Recursive @graph definitions are also flattened into map for the merged graph, execute the default graph. The algorithm should also take an option which descends into again, but pass @graph merged and flattens all definitions at the same level, effectively flatting default and named graphs into a single default graph; this should be the default implementation for 1.0. 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 canonical lexical representation of a double , i.e., a number with fractions or a number coerced to xsd:double , consists of a mantissa followed by the character "E", followed by algorithm takes two input variables, an exponent. The mantissa must be a decimal number. The exponent must element be an integer. Leading zeroes and a preceding plus sign ( + ) are prohibited in the exponent. If the exponent is zero, it must be indicated by E0 . For the mantissa, the preceding optional plus sign is prohibited and the decimal point is required. Leading and trailing zeroes are prohibited subject to the following: number representations must be normalized such that there is a single digit which is non-zero to the left of the decimal point flatten and at least a single digit to the right of the decimal point unless the value being represented is zero. The canonical representation graph for zero is 0.0E0 . To convert the number in JavaScript, implementers can use the following snippet of code: (value).toExponential().replace(/e\+?/,'E') xsd:double 's value space is defined by which the IEEE double-precision 64-bit floating point type [ IEEE-754-1985 ]. When data such as decimals need to be normalized, JSON-LD authors node definitions should not use values that are going to undergo automatic conversion. This be returned. If graph is due not set, it will default to @merged which represents the lossy nature result of xsd:double values. Authors should instead use the expanded object form to set the canonical lexical representation directly. When JSON-native datatypes, like number s, are type coerced, lossless data round-tripping can not be guaranted. Consider merging all graphs including the following code example: var myObj1 = { "@context": { "number": { "@id": "http://example.com/vocab#number", } }, "number" : }; // Convert the JSON-LD document to RDF; this converts 42 to a string var jsonldText = jsonld.toRDF(myObj1, myRdfTripleCollector); // Convert the RDF triples back to a JavaScript object var myObj2 = jsonld.fromRDF(myRdfTripleCollector.getTriples()); At this point, myObj1 and default graph ( myObj2 @default will have different values for ).

1. Expand element according the "number" property. myObj1 will have Expansion Algorithm .
2. Generate a subjectMap according the number 42 , while myObj2 have Subject Map Generation Algorithm .
3. Initialize an object consisting of @value empty array result .
4. If subjectMap has no property graph , return result , otherwise set definitions to the string "42" its value.
5. Foreach property and @type set to the expanded value of of xsd:nonNegativeInteger . Some JSON serializers, such as PHP's native implementation in some versions, backslash-escape the forward slash character. For example, the definitions :
   1. Add value http://example.com/ would be serialized as http:\/\/example.com\/ . This is problematic as other JSON parsers might not understand those escaping characters. There is no need to backslash-escape forward slashes in JSON-LD. To aid interoperability between JSON-LD processors, a JSON-LD serializer must not backslash-escape forward slashes. to result .
6. Return result .

5.2 3.13.2 RDF Conversion Algorithm Terms

graph name

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

5.3 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 Statement Quads s 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, 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 follows: 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. As 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 after performing IRI Expansion on property, set the specified @type . active object to a typed literal .
      4. Otherwise, as set the active object to a plain literal . If element contains a @language property, use it's 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 nether neither active subject nor active property are null , generate a Statement 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 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 , set the active object to a plain literal value created from the string. Otherwise, if element is a number , set then the active object to a typed literal property using a string representation of the value with datatype set to either must be xsd:integer rdf:type or xsd:double , depending on if the value contains a fractional and/or an exponential component. Otherwise, if element is true or false , so set the active object to a typed literal created from the string representation of the value with datatype set to an xsd:boolean . IRI .
4. If any of these steps created an active object and neither active subject nor active property are null , generate a Statement Quad using active subject , active property , active object and graph name .
5. Return active object .

5.4 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 Statement Quad using using the active subject , active property and a newly generated blank node 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 blank node BlankNode identified as rest blank node , otherwise use rdf:nil .
   3. Generate a new Statement 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 .

5.5 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 Statement Quads s into a JSON-LD document.

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

1. Construct a JSON array array defaultGraph to serve as the output object. Construct a JSON object containing listMap subjects to map graph names and subjects to objects derived from statements having a property of rdf:first . Construct a listMap ,each an empty JSON object restMap to map graph names and subjects to objects derived from statements having a property of rdf:rest . .
2. Construct a JSON object subjectMap graphs to map graph names and subjects to as a JSON object instances contained in containing array . defaultGraph identified by an empty string .
3. For each statement 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 , create a new use the entry in listMap with for name graph.listMap and indexed by subject and an array value containing , 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 statement. quad.
   3. If property is rdf:rest , and :
      1. If object is a BlankNode , create a new use the entry in restMap to map name graph.listMap and indexed by subject , initializing it to a value being new JSON object if necessary. Add the result nominalValue of IRI expansion on object and skip to the entry indexed by rest .
      2. Skip to the next statement. quad.
   4. If name is not null : If , and subjectMap defaultGraph.subjects does not have contain an entry for null as name and name as subject: Create , create a new JSON object with key/value pair of @id and a string representation of name and use as value . Save value in subjectMap and append to array . Otherwise, use that entry as value . If value does not have an entry for @graph , initialize it as a new array ary . Otherwise, let ary be that array. If subjectMap does not have an entry for name and subject : Create from a new JSON object with key/value pair of @id and a string representation of subject and use as value name .
   5. Save Set value in subjectMap and append to ary . Otherwise, use that entry as the entry from value . Otherwise, if subjectMap graph.subjects does not have an entry for null as name and subject : Create , initializing it to a new JSON object with key/value pair of @id and a string representation of subject and use as value . Save value in subjectMap and append to array . Otherwise, use that entry as value . 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. Set Append an empty @list representation to the array value for key , creating an entry in value to an empty @list representation: {"@list": []} . 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 map graph in restMap graphs :
   1. For each key/value prev , rest subject and entry in map , append to the graph where listMap entry value identified by has both name head and prev first keys:
      1. Set value to the value of listMap head in entry .
      2. Remove the entry for @id in value identified by .
      3. Add an entry to name value and 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 name , subject and map entry in listMap defaultGraph.subjects ordered by subject :
   1. For each key/value Add node , entry to list array .
   2. If graphs has an entry for subject , add a property @graph in map entry where containing the ordered entries from list graphs[subject].subjects .
7. Return array exists as the result.