--- a/spec/latest/json-ld-api/index.html Wed Mar 13 19:34:04 2013 +0100
+++ b/spec/latest/json-ld-api/index.html Wed Mar 13 20:00:44 2013 +0100
@@ -832,7 +832,7 @@
<section class="informative">
<h3>General Solution</h3>
- <p>First we prepare a new <tref>active context</tref> <em>result</em> by cloning
+ <p>First we prepare a new <tref>active context</tref> <i>result</i> by cloning
the current <tref>active context</tref>. Then we normalize the form the passed
<tref>local context</tref> to an <tref>array</tref>.
<tref title="local context">Local contexts</tref> may be in the form of a
@@ -855,7 +855,7 @@
they affect how the other keys are processed.</p>
<p>Then, for every other key in <tref>local context</tref>, we update
- the <tref>term definition</tref> in <em>result</em>. Since
+ the <tref>term definition</tref> in <i>result</i>. Since
<tref title="context">context</tref> values in a <tref>local context</tref>
may themselves contain <tref title="compact IRI">compact IRIs</tref>, we may
need to recurse to define a <tref>prefix</tref>. When doing so, we must ensure
@@ -865,7 +865,7 @@
a keyword alias or consist of <code>@id</code>, <code>@language</code>,
<code>@type</code>, or <code>@container</code> mappings.</p>
- <p>Finally, we return <em>result</em> as the new <tref>active context</tref>.</p>
+ <p>Finally, we return <i>result</i> as the new <tref>active context</tref>.</p>
</section>
<section>
@@ -874,95 +874,95 @@
<p>This algorithm specifies how a new <tref>active context</tref> is updated
with a <tref>local context</tref>. The algorithm takes three input variables:
an <tref>active context</tref>, a <tref>local context</tref>, and an <tref>array</tref>
- <em>remote contexts</em> which is used to detect cyclical context inclusions.
- If <em>remote contexts</em> is not passed, it is initialized to an empty
+ <i>remote contexts</i> which is used to detect cyclical context inclusions.
+ If <i>remote contexts</i> is not passed, it is initialized to an empty
<tref>array</tref>.</p>
<ol class="algorithm">
- <li>Initialize <em>result</em> to the result of cloning
+ <li>Initialize <i>result</i> to the result of cloning
<tref>active context</tref>.</li>
<li>If <tref>local context</tref> is not an <tref>array</tref>, then
set it to an <tref>array</tref> containing only
<tref>local context</tref>.</li>
<li>
- For each item <em>context</em> in <tref>local context</tref>:
+ For each item <i>context</i> in <tref>local context</tref>:
<ol class="algorithm">
- <li>If <em>context</em> is <tref>null</tref>, then set <em>result</em>
+ <li>If <i>context</i> is <tref>null</tref>, then set <i>result</i>
to a newly-initialized <tref>active context</tref> and continue to the
- next <em>context</em>.</li>
- <li>If <em>context</em> is a <tref>string</tref>,
+ next <i>context</i>.</li>
+ <li>If <i>context</i> is a <tref>string</tref>,
<ol class="algorithm">
- <li>Set <em>context</em> to the result of calling the
+ <li>Set <i>context</i> to the result of calling the
<a href="#iri-expansion">IRI Expansion algorithm</a>
- passing <tref>active context</tref>, <em>context</em> for <em>value</em>,
- <tref>false</tref> for <em>vocabRelative</em> and <tref>true</tref> for
- <em>documentRelative</em>.</li>
- <li>If <em>context</em> is in the <em>remote contexts</em> array, a
+ passing <tref>active context</tref>, <i>context</i> for <i>value</i>,
+ <tref>false</tref> for <i>vocabRelative</i> and <tref>true</tref> for
+ <i>documentRelative</i>.</li>
+ <li>If <i>context</i> is in the <i>remote contexts</i> array, a
<code class="error"><a href="#idl-def-JsonLdErrorCode.recursive-context-inclusion">recursive context inclusion</a></code>
error has been detected;
- otherwise, add <em>context</em> to <em>remote contexts</em>.</li>
- <li>Dereference <em>context</em>. If the dereferenced document has no
+ otherwise, add <i>context</i> to <i>remote contexts</i>.</li>
+ <li>Dereference <i>context</i>. If the dereferenced document has no
top-level <tref>JSON object</tref> with an <code>@context</code> member, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-remote-context">invalid remote context</a></code>
has been detected; otherwise,
- set <em>context</em> to the value of that member.</li>
- <li>Set <em>context</em> to the result of recursively calling this algorithm,
- passing <tref>active context</tref>, <em>context</em> as <tref>local context</tref>,
- and <em>remote contexts</em>.</li>
+ set <i>context</i> to the value of that member.</li>
+ <li>Set <i>context</i> to the result of recursively calling this algorithm,
+ passing <tref>active context</tref>, <i>context</i> as <tref>local context</tref>,
+ and <i>remote contexts</i>.</li>
</ol>
- <li>If <em>context</em> has an <code>@base</code> key:
+ <li>If <i>context</i> has an <code>@base</code> key:
<p class="issue atrisk">This feature is at risk as the fact that a document may
have multiple base IRIs is potentially confusing for developers.</p>
<ol class="algorithm">
- <li>Initialize <em>value</em> to the value associated with the
+ <li>Initialize <i>value</i> to the value associated with the
<code>@base</code> key.</li>
- <li>If <em>value</em> is <tref>null</tref>, then set the
- <tref>base IRI</tref> of <em>result</em> to the document's base IRI according section
+ <li>If <i>value</i> is <tref>null</tref>, then set the
+ <tref>base IRI</tref> of <i>result</i> to the document's base IRI according section
<cite><a href="http://www.ietf.org/rfc/rfc2396.txt">section 5.1 Establishing a Base URI</a></cite>
of [[!RFC3986]].</li>
- <li>Otherwise, <em>value</em> must be a <tref>string</tref>, if not, an
+ <li>Otherwise, <i>value</i> must be a <tref>string</tref>, if not, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-base-IRI">invalid base IRI</a></code>
- error has been detected. Set <em>result</em>'s <tref>base IRI</tref>
- to <em>value</em>.</li>
- </ol>
- </li>
- <li>If <em>context</em> has an <code>@vocab</code> key:
- <ol class="algorithm">
- <li>Initialize <em>value</em> to the value associated with the
- <code>@vocab</code> key.</li>
- <li>If <em>value</em> is <tref>null</tref>, then remove
- any <tref>vocabulary mapping</tref> from <em>result</em>.</li>
- <li>Otherwise, <em>value</em> must be an <tref>absolute IRI</tref>, if not, an
- <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-vocab-mapping">invalid vocab mapping</a></code>
- error has been detected. Set <em>result</em>'s
- <tref>vocabulary mapping</tref> to <em>value</em>.</li>
+ error has been detected. Set <i>result</i>'s <tref>base IRI</tref>
+ to <i>value</i>.</li>
</ol>
</li>
- <li>If <em>context</em> has an <code>@language</code> key:
+ <li>If <i>context</i> has an <code>@vocab</code> key:
<ol class="algorithm">
- <li>Initialize <em>value</em> to the value associated with the
- <code>@language</code> key.</li>
- <li>If <em>value</em> is <tref>null</tref>, then remove
- any <tref>default language</tref> from <em>result</em>.</li>
- <li>Otherwise, <em>value</em> must be a <tref>string</tref>, if not, an
- <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-default-language">invalid default language</a></code>
- error has been detected. Set <em>result</em>'s
- <tref>default language</tref> to lowercased <em>value</em>.</li>
+ <li>Initialize <i>value</i> to the value associated with the
+ <code>@vocab</code> key.</li>
+ <li>If <i>value</i> is <tref>null</tref>, then remove
+ any <tref>vocabulary mapping</tref> from <i>result</i>.</li>
+ <li>Otherwise, <i>value</i> must be an <tref>absolute IRI</tref>, if not, an
+ <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-vocab-mapping">invalid vocab mapping</a></code>
+ error has been detected. Set <i>result</i>'s
+ <tref>vocabulary mapping</tref> to <i>value</i>.</li>
</ol>
</li>
- <li>Create a <tref>JSON object</tref> <em>defined</em> to use to keep
+ <li>If <i>context</i> has an <code>@language</code> key:
+ <ol class="algorithm">
+ <li>Initialize <i>value</i> to the value associated with the
+ <code>@language</code> key.</li>
+ <li>If <i>value</i> is <tref>null</tref>, then remove
+ any <tref>default language</tref> from <i>result</i>.</li>
+ <li>Otherwise, <i>value</i> must be a <tref>string</tref>, if not, an
+ <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-default-language">invalid default language</a></code>
+ error has been detected. Set <i>result</i>'s
+ <tref>default language</tref> to lowercased <i>value</i>.</li>
+ </ol>
+ </li>
+ <li>Create a <tref>JSON object</tref> <i>defined</i> to use to keep
track of whether or not a <tref>term</tref> has already been defined
or currently being defined during recursion.</li>
- <li>For each <em>key</em>-<em>value</em> pair in <em>context</em> where
- <em>key</em> is not <code>@base</code>, <code>@vocab</code>, or
+ <li>For each <i>key</i>-<i>value</i> pair in <i>context</i> where
+ <i>key</i> is not <code>@base</code>, <code>@vocab</code>, or
<code>@language</code>, invoke the
<a href="#create-term-definition">Create Term Definition algorithm</a>,
- passing <em>result</em> for <tref>active context</tref>,
- <em>context</em> for <tref>local context</tref>, <em>key</em>,
- and <em>defined</em>.</li>
+ passing <i>result</i> for <tref>active context</tref>,
+ <i>context</i> for <tref>local context</tref>, <i>key</i>,
+ and <i>defined</i>.</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of Context Processing -->
@@ -996,7 +996,7 @@
<tref>term definition</tref> can depend on other
<tref title="term definition">term definitions</tref>, a mechanism must
be used to detect cyclical dependencies. The solution employed here
- uses a map, <em>defined</em>, that keeps track of whether or not a
+ uses a map, <i>defined</i>, that keeps track of whether or not a
<tref>term</tref> has been defined or is currently in the process of
being defined. This map is checked before any recursion is attempted.</p>
@@ -1013,61 +1013,61 @@
<p>The algorithm has four required inputs which are:
an <tref>active context</tref>, a <tref>local context</tref>,
- a <em>term</em>, and a map <em>defined</em>.</p>
+ a <i>term</i>, and a map <i>defined</i>.</p>
<ol class="algorithm">
- <li>If <em>defined</em> contains the key <em>term</em>, then the associated
+ <li>If <i>defined</i> contains the key <i>term</i>, then the associated
value must be <tref>true</tref>, indicating that the
<tref>term definition</tref> has already been created, so return. Otherwise, a
<code class="error"><a href="#idl-def-JsonLdErrorCode.cyclic-IRI-mapping">cyclic IRI mapping</a></code>
error has been detected.</li>
- <li>Set the value associated with <em>defined</em>'s <em>term</em> key to
+ <li>Set the value associated with <i>defined</i>'s <i>term</i> key to
<tref>false</tref>. This indicates that the <tref>term definition</tref>
is now being created but is not yet complete.</li>
<li>Since <tref title="keyword">keywords</tref> cannot be overridden,
- <em>term</em> must not be a <tref>keyword</tref>. Otherwise, a
+ <i>term</i> must not be a <tref>keyword</tref>. Otherwise, a
<code class="error"><a href="#idl-def-JsonLdErrorCode.keyword-redefinition">keyword redefinition</a></code>
error has been detected.</li>
- <li>Remove any existing <tref>term definition</tref> for <em>term</em> in
+ <li>Remove any existing <tref>term definition</tref> for <i>term</i> in
<tref>active context</tref>.</li>
- <li>Initialize <em>value</em> to the value associated with the key
- <em>term</em> in <tref>local context</tref>.</li>
- <li>If <em>value</em> is <tref>null</tref> or <em>value</em>
+ <li>Initialize <i>value</i> to the value associated with the key
+ <i>term</i> in <tref>local context</tref>.</li>
+ <li>If <i>value</i> is <tref>null</tref> or <i>value</i>
is a <tref>JSON object</tref> containing the key-value pair
(<code>@id</code>-<tref>null</tref>), then set the
<tref>term definition</tref> in <tref>active context</tref> to
- <tref>null</tref>, set the value associated with <em>defined</em>'s
- key <em>term</em> to <tref>true</tref>, and return.</li>
- <li>Otherwise, if <em>value</em> is a <tref>string</tref>:
+ <tref>null</tref>, set the value associated with <i>defined</i>'s
+ key <i>term</i> to <tref>true</tref>, and return.</li>
+ <li>Otherwise, if <i>value</i> is a <tref>string</tref>:
<ol class="algorithm">
- <li>Expand <em>value</em> by setting it to the result of
+ <li>Expand <i>value</i> by setting it to the result of
using the <a href="#iri-expansion">IRI Expansion algorithm</a>,
- passing <tref>active context</tref>, <em>value</em>,
- <tref>true</tref> for <em>vocabRelative</em>,
- <tref>true</tref> for <em>documentRelative</em>,
- <tref>local context</tref>, and <em>defined</em>.</li>
- <li>If <em>value</em> is a <tref>keyword</tref>, then <em>value</em>
+ passing <tref>active context</tref>, <i>value</i>,
+ <tref>true</tref> for <i>vocabRelative</i>,
+ <tref>true</tref> for <i>documentRelative</i>,
+ <tref>local context</tref>, and <i>defined</i>.</li>
+ <li>If <i>value</i> is a <tref>keyword</tref>, then <i>value</i>
must not be <code>@context</code>, if it is, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-keyword-alias">invalid keyword alias</a></code>
error has been
- detected. Add <em>term</em> to <tref>active context</tref> as a
- <tref>keyword</tref> alias for <em>value</em>. If there is more than
- one <tref>keyword</tref> alias for <em>value</em>, then store its
+ detected. Add <i>term</i> to <tref>active context</tref> as a
+ <tref>keyword</tref> alias for <i>value</i>. If there is more than
+ one <tref>keyword</tref> alias for <i>value</i>, then store its
aliases as an <tref>array</tref>, sorted by length, breaking ties
lexicographically.</li>
<li>Set the <tref>IRI mapping</tref> for the <tref>term definition</tref>
- for <em>term</em> in <tref>active context</tref> to <em>value</em>,
- set the value associated with <em>defined</em>'s key <em>term</em> to
+ for <i>term</i> in <tref>active context</tref> to <i>value</i>,
+ set the value associated with <i>defined</i>'s key <i>term</i> to
<tref>true</tref>, and return.</li>
</ol>
</li>
- <li>Otherwise, <em>value</em> must be a <tref>JSON object</tref>, if not, an
+ <li>Otherwise, <i>value</i> must be a <tref>JSON object</tref>, if not, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-term-definition">invalid term definition</a></code>
error has been detected.</li>
- <li>Create a new <tref>term definition</tref>, <em>definition</em>.</li>
- <li>If <em>value</em> contains the key <code>@reverse</code>:
+ <li>Create a new <tref>term definition</tref>, <i>definition</i>.</li>
+ <li>If <i>value</i> contains the key <code>@reverse</code>:
<ol class="algorithm">
- <li>If <em>value</em> contains an <code>@id</code>, an
+ <li>If <i>value</i> contains an <code>@id</code>, an
<code>@type</code>, or an <code>@language</code>, member, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-reverse-property">invalid reverse property</a></code>
error has been detected.</li>
@@ -1075,114 +1075,114 @@
is not a <tref>string</tref>, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-IRI-mapping">invalid IRI mapping</a></code>
error has been detected.</li>
- <li>Otherwise, set the <tref>IRI mapping</tref> for<em>definition</em> to the
+ <li>Otherwise, set the <tref>IRI mapping</tref> for<i>definition</i> to the
result of using the <a href="#iri-expansion">IRI Expansion algorithm</a>,
passing <tref>active context</tref>, the value associated with
- the <code>@reverse</code> key for <em>value</em>, <tref>true</tref>
- for <em>vocabRelative</em>, <tref>true</tref> for <em>documentRelative</em>,
- <tref>local context</tref>, and <em>defined</em>. If the result
+ the <code>@reverse</code> key for <i>value</i>, <tref>true</tref>
+ for <i>vocabRelative</i>, <tref>true</tref> for <i>documentRelative</i>,
+ <tref>local context</tref>, and <i>defined</i>. If the result
is not an <tref>absolute IRI</tref>, i.e., it contains no
colon (<code>:</code>), an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-IRI-mapping">invalid IRI mapping</a></code>
error has been detected.</li>
- <li>Set the <tref>type mapping</tref> for <em>definition</em> to
+ <li>Set the <tref>type mapping</tref> for <i>definition</i> to
<code>@id</code>.</li>
- <li>If <em>value</em> contains an <code>@container</code> member,
- set the <tref>container mapping</tref> for <em>definition</em>
+ <li>If <i>value</i> contains an <code>@container</code> member,
+ set the <tref>container mapping</tref> for <i>definition</i>
to <code>@index</code> if that is the value of the
<code>@container</code> member; otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-reverse-property">invalid reverse property</a></code>
error has been detected (reverse properties only support index-containers).</li>
- <li>Set the <tref>reverse property</tref> flag for <em>definition</em>
+ <li>Set the <tref>reverse property</tref> flag for <i>definition</i>
to <tref>true</tref>.</li>
- <li>Set the <tref>term definition</tref> for <em>term</em> in
- <tref>active context</tref> to <em>definition</em> and the
- value associated with <em>defined</em>'s key <em>term</em> to
+ <li>Set the <tref>term definition</tref> for <i>term</i> in
+ <tref>active context</tref> to <i>definition</i> and the
+ value associated with <i>defined</i>'s key <i>term</i> to
<tref>true</tref>; then return.</li>
</ol>
</li>
- <li>Set the <tref>reverse property</tref> flag for <em>definition</em>
+ <li>Set the <tref>reverse property</tref> flag for <i>definition</i>
to <tref>false</tref>.</li>
- <li>If <em>value</em> contains the key <code>@id</code>:
+ <li>If <i>value</i> contains the key <code>@id</code>:
<ol class="algorithm">
<li>If the value associated with the <code>@id</code> key is not a <tref>string</tref>, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-IRI-mapping">invalid IRI mapping</a></code>
error has been detected.</li>
- <li>Otherwise, set the <tref>IRI mapping</tref> for <em>definition</em> to the
+ <li>Otherwise, set the <tref>IRI mapping</tref> for <i>definition</i> to the
result of using the <a href="#iri-expansion">IRI Expansion algorithm</a>, passing
<tref>active context</tref>, the value associated with the <code>@id</code> key for
- <em>value</em>, <tref>true</tref> for <em>vocabRelative</em>,
- <tref>true</tref> for <em>documentRelative</em>,
- <tref>local context</tref>, and <em>defined</em>.</li>
+ <i>value</i>, <tref>true</tref> for <i>vocabRelative</i>,
+ <tref>true</tref> for <i>documentRelative</i>,
+ <tref>local context</tref>, and <i>defined</i>.</li>
</ol>
</li>
<li>
- Otherwise if the <em>term</em> contains a colon (<code>:</code>):
+ Otherwise if the <i>term</i> contains a colon (<code>:</code>):
<ol class="algorithm">
- <li>If <em>term</em> is a <tref>compact IRI</tref> with a
+ <li>If <i>term</i> is a <tref>compact IRI</tref> with a
<tref>prefix</tref> that is a key in <tref>local context</tref> then
a dependency has been found. Use this algorithm recursively passing
<tref>active context</tref>, <tref>local context</tref>, the
- <tref>prefix</tref> as <em>term</em>, and <em>defined</em>.</li>
- <li>If <em>term</em>'s <tref>prefix</tref> has a
+ <tref>prefix</tref> as <i>term</i>, and <i>defined</i>.</li>
+ <li>If <i>term</i>'s <tref>prefix</tref> has a
<tref>term definition</tref> in <tref>active context</tref>, set
- the <tref>IRI mapping</tref> for <em>definition</em> to the result of
+ the <tref>IRI mapping</tref> for <i>definition</i> to the result of
concatenating the value associated with the <tref>prefix</tref>'s
- <tref>IRI mapping</tref> and the <em>term</em>'s <em>suffix</em>.</li>
- <li>Otherwise, <em>term</em> is an <tref>absolute IRI</tref>. Set the
- <tref>IRI mapping</tref> for <em>definition</em> to <em>term</em>.</li>
+ <tref>IRI mapping</tref> and the <i>term</i>'s <i>suffix</i>.</li>
+ <li>Otherwise, <i>term</i> is an <tref>absolute IRI</tref>. Set the
+ <tref>IRI mapping</tref> for <i>definition</i> to <i>term</i>.</li>
</ol>
</li>
<li>Otherwise, <tref>active context</tref> must have a
<tref>vocabulary mapping</tref>, if not, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-IRI-mapping">invalid IRI mapping</a></code>
error been detected. Set the <tref>IRI mapping</tref>
- for <em>definition</em> to the result of concatenating the value
- associated with the <tref>vocabulary mapping</tref> and <em>term</em>.</li>
- <li>If <em>value</em> contains the key <code>@type</code>:
+ for <i>definition</i> to the result of concatenating the value
+ associated with the <tref>vocabulary mapping</tref> and <i>term</i>.</li>
+ <li>If <i>value</i> contains the key <code>@type</code>:
<ol class="algorithm">
- <li>Initialize <em>type</em> to the value associated with the
+ <li>Initialize <i>type</i> to the value associated with the
<code>@type</code> key, which must be a <tref>string</tref>. Otherwise, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-type-mapping">invalid type mapping</a></code>
error has been detected.</li>
- <li>If <em>type</em> is not <code>@id</code> then set it to
+ <li>If <i>type</i> is not <code>@id</code> then set it to
the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>type</em> for <em>value</em>,
- <tref>true</tref> for <em>vocabRelative</em>,
- <tref>true</tref> for <em>documentRelative</em>,
- <tref>local context</tref>, and <em>defined</em>. Set the
- <tref>type mapping</tref> for <em>definition</em> to <em>type</em>.</li>
+ <tref>active context</tref>, <i>type</i> for <i>value</i>,
+ <tref>true</tref> for <i>vocabRelative</i>,
+ <tref>true</tref> for <i>documentRelative</i>,
+ <tref>local context</tref>, and <i>defined</i>. Set the
+ <tref>type mapping</tref> for <i>definition</i> to <i>type</i>.</li>
</ol>
</li>
- <li>If <em>value</em> contains the key <code>@container</code>:
+ <li>If <i>value</i> contains the key <code>@container</code>:
<ol class="algorithm">
- <li>Initialize <em>container</em> to the value associated with the
+ <li>Initialize <i>container</i> to the value associated with the
<code>@container</code> key, which must be either:
<code>@list</code>, <code>@set</code>, <code>@index</code>,
or <code>@language</code>. Otherwise, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-container-mapping">invalid container mapping</a></code> error
has been detected.</li>
- <li>Set the <tref>container mapping</tref> for <em>definition</em> to
- <em>container</em>.</li>
+ <li>Set the <tref>container mapping</tref> for <i>definition</i> to
+ <i>container</i>.</li>
</ol>
</li>
- <li>If <em>value</em> contains the key <code>@language</code> and
+ <li>If <i>value</i> contains the key <code>@language</code> and
does not contain the key <code>@type</code>:
<ol class="algorithm">
- <li>Initialize <em>language</em> to the value associated with the
+ <li>Initialize <i>language</i> to the value associated with the
<code>@language</code> key, which must be either <tref>null</tref>
or a <tref>string</tref>. Otherwise, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-language-mapping">invalid language mapping</a></code>
error has been detected.</li>
- <li>If <em>language</em> is a <tref>string</tref> set it to
- lowercased <em>language</em>. Set the <tref>language mapping</tref>
- for <em>definition</em> to <em>language</em>.</li>
+ <li>If <i>language</i> is a <tref>string</tref> set it to
+ lowercased <i>language</i>. Set the <tref>language mapping</tref>
+ for <i>definition</i> to <i>language</i>.</li>
</ol>
</li>
- <li>Set the <tref>term definition</tref> for <em>term</em> in
- <tref>active context</tref> to <em>definition</em> and set the value
- associated with <em>defined</em>'s key <em>term</em> to
+ <li>Set the <tref>term definition</tref> for <i>term</i> in
+ <tref>active context</tref> to <i>definition</i> and set the value
+ associated with <i>defined</i>'s key <i>term</i> to
<tref>true</tref>.</li>
</ol>
</section>
@@ -1199,7 +1199,7 @@
<p><tref>IRI</tref> expansion may occur during context processing or during
any of the other JSON-LD algorithms. If IRI expansion occurs during context
- processing, then the <tref>local context</tref> and its related <em>defined</em>
+ processing, then the <tref>local context</tref> and its related <i>defined</i>
map from the <a href="#context-processing-algorithm">Context Processing algorithm</a>
are passed to this algorithm. This allows for <tref>term definition</tref>
dependencies to be processed via the
@@ -1223,22 +1223,22 @@
<section class="informative">
<h3>General Solution</h3>
- <p>In order to expand <em>value</em> to an <tref>absolute IRI</tref>, we must
+ <p>In order to expand <i>value</i> to an <tref>absolute IRI</tref>, we must
first determine if it is <tref>null</tref>, a <tref>term</tref>, a
<tref>keyword</tref> alias, or some form of <tref>IRI</tref>. Based on what
we find, we handle the specific kind of expansion; for example, we expand
a <tref>keyword</tref> alias to a <tref>keyword</tref> and a <tref>term</tref>
to an <tref>absolute IRI</tref> according to its <tref>IRI mapping</tref>
- in the <tref>active context</tref>. While inspecting <em>value</em> we
+ in the <tref>active context</tref>. While inspecting <i>value</i> we
may also find that we need to create <tref>term definition</tref>
dependencies because we're running this algorithm during context processing.
We can tell whether or not we're running during context processing by
checking <tref>local context</tref> against <tref>null</tref>.
We know we need to create a <tref>term definition</tref> in the
- <tref>active context</tref> when <em>value</em> is
- a key in the <tref>local context</tref> and the <em>defined</em> map
- does not have a key for <em>value</em> with an associated value of
- <tref>true</tref>. The <em>defined</em> map is used during
+ <tref>active context</tref> when <i>value</i> is
+ a key in the <tref>local context</tref> and the <i>defined</i> map
+ does not have a key for <i>value</i> with an associated value of
+ <tref>true</tref>. The <i>defined</i> map is used during
<a href="#context-processing-algorithm">Context Processing</a> to keep track of
which <tref title="term">terms</tref> have already been defined or are
in the process of being defined. We create a
@@ -1250,86 +1250,86 @@
<h3>Algorithm</h3>
<p>The algorithm takes two required and four optional input variables. The
- required inputs are an <tref>active context</tref> and a <em>value</em>
+ required inputs are an <tref>active context</tref> and a <i>value</i>
to be expanded. The optional inputs are two flags,
- <em>documentRelative</em> and <em>vocabRelative</em>, that specifying
- whether <em>value</em> can be interpreted as a <tref>relative IRI</tref>
+ <i>documentRelative</i> and <i>vocabRelative</i>, that specifying
+ whether <i>value</i> can be interpreted as a <tref>relative IRI</tref>
against the document's base <tref>IRI</tref> or the
<tref title="active context">active context's</tref>
<tref>vocabulary mapping</tref>, respectively, and
- a <tref>local context</tref> and a map <em>defined</em> to be used when
+ a <tref>local context</tref> and a map <i>defined</i> to be used when
this algorithm is used during <a href="#context-processing-algorithm">Context Processing</a>.
If not passed, the two flags are set to <code>false</code> and
- <tref>local context</tref> and <em>defined</em> are initialized to <tref>null</tref>.</p>
+ <tref>local context</tref> and <i>defined</i> are initialized to <tref>null</tref>.</p>
<ol class="algorithm">
- <li>If <em>value</em> is a <tref>keyword</tref> or is <tref>null</tref>,
- return <em>value</em> as is.</li>
+ <li>If <i>value</i> is a <tref>keyword</tref> or is <tref>null</tref>,
+ return <i>value</i> as is.</li>
<li>If <tref>local context</tref> is not <tref>null</tref>, it contains
- a key that equals <em>value</em>, and the value associated with the key
- that equals <em>value</em> in <em>defined</em> is not <tref>true</tref>,
+ a key that equals <i>value</i>, and the value associated with the key
+ that equals <i>value</i> in <i>defined</i> is not <tref>true</tref>,
then invoke the
<a href="#create-term-definition">Create Term Definition algorithm</a>,
passing <tref>active context</tref>, <tref>local context</tref>,
- <em>value</em> as <em>term</em>, and <em>defined</em>. This will ensure that
- a <tref>term definition</tref> is created for <em>value</em> in
+ <i>value</i> as <i>term</i>, and <i>defined</i>. This will ensure that
+ a <tref>term definition</tref> is created for <i>value</i> in
<tref>active context</tref> during <a href="#context-processing-algorithm">Context Processing</a>.
</li>
- <li>Initialize <em>result</em> to <tref>null</tref>.</li>
- <li>If <em>vocabRelative</em> is <tref>true</tref>:
+ <li>Initialize <i>result</i> to <tref>null</tref>.</li>
+ <li>If <i>vocabRelative</i> is <tref>true</tref>:
<ol class="algorithm">
- <li>If <em>value</em> has a <tref>null</tref> mapping in
+ <li>If <i>value</i> has a <tref>null</tref> mapping in
<tref>active context</tref>, then return <tref>null</tref>.</li>
<li>If <tref>active context</tref> has a <tref>term definition</tref> for
- <em>value</em>, then set <em>result</em> to the associated
+ <i>value</i>, then set <i>result</i> to the associated
<tref>IRI mapping</tref>.</li>
</ol>
</li>
- <li>If <em>result</em> is <tref>null</tref> and <em>value</em> contains a
+ <li>If <i>result</i> is <tref>null</tref> and <i>value</i> contains a
colon (<code>:</code>), then it is either an <tref>absolute IRI</tref> or
a <tref>compact IRI</tref>:
<ol class="algorithm">
- <li>Split <em>value</em> into a <tref>prefix</tref> and <em>suffix</em>
+ <li>Split <i>value</i> into a <tref>prefix</tref> and <i>suffix</i>
at the first occurrence of a colon (<code>:</code>).</li>
<li>If <tref>prefix</tref> is not underscore (<code>_</code>)
- and <em>suffix</em> does not begin with double-forward-slash
+ and <i>suffix</i> does not begin with double-forward-slash
(<code>//</code>), then it may be a <tref>compact IRI</tref>:
<ol class="algorithm">
<li>If <tref>local context</tref> is not <tref>null</tref> and it
contains a key that equals <tref>prefix</tref>, then invoke the
<a href="#create-term-definition">Create Term Definition algorithm</a>,
passing <tref>active context</tref>,
- <tref>local context</tref>, <em>prefix</em> as <em>term</em>,
- and <em>defined</em>. This will ensure that a
+ <tref>local context</tref>, <i>prefix</i> as <i>term</i>,
+ and <i>defined</i>. This will ensure that a
<tref>term definition</tref> is created for <tref>prefix</tref>
in <tref>active context</tref> during
<a href="#context-processing-algorithm">Context Processing</a>.</li>
<li>If <tref>active context</tref> contains a <tref>term definition</tref>
- for <tref>prefix</tref> then set <em>result</em>
+ for <tref>prefix</tref> then set <i>result</i>
to the result of concatenating the value associated with the
<tref>prefix</tref>'s <tref>IRI mapping</tref> and
- <em>suffix</em>.</li>
+ <i>suffix</i>.</li>
</ol>
</li>
</ol>
</li>
- <li>If <em>result</em> is <tref>null</tref>, set it to <em>value</em>.</li>
- <li>If <tref>active context</tref> indicates that <em>value</em> is a
+ <li>If <i>result</i> is <tref>null</tref>, set it to <i>value</i>.</li>
+ <li>If <tref>active context</tref> indicates that <i>value</i> is a
<tref>keyword</tref> alias then return the associated <tref>keyword</tref>.</li>
- <li>If <tref>local context</tref> is <tref>null</tref> and <em>result</em>
- begins with an underscore and colon (<code>_:</code>) then <em>result</em> is a
- <tref>blank node identifier</tref>. Set <em>result</em> to the
+ <li>If <tref>local context</tref> is <tref>null</tref> and <i>result</i>
+ begins with an underscore and colon (<code>_:</code>) then <i>result</i> is a
+ <tref>blank node identifier</tref>. Set <i>result</i> to the
result of the
<a href="#generate-blank-node-identifier">Generate Blank Node Identifier algorithm</a>,
- passing <tref>active context</tref> and <em>result</em>
- for <em>identifier</em>.</li>
- <li>Otherwise, if <em>result</em> does not contain a colon (<code>:</code>),
- <em>vocabRelative</em> is <tref>true</tref>, and
+ passing <tref>active context</tref> and <i>result</i>
+ for <i>identifier</i>.</li>
+ <li>Otherwise, if <i>result</i> does not contain a colon (<code>:</code>),
+ <i>vocabRelative</i> is <tref>true</tref>, and
<tref>active context</tref> has a <tref>vocabulary mapping</tref>,
- then set <em>result</em> to the result of concatenating the
- <tref>vocabulary mapping</tref> with <em>result</em>.</li>
- <li>Otherwise, if <em>documentRelative</em> is <tref>true</tref>,
- set <em>result</em> to the result of resolving <em>result</em> against
+ then set <i>result</i> to the result of concatenating the
+ <tref>vocabulary mapping</tref> with <i>result</i>.</li>
+ <li>Otherwise, if <i>documentRelative</i> is <tref>true</tref>,
+ set <i>result</i> to the result of resolving <i>result</i> against
the <tref>base IRI</tref>. Only the basic algorithm in
section 5.2 of [[!RFC3986]] is used; neither Syntax-Based Normalization
nor Scheme-Based Normalization (as described in sections 6.2.2 and
@@ -1337,10 +1337,10 @@
IRI references are treated in the same way that unreserved characters
are treated in URI references, per section 6.5 of [[!RFC3987]].</li>
<li>If <tref>local context</tref> is not <tref>null</tref> then
- <em>result</em> must be an <tref>absolute IRI</tref>, if not,
+ <i>result</i> must be an <tref>absolute IRI</tref>, if not,
an <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-IRI-mapping">invalid IRI mapping</a></code>
error has been detected.</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of IRI Expansion -->
@@ -1352,25 +1352,25 @@
<tref title="blank node identifier">blank node identifiers</tref> or to
relabel an existing <tref>blank node identifier</tref> to avoid collision
by the introduction of new ones. Between its executions, the algorithm
- needs to keep an <em>identifier map</em> to relabel existing
+ needs to keep an <i>identifier map</i> to relabel existing
<tref title="blank node identifier">blank node identifiers</tref> consistently
- and a <em>counter</em> to generate new
+ and a <i>counter</i> to generate new
<tref title="blank node identifier">blank node identifiers</tref>. The
- <em>counter</em> is initialized to <code>0</code> by default.</p>
-
- <p>The algorithm takes a single input variable <em>identifier</em> which may
+ <i>counter</i> is initialized to <code>0</code> by default.</p>
+
+ <p>The algorithm takes a single input variable <i>identifier</i> which may
be <tref>null</tref>.</p>
<ol class="algorithm">
- <li>If the <em>identifier</em> is not <tref>null</tref> and is in the
- <em>identifier map</em>, return the mapped identifier.</li>
- <li>Otherwise, generate a new <em>blankNodeIdentifier</em> by concatenating
- the string <code>_:b</code> and <em>counter</em>.</li>
- <li>Increment <em>counter</em> by <code>1</code>.</li>
- <li>If <em>identifier</em> is not <tref>null</tref>, create a new entry
- for <em>identifier</em> in <em>identifier map</em> and set its value
- to <em>blankNodeIdentifer</em>.</li>
- <li>Return <em>blankNodeIdentifier</em>.</li>
+ <li>If the <i>identifier</i> is not <tref>null</tref> and is in the
+ <i>identifier map</i>, return the mapped identifier.</li>
+ <li>Otherwise, generate a new <i>blankNodeIdentifier</i> by concatenating
+ the string <code>_:b</code> and <i>counter</i>.</li>
+ <li>Increment <i>counter</i> by <code>1</code>.</li>
+ <li>If <i>identifier</i> is not <tref>null</tref>, create a new entry
+ for <i>identifier</i> in <i>identifier map</i> and set its value
+ to <i>blankNodeIdentifer</i>.</li>
+ <li>Return <i>blankNodeIdentifier</i>.</li>
</ol>
</section> <!-- end of Generate Blank Node Identifier -->
</section> <!-- end of Context Processing section -->
@@ -1396,23 +1396,23 @@
<section class="informative">
<h3>General Solution</h3>
- <p>Starting with its root <em>element</em>, we can process the
+ <p>Starting with its root <i>element</i>, we can process the
JSON-LD document recursively, until we have a fully
- <tref title="expansion">expanded</tref> <em>result</em>. When
- <tref title="expansion">expanding</tref> an <em>element</em>, we can treat
+ <tref title="expansion">expanded</tref> <i>result</i>. When
+ <tref title="expansion">expanding</tref> an <i>element</i>, we can treat
each one differently according to its type, in order to break down the
problem:</p>
<ol>
- <li>If the <em>element</em> is <tref>null</tref>, there is nothing
+ <li>If the <i>element</i> is <tref>null</tref>, there is nothing
to expand.</li>
- <li>Otherwise, if <em>element</em> is a <tref>scalar</tref>, we expand it
+ <li>Otherwise, if <i>element</i> is a <tref>scalar</tref>, we expand it
according to the <a href="#value-expansion">Value Expansion algorithm</a>.</li>
- <li>Otherwise, if the <em>element</em> is an <tref>array</tref>, then we expand
+ <li>Otherwise, if the <i>element</i> is an <tref>array</tref>, then we expand
each of its items recursively and return them in a new
<tref>array</tref>.</li>
- <li>Otherwise, <em>element</em> is a <tref>JSON object</tref>. We expand
- each of its keys, adding them to our <em>result</em>, and then we expand
+ <li>Otherwise, <i>element</i> is a <tref>JSON object</tref>. We expand
+ each of its keys, adding them to our <i>result</i>, and then we expand
each value for each key recursively. Some of the keys will be
<tref title="term">terms</tref> or
<tref title="compact IRI">compact IRIs</tref> and others will be
@@ -1423,30 +1423,30 @@
</li>
</ol>
- <p>Finally, after ensuring <em>result</em> is in an <tref>array</tref>,
- we return <em>result</em>.</p>
+ <p>Finally, after ensuring <i>result</i> is in an <tref>array</tref>,
+ we return <i>result</i>.</p>
</section>
<section>
<h3>Algorithm</h3>
<p>The algorithm takes four input variables: an <tref>active context</tref>,
- an <tref>active property</tref>, an <em>element</em> to be expanded, and
- an <em>insideList</em> flag. To begin, the <tref>active context</tref> is set
+ an <tref>active property</tref>, an <i>element</i> to be expanded, and
+ an <i>insideList</i> flag. To begin, the <tref>active context</tref> is set
to the result of performing, <a href="#context-processing-algorithm">Context Processing</a> on the passed
<code class="idlMemberName"><a href="#widl-JsonLdOptions-expandContext">expandContext</a></code>,
or empty if <code class="idlMemberName"><a href="#widl-JsonLdOptions-expandContext">expandContext</a></code>
is <tref>null</tref>, <tref>active property</tref> is set to <tref>null</tref>,
- <em>element</em> is set to the <tref>JSON-LD input</tref>, and <em>insideList</em>
+ <i>element</i> is set to the <tref>JSON-LD input</tref>, and <i>insideList</i>
is set to <tref>false</tref>. This algorithm expects the
<tref>JSON-LD input</tref> to be a well-formed JSON-LD document as defined
in [[!JSON-LD]].</p>
<ol class="algorithm">
- <li>If <em>element</em> is <tref>null</tref>, return <tref>null</tref>.</li>
- <li>If <em>element</em> is a <tref>scalar</tref>,
+ <li>If <i>element</i> is <tref>null</tref>, return <tref>null</tref>.</li>
+ <li>If <i>element</i> is a <tref>scalar</tref>,
<ol class="algorithm">
- <li>If <em>insideList</em> is <tref>false</tref> and
+ <li>If <i>insideList</i> is <tref>false</tref> and
either <tref>active property</tref> is <tref>null</tref> or
the result of expanding <tref>active property</tref> using the
<a href="#iri-expansion">IRI Expansion algorithm </a> is
@@ -1455,320 +1455,320 @@
<li>Return the result of the
<a href="#value-expansion">Value Expansion algorithm</a>, passing the
<tref>active context</tref>, <tref>active property</tref>, and
- <em>element</em> as <em>value</em>.</li>
+ <i>element</i> as <i>value</i>.</li>
</ol>
</li>
- <li>If <em>element</em> is an <tref>array</tref>,
+ <li>If <i>element</i> is an <tref>array</tref>,
<ol class="algorithm">
- <li>Initialize an empty array, <em>result</em>.</li>
- <li>For each <em>item</em> in <em>element</em>:
+ <li>Initialize an empty array, <i>result</i>.</li>
+ <li>For each <i>item</i> in <i>element</i>:
<ol class="algorithm">
- <li>Initialize <em>expanded item</em> to the result of using this
+ <li>Initialize <i>expanded item</i> to the result of using this
algorithm recursively, passing <tref>active context</tref>,
- <tref>active property</tref>, <em>item</em> as <em>element</em>,
- and <em>insideList</em>.</li>
- <li>If <em>insideList</em> is <tref>true</tref> then
- <em>expanded item</em> must not be an <tref>array</tref> or a
+ <tref>active property</tref>, <i>item</i> as <i>element</i>,
+ and <i>insideList</i>.</li>
+ <li>If <i>insideList</i> is <tref>true</tref> then
+ <i>expanded item</i> must not be an <tref>array</tref> or a
<tref>list object</tref>, otherwise a
<code class="error"><a href="#idl-def-JsonLdErrorCode.list-of-lists">list of lists</a></code> error has been detected.</li>
- <li>If <em>expanded item</em> is an <tref>array</tref>, append each
- of its items to <em>result</em>. Otherwise, if
- <em>expanded item</em> is not null, append it to <em>result</em>.</li>
+ <li>If <i>expanded item</i> is an <tref>array</tref>, append each
+ of its items to <i>result</i>. Otherwise, if
+ <i>expanded item</i> is not null, append it to <i>result</i>.</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</li>
- <li>Otherwise <em>element</em> is a <tref>JSON object</tref>.</li>
- <li>If <em>element</em> contains the key <code>@context</code>, set
+ <li>Otherwise <i>element</i> is a <tref>JSON object</tref>.</li>
+ <li>If <i>element</i> contains the key <code>@context</code>, set
<tref>active context</tref> to the result of the
<a href="#context-processing-algorithm">Context Processing algorithm</a>,
passing <tref>active context</tref> and the value of the
<code>@context</code> key as <tref>local context</tref>.</li>
- <li>Initialize <em>expanded active property</em> to the result of the
+ <li>Initialize <i>expanded active property</i> to the result of the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
<tref>active context</tref>, <tref>active property</tref> for
- <em>value</em>, and <tref>true</tref> for <em>vocabRelative</em>.</li>
- <li>Initialize an empty <tref>JSON object</tref>, <em>result</em>.</li>
- <li>For each <em>key</em> and <em>value</em> in <em>element</em>,
- ordered lexicographically by <em>key</em>:
+ <i>value</i>, and <tref>true</tref> for <i>vocabRelative</i>.</li>
+ <li>Initialize an empty <tref>JSON object</tref>, <i>result</i>.</li>
+ <li>For each <i>key</i> and <i>value</i> in <i>element</i>,
+ ordered lexicographically by <i>key</i>:
<ol class="algorithm">
- <li>If <em>key</em> is <code>@context</code>, continue to
- the next <em>key</em>.</li>
- <li>Set <em>expanded property</em> to the result of
+ <li>If <i>key</i> is <code>@context</code>, continue to
+ the next <i>key</i>.</li>
+ <li>Set <i>expanded property</i> to the result of
using the <a href="#iri-expansion">IRI Expansion algorithm</a>,
- passing <tref>active context</tref>, <em>key</em> for
- <em>value</em>, and <tref>true</tref> for <em>vocabRelative</em>.</li>
- <li>If <em>expanded property</em> is either <tref>null</tref> or
+ passing <tref>active context</tref>, <i>key</i> for
+ <i>value</i>, and <tref>true</tref> for <i>vocabRelative</i>.</li>
+ <li>If <i>expanded property</i> is either <tref>null</tref> or
neither an <tref>absolute IRI</tref> nor a <tref>keyword</tref>,
- drop <em>key</em> by continuing to the next <em>key</em>.</li>
- <li>Validate <em>expanded property</em> against <em>value</em>
+ drop <i>key</i> by continuing to the next <i>key</i>.</li>
+ <li>Validate <i>expanded property</i> against <i>value</i>
as follows:
<ol class="algorithm">
- <li>If <em>expanded property</em> is a <tref>keyword</tref>
+ <li>If <i>expanded property</i> is a <tref>keyword</tref>
and <tref>active property</tref> equals <code>@reverse</code>,
an <code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-reverse-property-map">invalid reverse property map</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@id</code> then
- <em>value</em> must be a <tref>string</tref>, otherwise an
+ <li>If <i>expanded property</i> is <code>@id</code> then
+ <i>value</i> must be a <tref>string</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--id-value">invalid @id value</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@type</code> then
- <em>value</em> must be a <tref>string</tref> or an <tref>array</tref>
+ <li>If <i>expanded property</i> is <code>@type</code> then
+ <i>value</i> must be a <tref>string</tref> or an <tref>array</tref>
of strings, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-type-value">invalid type value</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@graph</code> then
- <em>value</em> must be a <tref>JSON object</tref> or an
+ <li>If <i>expanded property</i> is <code>@graph</code> then
+ <i>value</i> must be a <tref>JSON object</tref> or an
<tref>array</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--graph-value">invalid @graph value</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@value</code> then
- <em>value</em> must not be a <tref>JSON object</tref> or
+ <li>If <i>expanded property</i> is <code>@value</code> then
+ <i>value</i> must not be a <tref>JSON object</tref> or
an <tref>array</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-value-object-value">invalid value object value</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@language</code> then
- <em>value</em> must be a <tref>string</tref>, otherwise an
+ <li>If <i>expanded property</i> is <code>@language</code> then
+ <i>value</i> must be a <tref>string</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-language-tagged-string">invalid language tagged string</a></code>
- error has been detected. Set <em>expanded value</em> to lowercased
- <em>value</em>.</li>
- <li>If <em>expanded property</em> is <code>@index</code>
- then <em>value</em> must be a <tref>string</tref>, otherwise an
+ error has been detected. Set <i>expanded value</i> to lowercased
+ <i>value</i>.</li>
+ <li>If <i>expanded property</i> is <code>@index</code>
+ then <i>value</i> must be a <tref>string</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--index-value">invalid @index value</a></code>
error has been detected.</li>
- <li>If <em>expanded property</em> is <code>@reverse</code> then
- <em>value</em> must be a <tref>JSON object</tref>, otherwise an
+ <li>If <i>expanded property</i> is <code>@reverse</code> then
+ <i>value</i> must be a <tref>JSON object</tref>, otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--reverse-value">invalid @reverse value</a></code>
error has been detected.</li>
</ol>
</li>
- <li>If <em>expanded property</em> is <code>@reverse</code>:
+ <li>If <i>expanded property</i> is <code>@reverse</code>:
<ol class="algorithm">
- <li>Initialize <em>expanded value</em> to the result of using this
+ <li>Initialize <i>expanded value</i> to the result of using this
algorithm recursively, passing <tref>active context</tref>,
- <code>@reverse</code> as <tref>active property</tref>, <em>value</em>
- as <em>element</em>, and <em>insideList</em>.</li>
- <li>If <em>expanded value</em> contains an <code>@reverse</code> member,
+ <code>@reverse</code> as <tref>active property</tref>, <i>value</i>
+ as <i>element</i>, and <i>insideList</i>.</li>
+ <li>If <i>expanded value</i> contains an <code>@reverse</code> member,
i.e., properties that are reversed twice, execute for each of its
- <em>property</em> and <em>item</em> the following steps:
+ <i>property</i> and <i>item</i> the following steps:
<ol class="algorithm">
- <li>If <em>result</em> does not have an <em>property</em> member, create
+ <li>If <i>result</i> does not have an <i>property</i> member, create
one and set its value to an empty <tref>array</tref>.</li>
- <li>Append <em>item</em> to the value of the <em>property</em> member
- of <em>result</em>.</li>
+ <li>Append <i>item</i> to the value of the <i>property</i> member
+ of <i>result</i>.</li>
</ol>
</li>
- <li>If <em>expanded value</em> contains members other than <code>@reverse</code>:
+ <li>If <i>expanded value</i> contains members other than <code>@reverse</code>:
<ol class="algorithm">
- <li>If <em>result</em> does not have an <code>@reverse</code> member, create
+ <li>If <i>result</i> does not have an <code>@reverse</code> member, create
one and set its value to an empty <tref>JSON object</tref>.</li>
- <li>Reference the value of the <code>@reverse</code> member in <em>result</em>
- using the variable <em>reverse map</em>.</li>
- <li>For each <em>property</em> and <em>items</em> in <em>expanded value</em>
+ <li>Reference the value of the <code>@reverse</code> member in <i>result</i>
+ using the variable <i>reverse map</i>.</li>
+ <li>For each <i>property</i> and <i>items</i> in <i>expanded value</i>
other than <code>@reverse</code>:
<ol class="algorithm">
- <li>For each <em>item</em> in <em>items</em>:
+ <li>For each <i>item</i> in <i>items</i>:
<ol class="algorithm">
- <li>If <em>item</em> is a <tref>value object</tref> or <tref>list object</tref>, an
+ <li>If <i>item</i> is a <tref>value object</tref> or <tref>list object</tref>, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--reverse-value">invalid reverse property value</a></code>
has been detected.</li>
- <li>If <em>reverse map</em> has no <em>property</em> member, create one
+ <li>If <i>reverse map</i> has no <i>property</i> member, create one
and initialize its value to an empty <tref>array</tref>.</li>
- <li>Append <em>item</em> to the value of the <em>property</em>
- member in <em>reverse map</em>.</li>
+ <li>Append <i>item</i> to the value of the <i>property</i>
+ member in <i>reverse map</i>.</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
- <li>Continue with the next <em>key</em> from <em>element</em>.</li>
+ <li>Continue with the next <i>key</i> from <i>element</i>.</li>
</ol>
</li>
- <li>If <em>key</em>'s <tref>container mapping</tref> in
+ <li>If <i>key</i>'s <tref>container mapping</tref> in
<tref>active context</tref> is <code>@language</code> and
- <em>value</em> is a <tref>JSON object</tref> then <em>value</em>
+ <i>value</i> is a <tref>JSON object</tref> then <i>value</i>
is expanded from a <tref href="../json-ld-syntax/#dfn-language-map">language map</tref>
as follows:
<ol class="algorithm">
- <li>Initialize <em>expanded value</em> to an empty
+ <li>Initialize <i>expanded value</i> to an empty
<tref>array</tref>.</li>
- <li>For each key <em>language</em> and value <em>language value</em>
- in <em>value</em>, ordered lexicographically by
- <em>language</em>:
+ <li>For each key <i>language</i> and value <i>language value</i>
+ in <i>value</i>, ordered lexicographically by
+ <i>language</i>:
<ol class="algorithm">
- <li>If <em>language value</em> is not an <tref>array</tref>
+ <li>If <i>language value</i> is not an <tref>array</tref>
set it to an <tref>array</tref> containing only
- <em>language value</em>.</li>
- <li>For each <em>item</em> in <em>language value</em>:
+ <i>language value</i>.</li>
+ <li>For each <i>item</i> in <i>language value</i>:
<ol class="algorithm">
- <li><em>item</em> must be a <tref>string</tref>,
+ <li><i>item</i> must be a <tref>string</tref>,
otherwise an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-language-map-value">invalid language map value</a></code>
error has been detected.</li>
<li>Append a <tref>JSON object</tref> to
- <em>expanded value</em> that consists of two
- key-value pairs: (<code>@value</code>-<em>item</em>)
+ <i>expanded value</i> that consists of two
+ key-value pairs: (<code>@value</code>-<i>item</i>)
and (<code>@language</code>-lowercased
- <em>language</em>).</li>
- </ol>
- </li>
- </ol>
- </li>
- </ol>
- </li>
- <li>If <em>key</em>'s <tref>container mapping</tref> in
- <tref>active context</tref> is <code>@index</code> and
- <em>value</em> is a <tref>JSON object</tref> then <em>value</em>
- is expanded from an index map as follows:
- <ol class="algorithm">
- <li>Initialize <em>expanded value</em> to an empty
- <tref>array</tref>.</li>
- <li>For each key <em>index</em> and value
- <em>index value</em> in <em>value</em>, ordered
- lexicographically by <em>index</em>:
- <ol class="algorithm">
- <li>If <em>index value</em> is not an <tref>array</tref>
- set it to an <tref>array</tref> containing only
- <em>index value</em>.</li>
- <li>Initialize <em>index value</em> to the result of
- using this algorithm recursively, passing
- <tref>active context</tref>, <tref>active property</tref>,
- <em>index value</em> as <em>element</em>, and
- <tref>false</tref> for <em>insideList</em>.</li>
- <li>For each <em>item</em> in <em>index value</em>:
- <ol class="algorithm">
- <li>If <em>item</em> does not have the key
- <code>@index</code>, add the key-value pair
- (<code>@index</code>-<em>index</em>) to
- <em>item</em>.</li>
- <li>Append <em>item</em> to <em>expanded value</em>.</li>
+ <i>language</i>).</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
- <li>Otherwise, if <em>expanded property</em> is <code>@list</code>
+ <li>If <i>key</i>'s <tref>container mapping</tref> in
+ <tref>active context</tref> is <code>@index</code> and
+ <i>value</i> is a <tref>JSON object</tref> then <i>value</i>
+ is expanded from an index map as follows:
+ <ol class="algorithm">
+ <li>Initialize <i>expanded value</i> to an empty
+ <tref>array</tref>.</li>
+ <li>For each key <i>index</i> and value
+ <i>index value</i> in <i>value</i>, ordered
+ lexicographically by <i>index</i>:
+ <ol class="algorithm">
+ <li>If <i>index value</i> is not an <tref>array</tref>
+ set it to an <tref>array</tref> containing only
+ <i>index value</i>.</li>
+ <li>Initialize <i>index value</i> to the result of
+ using this algorithm recursively, passing
+ <tref>active context</tref>, <tref>active property</tref>,
+ <i>index value</i> as <i>element</i>, and
+ <tref>false</tref> for <i>insideList</i>.</li>
+ <li>For each <i>item</i> in <i>index value</i>:
+ <ol class="algorithm">
+ <li>If <i>item</i> does not have the key
+ <code>@index</code>, add the key-value pair
+ (<code>@index</code>-<i>index</i>) to
+ <i>item</i>.</li>
+ <li>Append <i>item</i> to <i>expanded value</i>.</li>
+ </ol>
+ </li>
+ </ol>
+ </li>
+ </ol>
+ </li>
+ <li>Otherwise, if <i>expanded property</i> is <code>@list</code>
or <code>@set</code>:
<ol class="algorithm">
- <li>Initialize <em>expanded value</em> to the result of using
+ <li>Initialize <i>expanded value</i> to the result of using
this algorithm recursively passing
<tref>active context</tref>, <tref>null</tref> for
- <tref>active property</tref> if <em>expanded property</em>
- is <code>@list</code> and <em>expanded active property</em>
+ <tref>active property</tref> if <i>expanded property</i>
+ is <code>@list</code> and <i>expanded active property</i>
is <code>@graph</code> otherwise <tref>active property</tref>,
- <em>value</em> for <em>element</em>, and <tref>true</tref>
- for <em>insideList</em> if <em>expanded property</em> is
+ <i>value</i> for <i>element</i>, and <tref>true</tref>
+ for <i>insideList</i> if <i>expanded property</i> is
<code>@list</code> otherwise <tref>false</tref>.</li>
- <li>If <em>expanded property</em> is <code>@list</code>
- then <em>expanded value</em> must not be a
+ <li>If <i>expanded property</i> is <code>@list</code>
+ then <i>expanded value</i> must not be a
<tref>list object</tref>, otherwise a
<code class="error"><a href="#idl-def-JsonLdErrorCode.list-of-lists">list of lists</a></code>
error has been detected.</li>
</ol>
</li>
- <li>Otherwise, initialize <em>expanded value</em> to the result of
+ <li>Otherwise, initialize <i>expanded value</i> to the result of
using this algorithm recursively, passing
- <tref>active context</tref>, <em>key</em> for
- <tref>active property</tref>, <em>value</em>
- for <em>element</em>, and <tref>false</tref> for
- <em>insideList</em>.</li>
- <li>If <em>expanded value</em> is <tref>null</tref> and
- <em>expanded property</em> is not <code>@value</code> then
- drop <em>key</em> by continuing to the next key.</li>
- <li>If <em>expanded property</em> is not <code>@list</code> and
- <em>expanded value</em> is not a <tref>list object</tref> and
- <em>key</em>'s <tref>container mapping</tref> in
+ <tref>active context</tref>, <i>key</i> for
+ <tref>active property</tref>, <i>value</i>
+ for <i>element</i>, and <tref>false</tref> for
+ <i>insideList</i>.</li>
+ <li>If <i>expanded value</i> is <tref>null</tref> and
+ <i>expanded property</i> is not <code>@value</code> then
+ drop <i>key</i> by continuing to the next key.</li>
+ <li>If <i>expanded property</i> is not <code>@list</code> and
+ <i>expanded value</i> is not a <tref>list object</tref> and
+ <i>key</i>'s <tref>container mapping</tref> in
<tref>active context</tref> is <code>@list</code> then convert
- <em>expanded value</em> to a <tref>list object</tref> by first
+ <i>expanded value</i> to a <tref>list object</tref> by first
setting it to an <tref>array</tref> containing only
- <em>expanded value</em> if it is not already an
+ <i>expanded value</i> if it is not already an
<tref>array</tref>, and then by setting it to a
<tref>JSON object</tref> containing the key-value pair
- (<code>@list</code>-<em>expanded value</em>).</li>
- <li>Otherwise, if <em>expanded property</em> is
+ (<code>@list</code>-<i>expanded value</i>).</li>
+ <li>Otherwise, if <i>expanded property</i> is
<code>@index</code>, <code>@id</code>, <code>@type</code>,
<code>@value</code>, or <code>@language</code>, then
- set key <em>expanded property</em>'s value to
- <em>expanded value</em> in <em>result</em>.</li>
+ set key <i>expanded property</i>'s value to
+ <i>expanded value</i> in <i>result</i>.</li>
<li>Otherwise, if key's <tref>term definition</tref> indicates that
it is a <tref>reverse property</tref>
<ol class="algorithm">
- <li>If <em>result</em> has no <code>@reverse</code> member, create
+ <li>If <i>result</i> has no <code>@reverse</code> member, create
one and initialize its value to an empty <tref>JSON object</tref>.</li>
- <li>Reference the value of the <code>@reverse</code> member in <em>result</em>
- using the variable <em>reverse map</em>.
- <li>If <em>expanded value</em> is not an <tref>array</tref>, set
- it to an <tref>array</tref> containing <em>expanded value</em>.</li>
- <li>For each <em>item</em> in <em>expanded value</em>
+ <li>Reference the value of the <code>@reverse</code> member in <i>result</i>
+ using the variable <i>reverse map</i>.
+ <li>If <i>expanded value</i> is not an <tref>array</tref>, set
+ it to an <tref>array</tref> containing <i>expanded value</i>.</li>
+ <li>For each <i>item</i> in <i>expanded value</i>
<ol class="algorithm">
- <li>If <em>item</em> is a <tref>value object</tref> or <tref>list object</tref>, an
+ <li>If <i>item</i> is a <tref>value object</tref> or <tref>list object</tref>, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid--reverse-value">invalid reverse property value</a></code>
has been detected.</li>
- <li>If <em>reverse map</em> has no <em>expanded property</em> member,
+ <li>If <i>reverse map</i> has no <i>expanded property</i> member,
create one and initialize its value to an empty <tref>array</tref>.</li>
- <li>Append <em>item</em> to the value of the <em>expanded property</em>
- member of <em>reverse map</em>.</li>
+ <li>Append <i>item</i> to the value of the <i>expanded property</i>
+ member of <i>reverse map</i>.</li>
</ol>
</li>
</ol>
</li>
- <li>Otherwise, if <em>result</em> does not have the key
- <em>expanded property</em>, set this key's value in <em>result</em>
- to an empty <tref>array</tref>. Append <em>expanded value</em>
- to the <tref>array</tref> value associated with <em>result</em>'s
- <em>expanded property</em> key.</li>
+ <li>Otherwise, if <i>result</i> does not have the key
+ <i>expanded property</i>, set this key's value in <i>result</i>
+ to an empty <tref>array</tref>. Append <i>expanded value</i>
+ to the <tref>array</tref> value associated with <i>result</i>'s
+ <i>expanded property</i> key.</li>
</ol>
</li>
- <li>If <em>result</em> contains the key <code>@value</code>:
+ <li>If <i>result</i> contains the key <code>@value</code>:
<ol class="algorithm">
- <li>The <em>result</em> must not contain any keys other than
+ <li>The <i>result</i> must not contain any keys other than
<code>@value</code>, <code>@language</code>, <code>@type</code>,
and <code>@index</code>. It must not contain both the
<code>@language</code> key and the <code>@type</code> key.
Otherwise, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-value-object">invalid value object</a></code>
error has been detected.</li>
- <li>If the value of <em>result</em>'s <code>@value</code> key is
- <tref>null</tref>, then set <em>result</em> to <tref>null</tref>.</li>
- <li>Otherwise, if <em>result</em> contains the key
- <code>@language</code> and the value of <em>result</em>'s
+ <li>If the value of <i>result</i>'s <code>@value</code> key is
+ <tref>null</tref>, then set <i>result</i> to <tref>null</tref>.</li>
+ <li>Otherwise, if <i>result</i> contains the key
+ <code>@language</code> and the value of <i>result</i>'s
<code>@value</code> key is not a <tref>string</tref>, then remove
- the <code>@language</code> key from <em>result</em>.</li>
+ the <code>@language</code> key from <i>result</i>.</li>
</ol>
</li>
- <li>Otherwise, if <em>result</em> contains the key <code>@type</code>
+ <li>Otherwise, if <i>result</i> contains the key <code>@type</code>
and its associated value is not an <tref>array</tref>, set it to
an <tref>array</tref> containing only the associated value.</li>
- <li>Otherwise, if <em>result</em> contains the key <code>@set</code>
+ <li>Otherwise, if <i>result</i> contains the key <code>@set</code>
or <code>@list</code>:
<ol class="algorithm">
- <li>The <em>result</em> must contain at most one other key and that
+ <li>The <i>result</i> must contain at most one other key and that
key must be <code>@index</code>. Otherwise, an
<code class="error"><a href="#idl-def-JsonLdErrorCode.invalid-set-or-list-object">invalid set or list object</a></code>
error has been detected.</li>
- <li>If <em>result</em> contains the key <code>@set</code>, then
- set <em>result</em> to the key's associated value.</li>
+ <li>If <i>result</i> contains the key <code>@set</code>, then
+ set <i>result</i> to the key's associated value.</li>
</ol>
</li>
- <li>If <em>result</em> contains only the key
- <code>@language</code>, set <em>result</em> to <tref>null</tref>.</li>
- <li>If <em>insideList</em> is <tref>false</tref> and either
+ <li>If <i>result</i> contains only the key
+ <code>@language</code>, set <i>result</i> to <tref>null</tref>.</li>
+ <li>If <i>insideList</i> is <tref>false</tref> and either
<tref>active property</tref> is <tref>null</tref> or
- <em>expanded active property</em> is <code>@graph</code>, then
+ <i>expanded active property</i> is <code>@graph</code>, then
drop free-floating values as follows:
<ol class="algorithm">
- <li>If <em>result</em> contains no keys or contains the key
- <code>@value</code>, setting <em>result</em> to
+ <li>If <i>result</i> contains no keys or contains the key
+ <code>@value</code>, setting <i>result</i> to
<tref>null</tref>.</li><li>
- Otherwise, if <em>result</em>'s keys are only keywords and none
+ Otherwise, if <i>result</i>'s keys are only keywords and none
of the keys are <code>@graph</code> or <code>@type</code> then
- set <em>result</em> to <tref>null</tref>.</li>
+ set <i>result</i> to <tref>null</tref>.</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
<p>If, after the above algorithm is run, the result is a
@@ -1792,42 +1792,42 @@
<section class="informative">
<h3>Purpose</h3>
- <p>A <em>value</em> associated with an <tref>active property</tref> must
+ <p>A <i>value</i> associated with an <tref>active property</tref> must
be <tref title="expansion">expanded</tref> to <tref>expanded form</tref>.</p>
</section>
<section class="informative">
<h3>General Solution</h3>
- <p>Other than the simple case where <em>value</em> is <tref>null</tref>, for
- which we return <tref>null</tref>, we must primarily look at <em>value</em>'s
+ <p>Other than the simple case where <i>value</i> is <tref>null</tref>, for
+ which we return <tref>null</tref>, we must primarily look at <i>value</i>'s
associated <tref>active property</tref> to determine how to expand it.</p>
<p>First we <tref title="expansion">expand</tref> the
<tref>active property</tref> itself, so that we can resolve
<tref>keyword</tref> aliases. Then, for certain
<tref title="keyword">keywords</tref> like <code>@id</code> and
- <code>@type</code>, we simply expand <em>value</em>
+ <code>@type</code>, we simply expand <i>value</i>
using the <a href="#iri-expansion">IRI Expansion algorithm</a> and return
the result.</p>
<p>Next, we check to see if <tref>active property</tref> has a
<tref>type mapping</tref> in the <tref>active context</tref> that would alter
what we return. If it has one that is <code>@vocab</code> or
- <code>@type</code> or if the <em>expanded property</em> is <code>@graph</code>
+ <code>@type</code> or if the <i>expanded property</i> is <code>@graph</code>
then we return a <tref>JSON object</tref> with a single key-pair of
<code>@id</code> and the result of using the
- <a href="#iri-expansion">IRI Expansion algorithm</a> on <em>value</em>.</p>
-
- <p>If we haven't returned yet and the <em>expanded property</em> is a
+ <a href="#iri-expansion">IRI Expansion algorithm</a> on <i>value</i>.</p>
+
+ <p>If we haven't returned yet and the <i>expanded property</i> is a
<tref>keyword</tref>, then there is no special <tref>expansion</tref> to be
- performed on the <em>value</em>, so we return it as is.</p>
+ performed on the <i>value</i>, so we return it as is.</p>
<p>Otherwise, we'll our result will be a <tref>JSON object</tref> containing
- the key <code>@value</code> with the value the <em>value</em>. Additionally,
+ the key <code>@value</code> with the value the <i>value</i>. Additionally,
a <code>@type</code> key-value pair will be included if there is a
<tref>type mapping</tref> associated with the <tref>active property</tref>
- or a <code>@language</code> key-value pair if <em>value</em> is a
+ or a <code>@language</code> key-value pair if <i>value</i> is a
<tref>string</tref> and there is <tref>language mapping</tref>.</p>
</section>
@@ -1835,78 +1835,78 @@
<h3>Algorithm</h3>
<p>The algorithm takes three required inputs: an <tref>active context</tref>,
- an <tref>active property</tref>, and a <em>value</em> to expand.</p>
+ an <tref>active property</tref>, and a <i>value</i> to expand.</p>
<ol class="algorithm">
- <li>If <em>value</em> is <tref>null</tref>, then return <tref>null</tref>.</li>
- <li>Initialize <em>expanded property</em> to the result of using the
+ <li>If <i>value</i> is <tref>null</tref>, then return <tref>null</tref>.</li>
+ <li>Initialize <i>expanded property</i> to the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
<tref>active context</tref>, <tref>active property</tref> for
- <em>value</em>, and <tref>true</tref> for <em>vocabRelative</em>.</li>
- <li>If <em>expanded property</em> is <code>@id</code> then return
+ <i>value</i>, and <tref>true</tref> for <i>vocabRelative</i>.</li>
+ <li>If <i>expanded property</i> is <code>@id</code> then return
the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>value</em>, and <tref>true</tref>
- for <em>documentRelative</em>.</li>
- <li>If <em>expanded property</em> is <code>@type</code> then
+ <tref>active context</tref>, <i>value</i>, and <tref>true</tref>
+ for <i>documentRelative</i>.</li>
+ <li>If <i>expanded property</i> is <code>@type</code> then
return the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>value</em>, <tref>true</tref> for
- <em>vocabRelative</em>, and <tref>true</tref> for
- <em>documentRelative</em>.</li>
+ <tref>active context</tref>, <i>value</i>, <tref>true</tref> for
+ <i>vocabRelative</i>, and <tref>true</tref> for
+ <i>documentRelative</i>.</li>
<li>If the <tref>active context</tref> indicates that <tref>active property</tref>
is a <tref>reverse property</tref>, <tref>active property</tref> has
a <tref>type mapping</tref> in <tref>active context</tref> that is
- <code>@id</code>, or if <em>expanded property</em> is <code>@graph</code>
- and <em>value</em> is a <tref>string</tref>, then return a new
+ <code>@id</code>, or if <i>expanded property</i> is <code>@graph</code>
+ and <i>value</i> is a <tref>string</tref>, then return a new
<tref>JSON object</tref> containing a single key-value pair where the
key is <code>@id</code> and the value is the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>value</em>, and <tref>true</tref> for
- <em>documentRelative</em>.</li>
+ <tref>active context</tref>, <i>value</i>, and <tref>true</tref> for
+ <i>documentRelative</i>.</li>
<li>If <tref>active property</tref> has a <tref>type mapping</tref> in
<tref>active context</tref> that is <code>@vocab</code>, then return
a new <tref>JSON object</tref> containing a single key-value pair
where the key is <code>@id</code> and the value is the result of
using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>value</em>, <tref>true</tref> for
- <em>vocabRelative</em>, and <tref>true</tref> for
- <em>documentRelative</em>.</li>
- <li>If <em>expanded property</em> is a <tref>keyword</tref> return
- <em>value</em> as is.</li>
- <li>Otherwise, initialize <em>result</em> to an empty
+ <tref>active context</tref>, <i>value</i>, <tref>true</tref> for
+ <i>vocabRelative</i>, and <tref>true</tref> for
+ <i>documentRelative</i>.</li>
+ <li>If <i>expanded property</i> is a <tref>keyword</tref> return
+ <i>value</i> as is.</li>
+ <li>Otherwise, initialize <i>result</i> to an empty
<tref>JSON object</tref>.</li>
<li>If <tref>active property</tref> has a <tref>type mapping</tref> in
<tref>active context</tref>:
<ol class="algorithm">
- <li>Initialize <em>type</em> to the value associated with the
+ <li>Initialize <i>type</i> to the value associated with the
<tref>type mapping</tref>.</li>
- <li>If <em>type</em> is a <tref>blank node identifier</tref> (it
+ <li>If <i>type</i> is a <tref>blank node identifier</tref> (it
begins with <code>_:</code>), then set it to the result of the
<a href="#generate-blank-node-identifier">Generate Blank Node Identifier algorithm</a>,
- passing <tref>active context</tref> and <em>type</em> for
- <em>identifier</em>.</li>
- <li>Add the key-value pair, (<code>@type</code>-<em>type</em>), to
- <em>result</em>.</li>
+ passing <tref>active context</tref> and <i>type</i> for
+ <i>identifier</i>.</li>
+ <li>Add the key-value pair, (<code>@type</code>-<i>type</i>), to
+ <i>result</i>.</li>
</ol>
</li>
- <li>Otherwise, if <em>value</em> is a <tref>string</tref>:
+ <li>Otherwise, if <i>value</i> is a <tref>string</tref>:
<ol class="algorithm">
- <li>If <em>value</em> has a <tref>language mapping</tref> in
+ <li>If <i>value</i> has a <tref>language mapping</tref> in
<tref>active context</tref> that is not <tref>null</tref>, then
- add a key-value pair to <em>result</em> where the key is
+ add a key-value pair to <i>result</i> where the key is
<code>@language</code> and the value is the value associated with
the <tref>language mapping</tref>.</li>
- <li>Otherwise, if <em>value</em> has no <tref>language mapping</tref> in
+ <li>Otherwise, if <i>value</i> has no <tref>language mapping</tref> in
<tref>active context</tref> and <tref>active context</tref> has a
<tref>default language</tref>, then add a key-value pair to
- <em>result</em> where the key is <code>@language</code> and the value
+ <i>result</i> where the key is <code>@language</code> and the value
is the <tref>default language</tref>.</li>
</ol>
</li>
- <li>Finally, add the key-value pair, (<code>@value</code>-<em>value</em>), to
- <em>result</em> and return <em>result</em>.</li>
+ <li>Finally, add the key-value pair, (<code>@value</code>-<i>value</i>), to
+ <i>result</i> and return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of Value Expansion -->
@@ -1937,20 +1937,20 @@
<section class="informative">
<h3>General Solution</h3>
- <p>Starting with its root <em>element</em>, we can process the
+ <p>Starting with its root <i>element</i>, we can process the
JSON-LD document recursively, until we have a fully
- <tref title="compaction">compacted</tref> <em>result</em>. When
- <tref title="compaction">compacting</tref> an <em>element</em>, we can treat
+ <tref title="compaction">compacted</tref> <i>result</i>. When
+ <tref title="compaction">compacting</tref> an <i>element</i>, we can treat
each one differently according to its type, in order to break down the
problem:</p>
<ol>
- <li>If the <em>element</em> is a <tref>scalar</tref>, it is
+ <li>If the <i>element</i> is a <tref>scalar</tref>, it is
already in <tref>compacted form</tref>, so we simply return it.</li>
- <li>If the <em>element</em> is an <tref>array</tref>, we compact
+ <li>If the <i>element</i> is an <tref>array</tref>, we compact
each of its items recursively and return them in a new
<tref>array</tref>.</li>
- <li>Otherwise <em>element</em> is a <tref>JSON object</tref>. The value
+ <li>Otherwise <i>element</i> is a <tref>JSON object</tref>. The value
of each key in element is compacted recursively. Some of the keys will be
compacted, using the <a href="#iri-compaction">IRI Compaction algorithm</a>,
to <tref title="term">terms</tref> or <tref title="compact IRI">compact IRIs</tref>
@@ -1967,10 +1967,10 @@
<p>The final output is a <tref>JSON object</tref> with a <code>@context</code>
key, if a <tref>context</tref> was given, where the <tref>JSON object</tref>
- is either <em>result</em> or a wrapper for it where <em>result</em> appears
- as the value of an aliased <code>@graph</code> key because <em>result</em>
+ is either <i>result</i> or a wrapper for it where <i>result</i> appears
+ as the value of an aliased <code>@graph</code> key because <i>result</i>
contained two or more items in an <tref>array</tref>. If no
- <tref>context</tref> was given, the <em>result</em> is only simplified
+ <tref>context</tref> was given, the <i>result</i> is only simplified
from an <tref>array</tref> to a <tref>JSON object</tref> if it has one or
fewer items and array compaction has been requested.</p>
</section>
@@ -1980,134 +1980,134 @@
<p>The algorithm takes four required input variables: an <tref>active context</tref>,
an <tref>inverse context</tref> an <tref>active property</tref>, and an
- <em>element</em> to be compacted. To begin, the <tref>active context</tref>
+ <i>element</i> to be compacted. To begin, the <tref>active context</tref>
is set to the result of performing <a href="#context-processing-algorithm">Context Processing</a>
- on the passed <em>context</em>, the <tref>inverse context</tref> is set to the result
+ on the passed <i>context</i>, the <tref>inverse context</tref> is set to the result
of performing the <a href="#inverse-context-creation">Inverse Context Creation algorithm</a>
on <tref>active context</tref>, the <tref>active property</tref> is set to <tref>null</tref>,
- and <em>element</em> is set to the result of performing the
+ and <i>element</i> is set to the result of performing the
<a href="#expansion-algorithm">Expansion algorithm</a> on the <tref>JSON-LD input</tref>.</p>
<ol class="algorithm">
- <li>If <em>element</em> is a <tref>scalar</tref>, it is already in its most
- compact form, so simply return <em>element</em>.</li>
- <li>If <em>element</em> is an <tref>array</tref>:
+ <li>If <i>element</i> is a <tref>scalar</tref>, it is already in its most
+ compact form, so simply return <i>element</i>.</li>
+ <li>If <i>element</i> is an <tref>array</tref>:
<ol class="algorithm">
- <li>Initialize <em>result</em> to an empty <tref>array</tref>.</li>
- <li>For each <em>item</em> in <em>element</em>:
+ <li>Initialize <i>result</i> to an empty <tref>array</tref>.</li>
+ <li>For each <i>item</i> in <i>element</i>:
<ol class="algorithm">
- <li>Initialize <em>compacted item</em> to the result of using this
+ <li>Initialize <i>compacted item</i> to the result of using this
algorithm recursively, passing <tref>active context</tref>,
<tref>inverse context</tref>, <tref>active property</tref>, and
- em>item</em> for <em>element</em>.</li>
- <li>If <em>compacted item</em> is not <tref>null</tref>, then append
- it to <em>result</em>.</li>
+ em>item</em> for <i>element</i>.</li>
+ <li>If <i>compacted item</i> is not <tref>null</tref>, then append
+ it to <i>result</i>.</li>
</ol>
</li>
- <li>If <em>result</em> contains only one item (it has a length of
+ <li>If <i>result</i> contains only one item (it has a length of
<code>1</code>) and <tref>active property</tref> has no
<tref>container mapping</tref> in <tref>active context</tref>,
- and array compaction has been requested, then set <em>result</em>
+ and array compaction has been requested, then set <i>result</i>
to its only item.</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</li>
- <li>Otherwise <em>element</em> is a <tref>JSON object</tref>.</li>
- <li>If <em>element</em> contains the key <code>@value</code> or
+ <li>Otherwise <i>element</i> is a <tref>JSON object</tref>.</li>
+ <li>If <i>element</i> contains the key <code>@value</code> or
if it contains only one key and that key is <code>@id</code>,
then return the result of using the
<a href="#value-compaction">Value Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <tref>active property</tref>,and <em>element</em> as <em>value</em>.</li>
- <li>Initialize <em>inside reverse</em> to <tref>true</tref> if
+ <tref>active property</tref>,and <i>element</i> as <i>value</i>.</li>
+ <li>Initialize <i>inside reverse</i> to <tref>true</tref> if
<tref>active property</tref> equals <code>@reverse</code>,
otherwise to <tref>false</tref>.</li>
- <li>Initialize <em>result</em> to an empty <tref>JSON object</tref>.</li>
- <li>For each key <em>expanded property</em> and value <em>expanded value</em>
- in <em>element</em>, ordered lexicographically by <em>expanded property</em>:
+ <li>Initialize <i>result</i> to an empty <tref>JSON object</tref>.</li>
+ <li>For each key <i>expanded property</i> and value <i>expanded value</i>
+ in <i>element</i>, ordered lexicographically by <i>expanded property</i>:
<ol class="algorithm">
- <li>If <em>expanded property</em> is <code>@id</code> or
+ <li>If <i>expanded property</i> is <code>@id</code> or
<code>@type</code>:
<ol class="algorithm">
- <li>If <em>expanded value</em> is a <tref>string</tref>,
- then initialize <em>compacted value</em> to the result
+ <li>If <i>expanded value</i> is a <tref>string</tref>,
+ then initialize <i>compacted value</i> to the result
of using the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <em>expanded value</em> for <em>iri</em>,
- and <tref>true</tref> for <em>vocabRelative</em> if
- <em>expanded property</em> is <code>@type</code>,
+ <i>expanded value</i> for <i>iri</i>,
+ and <tref>true</tref> for <i>vocabRelative</i> if
+ <i>expanded property</i> is <code>@type</code>,
<tref>false</tref> otherwise.</li>
- <li>Otherwise, <em>expanded value</em> must be a
+ <li>Otherwise, <i>expanded value</i> must be a
<code>@type</code> <tref>array</tref>:
<ol class="algorithm">
- <li>Initialize <em>compacted value</em> to an empty
+ <li>Initialize <i>compacted value</i> to an empty
<tref>array</tref>.</li>
- <li>For each item <em>expanded type</em> in
- <em>expanded value</em>, append the result of
+ <li>For each item <i>expanded type</i> in
+ <i>expanded value</i>, append the result of
of using the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <em>expanded type</em> for <em>iri</em>, and
- <tref>true</tref> for <em>vocabRelative</em>,
- to <em>compacted value</em>.</li>
- <li>If <em>compacted value</em> contains only one
+ <i>expanded type</i> for <i>iri</i>, and
+ <tref>true</tref> for <i>vocabRelative</i>,
+ to <i>compacted value</i>.</li>
+ <li>If <i>compacted value</i> contains only one
item (it has a length of <code>1</code>), then
- set <em>compacted value</em> to its only item.</li>
+ set <i>compacted value</i> to its only item.</li>
</ol>
</li>
- <li>Initialize <em>alias</em> to the result of using the
+ <li>Initialize <i>alias</i> to the result of using the
<a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>, and
- <em>expanded property</em> for <em>iri</em>.</li>
+ <i>expanded property</i> for <i>iri</i>.</li>
<li>Add the key-value pair,
- (<em>alias</em>-<em>compacted value</em>) to
- <em>result</em> and continue to the next
- <em>expanded property</em>.</li>
+ (<i>alias</i>-<i>compacted value</i>) to
+ <i>result</i> and continue to the next
+ <i>expanded property</i>.</li>
</ol>
</li>
- <li>If <em>expanded property</em> is <code>@reverse</code>:
+ <li>If <i>expanded property</i> is <code>@reverse</code>:
<ol class="algorithm">
- <li>Initialize <em>compacted value</em> to the result of using this
+ <li>Initialize <i>compacted value</i> to the result of using this
algorithm recursively, passing <tref>active context</tref>,
<tref>inverse context</tref>, <code>@reverse</code> for
- <tref>active property</tref>, and <em>expanded value</em>
- for <em>element</em>.</li>
- <li>For each <em>property</em> and <em>value</em> in <em>compacted value</em>:
+ <tref>active property</tref>, and <i>expanded value</i>
+ for <i>element</i>.</li>
+ <li>For each <i>property</i> and <i>value</i> in <i>compacted value</i>:
<ol class="algorithm">
- <li>If the <tref>term definition</tref> for <em>property</em> in the
- <tref>active context</tref> indicates that <em>property</em> is
+ <li>If the <tref>term definition</tref> for <i>property</i> in the
+ <tref>active context</tref> indicates that <i>property</i> is
a <tref>reverse property</tref>
<ol class="algorithm">
- <li>If array compaction has not been requested and <em>value</em>
- is not an <tref>array</tref>, set <em>value</em> to a new
- <tref>array</tref> containing only <em>value</em>.</li>
- <li>If <em>property</em> is not a member of
- <em>result</em>, add one and set its value to <em>value</em>.</li>
- <li>Otherwise, if the value of the <em>property</em> member of
- <em>result</em> is not an <tref>array</tref>, set it to a new
+ <li>If array compaction has not been requested and <i>value</i>
+ is not an <tref>array</tref>, set <i>value</i> to a new
+ <tref>array</tref> containing only <i>value</i>.</li>
+ <li>If <i>property</i> is not a member of
+ <i>result</i>, add one and set its value to <i>value</i>.</li>
+ <li>Otherwise, if the value of the <i>property</i> member of
+ <i>result</i> is not an <tref>array</tref>, set it to a new
<tref>array</tref> containing only the value. Then
- append <em>value</em> to its value if <em>value</em>
+ append <i>value</i> to its value if <i>value</i>
is not an <tref>array</tref>, otherwise append each
of its items.</li>
- <li>Remove the <em>property</em> member from
- <em>compacted value</em>.</li>
+ <li>Remove the <i>property</i> member from
+ <i>compacted value</i>.</li>
</ol>
</li>
</ol>
</li>
- <li>If <em>compacted value</em> has some remaining members, i.e.,
+ <li>If <i>compacted value</i> has some remaining members, i.e.,
it is not an empty <tref>JSON object</tref>:
<ol class="algorithm">
- <li>Initialize <em>alias</em> to the result of using the
+ <li>Initialize <i>alias</i> to the result of using the
<a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>, and
- <code>@reverse</code> for <em>iri</em>.</li>
- <li>Set the value of the <em>alias</em> member of <em>result</em> to
- <em>compacted value</em> and continue with the next
- <em>expanded property</em> from <em>element</em>.</li>
+ <code>@reverse</code> for <i>iri</i>.</li>
+ <li>Set the value of the <i>alias</i> member of <i>result</i> to
+ <i>compacted value</i> and continue with the next
+ <i>expanded property</i> from <i>element</i>.</li>
</ol>
</ol>
</li>
- <li>If <em>expanded property</em> is <code>@index</code>:
+ <li>If <i>expanded property</i> is <code>@index</code>:
<ol class="algorithm">
<li>If <tref>active property</tref> has a
<tref>container mapping</tref> in <tref>active context</tref>
@@ -2115,84 +2115,84 @@
result will be inside of an <code>@index</code>
container, so simply drop the <code>@index</code>
property by continuing to the next
- <em>expanded property</em>.</li>
- <li>Otherwise, initialize <em>alias</em> to the result of using
+ <i>expanded property</i>.</li>
+ <li>Otherwise, initialize <i>alias</i> to the result of using
the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>, and
- <em>expanded property</em> for <em>iri</em>.</li>
+ <i>expanded property</i> for <i>iri</i>.</li>
<li>Add the key-value pair,
- (<em>alias</em>-<em>expanded value</em>) to
- <em>result</em> and continue to the next
- <em>expanded property</em>.</li>
+ (<i>alias</i>-<i>expanded value</i>) to
+ <i>result</i> and continue to the next
+ <i>expanded property</i>.</li>
</ol>
</li>
- <li>If <em>expanded value</em> is an empty <tref>array</tref>:
+ <li>If <i>expanded value</i> is an empty <tref>array</tref>:
<ol class="algorithm">
- <li>Initialize <em>item active property</em> to the result of
+ <li>Initialize <i>item active property</i> to the result of
using the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <em>expanded property</em> for <em>iri</em>,
- <em>expanded value</em> for <em>value</em>,
- <tref>true</tref> for <em>vocabRelative</em>, and
- <em>inside reverse</em>.</li>
- <li>If <em>result</em> does not have the key that equals
- <em>item active property</em>, set this key's value in
- <em>result</em> to an empty <tref>array</tref>. Otherwise, if
+ <i>expanded property</i> for <i>iri</i>,
+ <i>expanded value</i> for <i>value</i>,
+ <tref>true</tref> for <i>vocabRelative</i>, and
+ <i>inside reverse</i>.</li>
+ <li>If <i>result</i> does not have the key that equals
+ <i>item active property</i>, set this key's value in
+ <i>result</i> to an empty <tref>array</tref>. Otherwise, if
the key's value is not an <tref>array</tref>, then set it
to one containing only the value.</li>
</ol>
</li>
<li>
- At this point, <em>expanded value</em> must be an
+ At this point, <i>expanded value</i> must be an
<tref>array</tref> due to the
<a href="#expansion-algorithm">Expansion algorithm</a>.
- For each item <em>expanded item</em> in <em>expanded value</em>:
+ For each item <i>expanded item</i> in <i>expanded value</i>:
<ol class="algorithm">
- <li>Initialize <em>item active property</em> to the result of using
+ <li>Initialize <i>item active property</i> to the result of using
the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <em>expanded property</em> for <em>iri</em>,
- <em>expanded item</em> for <em>value</em>,
- <tref>true</tref> for <em>vocabRelative</em>, and
- <em>inside reverse</em>.</li>
- <li>Initialize <em>container</em> to <tref>null</tref>. If there
+ <i>expanded property</i> for <i>iri</i>,
+ <i>expanded item</i> for <i>value</i>,
+ <tref>true</tref> for <i>vocabRelative</i>, and
+ <i>inside reverse</i>.</li>
+ <li>Initialize <i>container</i> to <tref>null</tref>. If there
is a <tref>container mapping</tref> for
- <em>item active property</em> in <tref>active context</tref>,
- set <em>container</em> to its value.</li>
- <li>Initialize <em>compacted item</em> to the result of using
+ <i>item active property</i> in <tref>active context</tref>,
+ set <i>container</i> to its value.</li>
+ <li>Initialize <i>compacted item</i> to the result of using
this algorithm recursively, passing
<tref>active context</tref>, <tref>inverse context</tref>,
- <em>item active property</em> for <tref>active property</tref>,
- <em>expanded item</em> for <em>element</em> if it does
+ <i>item active property</i> for <tref>active property</tref>,
+ <i>expanded item</i> for <i>element</i> if it does
not contain the key <code>@list</code>, otherwise pass
- the key's associated value for <em>element</em>.</li>
+ the key's associated value for <i>element</i>.</li>
<li>
- If <em>expanded item</em> is a <tref>list object</tref>:
+ If <i>expanded item</i> is a <tref>list object</tref>:
<ol class="algorithm">
- <li>If <em>compacted item</em> is not an <tref>array</tref>,
+ <li>If <i>compacted item</i> is not an <tref>array</tref>,
then set it to an <tref>array</tref> containing only
- <em>compacted item</em>.</li>
- <li>If <em>container</em> is not <code>@list</code>:
+ <i>compacted item</i>.</li>
+ <li>If <i>container</i> is not <code>@list</code>:
<ol class="algorithm">
- <li>Convert <em>compacted item</em> to a
+ <li>Convert <i>compacted item</i> to a
<tref>list object</tref> by setting it to a
<tref>JSON object</tref> containing key-value pair
where the key is the result of the
<a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@list</code> for <em>iri</em>, and <em>compacted item</em>
- for <em>value</em>.</li>
- <li>If <em>expanded item</em> contains the key
+ <code>@list</code> for <i>iri</i>, and <i>compacted item</i>
+ for <i>value</i>.</li>
+ <li>If <i>expanded item</i> contains the key
<code>@index</code>, then add a key-value pair
- to <em>compacted item</em> where the key is the
+ to <i>compacted item</i> where the key is the
result of the <a href="#iri-compaction">IRI Compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@index</code> as <em>iri</em>, and the associated with the
- <code>@index</code> key in <em>expanded item</em> as <em>value</em>.</li>
+ <code>@index</code> as <i>iri</i>, and the associated with the
+ <code>@index</code> key in <i>expanded item</i> as <i>value</i>.</li>
</ol>
</li>
- <li>Otherwise, <em>item active property</em> must not be a key
- in <em>result</em> because there cannot be two
+ <li>Otherwise, <i>item active property</i> must not be a key
+ in <i>result</i> because there cannot be two
<tref title="list object">list objects</tref> associated
with an <tref>active property</tref> that has a
<tref>container mapping</tref>; a
@@ -2201,53 +2201,53 @@
</ol>
</li>
<li>
- If <em>container</em> is <code>@language</code> or
+ If <i>container</i> is <code>@language</code> or
<code>@index</code>:
<ol class="algorithm">
- <li>If <em>item active property</em> is a key in
- <em>result</em>, then initialize <em>map object</em> to
+ <li>If <i>item active property</i> is a key in
+ <i>result</i>, then initialize <i>map object</i> to
its associated value, otherwise initialize it to an empty
<tref>JSON object</tref>.</li>
- <li>If <em>container</em> is <code>@language</code> and
- <em>compacted item</em> contains the key
- <code>@value</code>, then set <em>compacted item</em>
+ <li>If <i>container</i> is <code>@language</code> and
+ <i>compacted item</i> contains the key
+ <code>@value</code>, then set <i>compacted item</i>
to the value associated with its <code>@value</code> key.</li>
- <li>Initialize <em>map key</em> to the value associated with
- with the key that equals <em>container</em> in
- <em>expanded item</em>.</li>
- <li>If <em>map key</em> is not a key in <em>map object</em>,
- then set this key's value in <em>map object</em>
- to <em>compacted item</em>. Otherwise, if the value
+ <li>Initialize <i>map key</i> to the value associated with
+ with the key that equals <i>container</i> in
+ <i>expanded item</i>.</li>
+ <li>If <i>map key</i> is not a key in <i>map object</i>,
+ then set this key's value in <i>map object</i>
+ to <i>compacted item</i>. Otherwise, if the value
is not an <tref>array</tref>, then set it to one
containing only the value and then append
- <em>compacted item</em> to it.</li>
+ <i>compacted item</i> to it.</li>
</ol>
</li>
<li>
Otherwise,
<ol class="algorithm">
- <li>Initialize <em>useArray</em> to <tref>false</tref>. If
+ <li>Initialize <i>useArray</i> to <tref>false</tref>. If
array compaction has not been requested, or
- <em>container</em> is <code>@set</code> or
- <code>@list</code>, or <em>compacted item</em> is
+ <i>container</i> is <code>@set</code> or
+ <code>@list</code>, or <i>compacted item</i> is
an empty <tref>array</tref>, or
- <em>expanded property</em> is <code>@list</code> or
- <code>@graph</code>, then set <em>useArray</em>
+ <i>expanded property</i> is <code>@list</code> or
+ <code>@graph</code>, then set <i>useArray</i>
to <tref>true</tref>.</li>
- <li>If <em>useArray</em> is <tref>true</tref> and
- <em>compacted item</em> is not an <tref>array</tref>,
+ <li>If <i>useArray</i> is <tref>true</tref> and
+ <i>compacted item</i> is not an <tref>array</tref>,
then set it to a new <tref>array</tref>
- containing only <em>compacted item</em>.</li>
- <li>If <em>item active property</em> is not a key in
- <em>result</em> then add the key-value pair,
- (<em>item active property</em>-<em>compacted item</em>),
- to <em>result</em>.</li>
+ containing only <i>compacted item</i>.</li>
+ <li>If <i>item active property</i> is not a key in
+ <i>result</i> then add the key-value pair,
+ (<i>item active property</i>-<i>compacted item</i>),
+ to <i>result</i>.</li>
<li>Otherwise, if the value associated with the key that
- equals <em>item active property</em> in <em>result</em>
+ equals <i>item active property</i> in <i>result</i>
is not an <tref>array</tref>, set it to a new
<tref>array</tref> containing only the value. Then
- append <em>compacted item</em> to the value if
- <em>compacted item</em> is not an <tref>array</tref>,
+ append <i>compacted item</i> to the value if
+ <i>compacted item</i> is not an <tref>array</tref>,
otherwise, concatenate it.</li>
</ol>
</li>
@@ -2255,23 +2255,23 @@
</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
- <p>If, after the algorithm outlined above is run, the result <em>result</em> is
- an <tref>array</tref> with two or more items and a <em>context</em> has
+ <p>If, after the algorithm outlined above is run, the result <i>result</i> is
+ an <tref>array</tref> with two or more items and a <i>context</i> has
been passed, replace it with a new <tref>JSON object</tref> with a single
key-value pair where the key is the result of using the
<a href="#iri-compaction">IRI Compaction algorithm</a>, passing
<tref>active context</tref>, <tref>inverse context</tref>, <code>@graph</code>
- as <em>iri</em>, and <em>result</em> as <em>value</em>. Otherwise, if
- <em>result</em> is an <tref>array</tref> with only one item and
- array compaction has been requested, set <em>result</em> to that item.
- Otherwise, if <em>result</em> is an <tref>array</tref> with zero items,
+ as <i>iri</i>, and <i>result</i> as <i>value</i>. Otherwise, if
+ <i>result</i> is an <tref>array</tref> with only one item and
+ array compaction has been requested, set <i>result</i> to that item.
+ Otherwise, if <i>result</i> is an <tref>array</tref> with zero items,
replace it with an empty <tref>JSON object</tref>. Finally, if a
- <em>context</em> has been passed, add an <code>@context</code> property to
- <em>result</em> and set its value to the initially passed
- <em>context</em>.</p>
+ <i>context</i> has been passed, add an <code>@context</code> property to
+ <i>result</i> and set its value to the initially passed
+ <i>context</i>.</p>
</section>
</section> <!-- end of Compaction -->
@@ -2340,10 +2340,10 @@
the <tref>inverse context</tref> is being created for.</p>
<ol class="algorithm">
- <li>Initialize <em>result</em> to an empty <tref>JSON object</tref>.</li>
- <li>Initialize <em>defaultLanguage</em> to <code>@none</code>. If the
+ <li>Initialize <i>result</i> to an empty <tref>JSON object</tref>.</li>
+ <li>Initialize <i>defaultLanguage</i> to <code>@none</code>. If the
<tref>active context</tref> has a <tref>default language</tref>,
- set <em>defaultLanguage</em> to it.</li>
+ set <i>defaultLanguage</i> to it.</li>
<li>For each key <tref>term</tref> and value <tref>term definition</tref> in
the <tref>active context</tref>, ordered by shortest <tref>term</tref>
first (breaking ties by choosing the lexicographically least
@@ -2352,32 +2352,32 @@
<li>If the <tref>term definition</tref> is <tref>null</tref>,
<tref>term</tref> cannot be selected during <tref>compaction</tref>,
so continue to the next <tref>term</tref>.</li>
- <li>Initialize <em>container</em> to <code>@none</code>. If there
+ <li>Initialize <i>container</i> to <code>@none</code>. If there
is a <tref>container mapping</tref> in
- <tref>term definition</tref>, set <em>container</em> to
+ <tref>term definition</tref>, set <i>container</i> to
its associated value.</li>
- <li>Initialize <em>iri</em> to the value of the <tref>IRI mapping</tref>
+ <li>Initialize <i>iri</i> to the value of the <tref>IRI mapping</tref>
for the <tref>term definition</tref>.</li>
- <li>If <em>iri</em> is not a key in <em>result</em>, add
- a key-value pair where the key is <em>iri</em> and the value
- is an empty <tref>JSON object</tref> to <em>result</em>.</li>
- <li>Reference the value associated with the <em>iri</em> member in
- <em>result</em> using the variable <em>container map</em>.</li>
- <li>If <em>container</em> has no <em>container map</em> member,
+ <li>If <i>iri</i> is not a key in <i>result</i>, add
+ a key-value pair where the key is <i>iri</i> and the value
+ is an empty <tref>JSON object</tref> to <i>result</i>.</li>
+ <li>Reference the value associated with the <i>iri</i> member in
+ <i>result</i> using the variable <i>container map</i>.</li>
+ <li>If <i>container</i> has no <i>container map</i> member,
create one and set its value to a new
<tref>JSON object</tref> with two members. The first member is
<code>@language</code> and its value is a new empty
<tref>JSON object</tref>, the second member is <code>@type</code>
and its value is a new empty <tref>JSON object</tref>.</li>
- <li>Reference the value associated with the <em>container</em> member
- in <em>container map</em> using the variable <em>typeOrLanguage map</em>.</li>
+ <li>Reference the value associated with the <i>container</i> member
+ in <i>container map</i> using the variable <i>typeOrLanguage map</i>.</li>
<li>If the <tref>term definition</tref> indicates that the <tref>term</tref>
represents a <tref>reverse property</tref>:
<ol class="algorithm">
<li>Reference the value associated with the <code>@type</code>
- member in <em>typeOrLanguage map</em> using the variable
- <em>type map</em>.</li>
- <li>If <em>type map</em> does not have a <code>@reverse</code>
+ member in <i>typeOrLanguage map</i> using the variable
+ <i>type map</i>.</li>
+ <li>If <i>type map</i> does not have a <code>@reverse</code>
member, create one and set its value to the <tref>term</tref>
being processed.</li>
</ol>
@@ -2386,9 +2386,9 @@
<tref>type mapping</tref>:
<ol class="algorithm">
<li>Reference the value associated with the <code>@type</code>
- member in <em>typeOrLanguage map</em> using the variable
- <em>type map</em>.</li>
- <li>If <em>type map</em> does not have a member corresponding
+ member in <i>typeOrLanguage map</i> using the variable
+ <i>type map</i>.</li>
+ <li>If <i>type map</i> does not have a member corresponding
to the <tref>type mapping</tref> in <tref>term definition</tref>,
create one and set its value to the <tref>term</tref>
being processed.</li>
@@ -2398,12 +2398,12 @@
<tref>language mapping</tref> (might be <tref>null</tref>):
<ol class="algorithm">
<li>Reference the value associated with the <code>@language</code>
- member in <em>typeOrLanguage map</em> using the variable
- <em>language map</em>.</li>
+ member in <i>typeOrLanguage map</i> using the variable
+ <i>language map</i>.</li>
<li>If the <tref>language mapping</tref> equals <tref>null</tref>,
- set <em>language</em> to <code>@null</code>; otherwise set it
+ set <i>language</i> to <code>@null</code>; otherwise set it
to the language code in <tref>language mapping</tref>.</li>
- <li>If <em>language map</em> does not have a <em>language</em> member,
+ <li>If <i>language map</i> does not have a <i>language</i> member,
create one and set its value to the <tref>term</tref>
being processed.</li>
</ol>
@@ -2411,25 +2411,25 @@
<li>Otherwise:
<ol class="algorithm">
<li>Reference the value associated with the <code>@language</code>
- member in <em>typeOrLanguage map</em> using the variable
- <em>language map</em>.</li>
- <li>If <em>language map</em> does not have a <em>defaultLanguage</em>
+ member in <i>typeOrLanguage map</i> using the variable
+ <i>language map</i>.</li>
+ <li>If <i>language map</i> does not have a <i>defaultLanguage</i>
member, create one and set its value to the <tref>term</tref>
being processed.</li>
- <li>If <em>language map</em> does not have a <code>@none</code>
+ <li>If <i>language map</i> does not have a <code>@none</code>
member, create one and set its value to the <tref>term</tref>
being processed.</li>
<li>Reference the value associated with the <code>@type</code>
- member in <em>typeOrLanguage map</em> using the variable
- <em>type map</em>.</li>
- <li>If <em>type map</em> does not have a <code>@none</code>
+ member in <i>typeOrLanguage map</i> using the variable
+ <i>type map</i>.</li>
+ <li>If <i>type map</i> does not have a <code>@none</code>
member, create one and set its value to the <tref>term</tref>
being processed.</li>
</ol>
</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of Inverse Context Creation -->
@@ -2489,139 +2489,139 @@
<p>This algorithm takes three required inputs and three optional inputs.
The required inputs an <tref>active context</tref>, an <tref>inverse context</tref>,
- and the <em>iri</em> to be compacted. The optional inputs are a <em>value</em> associated
- with the <em>iri</em>, a <em>vocabRelative</em> flag which specifies whether the
- passed <em>iri</em> should be compacted using the
+ and the <i>iri</i> to be compacted. The optional inputs are a <i>value</i> associated
+ with the <i>iri</i>, a <i>vocabRelative</i> flag which specifies whether the
+ passed <i>iri</i> should be compacted using the
<tref title="active context">active context's</tref>
- <tref>vocabulary mapping</tref>, and a <em>reverse</em> flag which specifies whether
- a <tref>reverse property</tref> is being compacted. If not passed, <em>value</em> is set to
- <tref>null</tref> and <em>vocabRelative</em> and <em>reverse</em> are both set to
+ <tref>vocabulary mapping</tref>, and a <i>reverse</i> flag which specifies whether
+ a <tref>reverse property</tref> is being compacted. If not passed, <i>value</i> is set to
+ <tref>null</tref> and <i>vocabRelative</i> and <i>reverse</i> are both set to
<code>false</code>.</p>
<ol class="algorithm">
- <li>If <em>iri</em> is <tref>null</tref>, return <tref>null</tref>.</li>
- <li>If <em>iri</em> is a <tref>keyword</tref> and does not have a
- <tref>keyword</tref> alias, return <em>iri</em>, otherwise return
+ <li>If <i>iri</i> is <tref>null</tref>, return <tref>null</tref>.</li>
+ <li>If <i>iri</i> is a <tref>keyword</tref> and does not have a
+ <tref>keyword</tref> alias, return <i>iri</i>, otherwise return
its first associated <tref>keyword</tref> alias from
<tref>active context</tref>.</li>
- <li>If <em>vocabRelative</em> is <tref>true</tref> and <em>iri</em> is a
+ <li>If <i>vocabRelative</i> is <tref>true</tref> and <i>iri</i> is a
key in <tref>inverse context</tref>:
<ol class="algorithm">
- <li>Initialize <em>defaultLanguage</em> to
+ <li>Initialize <i>defaultLanguage</i> to
<tref title="active context">active context's</tref>
<tref>default language</tref>, if it has one, otherwise to
<code>@none</code>.</li>
- <li>Initialize <em>containers</em> to an empty <tref>array</tref>. This
+ <li>Initialize <i>containers</i> to an empty <tref>array</tref>. This
<tref>array</tref> will be used to keep track of an ordered list of
preferred <tref title="container mapping">container mappings</tref>
for a <tref>term</tref>, based on what is compatible with
- <em>value</em>.</li>
- <li>If <em>value</em> is a <tref>JSON object</tref> that contains the
+ <i>value</i>.</li>
+ <li>If <i>value</i> is a <tref>JSON object</tref> that contains the
key <code>@index</code>, then append the value <code>@index</code>
- to <em>containers</em>.</li>
- <li>Initialize <em>typeOrLanguage</em> to <code>@language</code>,
- and <em>typeOrLanguageValue</em> to <code>@null</code>. These two
+ to <i>containers</i>.</li>
+ <li>Initialize <i>typeOrLanguage</i> to <code>@language</code>,
+ and <i>typeOrLanguageValue</i> to <code>@null</code>. These two
variables will keep track of the preferred
<tref>type mapping</tref> or <tref>language mapping</tref> for
- a <tref>term</tref>, based on what is compatible with <em>value</em>.</li>
- <li>If <em>reverse</em> is <tref>true</tref>, set <em>typeOrLanguage</em>
- to <code>@type</code>, <em>typeOrLanguageValue</em> to
- <code>@reverse</code>, and append <code>@set</code> to <em>containers</em>.</li>
- <li>Otherwise, if <em>value</em> is a <tref>list object</tref>, then set
- <em>typeOrLanguage</em> and <em>typeOrLanguageValue</em>
+ a <tref>term</tref>, based on what is compatible with <i>value</i>.</li>
+ <li>If <i>reverse</i> is <tref>true</tref>, set <i>typeOrLanguage</i>
+ to <code>@type</code>, <i>typeOrLanguageValue</i> to
+ <code>@reverse</code>, and append <code>@set</code> to <i>containers</i>.</li>
+ <li>Otherwise, if <i>value</i> is a <tref>list object</tref>, then set
+ <i>typeOrLanguage</i> and <i>typeOrLanguageValue</i>
to the most specific values that work for all items in
the list as follows:
<ol class="algorithm">
- <li>If <code>@index</code> is a not key in <em>value</em>, then
- append <code>@list</code> to <em>containers</em>.</li>
- <li>Initialize <em>list</em> to the <tref>array</tref> associated
- with the key <code>@list</code> in <em>value</em>.</li>
- <li>Initialize <em>commonLanguage</em> to <tref>null</tref>. If
- <em>list</em> is empty, set <em>commonLanguage</em> to
- <em>defaultLanguage</em>.</li>
- <li>For each <em>item</em> in <em>list</em>:
+ <li>If <code>@index</code> is a not key in <i>value</i>, then
+ append <code>@list</code> to <i>containers</i>.</li>
+ <li>Initialize <i>list</i> to the <tref>array</tref> associated
+ with the key <code>@list</code> in <i>value</i>.</li>
+ <li>Initialize <i>commonLanguage</i> to <tref>null</tref>. If
+ <i>list</i> is empty, set <i>commonLanguage</i> to
+ <i>defaultLanguage</i>.</li>
+ <li>For each <i>item</i> in <i>list</i>:
<ol class="algorithm">
- <li>Initialize <em>itemLanguage</em> to <code>@none</code> and
- <em>itemType</em> to <code>@none</code>.</li>
- <li>If <em>item</em> contains the key <code>@value</code>:
+ <li>Initialize <i>itemLanguage</i> to <code>@none</code> and
+ <i>itemType</i> to <code>@none</code>.</li>
+ <li>If <i>item</i> contains the key <code>@value</code>:
<ol class="algorithm">
- <li>If <em>item</em> contains the key <code>@language</code>,
- then set <em>itemLanguage</em> to its associated
+ <li>If <i>item</i> contains the key <code>@language</code>,
+ then set <i>itemLanguage</i> to its associated
value.</li>
- <li>Otherwise, if <em>item</em> contains the key
- <code>@type</code>, set <em>itemType</em> to its
+ <li>Otherwise, if <i>item</i> contains the key
+ <code>@type</code>, set <i>itemType</i> to its
associated value.</li>
- <li>Otherwise, set <em>itemLanguage</em> to
+ <li>Otherwise, set <i>itemLanguage</i> to
<code>@null</code>.</li>
</ol>
</li>
- <li>Otherwise, set <em>itemType</em> to <code>@id</code>.</li>
- <li>If <em>commonLanguage</em> is <tref>null</tref>, set it
- to <em>itemLanguage</em>.</li>
- <li>Otherwise, if <em>itemLanguage</em> does not equal
- <em>commonLanguage</em> and <em>item</em> contains the
- key <code>@value</code>, then set <em>commonLanguage</em>
+ <li>Otherwise, set <i>itemType</i> to <code>@id</code>.</li>
+ <li>If <i>commonLanguage</i> is <tref>null</tref>, set it
+ to <i>itemLanguage</i>.</li>
+ <li>Otherwise, if <i>itemLanguage</i> does not equal
+ <i>commonLanguage</i> and <i>item</i> contains the
+ key <code>@value</code>, then set <i>commonLanguage</i>
to <code>@none</code> because list items have conflicting
languages.</li>
- <li>If <em>commonType</em> is <tref>null</tref>, set it
- to <em>itemType</em>.</li>
- <li>Otherwise, if <em>itemType</em> does not equal
- <em>commonType</em>, then set <em>commonType</em>
+ <li>If <i>commonType</i> is <tref>null</tref>, set it
+ to <i>itemType</i>.</li>
+ <li>Otherwise, if <i>itemType</i> does not equal
+ <i>commonType</i>, then set <i>commonType</i>
to <code>@none</code> because list items have conflicting
types.</li>
- <li>If <em>commonLanguage</em> is <code>@none</code> and
- <em>commonType</em> is <code>@none</code>, then
+ <li>If <i>commonLanguage</i> is <code>@none</code> and
+ <i>commonType</i> is <code>@none</code>, then
stop processing items in the list because it has been
detected that there is no common language or type amongst
the items.</li>
</ol>
</li>
- <li>If <em>commonLanguage</em> is <tref>null</tref>, set it to
- <code>@none</code>.</li>
- <li>If <em>commonType</em> is <tref>null</tref>, set it to
+ <li>If <i>commonLanguage</i> is <tref>null</tref>, set it to
<code>@none</code>.</li>
- <li>If <em>commonType</em> is not <code>@none</code> then set
- <em>typeOrLanguage</em> to <code>@type</code> and
- <em>typeOrLanguageValue</em> to <em>commonType</em>.</li>
- <li>Otherwise, set <em>typeOrLanguageValue</em> to
- <em>commonLanguage</em>.</li>
+ <li>If <i>commonType</i> is <tref>null</tref>, set it to
+ <code>@none</code>.</li>
+ <li>If <i>commonType</i> is not <code>@none</code> then set
+ <i>typeOrLanguage</i> to <code>@type</code> and
+ <i>typeOrLanguageValue</i> to <i>commonType</i>.</li>
+ <li>Otherwise, set <i>typeOrLanguageValue</i> to
+ <i>commonLanguage</i>.</li>
</ol>
</li>
<li>Otherwise:
<ol class="algorithm">
- <li>If <em>value</em> contains the key <code>@value</code>:
+ <li>If <i>value</i> contains the key <code>@value</code>:
<ol class="algorithm">
- <li>If <em>value</em> contains the key <code>@language</code>
+ <li>If <i>value</i> contains the key <code>@language</code>
and does not contain the key <code>@index</code>,
- then set <em>typeOrLanguageValue</em> to its associated
+ then set <i>typeOrLanguageValue</i> to its associated
value and append <code>@language</code> to
- <em>containers</em>.</li>
- <li>Otherwise, if <em>value</em> contains the key
- <code>@type</code>, then set <em>typeOrLanguageValue</em> to
- its associated value and set <em>typeOrLanguage</em> to
+ <i>containers</i>.</li>
+ <li>Otherwise, if <i>value</i> contains the key
+ <code>@type</code>, then set <i>typeOrLanguageValue</i> to
+ its associated value and set <i>typeOrLanguage</i> to
<code>@type</code>.</li>
</ol>
</li>
- <li>Otherwise, set <em>typeOrLanguage</em> to <code>@type</code>
- and set <em>typeOrLanguageValue</em> to <code>@id</code>.</li>
- <li>Append <code>@set</code> to <em>containers</em>.</li>
+ <li>Otherwise, set <i>typeOrLanguage</i> to <code>@type</code>
+ and set <i>typeOrLanguageValue</i> to <code>@id</code>.</li>
+ <li>Append <code>@set</code> to <i>containers</i>.</li>
</ol>
</li>
- <li>Append <code>@none</code> to <em>containers</em>. This represents
+ <li>Append <code>@none</code> to <i>containers</i>. This represents
the non-existence of a <tref>container mapping</tref>, and it will
be the last <tref>container mapping</tref> value to be checked as it
is the most generic.</li>
- <li>Initialize <em>term</em> to the result of the
+ <li>Initialize <i>term</i> to the result of the
<a href="#term-selection">Term Selection algorithm</a>, passing
- <tref>active context</tref>, <tref>inverse context</tref>, <em>iri</em>,
- <em>value</em>, <em>containers</em>, <em>typeOrLanguage</em>, and
- <em>typeOrLanguageValue</em>.</li>
- <li>If <em>term</em> is not <tref>null</tref>, return <em>term</em>.</li>
+ <tref>active context</tref>, <tref>inverse context</tref>, <i>iri</i>,
+ <i>value</i>, <i>containers</i>, <i>typeOrLanguage</i>, and
+ <i>typeOrLanguageValue</i>.</li>
+ <li>If <i>term</i> is not <tref>null</tref>, return <i>term</i>.</li>
</ol>
</li>
- <li>At this point, there is no simple <tref>term</tref> that <em>iri</em>
+ <li>At this point, there is no simple <tref>term</tref> that <i>iri</i>
can be compacted to. Instead, try to create a <tref>compact IRI</tref>,
- starting by initializing <em>compact IRI</em> to <tref>null</tref>. This
+ starting by initializing <i>compact IRI</i> to <tref>null</tref>. This
variable will be used to store the created <tref>compact IRI</tref>, if
any.</li>
<li>For each key <tref>term</tref> and value <tref>term definition</tref> in
@@ -2632,43 +2632,43 @@
<tref title="term">terms</tref> with colons can't be
used as <tref title="prefix">prefixes</tref>.</li>
<li>If the <tref>term definition</tref> is <tref>null</tref>,
- its <tref>IRI mapping</tref> equals <em>iri</em>, or its
+ its <tref>IRI mapping</tref> equals <i>iri</i>, or its
<tref>IRI mapping</tref> is not a substring at the beginning of
- <em>iri</em>, the <tref>term</tref> cannot be used as a <tref>prefix</tref>
- because it is not a partial match with <em>iri</em>.
+ <i>iri</i>, the <tref>term</tref> cannot be used as a <tref>prefix</tref>
+ because it is not a partial match with <i>iri</i>.
Continue with the next <tref>term</tref>.</li>
- <li>Initialize <em>candidate</em> by concatenating <tref>term</tref>,
- a colon (<code>:</code>), and the substring of <em>iri</em>
+ <li>Initialize <i>candidate</i> by concatenating <tref>term</tref>,
+ a colon (<code>:</code>), and the substring of <i>iri</i>
that follows after the value of the
<tref title="term definition">term definition's</tref>
<tref>IRI mapping</tref>.</li>
- <li>If either <em>compact IRI</em> is <tref>null</tref> or <em>candidate</em> is
+ <li>If either <i>compact IRI</i> is <tref>null</tref> or <i>candidate</i> is
shorter or the same length but lexicographically less than
- <em>compact IRI</em> and <em>candidate</em> does not have a
+ <i>compact IRI</i> and <i>candidate</i> does not have a
<tref>term definition</tref> in <tref>active context</tref> or if the
<tref>term definition</tref> has an <tref>IRI mapping</tref>
- that equals <em>iri</em> and <em>value</em> is <tref>null</tref>,
- set <em>compact IRI</em> to <em>candidate</em>.</li>
+ that equals <i>iri</i> and <i>value</i> is <tref>null</tref>,
+ set <i>compact IRI</i> to <i>candidate</i>.</li>
</ol>
</li>
- <li>If <em>compact IRI</em> is not <tref>null</tref>, return <em>compact IRI</em>.</li>
- <li>At this point, there is no <tref>compact IRI</tref> that <em>iri</em>
- can be compacted to, so if <em>vocabRelative</em> is
+ <li>If <i>compact IRI</i> is not <tref>null</tref>, return <i>compact IRI</i>.</li>
+ <li>At this point, there is no <tref>compact IRI</tref> that <i>iri</i>
+ can be compacted to, so if <i>vocabRelative</i> is
<tref>true</tref> and <tref>active context</tref> has a
<tref>vocabulary mapping</tref>:
<ol class="algorithm">
- <li>If <em>iri</em> begins with the
+ <li>If <i>iri</i> begins with the
<tref title="vocabulary mapping">vocabulary mapping's</tref> value
- but is longer, then initialize <em>suffix</em> to the substring
- of <em>iri</em> that does not match. If <em>suffix</em> does not
+ but is longer, then initialize <i>suffix</i> to the substring
+ of <i>iri</i> that does not match. If <i>suffix</i> does not
have a <tref>term definition</tref> in <tref>active context</tref>,
- then return <em>suffix</em>.</li>
+ then return <i>suffix</i>.</li>
</ol>
</li>
- <li>If <em>vocabRelative</em> is <tref>false</tref> then
- transform <em>iri</em> to a <tref>relative IRI</tref> using
+ <li>If <i>vocabRelative</i> is <tref>false</tref> then
+ transform <i>iri</i> to a <tref>relative IRI</tref> using
the document's base <tref>IRI</tref>.</li>
- <li>Finally, return <em>iri</em> as is.</li>
+ <li>Finally, return <i>iri</i> as is.</li>
</ol>
</section>
</section> <!-- end of IRI Compaction -->
@@ -2688,7 +2688,7 @@
<section class="informative">
<h3>Purpose</h3>
- <p>An <tref>IRI</tref> with an associated <em>value</em> should be compacted
+ <p>An <tref>IRI</tref> with an associated <i>value</i> should be compacted
to the most appropriate <tref>term</tref> in the <tref>active context</tref>.</p>
</section>
@@ -2723,76 +2723,76 @@
<p>This algorithm has seven required inputs. They are:
an <tref>active context</tref>, an <tref>inverse context</tref>, an
- <tref>IRI</tref> <em>iri</em>, a <em>value</em> associated with the
- <tref>IRI</tref>, an <tref>array</tref> <em>containers</em> that
+ <tref>IRI</tref> <i>iri</i>, a <i>value</i> associated with the
+ <tref>IRI</tref>, an <tref>array</tref> <i>containers</i> that
represents ordered list of preferred
<tref title="container mapping">container mappings</tref>, a
- <tref>string</tref> <em>typeOrLanguage</em> that indicates whether
+ <tref>string</tref> <i>typeOrLanguage</i> that indicates whether
to look for a <tref>term</tref> with a matching <tref>type mapping</tref>
or <tref>language mapping</tref>, and a <tref>string</tref>
- <em>typeOrLanguageValue</em> with the associated value for the
+ <i>typeOrLanguageValue</i> with the associated value for the
<tref>type mapping</tref> or <tref>language mapping</tref> to look for.</p>
<ol class="algorithm">
- <li>Initialize <em>container map</em> to the value associated with
- <em>iri</em> in the <tref>inverse context</tref>.</li>
- <li>If <em>typeOrLanguageValue</em> is <tref>null</tref>, set it to
+ <li>Initialize <i>container map</i> to the value associated with
+ <i>iri</i> in the <tref>inverse context</tref>.</li>
+ <li>If <i>typeOrLanguageValue</i> is <tref>null</tref>, set it to
<code>@null</code>. This is the key under which <tref>null</tref> values
- are stored in the <tref>inverse context</tref> <em>entry</em>.</li>
- <li>Initialize <em>preferred values</em> to an empty <tref>array</tref>.
+ are stored in the <tref>inverse context</tref> <i>entry</i>.</li>
+ <li>Initialize <i>preferred values</i> to an empty <tref>array</tref>.
This <tref>array</tref> will indicate, in order, the preferred values for
a <tref title="term">term's</tref> <tref>type mapping</tref> or
<tref>language mapping</tref>.</li>
<!-- FIXME: This is better done in IRI compaction, this way we don't need to pass around the active context etc. -->
- <li>If <em>typeOrLanguageValue</em> is <code>@id</code> or <code>@reverse</code>
- and <em>value</em> is a <tref>JSON object</tref> containing the key
+ <li>If <i>typeOrLanguageValue</i> is <code>@id</code> or <code>@reverse</code>
+ and <i>value</i> is a <tref>JSON object</tref> containing the key
<code>@id</code>:
<ol class="algorithm">
- <li>If <em>typeOrLanguageValue</em> is <code>@reverse</code>, append
- <code>@reverse</code> to <em>preferred values</em>.</li>
+ <li>If <i>typeOrLanguageValue</i> is <code>@reverse</code>, append
+ <code>@reverse</code> to <i>preferred values</i>.</li>
<li>If the result of using the
<a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- the value associated with the <code>@id</code> key in <em>value</em> for
- <em>iri</em>, <tref>true</tref> for <em>vocabRelative</em>, and
- <tref>true</tref> for <em>documentRelative</em> has a
+ the value associated with the <code>@id</code> key in <i>value</i> for
+ <i>iri</i>, <tref>true</tref> for <i>vocabRelative</i>, and
+ <tref>true</tref> for <i>documentRelative</i> has a
<tref>term definition</tref> in the <tref>active context</tref>
with an <tref>IRI mapping</tref> that equals the value associated
- with the <code>@id</code> key in <em>value</em>,
+ with the <code>@id</code> key in <i>value</i>,
then append <code>@vocab</code>, <code>@id</code>, and
- <code>@none</code>, in that order, to <em>preferred values</em>.</li>
+ <code>@none</code>, in that order, to <i>preferred values</i>.</li>
<li>Otherwise, append <code>@id</code>, <code>@vocab</code>, and
- <code>@none</code>, in that order, to <em>preferred values</em>.</li>
+ <code>@none</code>, in that order, to <i>preferred values</i>.</li>
</ol>
</li>
- <li>Otherwise, append <em>typeOrLanguageValue</em> and <code>@none</code>, in
- that order, to <em>preferred values</em>.</li>
- <li>Initialize <em>selected term</em> to <tref>null</tref>.</li>
- <li>For each item <em>container</em> in <em>containers</em> while
- <em>selected term</em> is <tref>null</tref>:
+ <li>Otherwise, append <i>typeOrLanguageValue</i> and <code>@none</code>, in
+ that order, to <i>preferred values</i>.</li>
+ <li>Initialize <i>selected term</i> to <tref>null</tref>.</li>
+ <li>For each item <i>container</i> in <i>containers</i> while
+ <i>selected term</i> is <tref>null</tref>:
<ol class="algorithm">
- <li>If <em>container</em> is not a key in <em>container map</em>, then
+ <li>If <i>container</i> is not a key in <i>container map</i>, then
there is no <tref>term</tref> with a matching
<tref>container mapping</tref> for it, so continue to the next
- <em>container</em>.</li>
- <li>Initialize <em>typeOrLanguage map</em> to the value associated
- with <em>container</em> in <em>container map</em>.</li>
- <li>Initialize <em>typeOrLanguageValue map</em> to the value associated
- with <em>typeOrLanguage</em> in <em>typeOrLanguage map</em>.</li>
- <li>For each <em>item</em> in <em>preferred values</em> while
- <em>selected term</em> is <tref>null</tref>:
+ <i>container</i>.</li>
+ <li>Initialize <i>typeOrLanguage map</i> to the value associated
+ with <i>container</i> in <i>container map</i>.</li>
+ <li>Initialize <i>typeOrLanguageValue map</i> to the value associated
+ with <i>typeOrLanguage</i> in <i>typeOrLanguage map</i>.</li>
+ <li>For each <i>item</i> in <i>preferred values</i> while
+ <i>selected term</i> is <tref>null</tref>:
<ol class="algorithm">
- <li>If <em>item</em> is not a key in <em>typeOrLanguageValue map</em>,
+ <li>If <i>item</i> is not a key in <i>typeOrLanguageValue map</i>,
then there is no <tref>term</tref> with a matching
<tref>type mapping</tref> or <tref>language mapping</tref>,
- so continue to the next <em>item</em>.</li>
- <li>Set <em>selected term</em> to the value associated with
- <em>item</em> in <em>typeOrLanguageValue map</em>.</li>
+ so continue to the next <i>item</i>.</li>
+ <li>Set <i>selected term</i> to the value associated with
+ <i>item</i> in <i>typeOrLanguageValue map</i>.</li>
</ol>
</li>
</ol>
</li>
- <li>Return <em>selected term</em>.</li>
+ <li>Return <i>selected term</i>.</li>
</ol>
</section>
</section> <!-- end of Term Selection -->
@@ -2810,23 +2810,23 @@
<section class="informative">
<h3>Purpose</h3>
- <p>A <em>value</em> associated with an <tref>active property</tref> must
+ <p>A <i>value</i> associated with an <tref>active property</tref> must
be <tref title="compaction">compacted</tref> to <tref>compacted form</tref>.</p>
</section>
<section class="informative">
<h3>General Solution</h3>
- <p>The <em>value</em> to compact either contains the key <code>@value</code>
+ <p>The <i>value</i> to compact either contains the key <code>@value</code>
or the key <code>@id</code>.</p>
<p>We start with the former case, first trying to compact the
- <em>value</em> into just the value associated with its
- <code>@value</code> key. This can be done if the <em>value</em> is not
+ <i>value</i> into just the value associated with its
+ <code>@value</code> key. This can be done if the <i>value</i> is not
going to be contained by an <code>@index</code> container and if the
<tref>active property</tref> has a matching <tref>type mapping</tref> or
<tref>language mapping</tref>. It can also be done if <code>@value</code>
- is the only key in <em>value</em> and either its associated value is
+ is the only key in <i>value</i> and either its associated value is
not a <tref>string</tref>, there's no <tref>default language</tref>, or
there's an explicit <tref>null</tref> <tref>language mapping</tref> for
the <tref>active property</tref>.</p>
@@ -2835,7 +2835,7 @@
<tref title="keyword">keywords</tref> with aliases and compact any
<tref title="IRI">IRIs</tref>.</p>
- <p>For the latter case, where the key <code>@id</code> appears in <em>value</em>,
+ <p>For the latter case, where the key <code>@id</code> appears in <i>value</i>,
we compact the associated value using the
<a href="#iri-compaction">IRI Compaction algorithm</a>, and
use its value if the <tref>type mapping</tref> associated with the
@@ -2849,89 +2849,89 @@
<h3>Algorithm</h3>
<p>This algorithm has four required inputs: an <tref>active context</tref>, an
- <tref>inverse context</tref>, an <tref>active property</tref>, and a <em>value</em>
+ <tref>inverse context</tref>, an <tref>active property</tref>, and a <i>value</i>
to be compacted.</p>
<ol class="algorithm">
- <li>If <em>value</em> contains the key <code>@value</code>:
+ <li>If <i>value</i> contains the key <code>@value</code>:
<ol class="algorithm">
- <li>Initialize <em>preserveIndex</em> to <tref>false</tref>. If
- <code>@index</code> is a key in <em>value</em> and
+ <li>Initialize <i>preserveIndex</i> to <tref>false</tref>. If
+ <code>@index</code> is a key in <i>value</i> and
<tref>active property</tref> does not have a
<tref>container mapping</tref> in <tref>active context</tref> that
- is <code>@index</code>, set <em>preserveIndex</em> to
+ is <code>@index</code>, set <i>preserveIndex</i> to
<tref>true</tref>.</li>
- <li>If <em>preserveIndex</em> is <tref>false</tref> and either
- <em>value</em> has a <code>@type</code> key with a value that
+ <li>If <i>preserveIndex</i> is <tref>false</tref> and either
+ <i>value</i> has a <code>@type</code> key with a value that
matches <tref title="active property">active property's</tref>
<tref>type mapping</tref> in <tref>active context</tref> or
- <em>value</em> has a <code>@language</code> key with a value that
+ <i>value</i> has a <code>@language</code> key with a value that
matches <tref title="active property">active property's</tref>
<tref>language mapping</tref> in <tref>active context</tref>, then
return the value associated with the <code>@value</code> key in
- <em>value</em>.</li>
- <li>If <code>@value</code> is the only key in <em>value</em> or
- <em>preserveIndex</em> is <tref>false</tref> and either
+ <i>value</i>.</li>
+ <li>If <code>@value</code> is the only key in <i>value</i> or
+ <i>preserveIndex</i> is <tref>false</tref> and either
there is no <tref>default language</tref> in
<tref>active context</tref>, the value associated with the
- <code>@value</code> key in <em>value</em> is not a
+ <code>@value</code> key in <i>value</i> is not a
<tref>string</tref>, or <tref>active property</tref>
has a <tref>null</tref> <tref>language mapping</tref> in
<tref>active context</tref>, then return the value
- associated with the <code>@value</code> key in <em>value</em>.</li>
- <li>Initialize <em>result</em> to an empty <tref>JSON object</tref>.</li>
- <li>If <em>preserveIndex</em> is <tref>true</tref>, then add
- a key-value pair to <em>result</em> where the key is the result
+ associated with the <code>@value</code> key in <i>value</i>.</li>
+ <li>Initialize <i>result</i> to an empty <tref>JSON object</tref>.</li>
+ <li>If <i>preserveIndex</i> is <tref>true</tref>, then add
+ a key-value pair to <i>result</i> where the key is the result
using the <a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@index</code> for <em>iri</em>, and the value associated wit
- the <code>@index</code> key in <em>value</em> as <em>value</em>.</li>
- <li>If <em>value</em> contains the key <code>@type</code>, then add
- a key-value pair to <em>result</em> where the key is the result
+ <code>@index</code> for <i>iri</i>, and the value associated wit
+ the <code>@index</code> key in <i>value</i> as <i>value</i>.</li>
+ <li>If <i>value</i> contains the key <code>@type</code>, then add
+ a key-value pair to <i>result</i> where the key is the result
using the <a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@type</code> for <em>iri</em>, and the <em>value</em> is the result
+ <code>@type</code> for <i>iri</i>, and the <i>value</i> is the result
of using the <a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>, the value
- associated with the <code>@type</code> key in <em>value</em> for <em>iri</em>,
- and <tref>true</tref> for <em>vocabRelative</em>.</li>
- <li>Otherwise, if <em>value</em> contains the key <code>@language</code>,
- then add a key-value pair to <em>result</em> where the key is the
+ associated with the <code>@type</code> key in <i>value</i> for <i>iri</i>,
+ and <tref>true</tref> for <i>vocabRelative</i>.</li>
+ <li>Otherwise, if <i>value</i> contains the key <code>@language</code>,
+ then add a key-value pair to <i>result</i> where the key is the
result using the
<a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@language</code> for <em>iri</em>, and the value associated
- with the <code>@language</code> key in <em>value</em> as <em>value</em>.</li>
- <li>Add a key-value pair to <em>result</em> where the key is the result
+ <code>@language</code> for <i>iri</i>, and the value associated
+ with the <code>@language</code> key in <i>value</i> as <i>value</i>.</li>
+ <li>Add a key-value pair to <i>result</i> where the key is the result
using the <a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@value</code> for <em>iri</em>, and the value is the value
- associated with the <code>@value</code> key in <em>value</em>.</li>
- <li>Return <em>result</em>.</li>
+ <code>@value</code> for <i>iri</i>, and the value is the value
+ associated with the <code>@value</code> key in <i>value</i>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</li>
- <li>Otherwise, <em>value</em> must contain the single key <code>@id</code>.
- Initialize <em>expanded property</em> to the result of using the
+ <li>Otherwise, <i>value</i> must contain the single key <code>@id</code>.
+ Initialize <i>expanded property</i> to the result of using the
<a href="#iri-expansion">IRI Expansion algorithm</a>, passing
- <tref>active context</tref>, <em>value</em>, and
- <tref>true</tref> for <em>vocabRelative</em>.</li>
- <li>Initialize <em>term</em> to the result of using the
+ <tref>active context</tref>, <i>value</i>, and
+ <tref>true</tref> for <i>vocabRelative</i>.</li>
+ <li>Initialize <i>term</i> to the result of using the
<a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>, the value
- associated with the key <code>@id</code> in <em>value</em> for <em>iri</em>, and
- <tref>true</tref> for <em>vocabRelative</em> if
+ associated with the key <code>@id</code> in <i>value</i> for <i>iri</i>, and
+ <tref>true</tref> for <i>vocabRelative</i> if
<tref>active property</tref> has a <tref>type mapping</tref> in the
<tref>active context</tref> that is <code>@vocab</code>.</li>
<li>If <tref>active property</tref> has a <tref>type mapping</tref> in
the <tref>active context</tref> that is <code>@id</code> or
- <code>@vocab</code> or if <em>expanded property</em> is
- <code>@graph</code>, then return <em>term</em>.</li>
- <li>Initialize <em>result</em> to an empty <tref>JSON object</tref>. Add
- a key-value pair to <em>result</em> where the key is the result of
+ <code>@vocab</code> or if <i>expanded property</i> is
+ <code>@graph</code>, then return <i>term</i>.</li>
+ <li>Initialize <i>result</i> to an empty <tref>JSON object</tref>. Add
+ a key-value pair to <i>result</i> where the key is the result of
using the <a href="#iri-compaction">IRI compaction algorithm</a>,
passing <tref>active context</tref>, <tref>inverse context</tref>,
- <code>@id</code> for <em>iri</em>, and <em>term</em> for <em>value</em>.</li>
- <li>Return <em>result</em>.</li>
+ <code>@id</code> for <i>iri</i>, and <i>term</i> for <i>value</i>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of Value Compaction algorithm -->
@@ -2944,35 +2944,35 @@
<section>
<h2>Flattening Algorithm</h2>
- <p>The algorithm takes two input variables, an <em>element</em> to flatten and a
- <em>context</em> used to compact the flattened document.</p>
+ <p>The algorithm takes two input variables, an <i>element</i> to flatten and a
+ <i>context</i> used to compact the flattened document.</p>
<ol class="algorithm">
- <li>Expand <em>element</em> according the
+ <li>Expand <i>element</i> according the
<a href="#expansion-algorithm">Expansion algorithm</a>.</li>
- <li>Generate a <em>nodeMap</em> according the
+ <li>Generate a <i>nodeMap</i> according the
<a href="#node-map-generation">Node Map Generation algorithm</a>.</li>
- <li>Let <em>defaultGraph</em> be the value of the <code>@default</code> member of
- <em>nodeMap</em>; a <tref>JSON object</tref> representing the <tref>default graph</tref>.</li>
- <li>For each other <em>graphName</em>-<em>graph</em> pair in <em>nodeMap</em>
+ <li>Let <i>defaultGraph</i> be the value of the <code>@default</code> member of
+ <i>nodeMap</i>; a <tref>JSON object</tref> representing the <tref>default graph</tref>.</li>
+ <li>For each other <i>graphName</i>-<i>graph</i> pair in <i>nodeMap</i>
perform the following steps:
<ol class="algorithm">
- <li>If <em>defaultGraph</em> does not have a <em>graphName</em> member, create
+ <li>If <i>defaultGraph</i> does not have a <i>graphName</i> member, create
one and initialize its value to a <tref>JSON object</tref> consisting of an
- <code>@id</code> member whose value is set to <em>graphName</em>.</li>
+ <code>@id</code> member whose value is set to <i>graphName</i>.</li>
<li>Add an <code>@graph</code> member set to an empty <tref>array</tref>
- (referred to as <em>nodes</em>) to the <tref>JSON object</tref> which is the
- value of the <em>graphName</em> member of <em>nodeMap</em>.</li>
- <li>For each <em>id</em>-<em>node</em> pair in <em>graph</em> ordered by <em>id</em>,
- add <em>node</em> to the <em>nodes</em> <tref>array</tref>.</li>
+ (referred to as <i>nodes</i>) to the <tref>JSON object</tref> which is the
+ value of the <i>graphName</i> member of <i>nodeMap</i>.</li>
+ <li>For each <i>id</i>-<i>node</i> pair in <i>graph</i> ordered by <i>id</i>,
+ add <i>node</i> to the <i>nodes</i> <tref>array</tref>.</li>
</ol>
</li>
<li>Initialize an empty <tref>array</tref> flattened.</li>
- <li>For each <em>id</em>-<em>node</em> pair in <em>defaultGraph</em> ordered by <em>id</em>,
- add <em>node</em> to <em>flattened</em>.</li>
- <li>If <em>context</em> is <tref>null</tref>, return <em>flattened</em>.</li>
- <li>Otherwise, return the result of compacting <em>flattened</em> according the
- <a href="#compaction-algorithm">Compaction algorithm</a> passing <em>context</em>
+ <li>For each <i>id</i>-<i>node</i> pair in <i>defaultGraph</i> ordered by <i>id</i>,
+ add <i>node</i> to <i>flattened</i>.</li>
+ <li>If <i>context</i> is <tref>null</tref>, return <i>flattened</i>.</li>
+ <li>Otherwise, return the result of compacting <i>flattened</i> according the
+ <a href="#compaction-algorithm">Compaction algorithm</a> passing <i>context</i>
ensuring that the compaction result uses the <code>@graph</code> keyword (or its alias)
at the top-level, even if the context is empty or if there is only one element to
put in the <code>@graph</code> <tref>array</tref>. This ensures that the returned
@@ -2983,124 +2983,124 @@
<section>
<h2>Node Map Generation</h2>
- <p>This algorithm creates a <tref>JSON object</tref> <em>nodeMap</em> holding an indexed
+ <p>This algorithm creates a <tref>JSON object</tref> <i>nodeMap</i> holding an indexed
representation of the <tref title="JSON-LD graph">graphs</tref> and <tref title="node">nodes</tref>
represented in the passed, expanded document. All <tref title="node">nodes</tref> that are not
uniquely identified by an IRI get assigned a (new) <tref>blank node identifier</tref>.
- The resulting <em>nodeMap</em> will have a member for every graph in the document whose
+ The resulting <i>nodeMap</i> will have a member for every graph in the document whose
value is another object with a member for every <tref>node</tref> represented in the document.
The default graph is stored under the <code>@default</code> member, all other graphs are
stored under their <tref>graph name</tref>.</p>
- <p>The algorithm takes as input an expanded JSON-LD document <em>element</em> and a reference to
- a <tref>JSON object</tref> <em>nodeMap</em>. Furthermore it has the optional parameters
+ <p>The algorithm takes as input an expanded JSON-LD document <i>element</i> and a reference to
+ a <tref>JSON object</tref> <i>nodeMap</i>. Furthermore it has the optional parameters
<tref>active graph</tref> (which defaults to <code>@default</code>), an <tref>active subject</tref>,
- <tref>active property</tref>, and a reference to a <tref>JSON object</tref> <em>list</em>. The
- <em>nodeMap</em> must be initialized to a <tref>JSON object</tref> consisting of a single member
+ <tref>active property</tref>, and a reference to a <tref>JSON object</tref> <i>list</i>. The
+ <i>nodeMap</i> must be initialized to a <tref>JSON object</tref> consisting of a single member
whose name corresponds with <tref>active graph</tref> and whose value is an empty <tref>JSON object</tref>.</p>
<ol class="algorithm">
- <li>If <em>element</em> is an array, process each entry in <em>element</em> recursively, using this algorithm
+ <li>If <i>element</i> is an array, process each entry in <i>element</i> recursively, using this algorithm
and return.</li>
- <li>Otherwise <em>element</em> is a <tref>JSON object</tref>. Let <em>activeGraph</em> be the
+ <li>Otherwise <i>element</i> is a <tref>JSON object</tref>. Let <i>activeGraph</i> be the
<tref>JSON object</tref> which is the value of the <tref>active graph</tref> member of
- <em>nodeMap</em>.</li>
- <li>If it has an <code>@type</code> member, perform for each <em>item</em> the following
+ <i>nodeMap</i>.</li>
+ <li>If it has an <code>@type</code> member, perform for each <i>item</i> the following
steps:
<ol class="algorithm">
- <li>If <em>item</em> is a <tref>blank node identifier</tref>, replace it with a
+ <li>If <i>item</i> is a <tref>blank node identifier</tref>, replace it with a
<a href="#generate-blank-node-identifier">new blank node identifier</a>.</li>
- <li>If <em>activeGraph</em> has no member <em>item</em>, create it and initialize its
+ <li>If <i>activeGraph</i> has no member <i>item</i>, create it and initialize its
value to a <tref>JSON object</tref> consisting of a single member <code>@id</code>
- with the value <em>item</em>.</li>
+ with the value <i>item</i>.</li>
</ol>
</li>
- <li>If <em>element</em> has an <code>@value</code> member, perform the following steps:
+ <li>If <i>element</i> has an <code>@value</code> member, perform the following steps:
<ol class="algorithm">
- <li>If no <em>list</em> has been passed, merge <em>element</em> into the
+ <li>If no <i>list</i> has been passed, merge <i>element</i> into the
<tref>active property</tref> member of the <tref>active subject</tref> in
- <em>activeGraph</em>.</li>
- <li>Otherwise, append <em>element</em> to the <code>@list</code> member of <em>list</em>.</li>
+ <i>activeGraph</i>.</li>
+ <li>Otherwise, append <i>element</i> to the <code>@list</code> member of <i>list</i>.</li>
</ol>
</li>
- <li>Otherwise, if <em>element</em> has an <code>@list</code> member, perform
+ <li>Otherwise, if <i>element</i> has an <code>@list</code> member, perform
the following steps:
<ol class="algorithm">
- <li>Initialize a new <tref>JSON object</tref> <em>result</em> having a single member
+ <li>Initialize a new <tref>JSON object</tref> <i>result</i> having a single member
<code>@list</code> whose value is initialized to an empty <tref>array</tref>.</li>
- <li>Recursively call this algorithm passing the value of <em>element's</em>
- <code>@list</code> member as new <em>element</em> and <em>result</em> as <em>list</em>.</li>
+ <li>Recursively call this algorithm passing the value of <i>element's</i>
+ <code>@list</code> member as new <i>element</i> and <i>result</i> as <i>list</i>.</li>
<li>If <tref>active property</tref> is <tref>null</tref> or <code>@graph</code>,
- <a href="#generate-blank-node-identifier">generate a blank node identifier</a> <em>id</em>
- and store <em>result</em> as value of the member <em>id</em> in <em>activeGraph</em>.</li>
- <li>Otherwise, add <em>result</em> to the the value of the <tref>active property</tref> member
- of the <tref>active subject</tref> in <em>activeGraph</em>.</li>
+ <a href="#generate-blank-node-identifier">generate a blank node identifier</a> <i>id</i>
+ and store <i>result</i> as value of the member <i>id</i> in <i>activeGraph</i>.</li>
+ <li>Otherwise, add <i>result</i> to the the value of the <tref>active property</tref> member
+ of the <tref>active subject</tref> in <i>activeGraph</i>.</li>
</ol>
</li>
- <li>Otherwise <em>element</em> is a <tref>node object</tref>, perform the following
+ <li>Otherwise <i>element</i> is a <tref>node object</tref>, perform the following
steps:
<ol class="algorithm">
- <li>If <em>element</em> has an <code>@id</code> member, store its value in <em>id</em> and remove
- the member from <em>element</em>. If <em>id</em> is a <tref>blank node identifier</tref>, replace it with
+ <li>If <i>element</i> has an <code>@id</code> member, store its value in <i>id</i> and remove
+ the member from <i>element</i>. If <i>id</i> is a <tref>blank node identifier</tref>, replace it with
<a href="#generate-blank-node-identifier">a new blank node identifier</a>.</li>
<li>Otherwise <a href="#generate-blank-node-identifier">generate a new blank node identifier</a>
- and store it as <em>id</em>.</li>
- <li>If <em>activeGraph</em> does not contain a member <em>id</em>, create one and initialize
+ and store it as <i>id</i>.</li>
+ <li>If <i>activeGraph</i> does not contain a member <i>id</i>, create one and initialize
it to a <tref>JSON object</tref> consisting of a single member <code>@id</code> whose
- value is set to <em>id</em>.</li>
+ value is set to <i>id</i>.</li>
<li>If <tref>active property</tref> is not <tref>null</tref>, perform the following steps:
<ol class="algorithm">
- <li>Create a new <tref>JSON object</tref> <em>reference</em> consisting of a single member
- <code>@id</code> whose value is <em>id</em>.</li>
- <li>If no <em>list</em> has been passed, merge <em>element</em> into the
+ <li>Create a new <tref>JSON object</tref> <i>reference</i> consisting of a single member
+ <code>@id</code> whose value is <i>id</i>.</li>
+ <li>If no <i>list</i> has been passed, merge <i>element</i> into the
<tref>active property</tref> member of the <tref>active subject</tref> in
- <em>activeGraph</em>.</li>
- <li>Otherwise, append <em>element</em> to the <code>@list</code> member of <em>list</em>.</li>
+ <i>activeGraph</i>.</li>
+ <li>Otherwise, append <i>element</i> to the <code>@list</code> member of <i>list</i>.</li>
</ol>
</li>
- <li>If <em>element</em> has an <code>@type</code> member, merge each value into the <code>@type</code>
- of <tref>active subject</tref> in <em>activeGraph</em>. Then remove the <code>@type</code> member
- from <em>element</em>.</li>
- <li>If <em>element</em> has an <code>@index</code> member, set the <code>@index</code>
- of <tref>active subject</tref> in <em>activeGraph</em> to its value. There must be no
+ <li>If <i>element</i> has an <code>@type</code> member, merge each value into the <code>@type</code>
+ of <tref>active subject</tref> in <i>activeGraph</i>. Then remove the <code>@type</code> member
+ from <i>element</i>.</li>
+ <li>If <i>element</i> has an <code>@index</code> member, set the <code>@index</code>
+ of <tref>active subject</tref> in <i>activeGraph</i> to its value. There must be no
existing member already in <tref>active subject</tref> with a different value, if there
is, then a
<code class="error"><a href="#idl-def-JsonLdErrorCode.conflicting-indexes">conflicting indexes</a></code>
error has been detected. Continue and remove the
- <code>@index</code> from <em>element</em>.</li>
- <li>If <em>element</em> has an <code>@reverse</code> member:
+ <code>@index</code> from <i>element</i>.</li>
+ <li>If <i>element</i> has an <code>@reverse</code> member:
<ol class="algorithm">
- <li>Create a <tref>JSON object</tref> <em>referenced node</em> with a single member <code>@id</code> whose
- value is <em>id</em>.</li>
- <li>Set <em>reverse map</em> to the value of the <code>@reverse</code> member of
- <em>element</em>.</li>
- <li>For each <em>property</em>-<em>values</em> pair in <em>reverse map</em>:
+ <li>Create a <tref>JSON object</tref> <i>referenced node</i> with a single member <code>@id</code> whose
+ value is <i>id</i>.</li>
+ <li>Set <i>reverse map</i> to the value of the <code>@reverse</code> member of
+ <i>element</i>.</li>
+ <li>For each <i>property</i>-<i>values</i> pair in <i>reverse map</i>:
<ol class="algorithm">
- <li>For each <em>item</em> of <em>values</em>:
+ <li>For each <i>item</i> of <i>values</i>:
<ol class="algorithm">
- <li>If <em>item</em> has a <em>property</em> member, append <em>referenced node</em>
- to its value; otherwise create a <em>property</em> member whose value is an
- <tref>array</tref> containing a <em>referenced node</em>.</li>
- <li>Recursively invoke this algorithm passing <em>nodeMap</em>, </em><em>item</em> as new
- <em>element</em>, and <tref>active graph</tref>.</li>
+ <li>If <i>item</i> has a <i>property</i> member, append <i>referenced node</i>
+ to its value; otherwise create a <i>property</i> member whose value is an
+ <tref>array</tref> containing a <i>referenced node</i>.</li>
+ <li>Recursively invoke this algorithm passing <i>nodeMap</i>, </em><i>item</i> as new
+ <i>element</i>, and <tref>active graph</tref>.</li>
</ol>
</li>
</ol>
</li>
- <li>Remove the <code>@reverse</code> member from <em>element</em>.</li>
+ <li>Remove the <code>@reverse</code> member from <i>element</i>.</li>
</ol>
</li>
- <li>If <em>element</em> has an <code>@graph</code> member, recursively invoke this algorithm passing
- the value of the <code>@graph</code> member as new <em>element</em> and <em>id</em> as new
- <tref>active subject</tref>. Then remove the <code>@graph</code> member from <em>element</em>.</li>
- <li>Finally for each <em>property</em>-<em>value</em> pair in <em>element</em> ordered by
- <em>property</em> perform the following steps:
+ <li>If <i>element</i> has an <code>@graph</code> member, recursively invoke this algorithm passing
+ the value of the <code>@graph</code> member as new <i>element</i> and <i>id</i> as new
+ <tref>active subject</tref>. Then remove the <code>@graph</code> member from <i>element</i>.</li>
+ <li>Finally for each <i>property</i>-<i>value</i> pair in <i>element</i> ordered by
+ <i>property</i> perform the following steps:
<ol class="algorithm">
- <li>If no <em>property</em> member exists in the <tref>JSON object</tref> which is the
- value of the <em>id</em> member of <em>activeGraph</em> create the member and initialize
+ <li>If no <i>property</i> member exists in the <tref>JSON object</tref> which is the
+ value of the <i>id</i> member of <i>activeGraph</i> create the member and initialize
its value to an empty <tref>array</tref>.</li>
- <li>Recursively invoke this algorithm passing <em>value</em> as new <em>element</em>, <em>id</em>
- as new <tref>active subject</tref>, and <em>property</em> as new <tref>active property</tref>.</li>
+ <li>Recursively invoke this algorithm passing <i>value</i> as new <i>element</i>, <i>id</i>
+ as new <tref>active subject</tref>, and <i>property</i> as new <tref>active property</tref>.</li>
</ol>
</li>
</ol>
@@ -3156,37 +3156,37 @@
<section class="informative">
<h3>General Solution</h3>
- <p>The JSON-LD document is expanded converted to a <em>node map</em> using the
+ <p>The JSON-LD document is expanded converted to a <i>node map</i> using the
<a href="#node-map-generation">Node Map Generation algorithm</a>.
This allows each graph represented within the document to be
extracted and flattened, making it easier to process each
- <tref>node object</tref>. Each graph from the <em>node map</em>
+ <tref>node object</tref>. Each graph from the <i>node map</i>
is processed to extract <tref title="rdf triple">RDF triples</tref>,
to which any (non-default) graph name is applied to create an <tref>RDF dataset</tref>.</p>
</section>
<section>
<h3>Algorithm</h3>
- <p>The algorithm takes a JSON-LD document <em>element</em> and creates an
+ <p>The algorithm takes a JSON-LD document <i>element</i> and creates an
<tref>RDF dataset</tref>.</p>
<ol class="algorithm">
- <li>Expand <em>element</em> according the
+ <li>Expand <i>element</i> according the
<a href="#expansion-algorithm">Expansion algorithm</a>.</li>
- <li>Generate a <em>nodeMap</em> according the
+ <li>Generate a <i>nodeMap</i> according the
<a href="#node-map-generation">Node Map Generation algorithm</a>.</li>
- <li>Initialize an empty <tref>RDF dataset</tref> <em>dataset</em>.</li>
- <li>For each <em>graph name</em> and <em>graph</em> in <em>nodeMap</em>:
+ <li>Initialize an empty <tref>RDF dataset</tref> <i>dataset</i>.</li>
+ <li>For each <i>graph name</i> and <i>graph</i> in <i>nodeMap</i>:
<ol class="algorithm">
- <li>Retrieve <em>triples</em> using the
+ <li>Retrieve <i>triples</i> using the
<a href="#node-map-to-rdf-conversion">Node Map to RDF Conversion algorithm</a>.</li>
- <li>If <em>graph name</em> is <code>@default</code>, add
- <em>triples</em> to the <tref>default graph</tref> in <em>dataset</em>.</li>
- <li>Otherwise, create a <tref>named graph</tref> in <em>dataset</em>
- composed of <em>graph name</em> and <em>triples</em>.</li>
+ <li>If <i>graph name</i> is <code>@default</code>, add
+ <i>triples</i> to the <tref>default graph</tref> in <i>dataset</i>.</li>
+ <li>Otherwise, create a <tref>named graph</tref> in <i>dataset</i>
+ composed of <i>graph name</i> and <i>triples</i>.</li>
</ol>
</li>
- <li>Return <em>dataset</em>.</li>
+ <li>Return <i>dataset</i>.</li>
</ol>
</section>
</section> <!-- end of Convert to RDF Algorithm -->
@@ -3194,9 +3194,9 @@
<section>
<h3>Node Map to RDF Conversion</h3>
- <p>This algorithm takes the a <em>Node Map</em> for a particular graph as generated
+ <p>This algorithm takes the a <i>Node Map</i> for a particular graph as generated
by the <a href="#node-map-generation">Node Map Generation algorithm</a>
- and returns a set of <em>RDF triples</em>.</p>
+ and returns a set of <i>RDF triples</i>.</p>
<section class="informative">
<h3>Purpose</h3>
@@ -3220,50 +3220,50 @@
<section>
<h3>Algorithm</h3>
- <p>The <em>nodeMap</em> is represented as an <tref>JSON object</tref>
+ <p>The <i>nodeMap</i> is represented as an <tref>JSON object</tref>
having keys which are node identifiers (<tref title="iri">IRIs</tref> or
<tref title="blank node identifier">blank node identifiers</tref>)
and values are <tref title="node object">Node objects</tref>.</p>
<ol class="algorithm">
- <li>Initialize <em>result</em> as an empty <tref>array</tref>.</li>
- <li>For each <em>subject</em> and <em>node</em> in <em>nodeMap</em>:
+ <li>Initialize <i>result</i> as an empty <tref>array</tref>.</li>
+ <li>For each <i>subject</i> and <i>node</i> in <i>nodeMap</i>:
<ol class="algorithm">
- <li>For each <em>property</em> and <em>values</em> in <em>node</em>:
+ <li>For each <i>property</i> and <i>values</i> in <i>node</i>:
<ol class="algorithm">
- <li>If <em>property</em> is <code>@type</code>, then for each
- <em>type</em> in <em>values</em>, append a <tref>triple</tref>
- composed of <em>subject</em>, <code>rdf:type</code>,
- and <em>type</em> to <em>result</em>.</li>
- <li>Otherwise, if <em>property</em> is a <tref>keyword</tref>
- continue to the next <em>property</em>-<em>values</em> pair.</li>
- <li>Otherwise, <em>property</em> is an <tref>IRI</tref> or
+ <li>If <i>property</i> is <code>@type</code>, then for each
+ <i>type</i> in <i>values</i>, append a <tref>triple</tref>
+ composed of <i>subject</i>, <code>rdf:type</code>,
+ and <i>type</i> to <i>result</i>.</li>
+ <li>Otherwise, if <i>property</i> is a <tref>keyword</tref>
+ continue to the next <i>property</i>-<i>values</i> pair.</li>
+ <li>Otherwise, <i>property</i> is an <tref>IRI</tref> or
<tref>blank node identifier</tref>.</li>
- <li>For each <em>item</em> in <em>values</em>:
+ <li>For each <i>item</i> in <i>values</i>:
<ol class="algorithm">
- <li>If <em>item</em> is a <tref>list object</tref>, initialize
- <em>list result</em> as an empty <tref>array</tref>, and
- <em>object</em> to the result of the <a
+ <li>If <i>item</i> is a <tref>list object</tref>, initialize
+ <i>list result</i> as an empty <tref>array</tref>, and
+ <i>object</i> to the result of the <a
href="#list-to-rdf-conversion">List Conversion algorithm</a>, passing
the value associated with the <code>@list</code> key from
- <em>item</em> and <em>list result</em>. Append a
- <tref>triple</tref> composed of <em>subject</em>,
- <em>property</em>, and <em>object</em> to <em>result</em> and
- add all <tref title="triple">triples</tref> from <em>list
- result</em> to <em>result</em>.</li>
- <li>Otherwise, <em>item</em> is a <tref>value object</tref>
- or a <tref>node object</tref>. Generate <em>object</em> as
+ <i>item</i> and <i>list result</i>. Append a
+ <tref>triple</tref> composed of <i>subject</i>,
+ <i>property</i>, and <i>object</i> to <i>result</i> and
+ add all <tref title="triple">triples</tref> from <i>list result</i>
+ to <i>result</i>.</li>
+ <li>Otherwise, <i>item</i> is a <tref>value object</tref>
+ or a <tref>node object</tref>. Generate <i>object</i> as
the result of the
<a href="#object-to-rdf-conversion">Object to RDF Conversion algorithm</a>
- passing <em>item</em>. Append a <tref>triple</tref> composed of
- <em>subject</em>, <em>property</em>, and <em>object</em> to
- <em>result</em>.</li>
+ passing <i>item</i>. Append a <tref>triple</tref> composed of
+ <i>subject</i>, <i>property</i>, and <i>object</i> to
+ <i>result</i>.</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
- <li>Return <em>result</em>.</li>
+ <li>Return <i>result</i>.</li>
</ol>
</section>
</section> <!-- end of Node Map to RDF Conversion -->
@@ -3295,42 +3295,42 @@
<section>
<h3>Algorithm</h3>
- <p>The algorithm takes as its sole argument <em>item</em> which must be
+ <p>The algorithm takes as its sole argument <i>item</i> which must be
either a <tref>value object</tref> or <tref>node object</tref>.</p>
<ol class="algorithm">
- <li>If <em>item</em> is a <tref>value object</tref>:
+ <li>If <i>item</i> is a <tref>value object</tref>:
<ol class="algorithm">
- <li>Initialize <em>value</em> to the value associated with the
- <code>@value</code> key in <em>item</em>. Initialize <em>datatype</em>
+ <li>Initialize <i>value</i> to the value associated with the
+ <code>@value</code> key in <i>item</i>. Initialize <i>datatype</i>
to the value associated with the <code>@type</code> key in
- <em>item</em>, or <code>null</code> if <em>item</em> does not contain
+ <i>item</i>, or <code>null</code> if <i>item</i> does not contain
that key.</li>
- <li>If <em>value</em> is <tref>true</tref> or
- <tref>false</tref>, then set <em>value</em> to its
+ <li>If <i>value</i> is <tref>true</tref> or
+ <tref>false</tref>, then set <i>value</i> to its
<tref>canonical lexical form</tref> as defined
in the section <a href="#data-round-tripping">Data Round Tripping</a>.
- If <em>datatype</em> is <tref>null</tref>, set it to
+ If <i>datatype</i> is <tref>null</tref>, set it to
<code>xsd:boolean</code>.</li>
- <li>Otherwise, if <em>value</em> is a <tref>number</tref>, then set
- <em>value</em> to its <tref>canonical lexical form</tref> as defined
+ <li>Otherwise, if <i>value</i> is a <tref>number</tref>, then set
+ <i>value</i> to its <tref>canonical lexical form</tref> as defined
in the section <a href="#data-round-tripping">Data Round Tripping</a>.
- If <em>datatype</em> is <tref>null</tref>, set it to either
+ If <i>datatype</i> is <tref>null</tref>, set it to either
<code>xsd:integer</code> or <code>xsd:double</code>, depending
on if the value contains a fractional and/or an exponential
component.</li>
- <li>Otherwise, if <em>datatype</em> is <tref>null</tref>, set it to
+ <li>Otherwise, if <i>datatype</i> is <tref>null</tref>, set it to
<code>xsd:string</code> or <code>rdf:langString</code>, depending on if
item has a <code>@language</code> key.</li>
- <li>Initialize <em>literal</em> as an <tref>RDF literal</tref> using
- <em>value</em> and <em>datatype</em>. If <em>item</em> has the key
- <code>@language</code> and <em>datatype</em> is
+ <li>Initialize <i>literal</i> as an <tref>RDF literal</tref> using
+ <i>value</i> and <i>datatype</i>. If <i>item</i> has the key
+ <code>@language</code> and <i>datatype</i> is
<code>rdf:langString</code>, then add the value associated with the
- <code>@language</code> key as the language of <em>literal</em>.</li>
- <li>Return <em>literal</em>.</li>
+ <code>@language</code> key as the language of <i>literal</i>.</li>
+ <li>Return <i>literal</i>.</li>
</ol>
</li>
- <li>Otherwise, <em>item</em> must be a <tref>node object</tref> containing
+ <li>Otherwise, <i>item</i> must be a <tref>node object</tref> containing
only <code>@id</code> having an <tref>IRI</tref> or
<tref>blank node identifier</tref> value. Return that value.</li>
</ol>
@@ -3368,28 +3368,28 @@
<h3>Algorithm</h3>
<p>The algorithm takes two inputs: an <tref>array</tref> of
- <tref title="node">nodes</tref> <em>list</em> and an empty <tref>array</tref>
- <em>list triples</em> used for returning the generated <tref title="RDF
+ <tref title="node">nodes</tref> <i>list</i> and an empty <tref>array</tref>
+ <i>list triples</i> used for returning the generated <tref title="RDF
triple">triples</tref>.</p>
<ol class="algorithm">
- <li>Create a new <tref>array</tref> <em>array</em> composed of a
+ <li>Create a new <tref>array</tref> <i>array</i> composed of a
<a href="#generate-blank-node-identifier">new blank node identifier</a>
- for each entry in <em>list</em>.</li>
- <li>For each pair of <em>subject</em> from <em>array</em> and <em>item</em> from <em>list</em>:
+ for each entry in <i>list</i>.</li>
+ <li>For each pair of <i>subject</i> from <i>array</i> and <i>item</i> from <i>list</i>:
<ol class="algorithm">
- <li>Generate <em>object</em> as the result of the
+ <li>Generate <i>object</i> as the result of the
<a href="#object-to-rdf-conversion">Object to RDF Conversion algorithm</a>
- passing <em>item</em>. Append a <tref>triple</tref> composed of <em>subject</em>,
- <code>rdf:first</code>, and <em>object</em> to <em>list triples</em>.</li>
- <li>Set <em>rest</em> as the next entry in <em>array</em>, or if that
+ passing <i>item</i>. Append a <tref>triple</tref> composed of <i>subject</i>,
+ <code>rdf:first</code>, and <i>object</i> to <i>list triples</i>.</li>
+ <li>Set <i>rest</i> as the next entry in <i>array</i>, or if that
does not exist, <code>rdf:nil</code>. Append a
- <tref>triple</tref> composed of <em>subject</em>,
- <code>rdf:rest</code>, and <em>rest</em> to <em>list triples</em>.</li>
+ <tref>triple</tref> composed of <i>subject</i>,
+ <code>rdf:rest</code>, and <i>rest</i> to <i>list triples</i>.</li>
</ol>
</li>
- <li>Return the first <tref>blank node</tref> from <em>array</em> or
- <code>rdf:nil</code> if <em>array</em> is empty.</li>
+ <li>Return the first <tref>blank node</tref> from <i>array</i> or
+ <code>rdf:nil</code> if <i>array</i> is empty.</li>
</ol>
</section>
</section> <!-- end of List to RDF -->
@@ -3430,118 +3430,118 @@
<section>
<h2>Algorithm</h2>
- <p>The algorithm takes a single parameter <em>dataSet</em> in the form of
+ <p>The algorithm takes a single parameter <i>dataSet</i> in the form of
an array of an <tref>RDF dataset</tref>.</p>
<ol class="algorithm">
- <li id="new_graph">Construct <em>defaultGraph</em> as a
- <tref>JSON object</tref> containing <em>nodes</em> and <em>listMap</em>,
+ <li id="new_graph">Construct <i>defaultGraph</i> as a
+ <tref>JSON object</tref> containing <i>nodes</i> and <i>listMap</i>,
each an empty <tref>JSON object</tref>.</li>
- <li>Construct <em>graphs</em> as a <tref>JSON object</tref>
- containing <em>defaultGraph</em> identified by <code>@default</code>.</li>
- <li>For each <em>graph</em> in <em>dataSet</em>:
+ <li>Construct <i>graphs</i> as a <tref>JSON object</tref>
+ containing <i>defaultGraph</i> identified by <code>@default</code>.</li>
+ <li>For each <i>graph</i> in <i>dataSet</i>:
<ol class="algorithm">
- <li>If <em>graph</em> is the <tref>default graph</tref>,
- set <em>name</em> to <code>@default</code>, otherwise to the
- <tref>graph name</tref> associated with <em>graph</em>.</li>
- <li>Set <em>graph object</em> to the entry in <em>graphs</em>
- identified by <em>name</em>, initializing it to a new entry as an empty
- <tref>JSON object</tref> containing <em>nodes</em> and
- <em>listMap</em>, each an empty <tref>JSON object</tref>.</li>
- <li>For each <tref>RDF triple</tref> <em>triple</em> in <em>graph</em>
- having <em>subject</em>, <em>predicate</em> and <em>object</em>:
+ <li>If <i>graph</i> is the <tref>default graph</tref>,
+ set <i>name</i> to <code>@default</code>, otherwise to the
+ <tref>graph name</tref> associated with <i>graph</i>.</li>
+ <li>Set <i>graph object</i> to the entry in <i>graphs</i>
+ identified by <i>name</i>, initializing it to a new entry as an empty
+ <tref>JSON object</tref> containing <i>nodes</i> and
+ <i>listMap</i>, each an empty <tref>JSON object</tref>.</li>
+ <li>For each <tref>RDF triple</tref> <i>triple</i> in <i>graph</i>
+ having <i>subject</i>, <i>predicate</i> and <i>object</i>:
<ol class="algorithm">
- <li>If <em>predicate</em> is <code>rdf:first</code>,
- use the entry in <em>graph.listMap</em> identified by
- <em>subject</em>, initializing it to a new <tref>JSON object</tref>
- if necessary. Represent <em>object</em> in <tref>expanded
+ <li>If <i>predicate</i> is <code>rdf:first</code>,
+ use the entry in <i>graph.listMap</i> identified by
+ <i>subject</i>, initializing it to a new <tref>JSON object</tref>
+ if necessary. Represent <i>object</i> in <tref>expanded
form</tref>, as described in the
<a href="#value-expansion">Value Expansion algorithm</a>.
- Add the resulting <em>object representation</em> to
- the entry indexed by <em>first</em>, and skip to the next
+ Add the resulting <i>object representation</i> to
+ the entry indexed by <i>first</i>, and skip to the next
<tref>triple</tref>.</li>
- <li>If <em>predicate</em> is <code>rdf:rest</code>:
+ <li>If <i>predicate</i> is <code>rdf:rest</code>:
<ol class="algorithm">
- <li>If <em>object</em> is a <tref>blank node</tref>,
- use the entry in <em>graph.listMap</em> identified by
- <em>subject</em>, initializing it to a new <tref>JSON
- object</tref> if necessary. Add the <em>nominalValue</em> of
- <em>object</em> to the entry indexed by <em>rest</em>.
- <p class="issue">What is <em>nominalValue</em>? Presumably
- this references the object in <em>graph.listMap</em>
- identified by <em>object</em>.</p></li>
+ <li>If <i>object</i> is a <tref>blank node</tref>,
+ use the entry in <i>graph.listMap</i> identified by
+ <i>subject</i>, initializing it to a new <tref>JSON
+ object</tref> if necessary. Add the <i>nominalValue</i> of
+ <i>object</i> to the entry indexed by <i>rest</i>.
+ <p class="issue">What is <i>nominalValue</i>? Presumably
+ this references the object in <i>graph.listMap</i>
+ identified by <i>object</i>.</p></li>
<li>Skip to the next <tref>triple</tref>.</li>
</ol>
</li>
- <li>If <em>name</em> is not <code>@default</code>,
- and <em>defaultGraph.nodes</em> does not contain an entry for
- <em>name</em>, create a new entry for <em>name</em> from a new
+ <li>If <i>name</i> is not <code>@default</code>,
+ and <i>defaultGraph.nodes</i> does not contain an entry for
+ <i>name</i>, create a new entry for <i>name</i> from a new
<tref>JSON object</tref> with key/value pair of <code>@id</code>
- and <em>name</em> represented in <tref>expanded IRI
+ and <i>name</i> represented in <tref>expanded IRI
form</tref>.</li>
- <li>Set <em>value</em> as the entry from <em>graph.nodes</em> for
- <em>subject</em>, initializing it to a new <tref>JSON object</tref>
- with key/value pair of <code>@id</code> and <em>subject</em>
+ <li>Set <i>value</i> as the entry from <i>graph.nodes</i> for
+ <i>subject</i>, initializing it to a new <tref>JSON object</tref>
+ with key/value pair of <code>@id</code> and <i>subject</i>
represented in <tref>expanded IRI form</tref> if necessary.</li>
- <li>If <em>predicate</em> is <code>rdf:type</code>, <em>object</em>
+ <li>If <i>predicate</i> is <code>rdf:type</code>, <i>object</i>
is not a <tref>JSON-LD value</tref>, and the <code
class="idlMemberName"><a
href="#widl-JsonLdOptions-useRdfType">useRdfType</a></code> option
is not present or <tref>false</tref>:
<ol class="algorithm">
- <li>Append <em>object</em> represented in
+ <li>Append <i>object</i> represented in
<tref>expanded IRI form</tref> to the array value for the key
- <code>@type</code>, creating an entry in <em>value</em> if
+ <code>@type</code>, creating an entry in <i>value</i> if
necessary.</li>
</ol>
</li>
- <li>Otherwise, if <em>object</em> is a <tref>typed value</tref>
+ <li>Otherwise, if <i>object</i> is a <tref>typed value</tref>
and the <code class="idlMemberName"><a
href="#widl-JsonLdOptions-useNativeTypes">useNativeTypes</a></code>
option is set to <tref>true</tref>:
<ol class="algorithm">
- <li>Generate a <em>converted value</em>:
+ <li>Generate a <i>converted value</i>:
<ol class="algorithm">
<li>If the literal's type is <code>xsd:boolean</code>, the
- <em>converted value</em> is <tref>true</tref> if the literal
+ <i>converted value</i> is <tref>true</tref> if the literal
matches the value <code>true</code> or <code>false</code> if
the literal matches the value <code>false</code>.</li>
<li>If the literal's type is <code>xsd:integer</code> or
<code>xsd:double</code>, try to convert the literal to a
JSON <tref>number</tref>. If the conversion is successful,
- store the result in <em>converted value</em>, otherwise
- set <em>converted value</em> to <em>value</em>.</li>
+ store the result in <i>converted value</i>, otherwise
+ set <i>converted value</i> to <i>value</i>.</li>
<li>Otherwise, do not perform a conversion. Set
- the <em>converted value</em> to the <em>value</em>.</li>
+ the <i>converted value</i> to the <i>value</i>.</li>
</ol>
</li>
- <li>Append the <em>converted value</em> to the array value for the
- key, creating an entry in <em>value</em> if necessary.</li>
+ <li>Append the <i>converted value</i> to the array value for the
+ key, creating an entry in <i>value</i> if necessary.</li>
</ol>
</li>
- <li>Otherwise, if <em>object</em> is <code>rdf:nil</code>:
+ <li>Otherwise, if <i>object</i> is <code>rdf:nil</code>:
<ol class="algorithm">
- <li>Let <em>key</em> be <em>predicate</em>
+ <li>Let <i>key</i> be <i>predicate</i>
expressed in <tref>expanded IRI form</tref>.</li>
<li>Append an empty <code>@list</code> representation
- to the array value for <em>key</em>, creating an entry in
- <em>value</em> if necessary.</li>
+ to the array value for <i>key</i>, creating an entry in
+ <i>value</i> if necessary.</li>
</ol>
</li>
<li>Otherwise,
<ol class="algorithm">
- <li>Let <em>key</em> be <em>predicate</em>
- expressed in <tref>expanded IRI form</tref> and let <em>object
- representation</em> be <em>object</em> represented in
+ <li>Let <i>key</i> be <i>predicate</i>
+ expressed in <tref>expanded IRI form</tref> and let
+ <i>object representation</i> be <i>object</i> represented in
<tref>expanded form</tref> as described in <a
href="#value-expansion">Value Expansion algorithm</a>.</li>
- <li>If <em>object</em> is a <tref>blank node</tref>,
- use the entry in <em>graph.listMap</em> indexed by
- <em>object</em>, initializing it to a new <tref>JSON
- object</tref> if necessary. Add an entry for <em>head</em> with
- <em>object representation</em>.</li>
- <li>Append <em>object representation</em> to the array value for
- <em>key</em>, creating an entry in <em>value</em> if
+ <li>If <i>object</i> is a <tref>blank node</tref>,
+ use the entry in <i>graph.listMap</i> indexed by
+ <i>object</i>, initializing it to a new <tref>JSON
+ object</tref> if necessary. Add an entry for <i>head</i> with
+ <i>object representation</i>.</li>
+ <li>Append <i>object representation</i> to the array value for
+ <i>key</i>, creating an entry in <i>value</i> if
necessary.</li>
</ol>
</li>
@@ -3549,36 +3549,36 @@
</li>
</ol>
</li>
- <li>For each <em>name</em> and <em>graph object</em> in <em>graphs</em>:
+ <li>For each <i>name</i> and <i>graph object</i> in <i>graphs</i>:
<ol class="algorithm">
- <li>For each <em>subject</em> and <em>entry</em> in <em>graph object</em>
- where <em>entry</em> has both <em>head</em> and <em>first</em> keys:
+ <li>For each <i>subject</i> and <i>entry</i> in <i>graph object</i>
+ where <i>entry</i> has both <i>head</i> and <i>first</i> keys:
<ol class="algorithm">
- <li>Set <em>value</em> to the value of <em>head</em> in <em>entry</em>.</li>
- <li>Remove the entry for <code>@id</code> in <em>value</em>.</li>
- <li>Add an entry to <em>value</em> for <code>@list</code> initialized to a new array
- containing the value of <em>first</em> from <em>entry</em>.</li>
- <li>While <em>entry</em> has a key for <em>rest</em>:
+ <li>Set <i>value</i> to the value of <i>head</i> in <i>entry</i>.</li>
+ <li>Remove the entry for <code>@id</code> in <i>value</i>.</li>
+ <li>Add an entry to <i>value</i> for <code>@list</code> initialized to a new array
+ containing the value of <i>first</i> from <i>entry</i>.</li>
+ <li>While <i>entry</i> has a key for <i>rest</i>:
<ol class="algorithm">
- <li>Set <em>entry</em> to the value of <em>graph.listMap</em> for <em>entry.rest</em>.</li>
- <li>Add the value for <em>entry.first</em> to the list array.</li>
+ <li>Set <i>entry</i> to the value of <i>graph.listMap</i> for <i>entry.rest</i>.</li>
+ <li>Add the value for <i>entry.first</i> to the list array.</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
- <li>Create <em>array</em> as an empty <tref>array</tref>.</li>
- <li>For each <em>subject</em> and <em>entry</em> in <em>defaultGraph.nodes</em>
- ordered by <em>subject</em>:
+ <li>Create <i>array</i> as an empty <tref>array</tref>.</li>
+ <li>For each <i>subject</i> and <i>entry</i> in <i>defaultGraph.nodes</i>
+ ordered by <i>subject</i>:
<ol class="algorithm">
- <li>Add <em>entry</em> to <em>array</em>.</li>
- <li>If <em>graphs</em> has an entry for <em>subject</em>, add a property
- <code>@graph</code> in <em>entry</em> containing the ordered entries
- from <em>graphs[subject].nodes</em>.</li>
+ <li>Add <i>entry</i> to <i>array</i>.</li>
+ <li>If <i>graphs</i> has an entry for <i>subject</i>, add a property
+ <code>@graph</code> in <i>entry</i> containing the ordered entries
+ from <i>graphs[subject].nodes</i>.</li>
</ol>
</li>
- <li>Return <em>array</em> as the result.</li>
+ <li>Return <i>array</i> as the result.</li>
</ol>
</section>
</section> <!-- end of Convert from RDF algorithm -->