CBOR-LD 1.0

此算法以映射 typeTable、整数 registryEntryId 和 JSON-LD 文档 jsonldDocument 作为输入，并返回十六进制字符串 cborldBytes。

1. 将 prefix 设为把 registryEntryId 传递给 5.6.1 获取 CBOR 标签结构算法所得的结果。
2. 将 state 设为空映射。
3. 如果与 registryEntryId 关联的注册表条目需要语义 压缩：
   1. 将 state.strategy 设为 "compression"。
   2. 将 state.typeTable 设为 typeTable。
   3. 将 state.registryEntryId 设为 registryEntryId。
   4. 将 state 设为把 state 传递给 5.2.1 初始化转换算法所得的结果。
   5. 将 output 设为把 state 和 jsonldDocument 作为 inputDocument 传递给 5.2.2 转换文档算法所得的结果。
   6. 将 suffix 设为 output 的 CBOR 编码。
4. 否则，将 suffix 设为 jsonldDocument 的 CBOR 编码。
5. 将 cborldBytes 设为在 suffix 前添加 prefix 后得到的 十六进制编码。
6. 返回 cborldBytes。

此算法以 CBOR-LD 载荷 cborldBytes 作为输入，并返回 JSON-LD 文档 jsonldDocument。

1. 将 state 设为空映射。
2. 将 result 设为把 cborldBytes 传给 5.6.2 获取 注册表条目 ID 算法的结果。
3. 将 state.registryEntryId 设为 result.registryEntryId，并将 suffix 设为 result.suffix。
4. 如果与 state.registryEntryId 关联的注册表条目使用 语义压缩：
   1. 将 state.strategy 设为 "decompression"。
   2. 对于与 registryEntryId 关联的 CBOR-LD Varint 注册表条目中 typeTables 数组里的每个条目 type: map， 将该条目添加到 state.typeTable，并将 state.reverseTypeTable 中 type 的值设为 inverseMap，其中 inverseMap 是将 map 的映射反转后的结果。
   3. 将 state 设为把 state 传给 5.2.1 初始化转换算法的结果。
   4. 将 input 设为把 suffix 从字节解码为 映射的结果。
   5. 将 jsonldDocument 设为把 state 和 input 作为 inputDocuments 传给 5.2.2 转换文档算法的结果。
5. 否则，将 jsonldDocument 设为解析 cborldBytes 的结果。
6. 返回 jsonldDocument。

此算法接收并返回映射 state。

1. 将 state 设为把 state 传递给 5.4.1 初始化上下文加载器算法所得的结果。
2. 将 state.initialActiveContext 设为把空映射 termMap 和 previousActiveContext 传递给 5.3.1 初始化活动上下文算法所得的结果。
3. 将 state.typesEncodedAsBytes 设为空集合。
4. 将 "none"、"http://www.w3.org/2001/XMLSchema#date"、 "http://www.w3.org/2001/XMLSchema#dateTime" 和 "url" 添加到 state.typesEncodedAsBytes。
5. 返回 state。

此算法以映射 state 和映射或 映射数组 inputDocuments 作为输入，并返回一个包含映射 state 和映射或 映射数组 outputMaps 的映射。

1. 如果 inputDocuments 是数组，则将 inputs 设为 inputDocuments。否则，将 inputs 设为 [inputDocuments]。
2. 将 outputMaps 设为空数组。
3. 对于 inputs 中的 input：
   1. 将 output 设为空映射。
   2. 将 result 设为把 state、input、 output 和 state.initialActiveContext 作为 activeContext 传递给 5.2.3 通用转换算法所得的结果。
   3. 将 result.output 添加到 outputMaps。
   4. 将 state 设为 result.state。
4. 如果 inputDocuments 是数组，则返回 outputMaps。否则，返回 outputMaps 的 第一个元素。

此算法以映射 input、output、state 和 activeContext 作为输入，并返回一个包含映射 state 和 output 的映射。

1. 如果 state.strategy 被设为 "compression"：
   1. 将 contextConversionResult 设为 5.2.5.1 为压缩转换上下文算法的结果， 并传入 state、activeContext、input 和 output。
   2. 将 activeContext 设为 contextConversionResult.activeContext， output 设为 contextConversionResult.output，并将 state 设为 contextConversionResult.state。
2. 否则，将 activeContext 设为 result.activeContext，并将 state 设为 result 的 result.state，其中 result 来自 5.2.6.1 为解压缩转换上下文算法，并传入 state、 activeContext、input 和 output。
3. 如果 state.strategy 被设为 "compression"，则将 state 设为 result.state，并将 objectTypes 设为 result.objectTypes，其中 result 来自 5.2.5.4 获取用于压缩的对象类型算法，并传入 state、 activeContext、input 和 output。
4. 否则，将 state 设为 result.state，并将 objectTypes 设为 result.objectTypes， 其中 result 来自 5.2.6.4 获取用于解压缩的对象类型 算法， 并传入 state、activeContext、input 和 output。
5. 将 activeContext 设为把 activeContext 和 objectTypes 传递给 5.3.4 应用类型作用域上下文算法所得的结果。
6. 如果 state.strategy 被设为 "compression"，则将 state 设为 result.state，并将 termEntries 设为 result.termEntries，其中 result 来自 5.2.5.3 获取用于压缩的输入项算法，并传入 state、 input 和 activeContext。
7. 否则，将 state 设为 result.state，将 output 设为 result.output， 并将 termEntries 设为 result.termEntries，其中 result 来自 5.2.6.3 获取用于解压缩的输入项算法， 并传入 state、input、output 和 activeContext。
8. 对于 termEntries 中的 [termInfo, value]：
   1. 将 term 设为 termInfo.term。
   2. 将 valueActiveContext 设为把 activeContext 和 term 传递给 5.3.3 应用属性作用域上下文算法所得的结果。
   3. 将 plural 设为 termInfo.plural 的值，并将 termType 设为 termInfo.def 中 @type 的值。
   4. 如果 plural 被设为 true，则将 values 设为 value 的值。否则，将 values 设为 一个包含 value 的值作为单个元素的数组。
   5. 将 outputs 设为空数组。
   6. 对于 values 中的 unconvertedValue：
      1. 将 result 设为 5.2.4 转换值算法的结果， 并传入 state、termType、作为 value 的 unconvertedValue 以及作为 activeContext 的 valueActiveContext。
      2. 将 state 设为 result.state，并将 result.output 添加到 outputs。
   7. 如果 plural 被设为 true，则将 outputValues 设为 outputs。否则，将 outputValues 设为 outputs 的第一个元素。
   8. 如果 state.strategy 被设为 "compression"，则在 output 中将 termInfo.termId 的值映射到 outputValues。否则，在 output 中将 termInfo.term 的值映射到 outputValues。
9. 将 result 设为空映射。
10. 将 result.state 设为 state，并将 result.output 设为 output。
11. 返回 result。

此算法以映射 state、activeContext、termInfo 以及 值 value 和 termType 作为输入。 它返回一个包含映射 state 和 output 的 result 对象。

1. 如果 value 是 null，则返回 null。
2. 如果 state.strategy 被设为 "compression"，则将 output 设为 把 state、termType、 termInfo 和 value 传递给 5.2.5.2 为压缩转换值算法所得的结果。
3. 否则，将 output 设为把 state、 termType、 termInfo 和 value 传递给 5.2.6.2 为解压缩转换值算法所得的结果。
4. 如果 output 已定义，则返回 result，即一个包含 state 和 output 的映射。
5. 如果 value 是数组：
   1. 将 outputs 设为空数组。
   2. 对于 value 中的 element：
      1. 令 result 为 5.2.4 转换值算法的结果， 并传入 activeContext、state、 termInfo、termType 以及作为 value 的 element。将 state 设为 result.state，并将 result.output 添加到 outputs。
   3. 将 result 设为空映射。将 result.state 设为 state，并将 result.output 设为 outputs。
   4. 返回 result。
6. 将 output 设为空映射。
7. 将 result 设为 5.2.3 通用转换算法的结果，并传入 state、 activeContext、作为 input 的 value，以及 output。
8. 返回 result。

本节中的算法定义了 "compression" 策略， 该策略将与前面定义的“转换”算法一起使用， 以将 JSON-LD 转换为 CBOR-LD。

本节中的算法定义了 "decompression" 策略， 该策略将与前面定义的“转换”算法一起使用， 以将 CBOR-LD 转换为 JSON-LD。

此算法以映射 previousActiveContext 和 termMap 作为输入，并返回映射 activeContext。它会更新正在使用的 活动上下文，并查找 '@type' 的所有别名。

1. 将 activeContext 设为一个新映射。
2. 将 activeContext.previousActiveContext 设为 previousActiveContext。
3. 将 activeContext.termMap 设为 termMap。
4. 将 activeContext.typeTerms 设为数组 ['@type']。
5. 对于 termMap 中的 [term, def]：
   1. 如果 def 中 "@id" 的值是 "@type"，则将 term 添加到 activeContext.typeTerms。
6. 返回 activeContext。

此算法以映射 state、activeContext 和 input 作为输入，并 返回一个包含映射 state 和 activeContext 的映射 result。

1. 将 termMapUpdateResult 设为把 state、 作为 activeTermMap 的 activeContext.termMap，以及 input 中 '@context' 的值作为 contexts 传递给 5.3.5 更新术语 映射算法所得的结果。
2. 将 state 设为 termMapUpdateResult.state。
3. 将 termMap 设为 termMapUpdateResult.activeTermMap。
4. 将 newActiveContext 设为 5.3.1 初始化活动上下文算法的结果， 并传入 termMap 以及作为 previousActiveContext 的 activeContext。
5. 将 result 设为一个新映射，并将 result.activeContext 设为 newActiveContext，并将 result.state 设为 state。
6. 返回 result。

此算法以映射 state、activeContext 和字符串 term 作为输入，并 返回一个包含映射 state 和 activeContext 的映射 result。

1. 将 revertedTermMap 设为 5.3.6 还原术语映射算法的结果， 并传入 activeContext。
2. 将 termDef 设为 activeContext.termMap 中 term 的值。将 contexts 设为 termDef 中 "@context" 的值。
3. 将 termMapUpdateResult 设为把 state、 作为 activeTermMap 的 revertedTermMap，作为 propertyScope 的 true，以及 contexts 传递给 5.3.5 更新术语 映射算法所得的结果。
4. 将 state 设为 termMapUpdateResult.state。
5. 将 termMap 设为 termMapUpdateResult.activeTermMap。
6. 将 newActiveContext 设为 5.3.1 初始化活动上下文算法的结果， 并传入 termMap 以及作为 previousActiveContext 的 activeContext。
7. 将 result 设为一个新映射，并将 result.activeContext 设为 newActiveContext，并将 result.state 设为 state。
8. 返回 result。

此算法以映射 state、activeContext 和集合 objectTypes 作为输入，并 返回一个包含映射 state 和 activeContext 的映射 result。

1. 将 objectTypesSorted 设为空数组。
2. 按字典序排序 objectTypes 的元素，并按顺序将这些元素添加到 objectTypesSorted。
3. 将 newTermMap 设为 activeContext.termMap。
4. 对于 objectTypesSorted 中的 type：
   1. 将 typeDef 设为 newTermMap 中 type 的值。 将 contexts 设为 typeDef 中 "@context" 的值。
   2. 将 termMapUpdateResult 设为把 state、 作为 activeTermMap 的 newTermMap、contexts 以及作为 typeScope 的 true 传递给 5.3.5 更新术语映射算法所得的结果。
   3. 将 state 设为 termMapUpdateResult.state，并将 newTermMap 设为 termMapUpdateResult.activeTermMap。
5. 将 newActiveContext 设为 5.3.1 初始化活动上下文算法的结果， 并传入作为 termMap 的 newTermMap 以及作为 previousActiveContext 的 activeContext。
6. 将 result 设为一个新映射，并将 result.activeContext 设为 newActiveContext，并将 result.state 设为 state。
7. 返回 result。

此算法以映射 state、activeTermMap 和映射或数组 contexts，以及布尔值 typeScope 和 propertyScope 作为输入；若未提供，这两个布尔值都默认为 false。它返回映射 state 和 activeTermMap。

1. 如果 contexts 不是数组，则将 contexts 设为一个数组，其唯一元素为 contexts 之前的值。
2. 将 allowProtectedOverride 设为 propertyScope 的值。
3. 将 propagateDefault 设为 typeScope 的值的否定。
4. 对于 contexts 中的 contextIdentifier：
   1. 将 loadResult 设为 5.4.2 加载上下文算法的结果，并传入 state 和 contextIdentifier。
   2. 将 entry 设为 loadResult.entry， 将 context 设为 entry.context，并将 state 设为 loadResult.state。
   3. 如果 @propagate 出现在 context 中，则将 propagate 设为 context 中 @propagate 的值。 否则，将 propagate 设为 propagateDefault 的值。
   4. 将 newTermMap 设为空映射。对于 entry.termMap 中的 [key, value]：
      1. 将 value 的内容浅拷贝到一个新映射 newValue 中，并将 propagate 添加到 newValue。
      2. 将 newTermMap 中 key 的值设为 newValue。
   5. 对于 activeTermMap 中的 [term, activeDef]：
      1. 令 def 为 newTermMap 中 term 的值。
      2. 如果 def 已定义：
         1. 如果 activeDef 中 protected 的值为 true：
            1. 如果 allowProtectedOverride 被设为 false，并且 def 与 activeDef 不完全相同， 则抛出错误 ERR_PROTECTED_TERM_REDEFINITION。
            2. 否则，将 newTermMap 中 term 的值设为一个映射，该映射包含来自 activeDef 的值，并将 propagate 设为 def.propagate 的值。
      3. 否则，如果 term 出现在 context 中，则将 newTermMap 中 term 的值设为 一个包含来自 activeDef 的所有值的映射。
   6. 将 activeTermMap 的值设为 newTermMap 的值。
5. 将 result 设为空映射。
6. 将 result.state 设为 state，并将 result.activeTermMap 设为 activeTermMap。
7. 返回 result。

此算法以映射 activeContext 作为输入，并返回映射 newTermMap。

1. 将 newTermMap 设为空映射。
2. 将 nonPropagatingTerms 设为空数组。
3. 对于 activeContext 中的 [term, def]：
   1. 如果 def.propagate 被设为 false，则将 term 添加到 nonPropagatingTerms， 并进入此循环的下一次迭代。
   2. 否则，将 newTermMap 中 term 的值设为 def。
4. 对于 nonPropagatingTerms 中的 term：
   1. 将 currentContext 设为 activeContext.previousActiveContext。
   2. 将 def 设为 currentContext.termMap 中 term 的值。
   3. 当 def 未定义且 def.propagate 被设为 false 时：
      1. 将 currentContext 设为 activeContext.previousActiveContext。
      2. 将 def 设为 currentContext.termMap 中 term 的值。
   4. 如果 def 未定义，则将 newTermMap 中 term 的值设为 def。
5. 返回 newTermMap。

此算法接收并返回映射 state。

1. 将 state.contextMap 设为一个新映射。
2. 将 state.nextTermId 设为 100。
3. 将 state.keywordsMap 设为以下 JSON-LD 关键词到其关联 整数值的映射：

   {
     '@context' => 0,
     '@type' => 2,
     '@id' => 4,
     '@value' => 6,
     '@direction' => 8,
     '@graph' => 10,
     '@included' => 12,
     '@index' => 14,
     '@json' => 16,
     '@language' => 18,
     '@list' => 20,
     '@nest' => 22,
     '@reverse' => 24,
     '@base' => 26,
     '@container' => 28,
     '@default' => 30,
     '@embed' => 32,
     '@explicit' => 34,
     '@none' => 36,
     '@omitDefault' => 38,
     '@prefix' => 40,
     '@preserve' => 42,
     '@protected' => 44,
     '@requireAll' => 46,
     '@set' => 48,
     '@version' => 50,
     '@vocab' => 52,
     '@propagate' => 54
   }

4. 将 state.keywordsMap 中的每个条目添加到 state.termToId。
5. 如果 state.strategy 被设为 "decompression"，则将 state.idToTerm 设为 state.termToId 的反向映射 （即从整数到 JSON-LD 关键词的映射）。
6. 返回 state。

此算法以映射 state 和上下文映射或 URL contextIdentifier 作为输入，并返回 result，即一个包含映射 state 和 entry 的映射。

1. 如果 state.contextMap 有 contextIdentifier 的条目：
   1. 将 result 初始化为空映射。
   2. 将 result.state 设为 state。
   3. 将 result.entry 设为 state.contextMap 中 contextIdentifier 的值。
   4. 返回 result。
2. 如果 context 是字符串：
   1. 获取关联的上下文对象，并将 context 设为 该对象中 "@context" 的值。
   2. 将 contextUrl 设为 contextIdentifier 的值。
3. 否则，将 context 设为 contextIdentifier。
4. 将 result 设为 5.4.3 添加上下文算法的结果，并传入 state、context，以及如果已设置则传入 contextUrl。
5. 返回 result。

此算法以映射 state、上下文对象 context 和上下文 URL contextUrl 作为输入，并返回 result，即一个包含映射 state 和 entry 的映射。

1. 如果 context 有条目 "@import"：
   1. 将 importUrl 设为 `context 中 "@import" 的值。
   2. 如果 state.contextMap 没有 importUrl 的条目：
      1. 获取与 importUrl 关联的上下文对象，并将 importContext 设为该对象中 "@context" 的值。
      2. 将 importedContextAdditionResult 设为 5.4.3 添加上下文算法的结果， 并传入 state、作为 context 的 importContext， 以及作为 contextUrl 的 importUrl。
      3. 将 state 设为 importedContextAdditionResult.state，并将 importEntry 设为 importedContextAdditionResult.entry。
   3. 否则，将 importEntry 设为 state.contextMap 中 importUrl 的值。
   4. 将 context 设为一个包含来自 context 的所有条目以及 importEntry.context 的映射。
2. 将 termMap 设为空映射。
3. 将 entry 设为一个包含 context 和 termMap 的对象。
4. 将 sortedTerms 设为按字典序排序 context 中键所得的结果。
5. 如果 "@protected" 在 context 中有条目，则将 isProtected 设为 true，否则设为 false。
6. 对于 sortedTerms 中的 term：
   1. 如果 term 在 state.keywordsMap 中有条目，则进入此循环的下一次 迭代。
   2. 将 definition 设为 context 中 term 的值。
   3. 如果 definition 是 null，则进入此循环的下一次 迭代。
   4. 如果 definition 是字符串：
      1. 将 newDefinition 设为空映射。
      2. 将 newDefinition 中 "@id" 的值设为 definition。
      3. 将 definition 的值设为 newDefinition。
   5. 将 definition 中 protected 的值设为 isProtected。
   6. 将 termMap 中 term 的值设为 definition。
   7. 如果 term 在 state.termToId 中没有条目：
      1. 将 termId 设为 state.nextTermId。
      2. 将 state.nextTermId 增加 2。
      3. 将 state.termToId 中 term 的值设为 termId。
      4. 将 state.idToTerm 中 termId 的值设为 term。
7. 如果 contextUrl 已定义，则将 state.contextMap 中 contextUrl 的值设为 entry。
8. 否则，将 state.contextMap 中 context 的值 设为 entry。
9. 将 result 设为空映射。
10. 将 result.state 设为 state，并将 result.entry 设为 entry。
11. 返回 result。

1. 将 registryEntryBytes 设为 registryEntryID 的 CBOR 编码
2. 将 prefix 设为把 registryEntryBytes 追加到 字节字符串 0xD9CB1D82 末尾所得的结果。
3. 返回 prefix。

此算法以已编码的 CBOR-LD 载荷 cborldBytes 作为输入，并返回 suffix（要解码的主要数据）以及 应用于解压缩 suffix 的 registryEntryId 值。

1. 如果 cborldbytes 上的 CBOR 标签不是 0xCB1D（标签值 51997）， 则抛出 ERR_NON_CBOR_LD_TAG 错误。
2. 如果被标记的项不是一个包含两个元素且第一个元素是 CBOR 整数的数组， 则抛出 ERR_INVALID_PAYLOAD_STRUCTURE 错误。
3. 将 registryEntryId 的值设为被标记 数组索引 0 处整数的值。
4. 将 suffix 的值设为该数组第二个元素的值。
5. 将 result 设为空映射。
6. 将 result.suffix 设为 suffix 的值，并将 result.registryEntryId 设为 registryEntryId 的值。
7. 返回 result。