CBOR-LD 1.0

摘要

CBOR 是一种紧凑的二进制数据序列化和消息传递格式。本规范定义了 CBOR-LD 1.0，这是一种基于 CBOR 的关联数据序列化格式。该编码旨在利用现有的 JSON-LD 生态系统，该生态系统目前已部署在数亿个系统中，从而为寻求高效编码方案的关联数据提供一种紧凑的序列化格式。通过采用语义压缩方案，可以实现比通用压缩方案高出 60% 以上的压缩率。此格式主要旨在提供一种在存储空间和带宽受限的编程环境中使用关联数据的方式，以构建可互操作的语义线级协议，并在基于 CBOR 的存储引擎中高效存储关联数据。

编解码器标识符	编解码器	在默认处理模型中绑定到的类型
`url`	URL 编解码器	`url`
`xsd-date`	XSD Date 编解码器	`http://www.w3.org/2001/XMLSchema#date`
`xsd-date-time`	XSD DateTime 编解码器	`http://www.w3.org/2001/XMLSchema#dateTime`
`multibase`	Multibase 编解码器	`https://w3id.org/security#multibase`

在本节中，我们规定将 JSON-LD 转换为 CBOR-LD 以及反向转换所需的算法。本节中的大多数算法都与语义压缩功能有关；当 CBOR-LD 载荷不使用语义压缩时，这些算法不会用于 CBOR-LD 与 JSON-LD 之间的转换。

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

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

此算法接受一个 CBOR-LD 载荷 cborldBytes，并返回一个 JSON-LD 文档 jsonldDocument。

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

本节中的算法描述了用于抽象地在数据形式之间转换输入的“转换器”的行为。当与“策略”结合使用时，例如本节后面定义的“压缩”和“解压缩”策略，可以实例化这些算法以在具体的数据形式之间进行转换。 “压缩”策略从 JSON-LD 转换为 CBOR-LD，而“解压缩” 策略从 CBOR-LD 转换为 JSON-LD。

此算法接受并返回一个映射 state。

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

此算法接受映射 state 和一个映射或映射数组 inputDocuments，并分别返回一个映射或映射数组 outputMaps。

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

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

如果 state.strategy 设置为 "compression"：
1. 将 contextConversionResult 设置为 6.2.5.1 用于压缩的上下文转换算法的结果，并传递 state、activeContext、input 和 output。
2. 将 activeContext 设置为 contextConversionResult.activeContext，将 output 设置为 contextConversionResult.output，并将 state 设置为 contextConversionResult.state。
否则，将 activeContext 设置为 result.activeContext，将 output 设置为 result.output，并将 state 设置为 result.state，其中 result 是 6.2.6.1 用于解压缩的上下文转换算法的结果，并传递 state、 activeContext、input 和 output。
如果 state.strategy 设置为 "compression"，则将 objectTypes 设置为 6.2.5.4 获取用于压缩的对象类型算法的结果，并传递 activeContext 和 input。
否则，将 objectTypes 设置为 6.2.6.4 获取用于解压缩的对象类型算法的结果，并传递 state、activeContext 和 input。
将 activeContext 设置为把 activeContext 和 objectTypes 传递给 6.3.4 应用类型作用域上下文算法所得的结果。
如果 state.strategy 设置为 "compression"，则将 termEntries 设置为 6.2.5.3 获取用于压缩的输入条目算法的结果，并传递 state、 input 和 activeContext。
否则，将 termEntries 设置为 6.2.6.3 获取用于解压缩的输入条目算法的结果，并传递 state、input、output 和 activeContext。
对于 termEntries 中的 [termInfo, value]：
1. 将 term 设置为 termInfo.term。
2. 将 valueActiveContext 设置为把 activeContext 和 term 传递给 6.3.3 应用属性作用域上下文算法所得的结果。
3. 将 plural 设置为 termInfo.plural 的值，并将 termType 设置为 termInfo.def 中 @type 的值。
4. 如果 plural 设置为 true，则将 values 设置为 value 的值。否则，将 values 设置为一个仅包含 value 值作为单个元素的数组。
5. 将 outputs 设置为空数组。
6. 对于 values 中的 unconvertedValue：
  1. 将 result 设置为 6.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。
将 result 设置为空映射。
将 result.state 设置为 state，并将 result.output 设置为 output。
返回 result。

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

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

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

此算法接受映射 state、activeContext、input 和 output，并返回一个包含映射 output、state 和 activeContext 的映射 result。

将 applyEmbeddedResult 设置为 6.3.2 应用嵌入上下文算法的结果，并传递 state、activeContext 和 input。
将 activeContext 设置为 applyEmbeddedResult.activeContext，并将 state 设置为 applyEmbeddedResult.state。
如果 input 中没有 "@context" 条目：
1. 将 result 设置为空映射。
2. 将 result.state 设置为 state，并将 result.activeContext 设置为 activeContext。
3. 返回 result。
将 context 设置为 input 中 "@context" 的值。
将 encodedContexts 设置为空数组。
如果 context 是数组，则将 isArray 设置为 true，并将 contexts 设置为 context。否则，将 isArray 设置为 false，并将 contexts 设置为 [context]。
对于 contexts 中的 contextValue：
1. 将 encoderData 设置为 6.5.1.1 创建上下文编码器的结果，并传递 state.typeTable 和 contextValue。
2. 如果 encoderData 是空映射，则将 contextValue 添加到 encodedContexts。
3. 否则，将 encoderData 的值添加到 encodedContexts。
如果 isArray 为 true，则将 id 设置为 state.keywordsMap 中 "@context" 的值加 1，并将 output 中 id 的值设置为 encodedContexts。
否则，将 id 设置为 state.keywordsMap 中 "@context" 的值，并将 output 中 id 的值设置为 encodedContexts 的第一个元素。
将 result.output 设置为 output，将 result.state 设置为 state，并将 result.activeContext 设置为 activeContext。
返回 result。

此算法接受映射 state 和 termInfo，以及值 valueToEncode 和 termType，并返回映射 encoderData。

如果 valueToEncode 是对象，则返回。
否则，将 result 设置为 6.5.2.1 创建值编码器的结果，并传递 state、termInfo、valueToToEncode 和 termType。
返回 result。

此算法接受映射 state、activeContext 和 input，并返回数组 entries。

将 entries 初始化为空数组。
将数组 keys 设置为 input 的键，并按字典顺序排序。
对于 keys 中的 key：
1. 如果 key 是 "@context"，则继续。
2. 将 value 设置为 input 中 key 的值。
3. 如果 value 是数组，则将 plural 设置为 true。否则，将 plural 设置为 false。
4. 如果 key 在 state.termToId 中没有条目，则将 termId 设置为 key。
5. 否则，如果 plural 为 true，则将 termId 设置为 state.termToId 中 key 的值加 1。
6. 否则，将 termId 设置为 state.termToId 中 key 的值。
7. 如果 activeContext.termMap 中有 key 的条目，则将 definition 设置为 activeContext.termMap 中 key 的值。否则，将 definition 设置为空映射。
8. 将 entryTerm 设置为新映射。
9. 将 entryTerm 中 "term" 的值设置为 key 的值。将 entryTerm 中 "def" 的值设置为 definition 的值。将 termId 和 plural 添加到 entryTerm。
10. 创建一个包含两个元素 entryTerm 和 value 的数组 entry。
11. 将 entry 添加到 entries。
返回 entries。

此算法接受映射 activeContext 和 input，并返回集合 objectTypes。

将 objectTypes 设置为空集合。
对于 activeContext.typeTerms 中的 term：
1. 如果 term 在 input 中有条目：
  1. 将 types 设置为 input 中 term 的值。
  2. 将 types 中的每个值添加到 objectTypes。
返回 objectTypes。

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

此算法接受映射 state、activeContext、input 和 output，并返回一个包含映射 output、state 和 activeContext 的映射 result。

将 decoderData 设置为 6.5.1.3 创建上下文解码器的结果，并传递 state.reverseTypeTable。
将 contextTermId 设置为 state.keywordsMap 中 "@context" 的值。
如果 contextTermId 在 input 中有条目，则将 output 中 "@context" 的值设置为 6.5.1.4 解码上下文的结果，并传递 decoderData 和 input 中 contextTermId 的值作为 value。
将 contextTermIdPlural 设置为 contextTermId 的值加 1。
如果 contextTermIdPlural 在 input 中有条目：
1. 如果在之前的检查中 contextTermId 也在 input 中有条目，则抛出 ERR_INVALID_ENCODED_CONTEXT 错误。
2. 将 encodedContexts 设置为 input 中 contextTermIdPlural 的值。如果 encodedContexts 不是数组，则抛出 ERR_INVALID_ENCODED_CONTEXT 错误。
3. 将 contexts 设置为空数组。
4. 对于 encodedContexts 中的每个 valueToDecode，将 decoderData 和作为 value 的 valueToDecode 传递给 6.5.1.4 解码上下文所得的结果添加到 contexts。
5. 将 output 中 "@context" 的值设置为 contexts。
将 embeddedContextResult 设置为 6.3.2 应用嵌入上下文算法的结果，并传递 activeContext、作为 input 的 output 和 state。
将 result 设置为 embeddedContextResult，并将 result.output 设置为 output。返回 result。

此算法接受映射 state 和 termInfo，以及值 termType 和 valueToDecode，并返回值 decodedValue。

如果 value 是映射，则返回。
将 decoderData 设置为 6.5.2.3 创建值解码器的结果，并传递 valueToDecode、 state、termInfo 和 termType。
将 decodedValue 设置为 6.5.2.4 解码值的结果，并传递 decoderData。
返回 decodedValue。

此算法接受映射 state、activeContext 和 input，并返回数组 entries。

将 entries 初始化为空数组。
对于 input 中的键值对 key 和 value：
1. 如果 key 是 state.keywordsMap 中 "@context" 的值或该值加 1，则继续。
2. 否则，如果 key 是字符串，则将 plural 设置为 false，并将 term 设置为 key。
3. 否则：
  1. 如果 key 是奇数，则将 plural 设置为 true。否则，将 plural 设置为 false。
  2. 如果 plural 为 true，则将 term 设置为 state.idToTerm 中 key 减 1 所对应的值。如果该值没有条目，则抛出错误 ERR_UNKNOWN_CBORLD_TERM_ID。
  3. 否则，将 term 设置为 state.idToTerm 中 key 的值。如果该值没有条目，则抛出错误 ERR_UNKNOWN_CBORLD_TERM_ID。
4. 将 definition 设置为 activeContext.termMap 中 term 的值。
5. 将 entryTerm 设置为新映射。
6. 将 entryTerm 中 "termId" 的值设置为 key 的值。将 entryTerm 中 "def" 的值设置为 definition 的值。将 term 和 plural 添加到 entryTerm。
7. 创建一个包含两个元素 entryTerm 和 value 的数组 entry。
8. 将 entry 添加到 entries。
按 entries 的每个元素中 term 的值对 entries 进行排序。
返回 entries。

此算法接受映射 state、activeContext、input 作为输入，并返回集合 objectTypes。

将 objectTypes 设置为空集合。
对于 activeContext.typeTerms 中的 term：
1. 如果 term 在 state.termToId 中没有条目，则将 termId 设置为 term。
2. 否则，将 termId 设置为 state.termToId 中 term 的值。
3. 如果 input 中既不存在 termId，也不存在 termId 加 1，则继续。
4. 否则，如果 termId 存在于 input 中，则将 value 设置为 input 中 termId 的值。
5. 否则，将 value 设置为 input 中 termId 加 1 所对应的值。
6. 如果 key 是字符串，则将 plural 设置为 false，并将 term 设置为 key。
7. 否则：
  1. 如果 key 是奇数，则将 plural 设置为 true。否则，将 plural 设置为 false。
  2. 如果 plural 为 true，则将 term 设置为 state.idToTerm 中 id 减 1 所对应的值。如果该值没有条目，则抛出错误 ERR_UNKNOWN_CBORLD_TERM_ID。
  3. 否则，将 term 设置为 state.idToTerm 中 id 的值。如果该值没有条目，则抛出错误 ERR_UNKNOWN_CBORLD_TERM_ID。
8. 将 definition 设置为 activeContext.termMap 中 term 的值。
9. 将 termInfo 设置为新映射。
10. 将 entryTerm 中 "def" 的值设置为 definition 的值。将 term、termId 和 plural 添加到 termInfo。
11. 如果 value 不是数组，则将 values 设置为一个仅包含 value 作为单个元素的数组。否则，将 values 设置为 value 的值。
12. 对于 values 中的每个 value：
  1. 将 decoderData 设置为 6.5.2.3 创建值解码器的结果，并传递 value、 termInfo、state，以及作为 termType 的 "@vocab"。
  2. 如果 decoderData 存在，则将 6.5.2.4 解码值的结果（传递 decoderData）添加到 `objectTypes。
  3. 否则，将 value 添加到 objectTypes。
返回 objectTypes。

本节中的算法描述如何确定与 JSON-LD 文档关联的上下文文档中的哪些组成部分在压缩或解压缩过程中的任意时刻正在使用。这些算法包括如何在 CBOR-LD 中应用嵌入式上下文、类型作用域上下文和属性作用域上下文。这与本规范后面定义的上下文加载算法形成对比，后者描述如何构建从术语到整数的映射，而这些映射正是 CBOR-LD 压缩技术的核心。活动上下文处理算法和上下文加载算法共同规定在与 CBOR-LD 相互转换时应如何处理 JSON-LD 上下文文档。

此算法接受映射 previousActiveContext 和 termMap，并返回映射 activeContext。它更新当前正在使用的活动上下文，并查找 '@type' 的所有别名。

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

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

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

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

将 revertedTermMap 设置为 6.3.6 还原术语映射算法的结果，并传递 activeContext。
将 termDef 设置为 activeContext.termMap 中 term 的值。将 contexts 设置为 termDef 中 "@context" 的值。
将 termMapUpdateResult 设置为把 state、作为 activeTermMap 的 revertedTermMap、作为 propertyScope 的 true，以及 contexts 传递给 6.3.5 更新术语映射算法所得的结果。
将 state 设置为 termMapUpdateResult.state。
将 termMap 设置为 termMapUpdateResult.activeTermMap。
将 newActiveContext 设置为 6.3.1 初始化活动上下文算法的结果，并传递 termMap 和作为 previousActiveContext 的 activeContext。
将 result 设置为一个新映射，并将 result.activeContext 设置为 newActiveContext，将 result.state 设置为 state。
返回 result。

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

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

此算法接受映射 state、activeTermMap 和值 contexts，以及布尔值 typeScope 和 propertyScope 作为输入；如果未提供，这两个布尔值均默认为 false。它返回映射 state 和 activeTermMap。

如果 contexts 不是数组，则将 contexts 设置为一个数组，并以 contexts 之前的值作为其唯一元素。
将 allowProtectedOverride 设置为 propertyScope 的值。
将 propagateDefault 设置为 typeScope 值的逻辑非。
对于 contexts 中的 contextIdentifier：
1. 将 loadResult 设置为 6.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 的值。
将 result 设置为空映射。
将 result.state 设置为 state，并将 result.activeTermMap 设置为 activeTermMap。
返回 result。

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

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

本节中的算法定义如何构建术语与整数之间的映射，这些映射被用作 CBOR-LD 的核心压缩技术。

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

将 state.contextMap 设置为一个新映射。
将 state.nextTermId 设置为 100。

将 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
}

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

此算法接受映射 state 和上下文映射或 URL contextIdentifier，并返回 result，即一个包含映射 state 和 entry 的映射。

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

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

如果 context 中存在条目 "@import"：
1. 将 importUrl 设置为 `context 中 "@import" 的值。
2. 如果 state.contextMap 中不存在 importUrl 的条目：
  1. 获取与 importUrl 关联的上下文对象，并将 importContext 设置为该对象中 "@context" 的值。
  2. 将 importedContextAdditionResult 设置为 6.4.3 添加上下文算法的结果，并传递 state、作为 context 的 importContext，以及作为 contextUrl 的 importUrl。
  3. 将 state 设置为 importedContextAdditionResult.state，并将 importEntry 设置为 importedContextAdditionResult.entry。
3. 否则，将 importEntry 设置为 state.contextMap 中 importUrl 的值。
4. 将 context 设置为一个包含 context 中所有条目以及 importEntry.context 中所有条目的映射。
将 termMap 设置为空映射。
将 entry 设置为一个包含 context 和 termMap 的对象。
将 sortedTerms 设置为按字典顺序对 context 中的键排序所得的结果。
如果 context 中存在 "@protected" 条目，则将 isProtected 设置为 true，否则设置为 false。
对于 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。
如果 contextUrl 已定义，则将 state.contextMap 中 contextUrl 的值设置为 entry。
否则，将 state.contextMap 中 context 的值设置为 entry。
将 result 设置为空映射。
将 result.state 设置为 state，并将 result.entry 设置为 entry。
返回 result。

本节中的编解码器精确定义了 JSON-LD 中的各个值应如何转换为 CBOR，以及如何进行反向转换。它们由上一节中的算法使用，并使 CBOR-LD 能够高效地将基本类型和非基本类型编码为 CBOR。

此算法接受映射 typeTable 和值 contextValue，并返回映射 encoderData。

将 encoderData 初始化为空映射。
如果 contextValue 不是字符串，则返回。
否则，将 contextTable 设置为 typeTable 中 "context" 的值。
将 encoderData.context 设置为 contextValue，并将 encoderData.contextTable 设置为 contextTable。
返回 encoderData。

此算法接受映射 encoderData，并返回 CBOR 二进制数据。

如果 encoderData.context 在 encoderData.contextTable 中有条目，则返回 encoderData 中 encoderData.context 的值的 CBOR 编码，并将其作为主类型 0（无符号整数）对象。
否则，返回 encoderData.context 的值的 CBOR 编码，并将其作为主类型 3 （文本字符串）对象。

此算法接受映射 reverseTypeTable，并返回映射 encoderData。

将 reverseContextTable 设置为 reverseTypeTable 中 "context" 的值。
将 decoderData 初始化为空映射。
将 decoderData.reverseContextTable 设置为 reverseContextTable 的值，并返回 decoderData。

此算法接受映射 decoderData 和值 value，并返回一个值。

如果 value 不是数字，则返回 value。
否则，如果 decoderData.reverseContextTable 中有 value 的条目，则返回该条目的值。
否则，抛出错误 ERR_UNDEFINED_COMPRESSED_CONTEXT。

此算法接受映射 state 和 termInfo，以及值 termType 和 valueToEncode，并返回映射 encoderData 或 valueToEncode。

将 isUrl 设置为 false。
如果 termInfo.term 是 "@id" 或 "@type"，则将 isUrl 设置为 true。
如果 termInfo.def 中 "@id" 的值是 "@id" 或 "@type"，则将 isUrl 设置为 true。
如果 termType 是 "@id" 或 "@vocab"，则将 isUrl 设置为 true。
如果 isUrl 为 true，则将 tableType 设置为 "url"。
否则，如果 termType 已定义，则将 tableType 设置为 termType。
否则，将 tableType 设置为 "none"。
如果 state.typeTable 中有 tableType 的条目：
1. 将 subTable 设置为 state.typeTable 中 tableType 的值。
2. 如果 subTable 中有 valueToEncode 的条目：
  1. 将 intValue 设置为 subTable 中 valueToEncode 的值。将 includeSign 设置为 false。
  2. 如果 state.typesEncodedAsBytes 中有 tableType 的条目，则将 convertToBytes 设置为 true。否则，将 convertToBytes 设置为 false。
3. 否则，如果 tableType 不是 "none" 且 valueToEncode 是整数：
  1. 将 intValue 设置为 valueToEncode 的值。
  2. 将 convertToBytes 和 includeSign 设置为 true。
4. 如果 intValue 已定义：
  1. 将 encoderData 初始化为空映射。
  2. 将 encoderData.intValue 设置为 intValue 的值，将 encoderData.convertToBytes 设置为 convertToBytes 的值，并将 encoderData.includeSign 设置为 includeSign 的值。
  3. 返回 encoderData。
如果 tableType 在 state.processingModeTypeEncoders 中有条目，则将 encoderData 设置为调用与该条目的编解码器关联的 Create Encoder 算法所得的结果。
如果 encoderData 已定义，则返回 encoderData。
返回 valueToEncode。

此算法接受映射 encoderData，并返回 CBOR 二进制数据。

如果 encoderData.convertToBytes 为 true：
1. 将 bytes 设置为把 intValue 转换为字节所得的结果，使用 includeSign 的值来确定该整数的二进制表示应为有符号还是无符号。
2. 返回 bytes 的 CBOR 编码，并将其作为主类型 2（字节字符串）对象。
否则，返回 intValue 的 CBOR 编码，并将其作为主类型 0（无符号整数）对象。

此算法接受映射 state 和 termInfo，以及值 termType 和 valueToDecode，并返回映射 decoderData。

将 isUrl 设置为 false。
如果 termInfo.term 是 "@id" 或 "@type"，则将 isUrl 设置为 true。
如果 termInfo.def 中 "@id" 的值是 "@id" 或 "@type"，则将 isUrl 设置为 true。
如果 termType 是 "@id" 或 "@vocab"，则将 isUrl 设置为 true。
如果 isUrl 为 true，则将 tableType 设置为 "url"。
否则，如果 termType 已定义，则将 tableType 设置为 termType。
否则，将 tableType 设置为 "none"。
如果 state.reverseTypeTable 中有 tableType 的条目：
1. 将 subTable 设置为 state.reverseTypeTable 中 tableType 的值。
2. 将 useTable 设置为 false。
3. 如果 valueToDecode 是字节数组，并且 state.typesEncodedAsBytes 中有 tableType 的条目：
  1. 将 useTable 设置为 true。
  2. 将 intValue 设置为 valueToDecode 字节转换为无符号整数所得的结果。
4. 否则，如果 valueToDecode 是整数，并且 state.typesEncodedAsBytes 中没有 tableType 的条目：
  1. 将 useTable 设置为 true。
  2. 将 intValue 设置为 valueToDecode。
5. 如果 useTable 为 true：
  1. 如果 intValue 不在 subTable 中，则抛出错误 ERR_UNKNOWN_COMPRESSED_VALUE。
  2. 否则，将 decoded 设置为 subTable 中 intValue 的值。
6. 否则，如果 valueToDecode 是字节数组且 tableType 不是 "none"，则将 decoded 设置为 valueToDecode 转换为整数所得的结果。
7. 如果 decoded 已定义，则将 decoderData 初始化为空映射，将 decoderData.decoded 设置为 decoded 的值，并返回 decoderData。
如果 tableType 在 state.processingModeTypeDecoders 中有条目，则将 DecoderData 设置为调用与该条目的编解码器关联的 Create Decoder 算法所得的结果。
如果 decoderData 已定义，则返回 decoderData。
否则，如果 valueToDecode 不是数组，则将 decoderData 初始化为空映射，将 decoderData.decoded 设置为 valueToDecode，并返回 decoderData。

此算法接受映射 decoderData，并返回一个值。

返回 decoderData.decoded。

URL 编解码器根据值的前缀压缩 URL 值，其中前缀是 URL 前缀表中最长的匹配条目。URL 被编码为数组，其中第一个整数标识 URL 的前缀。编解码器首先检查该值是否与已知的 JSON-LD 术语标识符匹配，如果匹配，则将其编码为一个简单整数。否则，它会根据值的前缀委托给以下特定于前缀的子编解码器之一。

URL 前缀表将 URL 前缀映射到其关联的压缩整数标识符。使用 URL 编解码器的实现必须使用下表。URL 前缀反向表是此表的反向映射（即从整数到 URL 前缀字符串的映射）。

URL 前缀	整数标识符
`http://`	1
`https://`	2
`urn:uuid:`	3
`data:`	4
`did:v1:nym:`	1024
`did:key:`	1025

此算法接受映射 state、映射 termInfo 和字符串 valueToEncode，并返回编码器对象或 undefined。

如果 valueToEncode 不是字符串，则抛出 ERR_UNSUPPORTED_JSON_TYPE 错误。
将 termId 设置为在 state.termToId 中查找 valueToEncode 所得的结果。
如果 termId 是整数，则返回一个编码器，该编码器在通过 6.5.3.3 编码 URL 调用时，将 termId 编码为主类型 0（无符号整数）CBOR 项。
尝试将 valueToEncode 解析为 URL。如果解析失败（即该值不是有效的 URL），则返回 undefined。
将 prefix 设置为 URL 前缀表中的条目，使得 valueToEncode 以 prefix 开头，并且 valueToEncode 中紧随 prefix 之后的其余部分不包含 ":"（U+003A 冒号）字符。如果不存在这样的条目，则返回 undefined（意味着此 URL 无法压缩）。
如果 prefix 是 "https://" 或 "http://"，则返回 6.5.3.6.1 创建 HTTP URL 编码器的结果，并传入 valueToEncode。
如果 prefix 是 "urn:uuid:"，则返回 6.5.3.7.1 创建 UUID URN 编码器的结果，并传入 valueToEncode。
如果 prefix 是 "data:"，则返回 6.5.3.8.1 创建 Data URL 编码器的结果，并传入 valueToEncode。
如果 prefix 是 "did:v1:nym:" 或 "did:key:"，则返回 6.5.3.9.1 创建 Base58 DID URL 编码器的结果，并传入 valueToEncode。
返回 undefined（意味着此 URL 无法压缩）。

此算法接受由 6.5.3.2 创建 URL 编码器生成的编码器对象，并返回 CBOR 二进制数据。

如果编码器是针对术语 ID 匹配创建的（ 6.5.3.2 创建 URL 编码器的第 3 步），则返回 termId 的 CBOR 编码，并将其作为主类型 0（无符号整数）对象。
否则，调用相应的特定于前缀的子编码器的 encode 方法，并返回生成的 CBOR 二进制数据。

此算法接受映射 state、映射 termInfo 和值 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 是字符串，则返回 undefined （意味着该值已经是未压缩的 URL 字符串；直接传递）。
如果 valueToDecode 是数组：
1. 将 prefixId 设置为 valueToDecode 的第一个元素。
2. 将 prefix 设置为 URL 前缀反向表中与 prefixId 对应的值。
3. 如果 prefix 是 "http://" 或 "https://"，则将 decoder 设置为 6.5.3.6.3 创建 HTTP URL 解码器的结果，并传入 valueToDecode。
4. 否则，如果 prefix 是 "urn:uuid:"，则将 decoder 设置为 6.5.3.7.3 创建 UUID URN 解码器的结果，并传入 valueToDecode。
5. 否则，如果 prefix 是 "data:"，则将 decoder 设置为 6.5.3.8.3 创建 Data URL 解码器的结果，并传入 valueToDecode。
6. 否则，如果 prefix 是 "did:v1:nym:" 或 "did:key:"，则将 decoder 设置为 6.5.3.9.4 创建 Base58 DID URL 解码器的结果，并传入 valueToDecode。
7. 如果 prefix 与以上任何一项都不匹配（包括 prefixId 在 URL 前缀反向表中没有条目的情况），或者 decoder 为 undefined（意味着子解码器拒绝了 valueToDecode 的结构），则抛出 ERR_UNKNOWN_COMPRESSED_VALUE 错误。
8. 返回 decoder。
如果 valueToDecode 是整数，则将 term 设置为在 state.idToTerm 中查找 valueToDecode 所得的结果，并返回一个解码器，其 6.5.3.5 解码 URL 调用返回 term。
返回 undefined。

此算法接受由 6.5.3.4 创建 URL 解码器生成的解码器对象，并返回字符串值。

如果解码器是针对整数术语 ID 值创建的（ 6.5.3.4 创建 URL 解码器的第 3 步），则返回关联的 term 字符串。
否则，调用相应的特定于前缀的子解码器的 decode 方法，并返回生成的字符串。

HTTP URL 编解码器处理前缀为 http:// 或 https:// 的值。编码后的 HTTP URL 表示为双元素 CBOR 数组 [prefixId, remainder]，其中 prefixId 是 URL 前缀表中的整数，而 remainder 是 URL 去除前缀后的部分，以文本字符串表示。

此算法接受字符串 value，并返回编码器对象或 undefined。

如果 value 以 "https://" 开头，则将 prefix 设置为 "https://"。
否则，如果 value 以 "http://" 开头，则将 prefix 设置为 "http://"。
否则，返回 undefined。
返回包含 value 和 prefix 的编码器对象。

此算法接受来自 6.5.3.6.1 创建 HTTP URL 编码器的编码器对象，并返回 CBOR 二进制数据。

将 prefixId 设置为 URL 前缀表中 encoderData.prefix 的值。
将 rest 设置为 encoderData.value 中从 encoderData.prefix 之后开始的子字符串。
返回双元素数组 [prefixId, rest] 的 CBOR 编码：主类型 4（数组），包含一个主类型 0（无符号整数）项，后跟一个主类型 3 （文本字符串）项。

此算法接受 CBOR 数组 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 恰好有两个元素，并且第二个元素是文本字符串：
1. 将 prefix 设置为 URL 前缀反向表中 valueToDecode[0] 的值。
2. 返回包含 prefix 的解码器对象。
否则，返回 undefined。

此算法接受来自 6.5.3.6.3 创建 HTTP URL 解码器的解码器对象和 CBOR 数组 valueToDecode，并返回字符串。

返回 decoderData.prefix 与 valueToDecode[1] 拼接后的结果。

UUID URN 编解码器处理前缀为 urn:uuid: 的值。编码后的 UUID URN 是一个双元素 CBOR 数组 [3, uuidValue]，其中 uuidValue 可以是表示 UUID 二进制形式的 16 字节主类型 2（字节字符串）（当 UUID 字符串全部为小写时），也可以是包含 UUID 原始值的主类型 3（文本字符串）（当大小写无法通过二进制形式往返还原时）。

此算法接受字符串 value，并返回编码器对象或 undefined。

如果 value 不以 "urn:uuid:" 开头，则返回 undefined。
返回包含 value 的编码器对象。

此算法接受编码器对象，并返回 CBOR 二进制数据。

将 prefixId 设置为 3（即 URL 前缀表中 "urn:uuid:" 的条目）。
将 rest 设置为 encoderData.value 中从 "urn:uuid:" 之后开始的子字符串。
如果 rest 不包含大写字符（即它与其小写形式相等）：
1. 将 uuidBytes 设置为通过按照 [RFC4122] 解析 rest 获得的 UUID 的 16 字节二进制表示。如果 rest 无法解析为有效的 UUID，则抛出错误并且编码失败。
2. 返回双元素数组 [3, uuidBytes] 的 CBOR 编码：主类型 4（数组），包含一个主类型 0（无符号整数）项，后跟一个长度为 16 的主类型 2 （字节字符串）项。
否则，返回双元素数组 [3, rest] 的 CBOR 编码：主类型 4（数组），包含一个主类型 0（无符号整数）项，后跟一个主类型 3 （文本字符串）项。

此算法接受 CBOR 数组 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 恰好有两个元素，并且第二个元素是字节字符串或文本字符串，则返回解码器对象。
否则，返回 undefined。

此算法接受解码器对象和 CBOR 数组 valueToDecode，并返回字符串。

如果 valueToDecode[1] 是文本字符串，则将 uuid 设置为 valueToDecode[1]。
否则，将 uuid 设置为按照 [RFC4122] 得到的 16 字节二进制值 valueToDecode[1] 的 UUID 字符串表示（小写、以连字符分隔的形式）。
返回 "urn:uuid:" 与 uuid 拼接后的结果。

Data URL 编解码器处理前缀为 data: 的值（data URL，如 [RFC2397] 中所定义）。 Base64 编码的 data URL （匹配 data:<mediatype>;base64,<data>）被编码为三元素 CBOR 数组 [4, mediatype, dataBytes]。非 base64 data URL 被编码为双元素 CBOR 数组 [4, rest]，其中 rest 是 URL 中 "data:" 之后的部分。

此算法接受字符串 value，并返回编码器对象或 undefined。

如果 value 不以 "data:" 开头，则返回 undefined。
尝试用正则表达式 ^data:(?<mediatype>.*);base64,(?<data>.*)$ 匹配 value，其中每个 .* 都是贪婪的（即，如果字符串 ";base64," 出现多次，则 mediatype 组扩展到最后一次出现的位置）。
如果匹配成功：
1. 将 data 设置为 data 捕获组的值。
2. 验证往返完整性：将 data 从 base64 解码，然后再重新编码为 base64。如果结果等于 data，则返回一个编码器对象，其中 value 和 base64 被设置为 true。
返回一个编码器对象，其中 value 和 base64 被设置为 false。

此算法接受来自 6.5.3.8.1 创建 Data URL 编码器的编码器对象，并返回 CBOR 二进制数据。

将 prefixId 设置为 4（即 URL 前缀表中 "data:" 的条目）。
如果 encoderData.base64 为 true：
1. 解析 encoderData.value 以提取 mediatype （"data:" 与 ";base64," 之间的子字符串）和 dataBytes（base64 数据部分的二进制解码结果）。
2. 返回三元素数组 [prefixId, mediatype, dataBytes] 的 CBOR 编码：主类型 4（数组），包含一个主类型 0 整数、一个主类型 3 文本字符串和一个主类型 2 字节字符串。
否则：
1. 将 rest 设置为 encoderData.value 中从 "data:" 之后开始的子字符串。
2. 返回双元素数组 [prefixId, rest] 的 CBOR 编码：主类型 4（数组），包含一个主类型 0 整数和一个主类型 3 文本字符串。

此算法接受 CBOR 数组 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 恰好有三个元素，第二个元素是文本字符串，并且第三个元素是字节字符串，则返回解码器对象（base64 模式）。
否则，如果 valueToDecode 恰好有两个元素，并且第二个元素是文本字符串，则返回解码器对象（非 base64 模式）。
否则，返回 undefined。

此算法接受解码器对象和 CBOR 数组 valueToDecode，并返回字符串。

如果 valueToDecode 有三个元素（base64 模式）：
1. 将 mediatype 设置为 valueToDecode[1]。
2. 将 encodedData 设置为字节字符串 valueToDecode[2] 的 base64 编码。
3. 返回 "data:"、 mediatype、";base64," 和 encodedData 拼接后的结果。
否则（非 base64 模式），返回 "data:" 与 valueToDecode[1] 拼接后的结果。

Base58 DID URL 编解码器处理前缀为 did:v1:nym: 或 did:key: 的 DID URL，并且其 authority（以及可选的 fragment）组成部分通常是 multibase base58btc 编码字符串（即以字符 'z' 开头的字符串）。压缩后的 DID URL 被编码为双元素或三元素 CBOR 数组 [prefixId, authority] 或 [prefixId, authority, fragment]。当某个组成部分以 'z' 开头并且是有效的 base58btc 时，它会以原始字节字符串形式存储；否则以文本字符串形式存储。

注

此编解码器使用的 URL 前缀表条目是 did:v1:nym: → 1024 和 did:key: → 1025。

此算法接受字符串 value，并返回编码器对象或 undefined。

对于 URL 前缀表中前缀以 "did:" 开头的每个 [prefix, prefixId] 对：
1. 如果 value 以 prefix 开头，则返回一个包含 value、prefix 和 prefixId 的编码器对象。
返回 undefined。

此算法接受来自 6.5.3.9.1 创建 Base58 DID URL 编码器的编码器对象，并返回 CBOR 二进制数据。

将 suffix 设置为 encoderData.value 中从 encoderData.prefix 之后开始的子字符串。
在 '#' 第一次出现的位置拆分 suffix，以生成 authority 以及存在时的 fragment。
将 authorityEncoded 设置为把 Multibase Base58 到 CBOR 令牌算法应用于 authority 所得的结果。
将 entries 初始化为 [encoderData.prefixId, authorityEncoded]。
如果 fragment 已定义：
1. 将 fragmentEncoded 设置为把 Multibase Base58 到 CBOR 令牌算法应用于 fragment 所得的结果。
2. 将 fragmentEncoded 追加到 entries。
返回 entries 的 CBOR 编码，并将其作为主类型 4 （数组）。

Multibase Base58 到 CBOR 令牌算法接受字符串 str，并返回主类型 2（字节字符串）CBOR 令牌（如果该值是 base58btc multibase 字符串）或主类型 3 （文本字符串）CBOR 令牌。

如果 str 以 'z' 开头：
1. 将 decoded 设置为解码 str 的 base58btc 内容（即 str[1:]）所得的结果。
2. 如果解码成功，则返回表示 decoded 的主类型 2（字节字符串）CBOR 令牌。
返回表示 str 的主类型 3（文本字符串）CBOR 令牌。

此算法接受 CBOR 数组 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 恰好有两个或三个元素：
1. 将 prefix 设置为 URL 前缀反向表中 valueToDecode[0] 的值。
2. 返回包含 prefix 的解码器对象。
否则，返回 undefined。

此算法接受来自 6.5.3.9.4 创建 Base58 DID URL 解码器的解码器对象和 CBOR 数组 valueToDecode，并返回字符串。

将 url 设置为 decoderData.prefix。
如果 valueToDecode[1] 是字节字符串，则向 url 追加 'z'，后跟 valueToDecode[1] 的 base58btc 编码。
否则，将 valueToDecode[1] 追加到 url。
如果 valueToDecode 有两个以上的元素：
1. 如果 valueToDecode[2] 是字节字符串，则向 url 追加 "#z"，后跟 valueToDecode[2] 的 base58btc 编码。
2. 否则，向 url 追加 "#"，后跟 valueToDecode[2]。
返回 url。

XSD Date 编解码器压缩类型为 http://www.w3.org/2001/XMLSchema#date 的值。日期值表示为自 Unix 纪元（1970-01-01T00:00:00Z）以来的秒数整数，对于非负值编码为 CBOR 主类型 0（无符号整数），对于纪元之前的日期编码为主类型 1（负整数）。该编解码器仅压缩能够通过此表示完全往返转换的日期字符串；否则将逐字保留原始字符串。

注

自纪元以来的秒数值根据 UTC 午夜的日期计算（即时间点 <date>T00:00:00Z）。由于时区偏移或时间组成部分会使往返转换产生歧义，包含时间组成部分（'T'）的值不会由此编解码器压缩。

此算法接受字符串 value，并返回编码器对象或 undefined。

如果 value 包含字符 'T'（表示时间组成部分），则返回 undefined（该值改由 XSD DateTime 编解码器压缩）。
将 parsed 设置为把 value 解析为 ISO 8601 日期字符串所得的结果，并以自 Unix 纪元以来的毫秒数表示。
如果 parsed 不是有效数字，则返回 undefined。
返回包含 value 和 parsed 的编码器对象。

此算法接受来自 6.5.4.1 创建 XSD Date 编码器的编码器对象，并返回 CBOR 二进制数据。

将 secondsSinceEpoch 设置为 floor(encoderData.parsed / 1000)。
将 reconstituted 设置为自 Unix 纪元以来 secondsSinceEpoch × 1000 毫秒处时间点的 ISO 8601 字符串。
将 expectedDate 设置为 reconstituted 中第一次出现 'T' 之前的子字符串。
如果 encoderData.value 不等于 expectedDate，则压缩将是有损的。返回 encoderData.value 的 CBOR 编码，并将其作为主类型 3（文本字符串）对象。
如果 secondsSinceEpoch 大于或等于 0，则返回 secondsSinceEpoch 的 CBOR 编码，并将其作为主类型 0（无符号整数）对象。
否则，返回 secondsSinceEpoch 的 CBOR 编码，并将其作为主类型 1（负整数）对象。

此算法接受值 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 是整数（正数、负数或零），则返回解码器对象。
否则，返回 undefined。

此算法接受解码器对象和整数值 value，并返回字符串。

将 dateString 设置为自 Unix 纪元以来 value * 1000 毫秒处时间点的 ISO 8601 字符串。
返回 dateString 中第一次出现 'T' 之前的子字符串。

XSD DateTime 编解码器压缩类型为 http://www.w3.org/2001/XMLSchema#dateTime 的值。精确到秒的日期时间值被编码为自 Unix 纪元以来的单个秒数整数（主类型 0 或 1）。精确到秒以下的日期时间值被编码为双元素 CBOR 数组 [seconds, milliseconds]，两者均作为主类型 0 整数。与 XSD Date 编解码器一样，仅当压缩无损时才压缩该值（原始字符串能够通过编码完全往返转换）。

此算法接受字符串 value，并返回编码器对象或 undefined。

如果 value 不包含字符 'T'，则返回 undefined（该值改由 XSD Date 编解码器压缩）。
将 parsed 设置为把 value 解析为 ISO 8601 日期时间字符串所得的结果，并以自 Unix 纪元以来的毫秒数表示。
如果 parsed 不是有效数字，则返回 undefined。
返回包含 value 和 parsed 的编码器对象。

此算法接受来自 6.5.5.1 创建 XSD DateTime 编码器的编码器对象，并返回 CBOR 二进制数据。

将 secondsSinceEpoch 设置为 floor(encoderData.parsed / 1000)。
如果 encoderData.value 不包含字符 '.'（没有毫秒组成部分）：
1. 将 expectedDate 设置为自 Unix 纪元以来 secondsSinceEpoch * 1000 毫秒处时间点的 ISO 8601 字符串，并将子字符串 ".000Z" 替换为 "Z"。
2. 如果 encoderData.value 不等于 expectedDate，则压缩将是有损的。返回 encoderData.value 的 CBOR 编码，并将其作为主类型 3 （文本字符串）对象。
3. 如果 secondsSinceEpoch 大于或等于 0，则返回 secondsSinceEpoch 的 CBOR 编码，并将其作为主类型 0（无符号整数）对象。
4. 否则，返回 secondsSinceEpoch 的 CBOR 编码，并将其作为主类型 1（负整数）对象。
否则（存在毫秒组成部分）：
1. 将 millisecondIndex 设置为 encoderData.value 中第一个 '.' 的索引。
2. 将 milliseconds 设置为 encoderData.value 中从位置 millisecondIndex + 1 开始的数字所表示的整数值。
3. 将 expectedDate 设置为自 Unix 纪元以来 secondsSinceEpoch * 1000 + milliseconds 毫秒处时间点的 ISO 8601 字符串。
4. 如果 encoderData.value 不等于 expectedDate，则压缩将是有损的。返回 encoderData.value 的 CBOR 编码，并将其作为主类型 3 （文本字符串）对象。
5. 返回双元素数组 [secondsSinceEpoch, milliseconds] 的 CBOR 编码：主类型 4（数组），包含两个主类型 0（无符号整数）项。

此算法接受值 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 是整数，则返回解码器对象。
如果 valueToDecode 是恰好包含两个元素且两个元素都是数字的数组，则返回解码器对象。
否则，返回 undefined。

此算法接受解码器对象和值 value （整数或由两个整数组成的数组），并返回字符串。

如果 value 是整数：
1. 将 instantMs 设置为 value * 1000。
2. 将 dateString 设置为自 Unix 纪元以来 instantMs 毫秒处时间点的 ISO 8601 字符串。
3. 返回将 dateString 中的子字符串 ".000Z" 替换为 "Z" 后的结果。
否则（value 是双元素数组）：
1. 将 instantMs 设置为 value[0] * 1000 + value[1]。
2. 返回 instantMs。

Multibase 编解码器压缩类型为 https://w3id.org/security#multibase 的值。multibase 编码的字符串被转换为原始字节字符串，其第一个字节是 Multibase 前缀字节，其余字节是解码后的二进制载荷。这使得二进制载荷可以紧凑存储，而无需承担基编码字符的额外开销。

支持以下 multibase 编码：

Multibase 前缀字符	Multibase 前缀字节	编码
`z`	`0x7a`	Base58btc
`u`	`0x75`	Base64url（无填充）
`M`	`0x4d`	Base64pad

此算法接受值 value，并返回编码器对象或 undefined。

如果 value 不是字符串，则返回 undefined。
如果 value 的第一个字符是 'z'、 'u' 或 'M'，则返回包含 value 的编码器对象。
否则，返回 undefined（不支持的 multibase 编码）。

此算法接受来自 6.5.6.1 创建 Multibase 编码器的编码器对象，并返回 CBOR 二进制数据。

将 prefixChar 设置为 encoderData.value 的第一个字符。
将 prefixByte 设置为与 prefixChar 对应的 Multibase 前缀字节。
将 content 设置为 encoderData.value 中从第一个字符之后开始的子字符串。
如果 prefixChar 是 'z'，则将 suffixBytes 设置为 content 的 base58btc 解码结果。
否则，如果 prefixChar 是 'u'，则将 suffixBytes 设置为 content 的 base64url 解码结果。
否则（prefixChar 是 'M'），将 suffixBytes 设置为 content 的 base64pad 解码结果。
将 bytes 设置为长度为 1 + length(suffixBytes) 的字节数组，第一个字节设置为 prefixByte，其余字节设置为 suffixBytes。
返回 bytes 的 CBOR 编码，并将其作为主类型 2（字节字符串）对象。

此算法接受值 valueToDecode，并返回解码器对象或 undefined。

如果 valueToDecode 不是字节字符串，则返回 undefined。
如果 valueToDecode 的第一个字节是 0x7a、 0x75 或 0x4d，则返回解码器对象。
否则，返回 undefined（不支持的 multibase 前缀字节）。

此算法接受解码器对象和字节字符串 value，并返回字符串。

将 prefixByte 设置为 value 的第一个字节。
将 suffix 设置为 value 的其余字节（即第一个字节之后的所有字节）。
如果 prefixByte 是 0x7a（'z'）：
1. 返回 "z" 与 suffix 的 base58btc 编码拼接后的结果。
如果 prefixByte 是 0x75（'u'）：
1. 返回 "u" 与 suffix 的 base64url 编码（无填充）拼接后的结果。
如果 prefixByte 是 0x4d（'M'）：
1. 返回 "M" 与 suffix 的 base64pad 编码拼接后的结果。
否则，返回 value。

此算法接受整数 registryEntryId 作为输入，并返回字节字符串 prefix。

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

此算法接受编码后的 CBOR-LD 载荷 cborldBytes 作为输入，并返回要解码的主要数据 suffix，以及解压缩 suffix 时应使用的 registryEntryId 值。

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

CBOR-LD 1.0

基于 CBOR 的关联数据序列化格式

摘要

本文档的状态

1. 简介

1.1 如何阅读本文档

1.1.1 一致性

1.2 参与贡献

1.3 设计目标和理由

2. 基本概念

3. 语义压缩

4. 处理模型

4.1 默认处理模型

4.2 表示处理模型

4.2.1 编解码器标识符

4.2.2 示例：默认 处理模型

4.2.3 示例：自定义 处理模型

4.2.4 用户指定的编解码器

5. CBOR-LD 的 CBOR 标签

5.1 CBOR-LD 注册表

5.1.1 注册

6. 算法

6.1 编码和解码

6.1.1 JSON-LD 到 CBOR-LD 的编码算法

6.1.2 CBOR-LD 到 JSON-LD 的解码算法

6.2 转换算法

6.2.1 初始化转换 算法

6.2.2 转换文档算法

6.2.3 通用转换 算法

6.2.4 转换值算法

6.2.5 压缩策略 算法

6.2.5.1 用于压缩的上下文转换算法

6.2.5.2 用于压缩的值转换算法

6.2.5.3 获取用于压缩的输入条目算法

6.2.5.4 获取用于压缩的对象类型算法

6.2.6 解压缩 策略算法

6.2.6.1 用于解压缩的上下文转换算法

6.2.6.2 用于解压缩的值转换算法

6.2.6.3 获取用于解压缩的输入条目算法

6.2.6.4 获取用于解压缩的对象类型算法

6.3 活动上下文处理

6.3.1 初始化活动 上下文算法

6.3.2 应用嵌入式 上下文算法

6.3.3 应用 属性作用域上下文算法

6.3.4 应用类型 作用域上下文算法

6.3.5 更新术语映射算法

6.3.6 还原术语映射算法

6.4 上下文加载

6.4.1 初始化 上下文加载器算法

6.4.2 加载上下文算法

6.4.3 添加上下文算法

6.5 编解码器

6.5.1 上下文编解码器

6.5.1.1 创建上下文编码器

6.5.1.2 编码上下文

6.5.1.3 创建上下文解码器

6.5.1.4 解码上下文

6.5.2 值编解码器

6.5.2.1 创建值编码器

6.5.2.2 编码值

6.5.2.3 创建值解码器

6.5.2.4 解码值

6.5.3 URL 编解码器

6.5.3.1 URL 前缀表

6.5.3.2 创建 URL 编码器

6.5.3.3 编码 URL

6.5.3.4 创建 URL 解码器

6.5.3.5 解码 URL

6.5.3.6 HTTP URL 编解码器

6.5.3.6.1 创建 HTTP URL 编码器

6.5.3.6.2 编码 HTTP URL

6.5.3.6.3 创建 HTTP URL 解码器

6.5.3.6.4 解码 HTTP URL

6.5.3.7 UUID URN 编解码器

6.5.3.7.1 创建 UUID URN 编码器

6.5.3.7.2 编码 UUID URN

6.5.3.7.3 创建 UUID URN 解码器

6.5.3.7.4 解码 UUID URN

6.5.3.8 Data URL 编解码器

6.5.3.8.1 创建 Data URL 编码器

4.2.2 示例：默认处理模型

4.2.3 示例：自定义处理模型

6.2.1 初始化转换算法

6.2.3 通用转换算法

6.2.5 压缩策略算法

6.2.6 解压缩策略算法

6.3.1 初始化活动上下文算法

6.3.2 应用嵌入式上下文算法

6.3.3 应用属性作用域上下文算法

6.3.4 应用类型作用域上下文算法

6.4.1 初始化上下文加载器算法

6.6.1 获取 CBOR 标签结构算法