JSON-LD 1.1 处理算法和 API

4.1.2 算法

此算法指定如何使用局部 上下文更新新的活动上下文。 该算法接受三个必需的 和四个可选的 输入变量。 必需输入是 active context、 local context， 以及用于解析相对上下文 URL 的 base URL。 可选输入是 一个数组 remote contexts， 默认为新的空数组，用于检测循环上下文 包含， override protected，默认为 false， 用于允许更改受保护术语， propagate，默认为 true， 用于标记与非传播上下文关联的术语 定义， 以及 validate scoped context，默认为 true， 用于在验证可能递归的作用域上下文时限制递归。

1. 将 result 初始化为克隆 active context的结果， 并将逆上下文设置为 null。
2. 如果 local context 是包含成员 @propagate 的对象， 则其值 MUST 为布尔值 true 或 false， 将 propagate 设置为该值。
   注

   错误处理在步骤 5.11中执行。
3. 如果 propagate 为 false，并且 result 没有先前上下文，则将 result 中的先前上下文 设置为 active context。
4. 如果 local context 不是数组， 则将 local context 设置为仅包含 local context 的数组。
5. 对 local context 中的每个项 context：
   1. 如果 context 是 null：
      1. 如果 override protected 为 false 且 active context 包含任何受保护的术语 定义， 则检测到 invalid context nullification 并中止处理。
      2. 将 result 初始化为一个 新初始化的活动 上下文， 将基准 IRI和原始基准 URL都设置为 active context 中原始基准 URL的值， 并且如果 propagate 为 false， 将 result 中的先前上下文 设置为 result 的先前值。
      3. 继续处理下一个 context。
   2. 如果 context 是字符串，
      1. 将 context 初始化为将 context 相对于 base URL 解析的结果。如果 base URL 不是有效的IRI， 则 context MUST 是有效的IRI，否则 检测到 loading document failed 错误 并中止处理。
         注

         base URL 通常不同于 base 或 active context 的基准 IRI。
      2. 如果 validate scoped context 为 false， 且 remote contexts 已经包含 context， 则不再进一步处理 context，并继续处理 local context 中任何下一个 context。
      3. 如果 remote contexts 数组中的条目数 超过处理器定义的限制，则检测到 context overflow 错误并中止处理； 否则，将 context 添加到 remote contexts。
      4. 如果 context 先前已被解引用， 则处理器 MUST NOT 进行 进一步解引用，并且 context 被设置为 先前建立的内部表示： 将 context document 设置为先前解引用的文档， 并将 loaded context 设置为 context document 中该文档的 @context 条目的值。
         注

         只需保留 @context 条目。
      5. 否则，将 context document 设置为通过使用 LoadDocumentCallback 解引用 context 所获得的 RemoteDocument， 传入 context 作为 url， 并传入 http://www.w3.org/ns/json-ld#context 作为profile 以及requestProfile。
         1. 如果 context 无法被 解引用， 或者 context document 中的 document 无法转换为内部表示 ， 则检测到 loading remote context failed 错误并中止处理。
         2. 如果 document 没有 带有 @context 条目的 顶层映射，则检测到 invalid remote context 并中止处理。
         3. 将 loaded context 设置为该条目的值。
      6. 将 result 设置为递归调用此算法的结果， 传入 result 作为 active context， loaded context 作为 local context， context document 的 documentUrl 作为 base URL， remote contexts 的副本， 以及 validate scoped context。
         注

         如果 context 先前已被解引用， 处理器MUST 提供保留该上下文的 base URL 的机制， 用于此步骤，以便能够解析处理期间可能遇到的任何 相对上下文 URL。
      7. 继续处理下一个 context。
   3. 如果 context 不是映射，则检测到 invalid local context 错误并中止处理。
   4. 否则，context 是一个上下文 定义。
   5. 如果 context 有 @version 条目：
      1. 如果关联值不是 1.1， 则检测到 invalid @version value 并中止处理。
         注

         使用 1.1 作为 @version 的值，旨在 使 JSON-LD 1.0 处理器停止处理。 尽管它显然意在与 JSON-LD 1.1 相关，但它并不 以其他方式遵循语义化版本控制的要求。 在比较具有非零小数部分的数字 值时，实现可能需要 特殊 考虑。
      2. 如果处理 模式 被设置为 json-ld-1.0， 则检测到 processing mode conflict 错误并中止处理。
   6. 如果 context 有 @import 条目：
      1. 如果处理 模式是 json-ld-1.0， 则检测到 invalid context entry 错误并中止处理。
      2. 否则，如果 @import 的值不是字符串， 则检测到 invalid @import value 错误并中止处理。
      3. 将 import 初始化为将 @import 的值相对于 base URL 解析的结果。
      4. 使用 LoadDocumentCallback 解引用 import，传入 import 作为 url， 并传入 http://www.w3.org/ns/json-ld#context 作为profile 以及requestProfile。
      5. 如果 import 无法被解引用， 或无法转换为内部 表示， 则检测到 loading remote context failed 错误并中止处理。
      6. 如果解引用的文档没有 带有 @context 条目的 顶层映射， 或者如果 @context 的值不是上下文 定义 （即它不是映射）， 则检测到 invalid remote context 并中止处理；否则， 将 import context 设置为该条目的值。
      7. 如果 import context 有 @import 条目， 则检测到 invalid context entry 错误并中止处理。
      8. 将 context 设置为将 context 合并到 import context 中的结果，用 context 中的条目替换共有条目。
   7. 如果 context 有 @base 条目，并且 remote contexts 为空，即当前 正在处理的上下文不是远程上下文：
      1. 将 value 初始化为与 @base 条目关联的值。
      2. 如果 value 为 null，则移除 result 的基准 IRI。
      3. 否则，如果 value 是IRI， 则将 result 的基准 IRI设置为 value。
      4. 否则，如果 value 是相对 IRI 引用 并且 result 的基准 IRI不是 null， 则将 result 的基准 IRI设置为 将 value 相对于 result 当前基准 IRI 解析的结果。
      5. 否则，检测到 invalid base IRI 错误并中止处理。
   8. 如果 context 有 @vocab 条目：
      1. 将 value 初始化为与 @vocab 条目关联的值。
      2. 如果 value 是null，则从 result 中移除 任何词汇表 映射。
      3. 否则，如果 value 是 IRI 或空白 节点标识符，则 result 的词汇表 映射 被设置为 使用 true 作为 document relative 对 value 进行 IRI 展开的结果 。 如果它不是IRI或空白 节点标识符，则检测到 invalid vocab mapping 错误并中止处理。
         注

         使用空白 节点标识符作为 @vocab 的值已过时， 并且可能会在 JSON-LD 的未来版本中移除。
   9. 如果 context 有 @language 条目：
      1. 将 value 初始化为与 @language 条目关联的值。
      2. 如果 value 为 null，则从 result 中移除 任何默认 语言。
      3. 否则，如果 value 是字符串，则将 result 的默认 语言设置为 value。 如果它不是字符串，则检测到 invalid default language 错误并中止处理。 如果 value 按照 [BCP47] 的第 2.2.9 节 不是格式良好的， 处理器 SHOULD 发出 警告。
         注

         处理器 MAY 将语言 标签规范化为小写。
   10. 如果 context 有 @direction 条目：
       1. 如果处理 模式是 json-ld-1.0， 则检测到 invalid context entry 错误并中止处理。
       2. 将 value 初始化为与 @direction 条目关联的值。
       3. 如果 value 为 null，则从 result 中移除 任何基准 方向。
       4. 否则，如果 value 是字符串，则将 result 的基准 方向设置为 value。如果它不是 null、"ltr" 或 "rtl"，则检测到 invalid base direction 错误并中止处理。
   11. 如果 context 有 @propagate 条目：
       1. 如果处理 模式是 json-ld-1.0， 则检测到 invalid context entry 错误并中止处理。
       2. 否则，如果 @propagate 的值不是布尔值 true 或 false， 则检测到 invalid @propagate value 错误并中止处理。
          注

          先前上下文实际上在 此算法的更早位置设置； 前两个步骤仅用于错误检查。
   12. 创建一个映射 defined，用于跟踪 某个术语是否已经被定义， 或当前是否正在递归期间被定义。
   13. 对于 context 中每个 key-value 对，其中 key 不是 @base、 @direction、 @import、 @language、 @propagate、 @protected、 @version 或 @vocab， 调用 创建术语定义算法， 传入 result 作为 active context， context 作为 local context，key， defined， base URL， context 中 @protected 条目的值（如果有）作为 protected， override protected， 以及 remote contexts 的副本。
6. 返回 result。

4.2.2 算法

该算法有四个必需输入，以及五个可选输入。 必需输入是 active context、 local context、 term， 以及映射 defined。 可选输入是 base URL，默认为 null； protected，默认为 false； 以及 override protected，默认为 false， 它用于允许更改受保护术语； 一个数组 remote contexts， 默认为新的空数组，用于检测循环 上下文包含； 以及 validate scoped context，默认为 true， 用于在验证可能递归的作用域上下文时限制递归。

1. 如果 defined 包含条目 term，且关联的 值为 true（表示 术语 定义已经创建），则返回。否则， 如果其值为 false，则检测到 cyclic IRI mapping 错误并中止处理。
2. 如果 term 是空字符串（""）， 则检测到 invalid term definition 错误并中止处理。 否则，将与 defined 的 term 条目关联的值设置为 false。这表示术语定义 现在正在创建，但尚未完成。
3. 将 value 初始化为与 local context 中 term 条目关联的值的副本。
4. 如果 term 是 @type， 并且处理模式为 json-ld-1.0， 则检测到 keyword redefinition 错误， 并中止处理。 此时， value MUST 是一个映射，且仅包含以下 条目中的任一个或二者：
   • 一个 @container 条目，其值为 @set。
   • 一个 @protected 条目。
   任何其他值都意味着已检测到 keyword redefinition 错误， 并中止处理。
5. 否则，由于关键字不能被覆盖， term MUST NOT 是关键字，否则 检测到 keyword redefinition 错误并中止处理。 如果 term 具有关键字的形式 （即它匹配 [RFC5234] 中的 ABNF 规则 "@"1*ALPHA）， 则返回；处理器 SHOULD 生成警告。
6. 将 previous definition 初始化为 active context 中 term 的任何现有 术语 定义， 并从 active context 中移除该术语定义。
7. 如果 value 为 null， 将其转换为一个映射，该映射由单个条目组成， 其键为 @id，值为 null。
8. 否则，如果 value 是字符串，则将其 转换为一个映射，该映射由单个条目组成， 其键为 @id，值为 value。 将 simple term 设置为 true。
9. 否则，value MUST 是一个映射；如果不是， 则检测到 invalid term definition 错误并中止处理。 将 simple term 设置为 false。
10. 创建一个新的术语定义 definition， 将前缀标志初始化为 false， 将受保护初始化为 protected， 并将反向 属性初始化为 false。
11. 如果 value 有 @protected 条目， 将 definition 中的受保护标志设置为该条目的值。 如果 @protected 的值不是布尔值， 则检测到 invalid @protected value 错误并 中止处理。 如果处理模式为 json-ld-1.0， 则检测到 invalid term definition 并中止处理。
12. 如果 value 包含条目 @type：
    1. 将 type 初始化为与 @type 条目关联的值，该值 MUST 是字符串。否则， 检测到 invalid type mapping 错误并中止处理。
    2. 将 type 设置为 对 type 进行IRI 展开的结果， 使用 local context 和 defined。
    3. 如果展开后的 type 是 @json 或 @none，且处理模式为 json-ld-1.0， 则检测到 invalid type mapping 错误并中止处理。
    4. 否则，如果展开后的 type 既不是 @id，也不是 @json， 也不是 @none， 也不是 @vocab， 也不是IRI， 则检测到 invalid type mapping 错误并中止处理。
    5. 将 definition 的类型映射设置为 type。
13. 如果 value 包含条目 @reverse：
    1. 如果 value 包含 @id 或 @nest 条目，则 检测到 invalid reverse property 错误并中止处理。
    2. 如果与 @reverse 条目关联的值 不是字符串，则 检测到 invalid IRI mapping 错误并中止处理。
    3. 如果与 @reverse 条目关联的值是一个 具有关键字形式的字符串 （即它匹配 [RFC5234] 中的 ABNF 规则 "@"1*ALPHA）， 则返回；处理器 SHOULD 生成警告。
    4. 否则，将 definition 的IRI 映射设置为 对与 @reverse 条目关联的值进行 IRI 展开 的结果， 使用 local context 和 defined。 如果结果不具有形式为 IRI或空白节点 标识符， 则检测到 invalid IRI mapping 错误并中止处理。
    5. 如果 value 包含 @container 条目， 将 definition 的容器映射 设置为包含其值的数组； 如果其值既不是 @set，也不是 @index，也不是 null，则检测到 invalid reverse property 错误（反向属性仅支持 set 和 index 容器）并中止处理。
    6. 将 definition 的反向 属性标志 设置为 true。
    7. 将 active context 中 term 的术语定义设置为 definition，并将与 defined 的条目 term关联的 值设置为 true，然后返回。
14. 如果 value 包含条目 @id，且其值 不等于 term：
    1. 如果 value 的 @id 条目 为 null，则该术语不用于 IRI 展开，但会 保留以便检测该术语未来的重新定义。
    2. 否则：
       1. 如果与 @id 条目关联的值不是字符串，则检测到 invalid IRI mapping 错误并中止处理。
       2. 如果与 @id 条目关联的值 不是关键字，但 具有关键字的形式 （即它匹配 [RFC5234] 中的 ABNF 规则 "@"1*ALPHA）， 则返回；处理器 SHOULD 生成 警告。
       3. 否则，将 definition 的IRI 映射设置为 对与 @id 条目关联的值进行 IRI 展开 的结果， 使用 local context 和 defined。 如果得到的IRI 映射 既不是关键字，也不是 IRI，也不是空白 节点标识符，则检测到 invalid IRI mapping 错误并中止处理；如果它等于 @context，则检测到 invalid keyword alias 错误并中止处理。
       4. 如果 term 包含冒号 （:），且该冒号不在 term 的第一个或最后一个字符处， 或者如果它在任何位置包含斜杠（/）：
          1. 将与 defined 的 term 条目关联的值设置为 true。
          2. 如果使用 local context 和 defined 对 term 进行IRI 展开的结果 与 definition 的IRI 映射不同， 则检测到 invalid IRI mapping 错误并中止处理。
       5. 如果 term 既不包含冒号（:）也不包含 斜杠（/）， simple term 为 true， 并且如果 definition 的IRI 映射 是一个以gen-delim 字符结尾的IRI， 或者是空白 节点标识符， 则将 definition 中的前缀标志设置为 true。
15. 否则，如果 term 包含冒号（:） 且该冒号位于第一个字符之后的任何位置：
    1. 如果 term 是一个紧凑 IRI，且其 前缀 是 local context 中的一个条目， 则发现一个依赖项。递归使用此算法，并传入 active context、local context、该 前缀作为 term，以及 defined。
    2. 如果 term 的前缀在 active context 中有一个 术语 定义，则将 definition 的IRI 映射设置为 将与前缀的 IRI 映射关联的值和 term 的 suffix 连接的结果。
    3. 否则，term 是一个IRI或 空白节点 标识符。将 definition 的IRI 映射 设置为 term。
16. 否则，如果 term 包含斜杠（/）：
    1. Term 是一个相对 IRI 引用。
    2. 将 definition 的IRI 映射设置为 对 term 进行IRI 展开的结果。 如果得到的IRI 映射不是IRI，则检测到 invalid IRI mapping 错误并中止处理。
17. 否则，如果 term 是 @type，则将 definition 的IRI 映射 设置为 @type。
18. 否则，如果 active context 有 词汇表映射，则 definition 的IRI 映射 被设置为将与词汇表映射关联的值和 term 连接的结果。 如果它没有词汇表映射，则检测到 invalid IRI mapping 错误并中止处理。
19. 如果 value 包含条目 @container：
    1. 将 container 初始化为与 @container 条目关联的值，该值 MUST 是 @graph、 @id、 @index、 @language、 @list、 @set、 @type， 或者是一个数组， 其中只包含这些关键字中的任意一个； 一个数组， 其中包含 @graph 以及 @id 或 @index 之一，并可选地 包含 @set； 或者是一个数组， 其中以任意顺序包含 @set 和 @index、@graph、 @id、@type、 @language 中任意项的组合 。 否则，检测到 invalid container mapping 并中止处理。
    2. 如果容器值 是 @graph、@id 或 @type，或者不是 字符串， 则在处理模式为 json-ld-1.0 时，生成 invalid container mapping 错误并中止处理。
    3. 将 definition 的容器映射设置为 container， 如有必要，将其强制转换为数组。
    4. 如果 definition 的容器映射包含 @type：
       1. 如果 definition 中的 type mapping 未定义，则将其设置为 @id。
       2. 如果 definition 中的 type mapping 既不是 @id 也不是 @vocab， 则检测到 invalid type mapping 错误并中止处理。
20. 如果 value 包含条目 @index：
    1. 如果处理模式为 json-ld-1.0，或 容器 映射不包含 @index， 则检测到 invalid term definition 并中止处理。
    2. 将 index 初始化为与 @index 条目关联的值。 如果对该值进行 IRI 展开的结果不是IRI， 则检测到 invalid term definition 并中止处理。
    3. 将 definition 的索引 映射设置为 index
21. 如果 value 包含条目 @context：
    1. 如果处理模式为 json-ld-1.0，则检测到 invalid term definition 并中止处理。
    2. 将 context 初始化为与 @context 条目关联的值，该值被视为局部 上下文。
    3. 调用上下文处理算法， 使用 active context、context 作为 local context、 base URL、 true 作为 override protected、 remote contexts 的副本， 以及 false 作为 validate scoped context。 如果检测到任何错误，则检测到 invalid scoped context 错误 并中止处理。
       注

       上下文 处理算法的结果 会被丢弃；调用它是为了在定义时检测错误。 如果使用该上下文，它将在活动 上下文中重新处理并应用， 作为展开或压缩的一部分。

    4. 将 definition 的局部上下文设置为 context， 并将基准 URL设置为 base URL。
22. 如果 value 包含条目 @language，且 不包含条目 @type：
    1. 将 language 初始化为与 @language 条目关联的值，该值 MUST 是 null 或字符串。 如果 language 按照 [BCP47] 的 第 2.2.9 节 不是格式良好的， 处理器 SHOULD 发出警告。 否则，检测到 invalid language mapping 错误并中止处理。
    2. 将 definition 的语言映射设置为 language。
       注

       处理器 MAY 将 语言 标签规范化为小写。
23. 如果 value 包含条目 @direction，且 不包含条目 @type：
    1. 将 direction 初始化为与 @direction 条目关联的值，该值 MUST 是 null、 "ltr" 或 "rtl"。否则，检测到 invalid base direction 错误并中止处理。
    2. 将 definition 的方向映射 设置为 direction。
24. 如果 value 包含条目 @nest：
    1. 如果处理模式为 json-ld-1.0，则检测到 invalid term definition 并中止处理。
    2. 将 definition 中的嵌套 值初始化为与 @nest 条目关联的值，该值 MUST 是字符串，并且 MUST NOT 是除 @nest 以外的关键字。否则，检测到 invalid @nest value 错误并中止处理。
25. 如果 value 包含条目 @prefix：
    1. 如果处理模式为 json-ld-1.0，或者如果 term 包含冒号（:）或斜杠（/），则检测到 invalid term definition 并中止处理。
    2. 将前缀 标志设置为与 @prefix 条目关联的值，该值 MUST 是布尔值。否则，检测到 invalid @prefix value 错误并中止处理。
    3. 如果 definition 的前缀 标志被设置为 true， 且其IRI 映射是关键字， 则检测到 invalid term definition 并中止处理。
26. 如果 value 包含除 @id、 @reverse、@container、 @context、 @direction、 @index、 @language、 @nest、 @prefix、 @protected 或 @type 之外的任何条目， 则检测到 invalid term definition 错误并 中止处理。
27. 如果 override protected 为 false， 且 previous definition 存在并且受保护：
    1. 如果 definition 与 previous definition 不相同 （除了受保护的值之外）， 则检测到 protected term redefinition 错误， 并中止处理。
    2. 将 definition 设置为 previous definition，以保留 受保护的值。
28. 将 active context 中 term 的术语 定义设置为 definition，并将与 defined 的条目 term关联的值设置为 true。

4.3.2 算法

该算法接受一个必需输入：正在为其创建 逆上下文的 active context。

1. 将 result 初始化为空映射。
2. 将 default language 初始化为 @none。 如果 active context 有默认语言， 则将 default language 设置为来自 活动 上下文的默认语言， 并规范化为小写。
3. 对于 active context 中的每个键术语 和值术语定义， 按最短术语 优先排序（平局时选择字典序最小的 术语）：
   1. 如果术语定义是 null， 则术语不能在 压缩期间被选择， 因此继续处理下一个术语。
   2. 将 container 初始化为 @none。 如果容器映射非空，则将 container 设置为容器映射的所有值按字典序排列后的连接结果 。
   3. 将 var 初始化为该IRI 映射的值， 该映射属于术语定义。
   4. 如果 var 不是 result 的条目，则向 result 添加一个条目， 其键为 var，其值 是一个空映射。
   5. 使用变量 container map 引用 result 中与 var 条目关联的值。
   6. 如果 container map 没有 container 条目， 则创建一个，并将其值设置为一个新的 映射，其中包含三个条目。 第一个条目是 @language， 其值是一个新的空 映射；第二个条目是 @type， 其值是一个新的空映射； 第三个条目是 @any， 其值是一个新的映射，其中 @none 条目被设置为正在 处理的术语。
   7. 使用变量 type/language map 引用 container map 中与 container 条目 关联的值。
   8. 使用变量 type map 引用 type/language map 中与 @type 条目关联的值。
   9. 使用变量 language map 引用 type/language map 中与 @language 条目关联的值。
   10. 如果术语定义 表明该术语 表示反向属性：
       1. 如果 type map 没有 @reverse 条目，则创建一个，并 将其值设置为正在处理的 术语。
   11. 否则，如果术语定义具有 一个 类型映射， 且该映射是 @none：
       1. 如果 language map 没有 @any 条目，则创建一个，并 将其值设置为正在处理的 术语。
       2. 如果 type map 没有 @any 条目，则创建一个，并 将其值设置为正在处理的 术语。
   12. 否则，如果术语定义具有 一个 类型映射：
       1. 如果 type map 没有与 术语 定义中的类型 映射相对应的条目， 则创建一个，并将其值设置为正在处理的 术语。
   13. 否则，如果术语定义同时具有 语言 映射和方向映射：
       1. 创建一个新变量 lang dir。
       2. 如果语言映射和方向映射 都不是 null，则将 lang dir 设置为 语言映射和方向映射以下划线（"_"） 分隔并连接后的结果， 并规范化为小写。
       3. 否则，如果语言映射不是 null， 则将 lang dir 设置为语言映射， 并规范化为小写。
       4. 否则，如果方向映射不是 null， 则将 lang dir 设置为前面带下划线 （"_"）的方向映射。
       5. 否则，将 lang dir 设置为 @null。
       6. 如果 language map 没有 lang dir 条目，则创建一个，并 将其值设置为正在处理的 术语。
   14. 否则，如果术语定义具有 一个语言 映射（可以是 null）：
       1. 如果语言映射等于 null， 则将 language 设置为 @null；否则 设置为语言映射， 并规范化为小写。
       2. 如果 language map 没有 language 条目， 则创建一个，并将其值设置为正在处理的 术语。
   15. 否则，如果术语定义具有 一个方向 映射（可以是 null）：
       1. 如果方向映射等于 null， 则将 direction 设置为 @none；否则 设置为前面带下划线 （"_"）的方向映射。
       2. 如果 language map 没有 direction 条目， 则创建一个，并将其值设置为正在处理的 术语。
   16. 否则，如果 active context 有 默认基准 方向：
       1. 初始化一个变量 lang dir， 其值为默认 语言和默认基准 方向以下划线（"_"） 分隔并连接后的结果， 并规范化为小写。
       2. 如果 language map 没有 lang dir 条目， 则创建一个，并将其值设置为正在处理的 术语。
       3. 如果 language map 没有 @none 条目， 则创建一个，并将其值设置为正在处理的 术语。
       4. 如果 type map 没有 @none 条目， 则创建一个，并将其值设置为正在处理的 术语。
   17. 否则：
       1. 如果 language map 没有 default language 条目 （规范化为小写后）， 则创建一个，并将其值设置为正在处理的 术语。
       2. 如果 language map 没有 @none 条目，则创建一个，并 将其值设置为正在处理的 术语。
       3. 如果 type map 没有 @none 条目，则创建一个，并 将其值设置为正在处理的 术语。
4. 返回 result。

4.4.2 算法

此算法有五个必需输入。它们是： 一个 active context， 一个关键字或 IRI var， 一个数组 containers，表示首选 容器映射的有序列表， 一个字符串 type/language，指示是否 查找具有匹配类型映射 或语言映射的 术语， 以及一个数组，表示 要为类型映射或 语言映射查找的 preferred values有序列表。

1. 如果 active context 具有 null 逆上下文， 则将 active context 中的逆上下文 设置为使用 active context 调用 逆上下文创建算法 的结果。
2. 将 inverse context 初始化为 active context 中逆上下文的值。
3. 将 container map 初始化为 inverse context 中与 var 关联的值。
4. 对于 containers 中的每一项 container：
   1. 如果 container 不是 container map 的条目，则 没有具有与其匹配的 容器 映射的术语，因此继续处理下一个 container。
   2. 将 type/language map 初始化为 container map 中与 container 条目关联的值。
   3. 将 value map 初始化为 type/language map 中与 type/language 条目关联的值。
   4. 对于 preferred values 中的每个 item：
      1. 如果 item 不是 value map 的条目， 则没有具有匹配 类型 映射或语言映射的 术语， 因此继续处理下一个 item。
      2. 否则，已找到匹配术语，返回 value map 中与 item 条目关联的值。
5. 未找到匹配术语。返回 null。

5.1.2 算法

该算法接受四个必需和三个可选输入变量。 必需输入是 active context、 active property、要展开的 element， 以及与原始待展开文档的 documentUrl 关联的 base URL。 可选输入是 frameExpansion 标志，它允许用于框架展开的特殊输入形式； ordered 标志，在注明之处用于按字典序排列 映射条目键； 以及 from map 标志，用于控制是否回退 与非传播上下文关联的 活动 上下文中的先前术语定义。 如果未传入，可选标志均设为 false。

该算法还执行特定于展开 JSON-LD 框架的处理步骤。对于框架，@id 和 @type 条目可以接受由 IRI组成的数组或 空映射。值对象的 条目也可以 接受由字符串组成的 数组，或空映射。 成帧还使用额外的关键字条目： （@explicit、@default、 @embed、@explicit、@omitDefault 或 @requireAll），它们会在展开过程中保留。 当 frameExpansion 标志被设置为 true 时，会调用 JSON-LD 框架的特殊处理。

1. 如果 element 是 null，返回 null。
2. 如果 active property 是 @default， 将 frameExpansion 标志初始化为 false。
3. 如果 active property 在 active context 中具有带局部 上下文的术语定义， 则将 property-scoped context 初始化为该局部上下文。
4. 如果 element 是标量，
   1. 如果 active property 是 null 或 @graph， 通过返回 null 丢弃自由浮动的标量。
   2. 如果定义了 property-scoped context， 则将 active context 设置为 上下文处理算法的结果， 传入 active context、property-scoped context 作为 local context， 以及 active property 在 active context 中的术语定义中的 base URL。
   3. 返回 值展开算法的结果，传入 active context、active property，以及 element 作为 value。
5. 如果 element 是数组，
   1. 初始化一个空数组 result。
   2. 对于 element 中的每个 item：
      1. 将 expanded item 初始化为递归使用此 算法的结果，传入 active context、 active property、item 作为 element、 base URL、 frameExpansion ordered 和 from map 标志。
      2. 如果 active property 的 容器映射 包含 @list， 并且 expanded item 是 数组， 则将 expanded item 设置为新的 映射，其中包含 @list 条目， 其值为原始的 expanded item。
      3. 如果 expanded item 是数组，将其每一项追加到 result。否则，如果 expanded item 不是 null，则将其追加到 result。
   3. 返回 result。
6. 否则，element 是映射。
7. 如果 active context 具有 先前上下文， 则 active context 不会传播。 如果 from map 未定义或为 false， 并且 element 不包含展开为 @value 的 条目， 且 element 也不只由单个展开为 @id 的 条目组成 （其中条目会被 IRI 展开）， 则将 active context 设置为 active context 中的 先前上下文， 因为术语作用域上下文的作用域在处理新的 节点对象时不适用。
8. 如果定义了 property-scoped context， 则将 active context 设置为 上下文处理算法的结果， 传入 active context、property-scoped context 作为 local context、 active property 在 active context 中的术语定义中的 base URL 以及 true 作为 override protected。
9. 如果 element 包含 @context 条目，则将 active context 设置为 上下文处理算法的结果， 传入 active context、@context 条目的值作为 local context 以及 base URL。
10. 将 type-scoped context 初始化为 active context。 这用于展开可能与任何先前 类型作用域上下文相关的值。
11. 对于 element 中每个 key 和 value， 按 key 字典序排列， 其中 key IRI 展开为 @type：
    1. 如果需要，将 value 转换为数组。
    2. 对于按字典序排列的 value 的每个值 term， 如果 term 是字符串， 并且 type-scoped context 中 term 的术语定义 具有局部上下文，则将 active context 设置为 上下文处理算法的结果， 传入 active context、 term 的 局部上下文的值作为 local context、 active context 中 value 的术语定义中的 base URL， 以及 false 作为 propagate。
12. 初始化两个空映射，result 和 nests。 将 input type 初始化为 element 中第一个 展开为 @type 的条目的最后一个值的展开结果 （如有），按键的字典序排列条目。 匹配条目的键和值都会被 IRI 展开。
13. 对于 element 中的每个 key 和 value， 如果 ordered 为 true，则按 key 字典序排列：
    1. 如果 key 是 @context，继续处理 下一个 key。
    2. 将 expanded property 初始化为 IRI 展开 key 的结果。
    3. 如果 expanded property 是 null，或者它既 不包含冒号（:）也不是关键字， 则通过继续处理下一个 key 来丢弃 key。
    4. 如果 expanded property 是关键字：
       1. 如果 active property 等于 @reverse，则 检测到 invalid reverse property map 错误，并中止处理。
       2. 如果 result 已经有一个 expanded property 条目， 且该条目不是 @included 或 @type （除非处理 模式是 json-ld-1.0）， 则检测到 colliding keywords 错误，并中止处理。
       3. 如果 expanded property 是 @id：
          1. 如果 value 不是字符串， 则检测到 invalid @id value 错误，并中止处理。 当 frameExpansion 标志被设置时，value MAY 是空映射，或由一个 或多个字符串组成的 数组。
          2. 否则， 将 expanded value 设置为 使用 true 作为 document relative 且使用 false 作为 vocab 对 value 进行 IRI 展开的结果。 当 frameExpansion 标志被设置时，expanded value 将是 由一个或多个值组成的数组，其中字符串 值使用上述 IRI 展开算法展开。
       4. 如果 expanded property 是 @type：
          1. 如果 value 既不是字符串， 也不是由 字符串组成的 数组， 则检测到 invalid type value 错误，并中止处理。 当 frameExpansion 标志被设置时，value MAY 是空映射，或 默认 对象， 其中 @default 的值被限制为 IRI。 所有其他值都表示已检测到 invalid type value 错误，并中止处理。
          2. 如果 value 是空映射，则将 expanded value 设置为 value。
          3. 否则，如果 value 是默认 对象，则将 expanded value 设置为 新的默认 对象，其中 @default 的值设置 为使用 type-scoped context 作为 active context 并使用 true 作为 document relative 对 value 进行 IRI 展开的结果。
          4. 否则， 将 expanded value 设置为 使用 type-scoped context 作为 active context 并使用 true 作为 document relative 对其每个值进行 IRI 展开 的结果。
          5. 如果 result 已经有 @type 条目， 则将 result 中 @type 的值前置到 expanded value， 如有必要，将其转换为数组。
             注

             不隐含从字符串 value 到数组 expanded value 的转换，并且 value 的形式 应在 expanded value 中保留。
       5. 如果 expanded property 是 @graph，则将 expanded value 设置为递归使用此算法的结果，传入 active context、@graph 作为 active property、value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志， 并确保 expanded value 是由一个或多个映射组成的 数组。
       6. 如果 expanded property 是 @included：
          1. 如果处理 模式是 json-ld-1.0， 继续处理 element 中的下一个 key。
          2. 将 expanded value 设置为 递归使用 此算法的结果，传入 active context、 null 作为 active property、 value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志， 并确保结果是数组。
          3. 如果 expanded value 的任一元素不是节点 对象， 则检测到 invalid @included value 错误，并中止处理。
          4. 如果 result 已经有 @included 条目， 则将 result 中 @included 的值前置到 expanded value。
       7. 如果 expanded property 是 @value：
          1. 如果 input type 是 @json， 将 expanded value 设置为 value。 如果处理 模式是 json-ld-1.0， 则检测到 invalid value object value 错误，并中止处理。
          2. 否则，如果 value 既不是标量 也不是 null， 则检测到 invalid value object value 错误，并中止处理。 当 frameExpansion 标志被设置时，value MAY 是空映射，或由 标量 值组成的数组。
          3. 否则，将 expanded value 设置为 value。 当 frameExpansion 标志被设置时， expanded value 将是由一个或 多个字符串 值组成的 数组， 或是包含空映射的 数组。
          4. 如果 expanded value 是 null，则将 result 的 @value 条目设置为 null，并继续处理 element 中的下一个 key。在这种情况下需要保留 Null 值，因为 @type 条目的含义取决于 @value 条目是否存在。
       8. 如果 expanded property 是 @language：
          1. 如果 value 不是字符串， 则检测到 invalid language-tagged string 错误，并中止处理。 当 frameExpansion 标志被设置时，value MAY 是空映射，或由零个或多个 字符串组成的数组。
          2. 否则，将 expanded value 设置为 value。 如果 value 按照 [BCP47] 的 第 2.2.9 节 不是格式良好的， 处理器 SHOULD 发出 警告。 当 frameExpansion 标志被设置时， expanded value 将是由一个或 多个字符串 值组成的 数组， 或是包含空映射的 数组。
             注

             处理器 MAY 将语言 标签规范化为小写。
       9. 如果 expanded property 是 @direction：
          1. 如果处理 模式是 json-ld-1.0， 继续处理 element 中的下一个 key。
          2. 如果 value 既不是 "ltr" 也不是 "rtl"，则检测到 invalid base direction 错误，并中止处理。 当 frameExpansion 标志被设置时，value MAY 是空映射，或由零个或多个 字符串组成的数组。
          3. 否则，将 expanded value 设置为 value。 当 frameExpansion 标志被设置时， expanded value 将是由一个或多个 字符串 值组成的 数组， 或是包含空映射的 数组。
       10. 如果 expanded property 是 @index：
           1. 如果 value 不是字符串， 则检测到 invalid @index value 错误，并中止处理。
           2. 否则， 将 expanded value 设置为 value。
       11. 如果 expanded property 是 @list：
           1. 如果 active property 是 null 或 @graph，继续处理 element 中的下一个 key 以移除自由浮动的列表。
           2. 否则，将 expanded value 初始化为 递归使用此算法的结果，传入 active context、 active property、value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志， 并确保结果是数组。
       12. 如果 expanded property 是 @set，则将 expanded value 设置为递归使用此算法的结果， 传入 active context、 active property、value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志。
       13. 如果 expanded property 是 @reverse：
           1. 如果 value 不是映射，则检测到 invalid @reverse value 错误，并中止处理。
           2. 否则，将 expanded value 初始化为递归使用 此 算法的结果，传入 active context、 @reverse 作为 active property、 value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志。
           3. 如果 expanded value 包含 @reverse 条目， 即属性 被反转了两次，则对其每个 property 和 item 执行以下步骤：
              1. 使用添加值将 item 添加到 result 中 property 条目， 使用 true 作为 as array。
           4. 如果 expanded value 包含除 @reverse 之外的条目：
              1. 将 reverse map 设置为 result 中 @reverse 条目的值， 如有必要，将其初始化为空映射。
              2. 对于 expanded value 中 除 @reverse 之外的每个 property 和 items：
                 1. 对于 items 中的每个 item：
                    1. 如果 item 是值 对象或列表 对象，则检测到 invalid reverse property value 错误，并中止处理。
                    2. 使用添加 值将 item 添加到 reverse map 中 property 条目， 使用 true 作为 as array。
           5. 继续处理 element 中的下一个 key。
       14. 如果 expanded property 是 @nest， 将 key 添加到 nests，如有必要将其初始化为空数组。 继续处理 element 中的下一个 key。
       15. 当 frameExpansion 标志被设置时， 如果 expanded property 是任何其他 成帧关键字（@default、 @embed、@explicit、@omitDefault 或 @requireAll）， 则将 expanded value 设置为递归执行 展开算法的结果， 传入 active context、 active property、value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志。
       16. 除非 expanded value 是 null， expanded property 是 @value， 并且 input type 不是 @json， 否则将 result 的 expanded property 条目设置为 expanded value。
       17. 继续处理 element 中的下一个 key。
    5. 将 container mapping 初始化为 active context 中 key 的容器 映射。
    6. 如果 active context 中 key 的术语定义 具有 @json 的类型 映射， 则将 expanded value 设置为新的映射，将 @value 条目设置为 value，并将 @type 条目设置为 @json。
    7. 否则，如果 container mapping 包含 @language，并且 value 是映射，则 value 按如下方式从语言映射 展开：
       1. 将 expanded value 初始化为空 数组。
       2. 将 direction 初始化为 active context 中的 默认基准 方向。
       3. 如果 活动 上下文中 key 的术语 定义 具有方向映射， 则用该值更新 direction。
       4. 对于 value 中的每个键值对 language-language value， 如果 ordered 为 true，则按 language 字典序排列：
          1. 如果 language value 不是数组， 将 language value 设置为只包含 language value 的数组。
          2. 对于 language value 中的每个 item：
             1. 如果 item 是 null， 继续处理 language value 中的下一个条目。
             2. item 必须是字符串， 否则检测到 invalid language map value 错误，并中止处理。
             3. 初始化一个新的映射 v， 它由两个 键值对组成：(@value-item) 和 (@language-language)。 如果 item 既不是 @none，也不是按照 [BCP47] 的 第 2.2.9 节格式良好， 处理器 SHOULD 发出警告。
                注

                处理器 MAY 将语言 标签规范化为小写。
             4. 如果 language 是 @none， 或展开为 @none，则从 v 中移除 @language。
             5. 如果 direction 不是 null， 则向 v 添加一个 @direction 的条目， 其值为 direction。
             6. 将 v 追加到 expanded value。
    8. 否则，如果 container mapping 包含 @index、 @type 或 @id，并且 value 是映射，则 value 按如下方式从映射展开：
       1. 将 expanded value 初始化为空数组。
       2. 将 index key 初始化为 活动 上下文中 key 的 索引映射， 或如果不存在，则为 @index。
       3. 对于 value 中的每个键值对 index-index value， 如果 ordered 为 true，则按 index 字典序排列：
          1. 如果 container mapping 包含 @id 或 @type， 则将 map context 初始化为 active context 中的 先前上下文 （如果存在）， 否则将 map context 设置为 active context。
          2. 如果 container mapping 包含 @type， 且 index 在 map context 中的术语 定义具有局部 上下文，则将 map context 更新为 上下文处理 算法的结果， 传入 map context 作为 active context， index 的局部 上下文的值 作为 local context， 以及 map context 中 index 的术语 定义中的 base URL。
          3. 否则，将 map context 设置为 active context。
          4. 将 expanded index 初始化为 IRI 展开 index 的结果。
          5. 如果 index value 不是数组， 则将 index value 设置为只包含 index value 的数组。
          6. 将 index value 初始化为 使用此算法递归处理的结果，传入 map context 作为 active context、 key 作为 active property、 index value 作为 element、 base URL、 true 作为 from map， 以及 frameExpansion 和 ordered 标志。
          7. 对于 index value 中的每个 item：
             1. 如果 container mapping 包含 @graph， 且 item 不是图 对象， 则将 item 设置为新的映射， 其中包含键值对 @graph-item， 并确保该值使用数组表示。
             2. 如果 container mapping 包含 @index， index key 不是 @index， 且 expanded index 不是 @none：
                1. 将 re-expanded index 初始化为调用 值展开 算法的结果， 传入 active context、 index key 作为 active property， 以及 index 作为 value。
                2. 将 expanded index key 初始化为 IRI 展开 index key 的结果。
                3. 将 index property values 初始化为 一个数组， 由 re-expanded index 后跟 item 中 expanded index key 的 连接结果的现有值（如有）组成。
                4. 将键值对（expanded index key-index property values） 添加到 item。
                5. 如果 item 是值对象， 它 MUST NOT 包含任何额外属性； 已检测到 invalid value object 错误，并中止处理。
             3. 否则，如果 container mapping 包含 @index， item 没有 @index 条目， 且 expanded index 不是 @none， 则将键值对（@index-index）添加到 item。
             4. 否则，如果 container mapping 包含 @id， item 没有 @id 条目， 且 expanded index 不是 @none， 则将键值对（@id-expanded index）添加到 item， 其中 expanded index 被设置为使用 true 作为 document relative 且使用 false 作为 vocab 对 index 进行 IRI 展开的结果。
             5. 否则，如果 container mapping 包含 @type 且 expanded index 不是 @none， 则将 types 初始化为一个新的数组， 由 expanded index 后跟 item 中 @type 的任何现有值组成。 将键值对（@type-types）添加到 item。
             6. 将 item 追加到 expanded value。
    9. 否则，将 expanded value 初始化为 递归使用此算法的结果，传入 active context、 key 作为 active property、value 作为 element、 base URL， 以及 frameExpansion 和 ordered 标志。
    10. 如果 expanded value 是 null，则通过继续处理 element 中的下一个 key 来忽略 key。
    11. 如果 container mapping 包含 @list 且 expanded value 尚不是列表对象， 则将 expanded value 转换为列表对象： 先在其尚不是数组时，将其设置为只包含 expanded value 的数组， 然后将其设置为包含 键值对 @list-expanded value 的映射。
    12. 如果 container mapping 包含 @graph， 且既不包含 @id 也不包含 @index， 则在必要时将 expanded value 转换为数组， 然后将 expanded value 中的每个值 ev 转换为 图 对象：
        1. 通过创建一个包含键值对 @graph-ev 的映射，将 ev 转换为 图对象， 其中 ev 表示为数组。
           注

           如果 ev 已经是图 对象形式， 这可能导致一个图 对象包含另一个图 对象。
    13. 如果与 key 关联的术语定义 表明它是反向属性
        1. 如果 result 没有 @reverse 条目，则创建 一个，并将其值初始化为空映射。
        2. 使用变量 reverse map 引用 result 中 @reverse 条目的值。
        3. 如果 expanded value 不是数组，则将 它设置为包含 expanded value 的数组。
        4. 对于 expanded value 中的每个 item
           1. 如果 item 是值 对象或列表 对象，则检测到 invalid reverse property value 错误，并中止处理。
           2. 如果 reverse map 没有 expanded property 条目， 则创建一个，并将其值初始化为空数组。
           3. 使用添加值将 item 添加到 reverse map 中的 expanded property 条目， 使用 true 作为 as array。
    14. 否则，key 不是反向属性， 使用添加值将 expanded value 添加到 result 中的 expanded property 条目， 使用 true 作为 as array。
14. 对于 nests 中的每个键 nesting-key， 如果 ordered 为 true，则按字典序排列：
    1. 将 nested values 初始化为 element 中 nesting-key 的值，并确保它是数组。
    2. 对于 nested values 中的每个 nested value：
       1. 如果 nested value 不是映射，或 nested value 中的任何键展开为 @value，则检测到 invalid @nest value 错误， 并中止处理。
       2. 递归重复步骤 13 和 14， 使用 nested value 作为 element。
          注

          通过在 nested value 上调用步骤 13 和 14， 我们能够展开任意层级的嵌套，并将结果 合并到 result 中。 步骤 13 遍历 nested value 中的每个条目并展开它，同时收集 每一层发现的新的 nested values，直到所有嵌套都被 提取出来。
15. 如果 result 包含 @value 条目：
    1. result 不得包含除 @direction、 @index、 @language、 @type 和 @value 之外的任何条目。 如果它包含 @language 或 @direction 条目中的任意一个， 则不得包含 @type 条目。 否则，检测到 invalid value object 错误，并中止处理。
    2. 如果 result 的 @type 条目 是 @json，则 @value 条目可以 包含任意值，并被视为JSON 字面量。
    3. 否则，如果 result 的 @value 条目的值是 null，或空数组，返回 null。
    4. 否则，如果 result 的 @value 条目的值 不是字符串，并且 result 包含 @language 条目， 则检测到 invalid language-tagged value 错误（只有字符串 可以带语言标签），并中止处理。
    5. 否则，如果 result 具有 @type 条目， 且其值不是IRI，则检测到 invalid typed value 错误，并中止处理。
16. 否则，如果 result 包含 @type 条目 且其关联值不是数组，则将其设置为 只包含该关联值的数组。
17. 否则，如果 result 包含 @set 或 @list 条目：
    1. result 最多只能包含一个其他条目， 且该条目必须是 @index。否则，检测到 invalid set or list object 错误，并中止处理。
    2. 如果 result 包含 @set 条目，则 将 result 设置为该条目的关联值。
18. 如果 result 是只包含 @language 条目的 映射，则返回 null。
19. 如果 active property 是 null 或 @graph， 按如下方式丢弃自由浮动值：
    1. 如果 result 是空的映射， 或只包含 @value 或 @list 条目， 则将 result 设置为 null。
    2. 否则，如果 result 是映射，其唯一 条目是 @id，则将 result 设置为 null。 当 frameExpansion 标志被设置时， 只包含 @id 条目的映射 会被保留。
20. 返回 result。

5.2.2 算法

该算法接受两个必需输入变量和四个可选输入变量。必需 输入是 active context 和要展开的 value。 可选输入是两个标志： document relative 和 vocab，它们指定 value 是否可以分别相对于文档的基准 IRI或 活动上下文的 词汇表 映射， 将 value 解释为相对 IRI 引用； 以及一个 local context 和一个映射 defined，供 此算法在上下文处理期间使用。 如果未传入，这两个标志被设置为 false， local context 和 defined 被初始化为 null。

1. 如果 value 是关键字或 null， 原样返回 value。
2. 如果 value 具有关键字形式 （即它匹配 [RFC5234] 中的 ABNF 规则 "@"1*ALPHA）， 处理器 SHOULD 生成警告并返回 null。
3. 如果 local context 不是 null，它包含 键等于 value 的条目， 并且 defined 中 value 对应 条目的值不是 true， 调用创建术语定义算法， 传入 active context、local context、 value 作为 term，以及 defined。这将确保在 上下文处理期间，为 active context 中的 value 创建 术语 定义。
4. 如果 active context 对 value 有术语定义，且关联的 IRI 映射是关键字， 返回该关键字。
5. 如果 vocab 是 true，并且 active context 对 value 有术语定义，则返回关联的 IRI 映射。
6. 如果 value 在第一个字符之后的 任意位置包含冒号（:）， 它要么是 IRI，要么是紧凑 IRI，要么是 空白节点 标识符：
   1. 在第一次出现冒号（:）的位置，将 value 拆分为 prefix 和 suffix。
   2. 如果 prefix 是下划线（_）， 或 suffix 以前置双斜杠 （//）开头，则原样返回 value，因为它已经是 IRI或空白节点 标识符。
   3. 如果 local context 不是 null，它 包含 prefix 条目，且 defined 中 prefix 条目的值 不是 true，则调用 创建术语定义算法， 传入 active context、 local context、prefix 作为 term， 以及 defined。这将确保在 上下文处理期间，为 active context 中的prefix创建 术语 定义。
   4. 如果 active context 包含 prefix 的术语定义， 且具有非 null 的IRI 映射， 并且该术语定义的 前缀 标志为 true， 则返回与 prefix 关联的 IRI 映射 和 suffix 连接后的结果。
   5. 如果 value 具有 形式为 IRI的形式， 返回 value。
7. 如果 vocab 是 true，并且 active context 有词汇表映射， 返回将该词汇表映射 与 value 连接的结果。
8. 否则，如果 document relative 是 true， 将 value 设置为相对于 active context 中的基准 IRI 解析 value 的结果。仅使用 [RFC3986] 的 第 5.2 节中的基本算法； 不执行 基于语法的规范化或 基于方案的规范化。 按照 [RFC3987] 的 第 6.5 节， IRI 引用中额外允许的字符 与 URI 引用中非保留字符的处理方式相同。
9. 原样返回 value。

5.3.2 算法

该算法接受三个必需输入：active context、 active property，以及要展开的 value。

1. 如果 active property 在 active context 中具有 @id 的类型映射， 且 value 是字符串， 则返回一个新的 映射，其中包含一个 条目，其键为 @id，其值为 使用 true 作为 document relative 且使用 false 作为 vocab 对 value 进行 IRI 展开的结果。
2. 如果 active property 在 active context 中具有 @vocab 的类型映射， 且 value 是字符串， 则返回一个新的 映射，其中包含一个 条目，其键为 @id，其值为 使用 true 作为 document relative 对 value 进行 IRI 展开的结果。
3. 否则，将 result 初始化为一个映射， 其中 @value 条目的值被设置为 value。
4. 如果 active property 在 active context 中具有 除 @id、@vocab 或 @none 之外的 类型映射， 则将 @type 添加到 result，并将其值设置为与 类型映射关联的值。
5. 否则，如果 value 是字符串：
   1. 将 language 初始化为 active context 中 active property 的语言映射（如有）， 否则初始化为 active context 的 默认语言。
   2. 将 direction 初始化为 active context 中 active property 的方向映射（如有）， 否则初始化为 active context 的默认基准 方向。
   3. 如果 language 不是 null， 则向 result 添加 @language，其值为 language。
   4. 如果 direction 不是 null， 则向 result 添加 @direction，其值为 direction。
6. 返回 result。

6.1.2 算法

该算法接受三个必需和两个可选输入变量。 必需输入是 active context、 active property 和要压缩的 element。 可选输入是 compactArrays 标志 和 ordered 标志，用于在注明之处按字典序排列 映射条目键。 如果未传入，两个标志均设置为 false。

1. 将 type-scoped context 初始化为 active context。 这用于压缩可能与任何先前 类型作用域上下文相关的值。
2. 如果 element 是标量，它已经处于其 最 紧凑形式，因此直接返回 element。
3. 如果 element 是数组：
   1. 将 result 初始化为空数组。
   2. 对于 element 中的每个 item：
      1. 将 compacted item 初始化为递归使用此 算法的结果，传入 active context、 active property、 item 作为 element， 以及 compactArrays 和 ordered 标志。
      2. 如果 compacted item 不是 null，则将 它追加到 result。
   3. 如果 result 为空或包含多于一个值， 或 compactArrays 为 false， 或 active property 是 @graph 或 @set， 或 active context 中 active property 的 容器映射包含 @list 或 @set， 返回 result。
   4. 否则，返回 result 中的值。
4. 否则 element 是映射。
5. 如果 active context 具有先前上下文， 则 active context 不会传播。 如果 element 不包含 @value 条目， 且 element 也不只由单个 @id 条目组成， 则将 active context 设置为来自 active context 的 先前上下文， 因为术语作用域上下文的作用域在处理新的 节点对象时不适用。
6. 如果 active context 中 active property 的术语定义 具有局部 上下文：
   1. 将 active context 设置为 上下文处理算法的结果， 传入 active context、 active property 的局部上下文的值作为 local context， active context 中 active property 的 术语定义中的 base URL， 以及 true 作为 override protected。
7. 如果 element 具有 @value 或 @id 条目，且使用 值压缩算法的结果 （传入 active context、 active property，以及 element 作为 value） 是标量， 或者 active property 的 术语定义 具有 @json 的类型映射， 则返回该结果。
8. 如果 element 是 列表对象， 且 active context 中 active property 的容器 映射包含 @list， 则返回递归使用此算法的结果，传入 active context、 active property、element 中 @list 的值作为 element， 以及 compactArrays 和 ordered 标志。
9. 如果 active property 等于 @reverse， 将 inside reverse 初始化为 true， 否则初始化为 false。
10. 将 result 初始化为空映射。
11. 如果 element 具有 @type 条目， 创建一个新数组 compacted types，通过将该 条目中的每个 expanded type 通过对 expanded type 进行 IRI 压缩转换为其压缩形式来初始化。 然后，对于按字典序排列的 compacted types 中的每个 term：
    1. 如果 type-scoped context 中 term 的术语定义具有 局部 上下文， 则将 active context 设置为 上下文处理算法的结果， 传入 active context 和 type-scoped context 中 term 的 局部 上下文的值作为 local context type-scoped context 中 term 的 术语定义中的 base URL， 以及 false 作为 propagate。
12. 对于 element 中的每个键 expanded property 和值 expanded value， 如果 ordered 为 true，则按 expanded property 字典序排列：
    1. 如果 expanded property 是 @id：
       1. 如果 expanded value 是字符串， 则通过 对 expanded value 进行 IRI 压缩 并将 vocab 设置为 false 初始化 compacted value。
       2. 通过 对 expanded property 进行 IRI 压缩 初始化 alias。
       3. 向 result 添加一个 alias 条目，其值 设置为 compacted value，并继续处理下一个 expanded property。
    2. 如果 expanded property 是 @type：
       1. 如果 expanded value 是字符串， 则通过 使用 type-scoped context 作为 active context 对 expanded value 进行 IRI 压缩 初始化 compacted value。
       2. 否则，expanded value 必须是 @type 数组：
          1. 将 compacted value 初始化为空 数组。
          2. 对于 expanded value 中的每一项 expanded type：
             1. 通过 使用 type-scoped context 作为 active context 对 expanded type 进行 IRI 压缩 设置 term。
             2. 将 term 追加到 compacted value。
       3. 通过 对 expanded property 进行 IRI 压缩 初始化 alias。
       4. 如果处理 模式为 json-ld-1.1，且 active context 中 alias 的 容器映射包含 @set， 则将 as array 初始化为 true， 否则初始化为 compactArrays的否定。
       5. 使用添加值将 compacted value 添加到 result 中的 alias 条目， 使用 as array。
       6. 继续处理下一个 expanded property。
    3. 如果 expanded property 是 @reverse：
       1. 将 compacted value 初始化为递归使用此 算法的结果，传入 active context、 @reverse 作为 active property、expanded value 作为 element， 以及 compactArrays 和 ordered 标志。
       2. 对于 compacted value 中的每个 property 和 value：
          1. 如果 active context 中 property 的 术语 定义表明 property 是 反向属性
             1. 如果 active context 中 property 的容器 映射包含 @set， 则将 as array 初始化为 true， 否则初始化为 compactArrays的否定。
             2. 使用添加值将 value 添加到 result 中的 property 条目， 使用 as array。
             3. 从 compacted value 中移除 property 条目。
       3. 如果 compacted value 仍有一些 映射条目，即 它不是空映射：
          1. 通过 对 @reverse 进行 IRI 压缩 初始化 alias。
          2. 将 result 的 alias 条目的值设置为 compacted value。
       4. 继续处理 element 中的下一个 expanded property。
    4. 如果 expanded property 是 @preserve 则：
       1. 将 compacted value 初始化为递归使用此 算法的结果，传入 active context、 active property、 expanded value 作为 element， 以及 compactArrays 和 ordered 标志。
       2. 除非 expanded value 是空数组， 否则将 compacted value 作为 result 中 @preserve 的值添加。
    5. 如果 expanded property 是 @index，并且 active property 在 active context 中具有 包含 @index 的容器映射， 则压缩结果将位于 @index 容器中，通过继续处理下一个 expanded property 来丢弃 @index 条目。
    6. 否则，如果 expanded property 是 @direction、 @index、 @language 或 @value：
       1. 通过 对 expanded property 进行 IRI 压缩 初始化 alias。
       2. 向 result 添加一个 alias 条目，其值 设置为 expanded value，并继续处理下一个 expanded property。
    7. 如果 expanded value 是空数组：
       1. 通过 使用 expanded value 作为 value 且使用 inside reverse 作为 reverse 对 expanded property 进行 IRI 压缩 初始化 item active property。
       2. 如果 active context 中 item active property 的术语 定义具有嵌套值 条目（nest term）：
          1. 如果 nest term 不是 @nest， 也不是 active context 中展开为 @nest 的 术语， 则检测到 invalid @nest value 错误，并中止处理。
          2. 如果 result 没有 nest term 条目， 则将其初始化为空映射。
          3. 将 nest result 初始化为 result 中 nest term 的值。
       3. 否则，将 nest result 初始化为 result。
       4. 使用添加值将空数组 添加到 nest result 中的 item active property 条目， 使用 true 作为 as array。
    8. 此时，由于 展开算法， expanded value 必须是 数组。 对于 expanded value 中的每一项 expanded item：
       1. 通过 使用 expanded item 作为 value 且使用 inside reverse 作为 reverse 对 expanded property 进行 IRI 压缩 初始化 item active property。
       2. 如果 active context 中 item active property 的术语 定义具有嵌套值 条目（nest term）：
          1. 如果 nest term 不是 @nest， 也不是 active context 中展开为 @nest 的 术语， 则检测到 invalid @nest value 错误，并中止处理。
          2. 如果 result 没有 nest term 条目， 则将其初始化为空映射。
          3. 将 nest result 初始化为 result 中 nest term 的值。
       3. 否则，将 nest result 初始化为 result。
       4. 将 container 初始化为 active context 中 item active property 的 容器映射， 或者如果没有这样的容器映射，则初始化为新的空 数组。
       5. 如果 container 包含 @set， 或 item active property 是 @graph 或 @list， 则将 as array 初始化为 true， 否则初始化为 compactArrays的否定。
       6. 将 compacted item 初始化为 使用 此算法递归处理的结果，传入 active context、 item active property 作为 active property、 expanded item 作为 element， 以及 compactArrays 和 ordered 标志。 如果 expanded item 是列表对象或 图对象， 则分别使用 @list 或 @graph 条目的值作为 element， 而不是 expanded item。
       7. 如果 expanded item 是列表对象：
          1. 如果 compacted item 不是数组， 则将 compacted item 设置为只包含 compacted item 的数组。
          2. 如果 container 不包含 @list：
             1. 将 compacted item 转换为 列表 对象，方法是将其设置为一个 映射， 其中包含一个 条目， 其键是对 @list 进行 IRI 压缩的结果， 其值是原始 compacted item。
             2. 如果 expanded item 包含 @index-value 条目， 则向 compacted item 添加一个 条目， 其键是对 @index 进行 IRI 压缩的结果， 其值是 value。
             3. 使用添加值将 compacted item 添加到 nest result 中的 item active property 条目， 使用 as array。
          3. 否则，将 nest result 中 item active property 条目的值 设置为 compacted item。
       8. 如果 expanded item 是图对象：
          1. 如果 container 包含 @graph 和 @id：
             1. 将 map object 初始化为 nest result 中 item active property 的值， 如有必要，将其初始化为新的空映射。
             2. 通过 对 expanded item 中 @id 的值进行 IRI 压缩 来初始化 map key； 如果不存在这样的值，则为 @none； 如果 expanded item 中有 @id 条目， 则将 vocab 设置为 false。
             3. 使用添加值将 compacted item 添加到 map object 中的 map key 条目， 使用 as array。
          2. 否则，如果 container 包含 @graph 和 @index， 并且 expanded item 是简单 图对象：
             1. 将 map object 初始化为 nest result 中 item active property 的值， 如有必要，将其初始化为新的空映射。
             2. 将 map key 初始化为 expanded item 中 @index 的值， 或者如果不存在这样的值，则为 @none。
             3. 使用添加值将 compacted item 添加到 map object 中的 map key 条目， 使用 as array。
          3. 否则，如果 container 包含 @graph 且 expanded item 是简单 图对象， 该值不能表示为映射对象。
             1. 如果 compacted item 是包含多个值的数组， 则它不能被直接表示， 因为多个对象会被解释为不同的命名图。 将 compacted item 设置为新的映射， 其中包含来自对 @included 进行 IRI 压缩所得的键 和作为值的原始 compacted item。
             2. 使用添加值将 compacted item 添加到 nest result 中的 item active property 条目， 使用 as array。
          4. 否则，container 不包含 @graph， 或者不匹配前述任一情况。
             1. 将 compacted item 设置为新的映射，其中包含 通过对 @graph 进行 IRI 压缩所得的键， 并使用原始 compacted item 作为值。
             2. 如果 expanded item 包含 @id 条目， 则在 compacted item 中添加一个条目，其键 来自对 @id 进行 IRI 压缩， 其值 使用对 expanded item 中 @id 的值进行 IRI 压缩 并使用 false 作为 vocab。
             3. 如果 expanded item 包含 @index 条目， 则在 compacted item 中添加一个条目，其键 来自对 @index 进行 IRI 压缩， 其值为 expanded item 中 @index 的值。
             4. 使用添加值将 compacted item 添加到 nest result 中的 item active property 条目， 使用 as array。
       9. 否则，如果 container 包含 @language、 @index、@id 或 @type 且 container 不包含 @graph：
          1. 将 map object 初始化为 nest result 中 item active property 的值， 如有必要，将其初始化为新的空映射。
          2. 通过 IRI 压缩 @language、@index、@id 或 @type 之一， 基于 container 的内容初始化 container key。
          3. 将 index key 初始化为 active context 中与 item active property 关联的 术语 定义中的索引映射的值， 或者如果不存在这样的值，则为 @index。
          4. 如果 container 包含 @language，且 expanded item 包含 @value 条目，则将 compacted item 设置为与其 @value 条目关联的值。 将 map key 设置为 expanded item 中 @language 的值（如有）。
          5. 否则，如果 container 包含 @index 且 index key 为 @index， 则将 map key 设置为 expanded item 中 @index 的值（如有）。
          6. 否则，如果 container 包含 @index 且 index key 不是 @index：
             1. 通过对 index key 进行IRI 压缩 重新初始化 container key。
             2. 将 map key 设置为 compacted item 中 container key 的第一个值（如有）。
             3. 如果 compacted item 中 container key 还有剩余值， 则使用添加值将 这些剩余值添加到 compacted item 中的 container key。 否则，从 compacted item 中移除该 条目。
          7. 否则，如果 container 包含 @id，则将 map key 设置为 compacted item 中 container key 的值，并从 compacted item 中移除 container key。
          8. 否则，如果 container 包含 @type：
             1. 将 map key 设置为 compacted item 中 container key 的第一个值（如有）。
             2. 如果 compacted item 中 container key 还有剩余值， 则使用添加值将 这些剩余值添加到 compacted item 中的 container key。
             3. 否则，从 compacted item 中移除该 条目。
             4. 如果 compacted item 包含单个 条目， 且其键展开为 @id，则将 compacted item 设置为使用 此算法递归处理的结果，传入 active context、 item active property 作为 active property， 以及由 expanded item 中 @id 的单个 条目 组成的映射 作为 element。
          9. 如果 map key 是 null， 则将其设置为对 @none 进行 IRI 压缩的结果。
          10. 使用添加值将 compacted item 添加到 map object 中的 map key 条目， 使用 as array。
       10. 否则，使用添加值将 compacted item 添加到 nest result 中的 item active property 条目， 使用 as array。
13. 返回 result。

6.2.2 算法

此算法接受两个必需输入和三个可选输入。 必需输入是 active context 和要压缩的 var。 可选输入是与 var 关联的 value、 vocab 标志，该标志指定传入的 var 是否应使用活动上下文的 词汇表 映射进行压缩， 以及 reverse 标志，该标志指定是否正在压缩 反向属性。 如果未传入，value 设置为 null， 且 vocab 和 reverse 都设置为 false。

1. 如果 var 是 null，返回 null。
2. 如果 active context 具有 null 逆上下文， 则将 active context 中的逆上下文 设置为使用 active context 调用 逆上下文创建算法 的结果。
3. 将 inverse context 初始化为 active context 中逆上下文的值。
4. 如果 vocab 是 true，并且 var 是 inverse context 的条目：
   1. 基于活动上下文的 默认语言 （规范化为小写）和默认基准 方向， 初始化 default language：
      1. 如果活动 上下文的默认基准 方向 不是 null，则设置为 活动 上下文的默认 语言 和默认基准 方向以下划线（"_"） 分隔并连接后的结果， 并规范化为小写。
      2. 否则，如果活动 上下文具有默认 语言， 则设置为该默认语言并 规范化为小写， 否则设置为 @none。
   2. 如果 value 是包含 @preserve 条目的映射， 则使用 @preserve 值中的第一个元素作为 value。
   3. 将 containers 初始化为空数组。该 数组将用于 跟踪某个术语的首选 容器映射的有序列表， 基于与 value 兼容的内容。
      注

      算法步骤可能会向 containers 追加相同的值， 但它们被添加的顺序对于选择最 合适的术语很重要。
   4. 将 type/language 初始化为 @language， 并将 type/language value 初始化为 @null。这两个 变量将用于跟踪某个术语的首选 类型映射或 语言 映射， 基于与 value 兼容的内容。
   5. 如果 value 是包含 @index 条目的 映射， 且 value 不是图对象， 则向 containers 追加值 @index 和 @index@set。
   6. 如果 reverse 是 true，将 type/language 设置为 @type，将 type/language value 设置为 @reverse，并将 @set 追加到 containers。
   7. 否则，如果 value 是列表对象，则将 type/language 和 type/language value 设置为对列表中所有项都适用的最具体值，如下：
      1. 如果 @index 不是 value 中的 条目， 则将 @list 追加到 containers。
      2. 将 list 初始化为 value 中 @list 条目关联的 数组。
      3. 将 common type 和 common language 初始化为 null。如果 list 为空，则将 common language 设置为 default language。
      4. 对于 list 中的每个 item：
         1. 将 item language 初始化为 @none，并将 item type 初始化为 @none。
         2. 如果 item 包含 @value 条目：
            1. 如果 item 包含 @direction 条目， 则将 item language 设置为 item 的 @language 条目（如有）与 item 的 @direction 以下划线（"_"）分隔并连接后的结果， 并规范化为小写。
            2. 否则，如果 item 包含 @language 条目， 则将 item language 设置为其关联值， 并规范化为小写。
            3. 否则，如果 item 包含 @type 条目， 则将 item type 设置为其 关联值。
            4. 否则，将 item language 设置为 @null。
         3. 否则，将 item type 设置为 @id。
         4. 如果 common language 是 null， 将 common language 设置为 item language。
         5. 否则，如果 item language 不等于 common language，并且 item 包含 @value 条目，则将 common language 设置为 @none，因为列表项具有冲突的 语言。
         6. 如果 common type 是 null， 将 common type 设置为 item type。
         7. 否则，如果 item type 不等于 common type，则将 common type 设置为 @none，因为列表项具有冲突的 类型。
         8. 如果 common language 是 @none，且 common type 是 @none，则 停止处理列表中的项，因为已经 检测到这些项之间不存在共同的语言或类型。
      5. 如果 common language 是 null， 将 common language 设置为 @none。
      6. 如果 common type 是 null， 将 common type 设置为 @none。
      7. 如果 common type 不是 @none，则将 type/language 设置为 @type，并将 type/language value 设置为 common type。
      8. 否则，将 type/language value 设置为 common language。
   8. 否则，如果 value 是图对象， 则首选最适合该特定值的映射。
      1. 如果 value 包含 @index 条目， 则将值 @graph@index 和 @graph@index@set 追加到 containers。
      2. 如果 value 包含 @id 条目， 则将值 @graph@id 和 @graph@id@set 追加到 containers。
      3. 将值 @graph、@graph@set 和 @set 追加到 containers。
      4. 如果 value 不包含 @index 条目， 则将值 @graph@index 和 @graph@index@set 追加到 containers。
      5. 如果 value 不包含 @id 条目， 则将值 @graph@id 和 @graph@id@set 追加到 containers。
      6. 将值 @index 和 @index@set 追加到 containers。
      7. 将 type/language 设置为 @type， 并将 type/language value 设置为 @id。
   9. 否则：
      1. 如果 value 是值对象：
         1. 如果 value 包含 @direction 条目 且不包含 @index 条目， 则将 type/language value 设置为 value 的 @language 条目（如有） 和 value 的 @direction 条目以下划线 （"_"）分隔并连接后的结果， 并规范化为小写。 将 @language 和 @language@set 追加到 containers。
         2. 否则，如果 value 包含 @language 条目 且不包含 @index 条目， 则将 type/language value 设置为 @language 的值并规范化为小写， 并将 @language 和 @language@set追加到 containers。
         3. 否则，如果 value 包含 @type 条目，则将 type/language value 设置为 其关联值，并将 type/language 设置为 @type。
      2. 否则，将 type/language 设置为 @type， 并将 type/language value 设置为 @id， 并将 @id、@id@set、 @type 和 @set@type 追加到 containers。
      3. 将 @set 追加到 containers。
   10. 将 @none 追加到 containers。这表示 不存在容器映射，并且它将 是最后一个要检查的容器映射值，因为它 最通用。
   11. 如果处理模式 不是 json-ld-1.0，并且 value 不是映射 或不包含 @index 条目， 则将 @index 和 @index@set 追加到 containers。
   12. 如果处理模式 不是 json-ld-1.0，并且 value 是只包含 @value 条目的映射， 则将 @language 和 @language@set 追加到 containers。
   13. 如果 type/language value 是 null， 将 type/language value 设置为 @null。 这是在 inverse context entry 中存储 null 值所用的键。
   14. 将 preferred values 初始化为空数组。 此数组 将按顺序指示某个 术语的 类型映射 或 语言 映射的首选值。
   15. 如果 type/language value 是 @reverse，将 @reverse 追加到 preferred values。
   16. 如果 type/language value 是 @id 或 @reverse，并且 value 是包含 @id 条目的 映射：
       1. 如果 对 value 中 @id 条目的值进行 IRI 压缩的结果 在 active context 中具有术语 定义， 且该定义具有一个等于 value 中 @id 条目的值的 IRI 映射， 则按此顺序将 @vocab、@id 和 @none 追加到 preferred values。
       2. 否则，按此顺序将 @id、@vocab 和 @none 追加到 preferred values。
   17. 否则，按此顺序将 type/language value 和 @none 追加到 preferred values。 如果 value 是列表对象， 且 @list 的值是空 array， 则将 type/language 设置为 @any。
   18. 将 @any 追加到 preferred values。
   19. 如果 preferred values 包含任何带下划线（"_"）的条目， 则将该条目中从下划线到字符串末尾的子字符串 追加到 preferred values。
   20. 将 term 初始化为 术语选择算法的结果，传入 var、containers、 type/language 和 preferred values。
   21. 如果 term 不是 null，返回 term。
5. 此时，没有简单术语可供 var 压缩为。如果 vocab 是 true，且 active context 具有词汇表映射：
   1. 如果 var 以 词汇表 映射的值开头 但更长，则将 suffix 初始化为 var 中不匹配的子字符串。如果 suffix 在 active context 中没有术语定义， 则返回 suffix。
6. 无法使用活动上下文的 词汇表映射 压缩 var。 尝试创建一个紧凑 IRI，首先将 compact IRI 初始化为 null。此变量将用于 存储创建的紧凑 IRI（如有）。
7. 对于 active context 中的每个 术语定义 definition：
   1. 如果 definition 的IRI 映射为 null， 其IRI 映射等于 var， 其IRI 映射不是 var 开头的子字符串， 或者 definition 没有值为 true 的前缀标志， 则 definition 的键不能用作前缀。 继续处理下一个 definition。
   2. 通过连接 definition 的键、 冒号（:）和 var 中位于 definition 的 IRI 映射值之后的子字符串， 初始化 candidate。
   3. 如果 compact IRI 是 null，或者 candidate 更短，或长度相同但字典序小于 compact IRI， 且 candidate 在 active context 中没有 术语 定义；或者如果该 术语 定义具有等于 var 的 IRI 映射 且 value 为 null， 则将 compact IRI 设置为 candidate。
8. 如果 compact IRI 不是 null，返回 compact IRI。
9. 为确保 IRI var 不会与紧凑 IRI混淆， 如果 var 的IRI 方案 与活动上下文中任何 前缀标志设置为 true 的术语匹配， 且 var 没有IRI authority（前面带有 双斜杠（//）， 则检测到 IRI confused with prefix 错误， 并中止处理。
10. 如果 vocab 是 false， 则使用active context 中的基准 IRI（如果存在） 将 var 转换为相对 IRI 引用。
11. 最后，原样返回 var。

6.3.2 算法

此算法有三个必需输入：active context、 active property 和要压缩的 value。

1. 将 result 初始化为 value 的副本。
2. 如果 active context 具有 null 逆上下文， 则将 active context 中的逆上下文 设置为使用 active context 调用 逆上下文创建算法 的结果。
3. 将 inverse context 初始化为 active context 中逆上下文的值。
4. 将 language 初始化为 active context 中 active property 的语言映射（如有），否则初始化为 active context 的默认语言。
5. 将 direction 初始化为 active context 中 active property 的方向映射（如有），否则初始化为 active context 的默认基准方向。
6. 如果 value 具有 @id 条目 且除了 @index 之外没有其他 条目：
   1. 如果 active property 的类型 映射 设置为 @id，则将 result 设置为 使用 false 作为 vocab 对 @id 条目关联的值进行 IRI 压缩 的结果。
   2. 否则，如果 active property 的类型映射 设置为 @vocab，则将 result 设置为 对 @id 条目关联的值进行 IRI 压缩 的结果。
7. 否则，如果 value 具有 @type 条目，其 值与 active property 的类型 映射匹配， 则将 result 设置为 value 的 @value 条目 关联的值。
8. 否则，如果 active property 的类型映射是 @none， 或者 value 具有 @type 条目， 且 value 中 @type 的值与 active property 的类型映射不匹配， 则让 value 保持原样，因为值压缩已禁用。
   1. 将 result 中 @type 的任何值替换为 对 @type 条目的值进行 IRI 压缩 的结果。
9. 否则，如果 @value 条目的值不是 字符串：
   1. 如果 value 具有 @index 条目， 并且与 active property 关联的 容器映射包含 @index， 或者如果 value 没有 @index 条目， 则将 result 设置为与 @value 条目关联的值。
10. 否则，如果 value 具有 @language 条目， 其值与 language 精确匹配； 如果它不是 null，则使用不区分大小写的比较； 或者如果 language 是 null，则不存在该条目， 并且 value 具有 @direction 条目， 其值与 direction 精确匹配； 如果它不是 null，则如此；或者如果 direction 是 null，则不存在该条目：
    1. 如果 value 具有 @index 条目， 且与 active property 关联的 容器映射包含 @index， 或者 value 没有 @index 条目， 则将 result 设置为与 @value 条目关联的值。
11. 如果 result 是 map， 则将 result 中的每个键替换为 对该键进行IRI 压缩的结果。
12. 返回 result。

7.1.2 算法

该算法接受一个必需和一个可选输入变量。 必需输入是要扁平化的 element。 可选输入是 ordered 标志，用于在注明之处按字典序排列 映射条目键。 如果未传入，ordered 标志设置为 false。

此算法使用 生成空白节点标识符算法 来生成新的空白节点 标识符 并重新标记现有空白节点 标识符。 生成空白节点标识符算法 维护一个 identifier map 以确保源文档中的空白节点标识符 被一致地重新映射为新的空白节点标识符， 从而避免冲突。 因此，在运行此算法之前，会重置 identifier map。

1. 将 node map 初始化为一个映射，它由 单个条目组成，其 键为 @default，其值为 空映射。
2. 执行节点映射生成算法，传入 element 和 node map。
3. 将 default graph 初始化为 node map 的 @default 条目的值，该值是表示 默认图的 映射。
4. 对于 node map 中的每个键值对 graph name-graph，其中 graph name 不是 @default， 如果 ordered 为 true， 则按 graph name 字典序排列， 执行以下步骤：
   1. 如果 default graph 没有 graph name 条目， 创建 一个，并将其值初始化为一个映射，该映射由一个 @id 条目组成，其值设置为 graph name。
   2. 使用变量 entry 引用 default graph 中与 graph name 条目关联的值。
   3. 向 entry 添加一个 @graph 条目，并将其设置为 空数组。
   4. 对于 graph 中的每个 id-node 对，按 id 字典序排列 （如果 ordered 为 true）， 将 node 添加到 entry 的 @graph 条目中， 除非 node 唯一的 条目是 @id。
5. 初始化一个空数组 flattened。
6. 对于 default graph 中的每个 id-node 对，按 id 字典序排列 （如果 ordered 为 true）， 将 node 添加到 flattened， 除非 node 唯一的条目是 @id。
7. 返回 flattened。

7.2.2 算法

该算法以展开的 JSON-LD 文档 element 和对 一个映射 node map 的引用作为输入。此外它还有可选参数 active graph（默认为 @default）、active subject、 active property，以及对映射 list 的引用。如果 未传入，active subject、active property 和 list 会被设置为 null。

1. 如果 element 是数组，则按如下方式处理 element 中的每个 item，然后返回：
   1. 递归运行此算法，传入 item 作为 element， node map、active graph、active subject、 active property 和 list。
2. 否则 element 是映射。使用变量 graph 引用 node map 的活动图 条目的值所对应的 映射。如果 active subject 是 null，则将 node 设置为 null， 否则使用变量 subject node 引用 graph 的 active subject 条目。
3. 对于 element 的 @type 条目中的每个 item（如果有），或者如果 @type 的值存在且 不是数组，则对于 @type 的值：
   1. 如果 item 是空白节点 标识符，则将其替换为一个新 生成的空白节点标识符， 传入 item 作为 identifier。
4. 如果 element 具有 @value 条目，执行以下步骤：
   1. 如果 list 是 null：
      1. 如果 subject node 没有 active property 条目， 创建一个，并将其值初始化为包含 element 的 数组。
      2. 否则，将 element 与 subject node 的 active property 条目关联的 数组 中的每一项进行比较。如果没有与 element 等价的项， 则将 element 追加到该 数组。如果两个 映射具有等价的 映射条目，则认为它们相等。
   2. 否则，将 element 追加到 list 的 @list 条目中。
5. 否则，如果 element 具有 @list 条目，执行 以下步骤：
   1. 初始化一个新的映射 result， 它由单个条目 @list 组成，其值初始化为空 数组。
   2. 递归调用此算法，传入 element 的 @list 条目的值作为 element、 node map、active graph、 active subject、active property，以及 result 作为 list。
   3. 如果 list 是 null， 则将 result 追加到 subject node 的 active property 条目的值。
   4. 否则，将 result 追加到 list 的 @list 条目中。
6. 否则 element 是节点对象，执行 以下步骤：
   1. 如果 element 具有 @id 条目，则将 id 设置为其值，并从 element 中移除该 条目。 如果 id 是空白节点 标识符，则将其替换为一个新 生成的空白节点标识符， 传入 id 作为 identifier。
   2. 否则，将 id 设置为 生成空白节点标识符算法的结果， 传入 null 作为 identifier。
   3. 如果 graph 不包含 id 的 条目，则创建一个， 并将其值初始化为一个映射，该映射由单个 条目 @id 组成，其 值为 id。
   4. 使用变量 node 引用 graph 的 id 条目的值。
   5. 如果 active subject 是映射，则正在处理反向属性 关系。执行以下步骤：
      1. 如果 node 没有 active property 条目， 创建一个，并将其值初始化为包含 active subject 的 数组。
      2. 否则，将 active subject 与 node 的 active property 条目关联的 数组 中的每一项进行比较。如果没有与 active subject 等价的项， 则将 active subject 追加到该 数组。如果两个 映射具有等价的 映射条目，则认为它们相等。
   6. 否则，如果 active property 不是 null，执行以下 步骤：
      1. 创建一个新的映射 reference，它由单个 条目 @id 组成，其值为 id。
      2. 如果 list 是 null：
         1. 如果 subject node 没有 active property 条目， 创建一个，并将其值初始化为包含 reference 的 数组。
         2. 否则，将 reference 与 subject node 的 active property 条目关联的 数组中的 每一项进行比较。如果没有与 reference 等价的项， 则将 reference 追加到该 数组。如果两个 映射具有等价的 映射条目，则认为 它们相等。
      3. 否则，将 reference 追加到 list 的 @list 条目中。
   7. 如果 element 具有 @type 条目，则将 其关联数组中的每一项追加到 node 的 @type 条目关联的 数组中， 除非它已经在该 数组中。最后 从 element 中移除 @type 条目。
   8. 如果 element 具有 @index 条目，则将 node 的 @index 条目 设置为其值。如果node 已经具有值不同的 @index 条目，则检测到 conflicting indexes 错误并中止处理。否则，继续从 element 中移除 @index 条目。
   9. 如果 element 具有 @reverse 条目：
      1. 创建一个映射 referenced node，其中包含单个 条目 @id，其 值为 id。
      2. 将 reverse map 初始化为 element 的 @reverse 条目的值。
      3. 对于 reverse map 中的每个键值对 property-values：
         1. 对于 values 中的每个 value：
            1. 递归调用此算法，传入 value 作为 element、node map、active graph、 referenced node 作为 active subject，以及 property 作为 active property。传入一个 映射 作为 active subject 表示 算法正在处理反向属性关系。
      4. 从 element 中移除 @reverse 条目。
   10. 如果 element 具有 @graph 条目，则递归调用此 算法，传入 @graph 条目的值作为 element、 node map，以及 id 作为 active graph，然后移除 element 中的 @graph 条目。
   11. 如果 element 具有 @included 条目， 则递归调用此算法，传入 @included 条目的值作为 element、 node map 和 active graph， 然后从 element 中移除 @included 条目。
   12. 最后，对于 element 中按 property 排序的每个键值对 property-value， 执行以下步骤：
       1. 如果 property 是空白 节点标识符，则将其替换为一个新 生成的空白节点标识符， 传入 property 作为 identifier。
          注

          使用空白 节点标识符标记属性已过时， 并可能在 JSON-LD 的未来版本中移除。
       2. 如果 node 没有 property 条目，创建一个并 将其值初始化为空 数组。
       3. 递归调用此算法，传入 value 作为 element、 node map、active graph、id 作为 active subject， 以及 property 作为 active property。

7.4.2 算法

该算法接受单个输入变量 identifier，它可以 是 null。该算法 维护一个 identifier map，用于将现有 空白 节点标识符重新标记为新的 空白节点 标识符， 该映射会在调用算法初始化时重置。

1. 如果 identifier 不是 null，且在 identifier map 中有条目，则返回映射后的标识符。
2. 否则，生成一个新的唯一空白节点 标识符。
3. 如果 identifier 不是 null，则在 identifier map 中为 identifier 创建一个新条目，并将其值 设置为新的空白节点 标识符。
4. 返回新的空白节点 标识符。

8.1.2 算法

该算法接受一个映射 node map，它是 节点映射生成算法的结果，以及一个 RDF 数据集 dataset，新的图和三元组 会被添加到其中。 它还接受两个可选输入变量：produceGeneralizedRdf 和 rdfDirection。 除非 produceGeneralizedRdf 选项 被设置为 true，否则包含空白节点 谓词的 三元组 会从输出中排除。

1. 对于 node map 中按 graph name 排序的每个 graph name 和 graph：
   1. 如果 graph name 不是格式良好的，则继续处理 下一个 graph name-graph 对。
   2. 如果 graph name 是 @default， 则将 triples 初始化为 dataset 的 defaultGraph 属性值。 否则，将 triples 初始化为空 RdfGraph， 并使用 dataset 的 add 方法将其添加到 dataset，同时传入 graph name 作为 graphName。
   3. 对于 graph 中按 subject 排序的每个 subject 和 node：
      1. 如果 subject 不是格式良好的，则继续处理 下一个 subject-node 对。
      2. 对于 node 中按 property 排序的每个 property 和 values：
         1. 如果 property 是 @type，则对于 values 中的每个 type， 创建一个新的 RdfTriple， 由 subject、作为 predicate 的 rdf:type， 以及作为 object 的 type 组成， 并使用 triples 的 add 方法 将其添加到 triples， 除非 type 不是格式良好的。
         2. 否则，如果 property 是 关键字， 则继续处理下一个 property-values 对。
         3. 否则，如果 property 是空白 节点标识符，并且 produceGeneralizedRdf 选项不是 true， 则继续处理下一个 property-values 对。
            注

            使用空白 节点标识符标记属性已过时， 并可能在 JSON-LD 的未来版本中移除， 对广义 RDF 数据集的支持也是如此， 因而 produceGeneralizedRdf 选项也可能被移除。
         4. 否则，如果 property 不是格式良好的， 则继续处理下一个 property-values 对。
         5. 否则，property 是 IRI或 空白 节点标识符。对于 values 中的每个 item：
            1. 将 list triples 初始化为空 数组。
               注

               item 是 值 对象、列表 对象， 或节点 对象。
            2. 向 triples 添加一个 三元组， 由 subject、property，以及 使用 对象到 RDF 转换算法 （传入 item 和 list triples） 的结果组成，使用 triples 的 add 方法添加， 除非结果为 null， 表示必须忽略一个非格式良好的 资源。
            3. 使用 triples 的 add 方法，将 list triples 中的所有 RdfTriple 实例 添加到 triples。

8.2.2 算法

该算法接受两个参数：item，它 MUST 是 值 对象、列表 对象或节点对象； 以及 list triples，它是一个空数组。

1. 如果 item 是节点对象，且其 @id 条目的值 不是格式良好的，则返回 null。
2. 如果 item 是节点对象，则返回与其 @id 条目关联的 IRI或 空白节点 标识符。
3. 如果 item 是列表对象， 则返回 列表转换算法的结果，传入 item 中与 @list 条目关联的值，以及 list triples。
4. 否则，item 是值对象。将 value 初始化为 item 中与 @value 条目关联的值。
5. 将 datatype 初始化为 item 的 @type 条目关联的值；如果 item 没有这样的条目，则初始化为 null。
6. 如果 datatype 不是 null， 且既不是格式良好的 IRI， 也不是 @json，则返回 null。
7. 如果 item 具有 @language 条目，且该条目不是 格式良好的，则返回 null。
8. 如果 datatype 是 @json， 则使用将 value 的 内部表示转换为 JSON 的结果，将 value 转换为规范词法形式， 并将 datatype 设置为 rdf:JSON。
   问题

   JSON 规范化方案（JCS）[RFC8785] 是一个用于 JSON 规范化的新兴标准。 本规范很可能会更新，以要求这样的规范表示。 提醒用户不要依赖 JSON 字面量作为 RDF 字面量的词法表示， 因为序列化细节可能会在本文档的未来修订版中改变。
9. 如果 value 是 true 或 false，则将 value 设置为 字符串 true 或 false，这就是 规范词法 形式，如 § 8.6 数据往返转换 中所述。如果 datatype 是 null， 则将 datatype 设置为 xsd:boolean。
10. 否则，如果 value 是具有非零小数 部分（模 1 运算的结果）的 数字 或绝对值大于或等于 10²¹， 或者 value 是数字 且 datatype 等于 xsd:double，则将 value 转换为 字符串， 其形式为 [XMLSCHEMA11-2] 中定义并在 § 8.6 数据往返转换中描述的 xsd:double 的 规范 词法形式。 如果 datatype 是 null， 则将 datatype 设置为 xsd:double。
11. 否则，如果 value 是 数字， 则将它转换为 字符串，其形式为 [XMLSCHEMA11-2] 中定义并在 § 8.6 数据往返转换中描述的 xsd:integer 的 规范 词法形式。 如果 datatype 是 null， 则将 datatype 设置为 xsd:integer。
    注

    由上一步可知，value 没有非零小数部分。
12. 否则，如果 datatype 是 null， 则根据 item 是否具有 @language 条目， 将 datatype 设置为 xsd:string 或 rdf:langString。
13. 如果 item 包含 @direction 条目， 且 rdfDirection 不是 null， 则 item 是一个使用特殊规则序列化的 值对象。
    1. 将 language 初始化为 item 中 @language 的值并规范化为小写， 如果没有这样的条目，则初始化为空字符串（""）。
       注

       通常语言标签不会被规范化， 但在创建 i18n-datatype 或 compound-literal 值时，值会被规范化为小写，以提高互操作性。
    2. 如果 rdfDirection 是 i18n-datatype， 则将 datatype 设置为把 language 和 item 中 @direction 的值以下划线 （"_"）分隔并追加到 https://www.w3.org/ns/i18n# 后的结果。 使用 value 和 datatype 将 literal 初始化为 RDF 字面量。
       注

       处理器 MAY 将 语言 标签规范化为小写。
       注

       由于 @direction 可以在没有 @language 的情况下使用， 因此可以合法地创建一个数据类型 IRI， 例如 http://w3.org/ns/i18n#_ltr，它并不编码 语言标签。
    3. 否则，如果 rdfDirection 是 compound-literal：
       1. 将 literal 初始化为新的 空白节点。
       2. 使用 literal 作为主语、 rdf:value 作为谓词，以及 item 中 @value 的值作为宾语， 创建一个新的三元组，并将其添加到 list triples。
       3. 如果 item 有 @language 条目， 使用 literal 作为主语、 rdf:language 作为谓词，以及 language 作为宾语，创建一个新的三元组，并将其添加到 list triples。
       4. 使用 literal 作为主语、 rdf:direction 作为谓词，以及 item 中 @direction 的值 作为宾语，创建一个新的三元组，并将其添加到 list triples。
14. 否则，使用 value 和 datatype 将 literal 初始化为 RDF 字面量。如果 item 具有 @language 条目， 则将与 @language 条目关联的值添加为 literal 的语言标签。
15. 返回 literal。