Copyright © 2020-2025 the Contributors to the CBOR-LD 1.0 Specification, published by the JSON for Linked Data Community Group under the W3C Community Contributor License Agreement (CLA) . A human-readable summary is available.
CBOR is a compact binary data serialization and messaging format. This specification defines CBOR-LD 1.0, a CBOR-based format to serialize Linked Data. The encoding is designed to leverage the existing JSON-LD ecosystem, which is deployed on hundreds of millions of systems today, to provide a compact serialization format for those seeking efficient encoding schemes for Linked Data. By utilizing semantic compression schemes, compression ratios in excess of 60% better than generalized compression schemes are possible. This format is primarily intended to be a way to use Linked Data in storage and bandwidth constrained programming environments, to build interoperable semantic wire-level protocols, and to efficiently store Linked Data in CBOR-based storage engines.
This specification was published by the JSON for Linked Data Community Group . It is not a W3C Standard nor is it on the W3C Standards Track. Please note that under the W3C Community Contributor License Agreement (CLA) there is a limited opt-out and other conditions apply. Learn more about W3C Community and Business Groups .
This document is experimental.
There is a reference implementation that is capable of demonstrating the features described in this document.
GitHub Issues are preferred for discussion of this specification.
This section is non-normative.
CBOR is a compact binary data serialization and messaging format. This specification defines CBOR-LD 1.0, a CBOR-based format to serialize Linked Data. The encoding is designed to leverage the existing JSON-LD ecosystem, which is deployed on hundreds of millions of systems today, to provide a compact serialization format for those seeking efficient encoding schemes for Linked Data. By utilizing semantic compression schemes, compression ratios in excess of 60% better than generalized compression schemes are possible. This format is primarily intended to be a way to use Linked Data in storage and bandwidth constrained programming environments, to build interoperable semantic wire-level protocols, and to efficiently store Linked Data in CBOR-based storage engines.
This section is non-normative.
This document is a detailed specification for a serialization of Linked Data in CBOR. The document is primarily intended for the following audiences:
As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.
The key word MUST in this document is to be interpreted as described in BCP 14 [ RFC2119 ] [ RFC8174 ] when, and only when, it appears in all capitals, as shown here.
This section is non-normative.
There are a number of ways that one may participate in the development of this specification:
This section is non-normative.
CBOR-LD satisfies the following design goals:
Similarly, the following are non-goals.
The following minefields have been identified while working on this specification:
This section is non-normative.
The general CBOR-LD encoding algorithm takes a JSON-LD Document and does the following:
"@type":
"@id"
,
replace
the
value
with
the
byte
value
associated
with
the
term.
"@type":
"@id"
,
replace
the
value
with
the
byte
value
associated
with
the
term.
The first step in decoding a CBOR-LD payload is to recreate the term codec map that was used to encode it by processing the contexts in the payload. However, the contexts needed to create the term codec map can have their URLs encoded as integers by CBOR-LD. If a CBOR-LD payload contains context URLs compressed in such a way, the consumer of the CBOR-LD needs to know what compression tables (maps from JSON-LD terms to integers) were used to compress the context URLs during creation to be able to reconstruct the term codec map. The following sections define the exact mechanism by which this can be accomplished, allowing an arbitrary CBOR-LD consumer to decompress any CBOR-LD payload that conforms to this specification.
To
this
end,
we
have
registered
the
CBOR
tag
0xCB1D
(tag
value
51997)
to
be
used
for
CBOR-LD.
The
data
that
follows
this
tag
value
is
used
to
lookup
look
up
what
compression
table(s)
are
needed
to
decompress
the
CBOR-LD
context
URLs.
This exact tag value has not yet been officially registered with the IANA CBOR Tag Registry . The exact value is subject to change.
To enable unbounded extension on possible use cases for CBOR-LD that require different compression table material for consumption while working with a single CBOR tag value, we define the following.
CBOR-LD
payloads
MUST
be
structured
such
that
the
item
tagged
with
tag
0xCB1D
is
a
two-element
array,
and
the
first
element
MUST
be
a
major
type
0
integer.
This
integer
is
a
CBOR-LD
Registry
Entry
ID.
The
value
of
the
CBOR-LD
Registry
Entry
ID
is
then
used
to
lookup
look
up
a
CBOR-LD
Registry
Entry
in
the
CBOR-LD
Registry
.
The CBOR-LD Registry is a global list that provides consumers of CBOR-LD payloads the information they need to reconstruct the term codec map required for decompression. A CBOR-LD Registry Entry contains the following:
typeTables
:
an
array
containing
what
Type
Tables
are
to
be
used
for
this
type
of
payload.
processingModel
:
what
processing
model
is
used
for
this
registry
entry.
A
processing
model
specifies
how
auto-generated
CBOR-LD
values
are
created
from
JSON-LD
contexts
as
well
as
what
type
encoders
are
used
alongside
the
Type
Tables
(e.g.
how
to
partially
compress
an
xsd:dateTime
value
that
does
not
appear
in
Type
Table
).
The
default
processing
model,
which
will
be
defined
later
in
this
specification,
will
be
used
unless
otherwise
specified
in
the
Registry
Entry.
The
typeTables
associated
with
a
CBOR-LD
Registry
Entry
MUST
be
an
array
of
or
JSON
objects.
The
only
exception
is
the
string
"callerProvidedTable",
which
may
appear
in
this
array,
denoting
that
for
this
use
case,
a
Type
Table
is
required
which
is
not
globally
defined.
Dereferencing one of these URLs MUST result in a JSON object with the following properties:
type
:
a
JSON-LD
type.
table
:
a
JSON
object
that
maps
values
of
the
above
type
to
integers.
If
a
JSON
object
is
present
in
the
typeTables
array,
it
MUST
be
in
the
above
format.
The following is the current CBOR-LD registry:
| Registry Entry Id | Use Case | Processing Model | Provisional | typeTables |
|---|---|---|---|---|
| 0 | Uncompressed CBORLD | DEFAULT | No | None |
| 1 | Compressed CBORLD, default use case. | DEFAULT | No | DEFAULT |
| 100 | Verifiable Credential Barcodes Specification Test Vectors | DEFAULT | Yes |
|
| 10001 | Provisional California DMV Credentials | DEFAULT | Yes |
|
| 10002 | Provisional First Responder Credentials | DEFAULT | Yes |
|
| 31000000 | California DL/ID Barcodes | DEFAULT | Yes |
|
This
algorithm
takes
a
map
typeTable
,
an
integer
registryEntryId
,
and
a
JSON-LD
document
jsonldDocument
as
inputs,
and
returns
a
hexadecimal
string
cborldBytes
.
prefix
to
the
result
of
passing
registryEntryId
to
4.6.1
Get
Varint
Structure
Algorithm
.
state
to
an
empty
map.
state.strategy
to
"compression".
state.typeTable
to
typeTable
.
state.registryEntryId
to
registryEntryId
.
state
to
the
result
of
passing
state
to
4.2.1
Initialize
Conversion
Algorithm
.
output
to
the
result
of
passing
state
and
jsonldDocument
as
inputDocument
to
4.2.2
Convert
Document
Algorithm
.
suffix
to
the
CBOR
encoding
of
output
.
cborldBytes
to
a
hexidecimal
encoding
of
prefix
prepended
to
suffix
.
cborldBytes
.
This
algorithm
takes
a
CBOR-LD
payload
cborldBytes
,
and
returns
a
JSON-LD
document
jsonldDocument
.
result
to
the
result
of
passing
registryEntryId
and
cborldBytes
to
4.6.1
Get
Varint
Structure
Algorithm
.
state
.
registryEntryId
to
result
.
registryEntryId
and
suffix
to
result
.
suffix
.
state
to
an
empty
map.
state.strategy
to
"decompression".
type
:
map
in
the
typeTables
array
in
the
CBOR-LD
Varint
Registry
Entry
associated
with
registryEntryId
,
add
that
entry
to
state
.
typeTable
,
and
set
the
value
of
type
in
state
.
reverseTypeTable
to
inverseMap
,
where
inverseMap
is
map
with
the
mapping
inverted.
state
to
the
result
of
passing
state
to
4.2.1
Initialize
Conversion
Algorithm
.
input
to
the
result
of
decoding
suffix
from
bytes
to
a
map.
jsonldDocument
to
the
result
of
passing
state
and
input
as
inputDocuments
to
4.2.2
Convert
Document
Algorithm
.
jsonldDocument
.
The algorithms in this section describe the behavior of a "converter" for abstractly converting inputs between data forms. When used in conjunction with a "strategy", such as the "compression" and "decompression" strategies defined later in this section, these algorithms can be instantiated to convert between concrete data forms. The "compression" strategy converts from JSON-LD to CBOR-LD, while the "decompression" strategy converts from CBOR-LD to JSON-LD.
This
algorithm
takes
and
returns
a
map
state
.
state
to
the
result
of
passing
state
to
4.4.1
Initialize
Context
Loader
Algorithm
.
state.initialActiveContext
to
the
result
of
passing
empty
maps
termMap
and
previousActiveContext
to
4.3.1
Initialize
Active
Context
Algorithm
.
state.typesEncodedAsBytes
to
an
empty
set.
state.typesEncodedAsBytes
.
state
.
This
algorithm
takes
a
map
state
and
a
map
or
array
of
maps
inputDocuments
,
and
returns
a
map
containing
a
map
state
and
a
map
or
array
of
maps
outputMaps
.
inputDocuments
is
an
array,
set
inputs
to
inputDocuments
.
Otherwise,
set
inputs
to
[inputDocuments]
.
outputMaps
to
an
empty
array.
input
in
inputs
:
output
to
an
empty
map.
result
to
the
result
of
passing
state
,
input
,
output
,
and
state.initialActiveContext
as
activeContext
to
4.2.3
General
Conversion
Algorithm
.
result.output
to
outputMaps
.
state
to
result.state
.
inputDocuments
is
an
array,
return
outputMaps
.
Otherwise,
return
the
first
element
of
outputMaps
.
This
algorithm
takes
maps
input
,
output
,
state
,
and
activeContext
as
inputs,
and
returns
a
map
containing
maps
state
and
output
.
state.strategy
is
set
to
"compression":
contextConversionResult
to
the
result
of
4.2.5.1
Convert
Contexts
for
Compression
Algorithm
,
passing
state
,
activeContext
,
input
,
and
output
.
activeContext
to
contextConversionResult.activeContext
,
output
to
contextConversionResult.output
,
and
state
to
contextConversionResult.state
.
activeContext
to
result.activeContext
and
state
to
result.state
of
result
resulting
from
4.2.6.1
Convert
Contexts
for
Decompression
Algorithm
,
passing
state
,
activeContext
,
input
,
and
output
.
state.strategy
is
set
to
"compression",
set
state
to
result.state
and
objectTypes
to
result.objectTypes
for
result
resulting
from
4.2.5.4
Get
Object
Types
for
Compression
Algorithm
,
passing
state
,
activeContext
,
input
,
and
output
.
state
to
result.state
and
objectTypes
to
result.objectTypes
for
result
resulting
from
4.2.6.4
Get
Object
Types
for
Decompression
Algorithm
,
passing
state
,
activeContext
,
input
,
and
output
.
activeContext
to
the
result
of
passing
activeContext
and
objectTypes
to
4.3.4
Apply
Type
Scoped
Contexts
Algorithm
.
state.strategy
is
set
to
"compression",
set
state
to
result.state
and
termEntries
to
result.termEntries
for
result
resulting
from
4.2.5.3
Get
Input
Entries
for
Compression
Algorithm
,
passing
state
,
input
,
and
activeContext
.
state
to
result.state
,
output
to
result.output
,
and
termEntries
to
result.termEntries
for
result
resulting
from
4.2.6.3
Get
Input
Entries
for
Decompression
Algorithm
,
passing
state
,
input
,
output,
and
activeContext
.
[termInfo,
value]
in
termEntries
:
term
to
termInfo.term
.
valueActiveContext
to
the
result
of
passing
activeContext
and
term
to
4.3.3
Apply
Property
Scoped
Contexts
Algorithm
.
plural
to
the
value
of
termInfo.plural
and
termType
to
the
value
of
@type
in
termInfo.def
.
plural
is
set
to
true
,
set
values
to
the
value
of
value
.
Otherwise,
set
values
to
an
array
containing
the
value
of
value
as
a
single
element.
outputs
to
an
empty
array.
unconvertedValue
in
values
:
result
to
the
result
of
4.2.4
Convert
Value
Algorithm
,
passing
state
,
termType
,
unconvertedValue
as
value
,
and
valueActiveContext
as
activeContext
.
state
to
result.state
and
add
result.output
to
outputs
.
plural
is
set
to
true
,
set
outputValues
to
outputs
.
Otherwise,
set
outputValues
to
the
first
element
of
outputs
.
state.strategy
is
set
to
"compression",
set
the
value
of
termInfo.termId
to
map
to
outputValues
in
output
.
Otherwise,
set
the
value
of
termInfo.term
to
map
to
outputValues
in
output
.
result
to
be
an
empty
map.
result.state
to
state
and
result.output
to
output
.
result
.
This
algorithm
takes
maps
state
,
activeContext
,
termInfo
,
and
values
value
and
termType
.
It
returns
a
result
object
containing
maps
state
and
output
.
value
is
null
,
return
null
.
state
.
strategy
is
set
to
"compression",
set
output
to
the
result
of
passing
state
,
termType
,
termInfo
,
and
value
to
4.2.5.2
Convert
Value
for
Compression
Algorithm
.
output
to
the
result
of
passing
state
,
termType
,
termInfo
,
and
value
to
4.2.6.2
Convert
Value
for
Decompression
Algorithm
.
output
is
defined,
return
result
,
a
map
contatining
state
and
output
.
value
is
an
array:
outputs
to
be
an
empty
array.
element
of
value
:
result
be
the
result
of
4.2.4
Convert
Value
Algorithm
,
passing
activeContext
,
state
,
termInfo
,
termType
,
and
element
as
value
.
Set
state
to
result
.
state
and
add
result
.
output
to
outputs
.
result
to
be
an
empty
map.
Set
result
.
state
to
state
and
result
.
output
to
outputs
.
result
.
output
to
an
empty
map.
result
to
the
result
of
4.2.3
General
Conversion
Algorithm
,
passing
state
,
activeContext
,
value
as
input
,
and
output
.
result
.
The algorithms in this section define the "compression" strategy to be used with the "conversion" algorithms defined previously to convert JSON-LD to CBOR-LD.
This
algorithm
takes
maps
state
,
activeContext
,
input
,
and
output
,
and
returns
a
map
result
containing
maps
output
,
state
,
and
activeContext
.
applyEmbeddedResult
to
the
result
of
4.3.2
Apply
Embedded
Contexts
Algorithm
,
passing
state
,
activeContext
,
and
input
.
activeContext
to
applyEmbeddedResult.activeContext
and
state
to
applyEmbeddedResult.state
.
input
:
result
to
an
empty
map.
result.state
to
state
and
result.activeContext
to
activeContext
.
result
.
context
to
the
value
of
"@context"
in
input
.
encodedContexts
to
an
empty
array.
context
is
an
array,
set
isArray
to
true
and
contexts
to
context
.
Otherwise,
set
isArray
to
false
and
contexts
to
[context]
.
contextValue
in
contexts
:
encoderData
to
the
result
of
4.5.1.1
Create
Context
Encoder
,
passing
state.typeTable
and
contextValue
.
encoderData
is
an
empty
map,
add
contextValue
to
encodedContexts
.
encoderData
to
encodedContexts
.
isArray
is
true
,
set
id
to
the
value
of
"@context"
in
state.keywordsMap
plus
1
and
set
the
value
of
id
in
output
to
encodedContexts
.
id
to
the
value
of
"@context"
in
state.keywordMap
and
set
the
value
of
id
in
output
to
the
first
element
of
encodedContexts
.
result.output
to
output
,
result.state
to
state
,
and
result.activeContext
to
activeContext
.
result
.
This
algorithm
takes
maps
state
and
termInfo
,
and
values
valueToEncode
and
termType
,
and
returns
a
map
encoderData
.
valueToEncode
is
an
object,
return.
result
to
the
result
of
4.5.2.1
Create
Value
Encoder
,
passing
state
,
termInfo
,
valueToToEncode
,
and
termType
.
result
.
This
algorithm
takes
maps
state
,
activeContext
,
and
input
,
and
returns
a
map
state
and
an
array
entries
.
entries
as
an
empty
array.
keys
to
the
keys
of
input
,
sorted
lexicographically.
key
in
keys
:
key
is
"@context",
continue.
value
to
the
value
of
key
in
input
.
value
is
an
array,
set
plural
to
true
.
Otherwise,
set
plural
to
false
.
key
does
not
have
an
entry
in
state
.
termToId
,
set
termId
to
key
.
plural
is
true
,
set
termId
to
the
value
of
key
in
state
.
termToId
plus
1.
termId
to
the
value
of
key
in
state
.
termToId
.
activeContext
.
termMap
has
an
entry
for
key
,
set
definition
to
the
value
of
key
in
activeContext
.
termMap
.
Otherwise,
set
definition
to
an
empty
map.
entryTerm
to
be
a
new
map.
entryTerm
to
be
the
value
of
key
.
Add
termId
,
plural
,
and
definition
to
entryTerm
.
entry
with
two
elements,
entryTerm
and
value
.
entry
to
entries
.
result
containing
entries
and
state
.
This
algorithm
takes
maps
activeContext
and
input
,
and
returns
a
set
objectTypes
.
objectTypes
to
be
an
empty
set.
term
in
activeContext
.
typeTerms
:
term
has
an
entry
in
input
:
types
to
the
value
of
term
in
input
.
types
to
objectTypes
.
objectTypes
.
The algorithms in this section define the "decompression" strategy to be used with the "conversion" algorithms defined previously to convert CBOR-LD to JSON-LD.
This
algorithm
takes
maps
state
,
activeContext
,
input
,
and
output
,
and
returns
a
map
result
containing
maps
output
,
state
,
and
activeContext
.
decoderData
to
the
result
of
4.5.1.3
Create
Context
Decoder
,
passing
state
.
reverseTypeTable
.
contextTermId
to
the
value
of
"@context"
in
state
.
keywordsMap
.
contextTermId
has
an
entry
in
input
,
set
the
value
of
"@context"
in
output
to
the
result
of
4.5.1.4
Decode
Context
,
passing
decoderData
and
the
value
of
contextTermId
in
input
as
value
.
contextTermIdPlural
to
the
value
of
contextTermId
plus
1.
contextTermIdPlural
has
an
entry
in
input
:
contextTermId
also
had
an
entry
in
input
during
the
previous
check,
throw
an
ERR_INVALID_ENCODED_CONTEXT
error.
encodedContexts
to
be
the
value
of
contextTermIdPlural
in
input
.
If
encodedContexts
is
not
an
array,
throw
an
ERR_INVALID_ENCODED_CONTEXT
error.
contexts
to
be
an
empty
array.
valueToDecode
in
encodedContexts
,
add
the
result
of
passing
decoderData
and
valueToDecode
as
value
to
4.5.1.4
Decode
Context
to
contexts
.
output
to
contexts
.
embeddedContextResult
to
the
result
of
4.3.2
Apply
Embedded
Contexts
Algorithm
,
passing
activeContext
,
output
as
input
,
and
state
.
result
to
an
empty
map.
result
.
state
to
embeddedContextResult
.
state
and
result.activeContext
to
embeddedContextResult
.
activeContext
.
result
.
This
algorithm
takes
maps
state
and
termInfo
,
and
values
termType
and
valueToDecode
,
and
returns
a
value
decodedValue
.
value
is
a
map,
return.
decoderData
to
the
result
of
4.5.2.3
Create
Value
Decoder
,
passing
valueToDecode
,
state
,
termInfo
,
and
termType
.
decodedValue
to
the
result
of
4.5.2.4
Decode
Value
,
passing
decoderData
.
decodedValue
.
This
algorithm
takes
maps
state
,
activeContext
,
and
input
,
and
returns
a
map
state
and
an
array
entries
.
entries
to
an
empty
array.
key
and
value
in
input
:
key
is
the
value
of
"@context"
in
state
.
keywordsMap
or
that
value
plus
1,
continue.
key
is
a
string,
set
plural
to
false
and
term
to
key
.
key
is
odd,
set
plural
to
true.
Otherwise,
set
plural
to
false.
plural
is
true
,
set
term
to
the
value
of
id
minus
1
in
state
.
idToTerm
.
If
that
value
does
not
have
an
entry,
throw
an
error
ERR_UNKNOWN_CBORLD_TERM_ID.
term
to
the
value
of
id
in
state
.
idToTerm
.
If
that
value
does
not
have
an
entry,
throw
an
error
ERR_UNKNOWN_CBORLD_TERM_ID.
definition
to
the
value
of
term
in
activeContext
.
termMap
.
entryTerm
to
be
a
new
map.
entryTerm
to
be
the
value
of
key
.
Add
term
,
plural
,
and
definition
to
entryTerm
.
entry
with
two
elements,
entryTerm
and
value
.
entry
to
entries
.
entries
by
the
value
of
term
in
each
element
of
entries
.
result
containing
entries
and
state
.
This
algorithm
takes
maps
state
,
activeContext
,
input
as
inputs,
and
returns
a
map
state
and
a
set
objectTypes
.
objectTypes
to
be
an
empty
set.
term
in
activeContext
.
typeTerms
:
term
does
not
have
an
entry
in
state
.
termToId
,
set
termId
to
term
.
termId
to
the
value
of
term
in
state
.
termToId
.
termId
nor
termId
plus
1
are
present
in
input
,
continue.
termId
is
present
in
input
,
set
value
to
the
value
of
termId
in
input
.
value
to
the
value
of
termId
plus
1
in
input
.
key
is
a
string,
set
plural
to
false
and
term
to
key
.
key
is
odd,
set
plural
to
true.
Otherwise,
set
plural
to
false.
plural
is
true
,
set
term
to
the
value
of
id
minus
1
in
state
.
idToTerm
.
If
that
value
does
not
have
an
entry,
throw
an
error
ERR_UNKNOWN_CBORLD_TERM_ID.
term
to
the
value
of
id
in
state
.
idToTerm
.
If
that
value
does
not
have
an
entry,
throw
an
error
ERR_UNKNOWN_CBORLD_TERM_ID.
definition
to
the
value
of
term
in
activeContext
.
termMap
.
termInfo
to
be
a
new
map.
term
,
termId
,
plural
,
and
definition
to
termInfo
.
value
is
not
an
array,
set
values
to
be
an
array
containing
as
a
single
element
value
.
Otherwise,
set
values
to
the
value
of
value
.
value
in
values
:
decoderData
to
the
result
of
4.5.2.3
Create
Value
Decoder
,
passing
value
,
termInfo
,
state
,
and
"@vocab"
as
termType
.
decoderData
exists,
add
the
result
of
4.5.2.4
Decode
Value
,
passing
decoderData
,
to
`objectTypes.
value
to
objectTypes
.
objectTypes
.
The algorithms in this section describe how to determine what components of the context documents associated with a JSON-LD document are in use at any point during compression or decompression. These algorithms include how to apply embedded, type-scoped, and property-scoped contexts with CBOR-LD. This is in contrast to the Context Loading algorithms defined later in this specification, which describe how to construct the mappings from terms to integers that are the core CBOR-LD compression technique. Together, the Active Context Processing and Context Loading algorithms specify how JSON-LD context documents should be processed when converting to and from CBOR-LD.
This
algorithm
takes
maps
previousActiveContext
and
termMap
,
and
returns
a
map
activeContext
.
It
updates
the
active
context
in
use
and
finds
all
aliases
for
'@type'
.
activeContext
to
a
new
map.
activeContext.previousActiveContext
to
previousActiveContext
.
activeContext.termMap
to
termMap
.
activeContext.typeTerms
to
the
array
['@type']
.
[term,
def]
in
termMap
:
def
is
"@type",
add
term
to
activeContext.typeTerms
.
activeContext
.
This
algorithm
takes
maps
state
,
activeContext
,
and
input
as
inputs,
and
returns
a
map
result
containing
maps
state
and
activeContext
.
termMapUpdateResult
to
the
result
of
passing
state
,
activeContext.termMap
as
activeTermMap
,
and
the
value
of
'@context'
in
input
as
contexts
to
4.3.5
Update
Term
Map
Algorithm
.
state
to
termMapUpdateResult.state
.
termMap
to
termMapUpdateResult.activeTermMap
.
newActiveContext
to
the
result
of
4.3.1
Initialize
Active
Context
Algorithm
,
passing
termMap
and
activeContext
as
previousActiveContext
.
result
to
be
a
new
map,
and
set
result.activeContext
to
newActiveContext
and
result.state
to
state
.
result
.
This
algorithm
takes
maps
state
,
activeContext
,
and
a
string
term
as
inputs
and
returns
a
map
result
containing
maps
state
and
activeContext
.
revertedTermMap
to
the
result
of
4.3.6
Revert
Term
Map
Algorithm
,
passing
activeContext
.
termDef
to
the
value
of
term
in
activeContext.termMap
.
Set
contexts
to
the
value
of
"@context"
in
termDef
.
termMapUpdateResult
to
the
result
of
passing
state
,
revertedTermMap
as
activeTermMap
,
true
as
propertyScope
,
and
contexts
to
4.3.5
Update
Term
Map
Algorithm
.
state
to
termMapUpdateResult.state
.
termMap
to
termMapUpdateResult.activeTermMap
.
newActiveContext
to
the
result
of
4.3.1
Initialize
Active
Context
Algorithm
,
passing
termMap
and
activeContext
as
previousActiveContext
.
result
to
be
a
new
map,
and
set
result.activeContext
to
newActiveContext
and
result.state
to
state
.
result
.
This
algorithm
takes
maps
state
,
activeContext
,and
a
set
objectTypes
as
inputs,
and
returns
a
map
result
containing
maps
state
and
activeContext
.
objectTypesSorted
to
an
empty
array.
objectTypes
and
add
the
elements
to
objectTypesSorted
in
order.
newTermMap
to
activeContext.termMap
.
type
in
objectTypesSorted
:
typeDef
to
the
value
of
type
in
newTermMap
.
Set
contexts
to
the
value
of
"@context"
in
typeDef
.
termMapUpdateResult
to
the
result
of
passing
state
,
newTermMap
as
activeTermMap
,
contexts
,
and
true
as
typeScope
to
4.3.5
Update
Term
Map
Algorithm
.
state
to
termMapUpdateResult.state
and
newTermMap
to
termMapUpdateResult.activeTermMap
.
newActiveContext
to
the
result
of
4.3.1
Initialize
Active
Context
Algorithm
,
passing
newTermMap
as
termMap
and
activeContext
as
previousActiveContext
.
result
to
be
a
new
map,
and
set
result.activeContext
to
newActiveContext
and
result.state
to
state
.
result
.
This
algorithm
takes
maps
state
,
activeTermMap
,
and
map
or
array
contexts
as
well
as
booleans
typeScope
and
propertyScope
,
both
of
which
default
to
false
if
not
provided,
as
inputs.
It
returns
maps
state
and
activeTermMap
.
contexts
is
not
an
array,
set
contexts
to
be
an
array
with
the
previous
value
of
contexts
as
its
sole
element.
allowProtectedOverride
to
the
value
of
propertyScope
.
propagateDefault
to
the
negation
of
the
value
of
typeScope
.
contextIdentifier
in
contexts
:
loadResult
to
the
result
of
4.4.2
Load
Context
Algorithm
,
passing
state
and
contextIdentifier
.
entry
to
loadResult
.
entry
,
context
to
entry
.
context
,
and
state
to
loadResult
.
state
.
@propagate
appears
in
context
,
set
propagate
to
the
value
of
@propagate
in
context
.
Otherwise,
set
propagate
to
the
value
of
propagateDefault
.
newTermMap
to
be
an
empty
map.
For
[
key
,
value
]
in
entry
.
termMap
:
value
into
a
new
map
newValue
and
add
propagate
to
newValue
.
key
in
newTermMap
to
newValue
.
term
,
activeDef
]
in
activeTermMap
:
def
be
the
value
of
term
in
newTermMap
.
def
is
defined:
protected
in
activeDef
is
true
:
allowProtectedOverride
is
set
to
false
and
def
is
not
identical
to
activeDef
,
throw
an
error
ERR_PROTECTED_TERM_REDEFINITION.
term
in
newTermMap
to
a
map
containing
the
values
from
activeDef
and
propagate
set
to
the
value
of
def
.
propagate
.
term
appears
in
context
,
set
the
value
of
term
in
newTermMap
to
a
map
containing
all
values
from
activeDef
.
activeTermMap
to
the
value
of
newTermMap
.
result
to
be
an
empty
map.
result
.
state
to
state
and
result
.
activeTermMap
to
activeTermMap
.
result
.
This
algorithm
takes
as
input
a
map
activeContext
,
and
returns
a
map
newTermMap
.
newTermMap
to
an
empty
map.
nonPropagatingTerms
to
an
empty
array.
[term,
def]
in
activeContext
:
def.propagate
is
set
to
false
,
add
term
to
nonPropagatingTerms
and
proceed
to
the
next
iteration
of
this
loop.
term
in
newTermMap
to
def
.
term
in
nonPropagatingTerms
:
currentContext
to
activeContext.previousActiveContext
.
def
to
the
value
of
term
in
currentContext.termMap
.
def
is
not
undefined
and
def.propagate
is
set
to
false
:
currentContext
to
activeContext.previousActiveContext
.
def
to
the
value
of
term
in
currentContext.termMap
.
def
is
not
undefined,
set
the
value
of
term
in
newTermMap
to
def
.
newTermMap
.
The algorithms in this section define how to construct the mappings between terms and integers that are used as the core CBOR-LD compression technique.
This
algorithm
takes
and
returns
a
map
state
.
state.contextMap
to
a
new
map.
state.nextTermId
to
100.
state.keywordsMap
to
the
following
map
of
JSON-LD
keywords
to
their
associated
integer
values:
{
'@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
to
state.termToId
.
state.strategy
is
set
to
"decompression",
set
state.idToTerm
to
the
reverse
map
of
state.termToId
(i.e.,
a
map
from
integers
to
JSON-LD
keywords).
state
.
This
algorithm
takes
a
map
state
and
a
context
map
or
URL
contextIdentifier
,
and
returns
result
,
a
map
containing
maps
state
and
entry
.
state.contextMap
has
an
entry
for
contextIdentifier
:
result
to
an
empty
map.
result.state
to
state
.
result.entry
to
the
value
of
contextIdentifier
in
state.contextMap
.
result
.
context
is
a
string:
context
to
the
value
of
"@context"
in
that
object.
contextUrl
to
the
value
of
contextIdentifier
.
context
to
contextIdentifier
.
result
to
the
result
of
4.4.3
Add
Context
Algorithm
,
passing
state
,
context
,
and
contextUrl
if
set.
result
.
This
algorithm
takes
a
map
state
,
a
context
object
context
,
and
a
context
URL
contextUrl
,
and
returns
result
,
a
map
containing
maps
state
and
entry
.
context
has
an
entry
"@import":
importUrl
to
the
value
of
"@import"
in
`context.
state.contextMap
does
not
have
an
entry
for
importUrl
:
importUrl
and
set
importContext
to
the
value
of
"@context"
in
that
object.
importedContextAdditionResult
to
the
result
of
4.4.3
Add
Context
Algorithm
,
passing
state
,
importContext
as
context
,
and
importUrl
as
contextUrl
.
state
to
importedContextAdditionResult.state
and
importEntry
to
importedContextAdditionResult.entry
.
importEntry
to
the
value
of
importUrl
in
state.contextMap
.
context
to
a
map
containing
all
entries
from
context
as
well
as
importEntry.context
.
termMap
to
an
empty
map.
entry
to
be
an
object
containing
context
and
termMap
.
sortedTerms
to
the
result
of
sorting
the
keys
in
context
in
lexicographic
order.
isProtected
to
true
if
"@protected"
has
an
entry
in
context
and
false
otherwise.
term
in
sortedTerms
:
term
has
an
entry
in
state.keywordsMap
,
proceed
to
the
next
iteration
of
this
loop.
definition
to
the
value
of
term
in
context
.
definition
is
null
,
proceed
to
the
next
iteration
of
this
loop.
definition
is
a
string:
newDefinition
to
an
empty
map.
newDefinition
to
definition
.
definition
to
newDefinition
.
protected
in
definition
to
isProtected
.
term
in
termMap
to
definition
.
term
does
not
have
an
entry
in
state.termToId
:
termId
to
state.nextTermId
.
state.nextTermId
by
2.
term
in
state.termToId
to
termId
.
termId
in
state.idToTerm
to
term
.
contextUrl
is
defined,
set
the
value
of
contextUrl
in
state.contextMap
to
entry
.
context
in
state.contextMap
to
entry
.
result
to
be
an
empty
map.
result.state
to
state
and
result.entry
to
entry
.
result
.
The codecs in this section specify exactly how individual values in JSON-LD should be converted to CBOR and vice versa. They are used by the algorithms in the previous section, and allow CBOR-LD to efficiently encode both primitive and non-primitive types as CBOR.
This
algorithm
takes
a
map
typeTable
and
a
value
contextValue
and
returns
a
map
encoderData
.
encoderData
to
an
empty
map.
contextValue
is
not
a
string,
return.
contextTable
to
the
value
of
"context"
in
typeTable
.
encoderData.context
to
contextValue
and
encoderData.contextTable
to
contextTable
.
encoderData
.
This
algorithm
takes
a
map
encoderData
,
and
returns
CBOR
binary
data.
encoderData
.
context
has
an
entry
in
encoderData
.
contextTable
,
return
a
CBOR
encoding
of
the
value
of
encoderData
.
context
in
encoderData
as
a
Major
Type
0
(unsigned
integer)
object.
encoderData
.
context
as
a
Major
Type
3
(text
string)
object.
This
algorithm
takes
a
map
reverseTypeTable
,
and
returns
a
map
encoderData
.
reverseContextTable
to
the
value
of
"context"
in
reverseTypeTable
.
decoderData
to
an
empty
map.
decoderData
.
reverseContextTable
to
the
value
of
reverseContextTable
and
return
decoderData
.
This
algorithm
takes
a
map
decoderData
and
a
value
value
,
and
returns
a
value.
value
is
not
a
number,
return
value
.
decoderData
.
reverseContextTable
has
an
entry
for
value
,
return
the
value
of
that
entry.
This
algorithm
takes
maps
state
and
termInfo
,
and
values
termType
and
valueToEncode
,
and
returns
a
map
encoderData
or
valueToEncode
.
isUrl
to
false
.
termInfo.term
is
"@id"
or
"@type",
set
isUrl
to
true
.
termInfo.def
is
"@id"
or
"@type",
set
isUrl
to
true.
termType
is
"@id"
or
"@vocab",
set
isUrl
to
true
.
isUrl
is
true
,
set
tableType
to
"url".
termType
is
defined,
set
tableType
to
termType
.
tableType
to
"none".
state.typeTable
has
an
entry
for
tableType
:
subTable
to
the
value
of
tableType
in
state.typeTable
.
subTable
has
an
entry
for
valueToEncode
:
intValue
to
the
value
of
valueToEncode
in
subTable
.
Set
includeSign
to
false
.
state
.
typesEncodedAsBytes
has
an
entry
for
tableType
,
set
convertToBytes
to
true
.
Otherwise,
set
convertToBytes
to
false
.
tableType
is
not
"none"
and
valueToEncode
is
an
integer:
intValue
to
the
value
of
valueToEncode
.
convertToBytes
and
includeSign
to
true
.
intValue
is
defined:
encoderData
to
an
empty
map.
encoderData
.
intValue
to
the
value
of
intValue
,
encoderData
.
convertToBytes
to
the
value
of
convertToBytes
,
and
encoderData
.
includeSign
to
the
value
of
includeSign
.
encoderData
.
tableType
has
an
entry
in
state.processingModeTypeEncoders
,
set
encoderData
to
the
result
of
calling
the
Create
Encoder
algorithm
associated
with
that
entry's
codec.
encoderData
is
defined,
return
encoderData
.
valueToEncode
.
This
algorithm
takes
a
map
encoderData
,
and
returns
CBOR
binary
data.
encoderData
.
convertToBytes
is
true
:
bytes
to
the
result
of
converting
intValue
to
bytes,
using
the
value
of
includeSign
to
determine
whether
the
binary
representation
of
the
integer
should
be
signed
or
unsigned.
bytes
as
a
Major
Type
2
(byte
string)
object.
intValue
as
a
Major
Type
0
(unsigned
integer)
object.
This
algorithm
takes
maps
state
and
termInfo
,
and
values
termType
and
valueToDecode
,
and
returns
a
map
decoderData
.
isUrl
to
false
.
termInfo.term
is
"@id"
or
"@type",
set
isUrl
to
true
.
termInfo.def
is
"@id"
or
"@type",
set
isUrl
to
true
.
termType
is
"@id"
or
"@vocab",
set
isUrl
to
true
.
isUrl
is
true
,
set
tableType
to
"url".
termType
is
defined,
set
tableType
to
termType
.
tableType
to
"none".
state.reverseTypeTable
has
an
entry
for
tableType
:
subTable
to
the
value
of
tableType
in
state.reverseTypeTable
.
useTable
to
false
.
valueToDecode
is
a
byte
array
and
state
.
typesEncodedAsBytes
has
an
entry
for
tableType
:
useTable
to
true
.
intValue
to
the
unsigned
integer
conversion
of
the
valueToDecode
bytes.
valueToDecode
is
an
integer
and
state
.
typesEncodedAsBytes
does
not
have
an
entry
for
tableType
:
useTable
to
true
.
intValue
to
valueToDecode
.
useTable
is
true
:
intValue
is
not
in
subTable
,
throw
an
error
ERR_UNKNOWN_COMPRESSED_VALUE.
decoded
to
the
value
of
intValue
in
subTable
.
valueToDecode
is
a
byte
array
and
tableType
is
not
"none",
set
decoded
to
the
integer
conversion
of
valueToDecode
.
decoded
is
defined,
initialize
decoderData
to
an
empty
map,
set
decoderData
.
decoded
to
the
value
of
decoded
,
and
return
decoderData
.
tableType
has
an
entry
in
state.processingModeTypeDecoders
,
set
DecoderData
to
the
result
of
calling
the
Create
Decoder
algorithm
associated
with
that
entry's
codec.
decoderData
is
defined,
return
decoderData
.
valueToDecode
is
not
an
array,
initialize
decoderData
to
an
empty
map,
set
decoderData
.
decoded
to
valueToDecode
,
and
return
decoderData
.
This
algorithm
takes
a
map
decoderData
,
and
returns
a
value.
decoderData
.
decoded
.
registryEntryId
,
and
returns
a
byte
string
prefix
.
registryEntryId
is
less
than
128:
varintEncoded
to
the
byte
encoding
of
registryEntryId
.
prefix
to
the
result
of
appending
varintEncoded
to
the
end
of
the
bytes
0xD906
.
varintArray
to
an
array
containing
the
varint
representation
of
registryEntryId
.
varintTagValue
to
varintArray[0]
appended
to
the
end
of
the
bytes
0xD906
.
varintBytesValue
to
a
CBOR
byte
string
containing
the
rest
of
varintArray
appended
to
the
end
of
the
bytes
0x82
.
prefix
to
varintBytesValue
appended
to
the
end
of
varintTagValue
.
prefix
.
This
algorithm
takes
an
encoded
CBOR-LD
payload
cborldBytes
as
input,
and
returns
suffix
,
the
main
data
to
be
decoded,
as
well
as
the
registryEntryId
value
that
should
be
used
to
decompress
suffix
.
cborldBytes
is
not
in
the
range
0x0600
-
0x06FF
,
throw
an
ERR_NON_CBOR_LD_TAG
error.
cborldBytes
is
in
the
range
0x0600
-
0x067F
,
set
registryEntryId
to
the
value
of
the
last
byte
of
the
CBOR
tag
and
set
suffix
to
the
portion
of
cborldBytes
after
the
tag.
ERR_INVALID_VARINT_VALUE
error.
ERR_INVALID_VARINT_STRUCTURE
error.
registryEntryId
to
the
value
of
the
varint
for
which
the
first
byte
is
the
last
byte
of
the
CBOR
tag
and
the
rest
of
the
varint
is
the
first
element
in
the
two
element
array.
Set
suffix
to
the
value
of
the
second
element
in
the
array.
result
to
be
an
empty
map.
result
.
suffix
to
the
value
of
suffix
and
result
.
registryEntryId
to
the
value
of
registryEntryId
.
result
.
This section is non-normative.
This specification registers a CBOR tag to allow consumers to identify CBOR-LD payloads. The following is provisional, and has not yet been ratified by IANA.
Tag : 51997
Registry : https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml
Data item : array
Semantics : a tag value of 51997 indicates that the payload is CBOR-LD.
Description of semantics : https://json-ld.github.io/cbor-ld-spec/#cbor-tags-for-cbor-ld
Point of contact : Wesley Smith (wsmith@digitalbazaar.com)