(inputs

   `(("guile" ,guile-3.0)

     ("guile-gnutls" ,gnutls)

     ("guile-rdf" ,guile-rdf)))

  (native-inputs

   `(("automake" ,automake)

      ;; 4

      (when (json-has-key? context "@context")

        (set! context (assoc-ref context "@context")))

      (let* ((base-iri (or (jsonld-options-base options)

                           (and (jsonld-options-compact-to-relative? options)

                                (string? input)

             (inverse-context (inverse-context-creation active-context))

             (compacted-output

               (compaction active-context inverse-context

                           expanded-input ;; element

                           #:compact-arrays? (jsonld-options-compact-arrays? options)

                           #:ordered? (jsonld-options-ordered? options)

                           #:processing-mode

                           (jsonld-options-processing-mode options))))

        (if (equal? compacted-output #())

            (set! compacted-output '())

            (when (json-array? compacted-output)

          (context-processing active-context context-url context-url))))

    ;; 7

                                      (if remote-document

                                          (or (json-document-document-url remote-document)

                                              (jsonld-options-base options))

                         (not (equal? (car kv) "@graph")))

                       expanded-output)))

        (set! expanded-output (assoc-ref expanded-output "@graph")))

        (set! expanded-output #()))

      (unless (json-array? expanded-output)

        (set! expanded-output `#(,expanded-output)))

(define* (compaction active-context inverse-context active-property element

                     #:key (compact-arrays? #f) (ordered? #f) processing-mode)

  ;; 1

  (let ((type-scoped-context active-context)

        (def (term-definition-ref active-context active-property)))

                                               #:ordered? ordered?

                                               #:processing-mode processing-mode)))

               ;; 3.2.2

                 (set! result (cons compacted-item result)))))

           (array->list element))

         (set! result (reverse result))

      ;; 4

      (else

        ;; 5

          (unless (or (json-has-key? element "@value")

                      (and (json-has-key? element "@id")

                           (null? (filter (lambda (kp) (not (equal? (car kp) "@id")))

            (set! active-context (active-context-previous active-context))

            (set! inverse-context (inverse-context-creation active-context))))

        ;; 6

          ;; 6.1

          (set! active-context

            (context-processing active-context (term-definition-context def)

                      (value-compaction active-context inverse-context

                                        active-property element processing-mode)))

                  (or (scalar? compact)

           (value-compaction active-context inverse-context active-property

                             element processing-mode))

          ;; 8

                             (iri-compaction active-context inverse-context type

                                             #:vocab? #t #:processing-mode processing-mode))

                           types)))

                  (for-each

                    (lambda (term)

                      ;; 11.1

                      (when (and

                              (term-definition-context

                                (term-definition-ref type-scoped-context term)))

                        ;; 11.1.1

  (cond

    ;; 12.1

    ((equal? expanded-property "@id")

     ;; XXX: not clear what to do if expanded-value is not a

     ;; string, make sure there is a test

     (let ((compacted-value

                 expanded-value))

           (alias (iri-compaction active-context inverse-context expanded-property

                                  #:vocab? #t #:processing-mode processing-mode)))

       (set! result

         (alist-set result alias compacted-value))))

    ;; 12.2

                (not compact-arrays?)))

            (type-scoped-inverse-context

              (inverse-context-creation type-scoped-context)))

       (if (string? expanded-value)

           (set! compacted-value

             (iri-compaction type-scoped-context type-scoped-inverse-context

               (list->array 1

                 (map

                   (lambda (v)

                                     v

                   expanded-value)))))

       (when (and (json-array? compacted-value) (= (array-length compacted-value) 1))

         (set! compacted-value (car (array->list compacted-value))))

       (set! result

       (for-each-pair

         (lambda (property value)

           (let ((def (term-definition-ref active-context property)))

               (let ((as-array? (or

                                  (member "@set"

                                          (container-mapping active-context property))

       (unless (null? compacted-value)

         (let ((alias (iri-compaction active-context inverse-context "@reverse"

                                      #:vocab? #t #:processing-mode processing-mode)))

           (set! result (alist-set result alias compacted-value))))))

    ;; 12.4

    ((equal? expanded-property "@preserve")

         (equal? expanded-property "@value"))

      (let ((alias (iri-compaction active-context inverse-context expanded-property

                                   #:vocab? #t #:processing-mode processing-mode)))

        (set! result

          (alist-set result alias expanded-value))))

    (else

                                 #:processing-mode processing-mode))

               (def (term-definition-ref active-context

                                         item-active-property))

               ;; 12.7.4

               (nest-result result))

          ;; 12.7.2

          (when nest-term

            (unless (or (equal? nest-term "@nest")

                     #:reverse? inside-reverse?

                     #:processing-mode processing-mode))

                 (def (term-definition-ref active-context item-active-property))

                 ;; 12.8.3

                 (nest-result result)

                 ;; 12.8.4

                 ;; 12.8.6

                 (compacted-item

                   (compaction active-context inverse-context item-active-property

                                   (assoc-ref expanded-item "@list")

                                   (if (graph-object? expanded-item)

                                       (assoc-ref expanded-item "@graph")

                                       expanded-item))

                               #:compact-arrays? compact-arrays?

                               #:ordered? ordered?)))

            ;; 12.8.2

              (unless (or (equal? nest-term "@nest")

                          (equal? (expand-key active-context nest-term) "@nest"))

                (throw 'invalid-@nest-value))

                 ((and (member "@id" container)

                       (member "@graph" container))

                  (let* ((map-object

                         (map-key

                           (if (json-has-key? expanded-item "@id")

                               (assoc-ref expanded-item "@id")

                       (member "@index" container)

                       (simple-graph-object? expanded-item))

                  (let ((map-object

                        (map-key

                          (if (json-has-key? expanded-item "@index")

                              (assoc-ref expanded-item "@index")

                                                       ((member "@id" container) "@id")

                                                       (else "@type"))

                                                     #:vocab? #t))

                      ;; 12.8.9.3

                      (def (term-definition-ref active-context item-active-property))

                 (cond

                   ;; 12.8.9.4

                   ((and (member "@language" container)

                    (set! compacted-item (assoc-ref expanded-item "@value"))

                    (when (json-has-key? expanded-item "@language")

                      (set! map-key (assoc-ref expanded-item "@language"))))

                           (keys (if (json-array? keys)

                                     (array->list keys)

                                     (list keys)))

                           (remaining (if key (cdr keys) '())))

                      (when key

                        (unless (string? key)

                           (keys (if (json-array? keys)

                                     (array->list keys)

                                     (list keys)))

                           (remaining (if key (cdr keys) '())))

                      ;; 12.8.9.8.1

                        (set! map-key key))

                      ;; 12.8.9.8.2

                      (if (null? remaining)

                            active-context inverse-context item-active-property

                            `(("@id" . ,(assoc-ref expanded-item "@id")))))))))

                 ;; 12.8.9.9

                   (set! map-key (iri-compaction active-context inverse-context

                                                 "@none" #:vocab? #t)))

                 ;; 12.8.9.10

  (when (json-has-key? local-context "@propagate")

    (set! propagate? (assoc-ref local-context "@propagate")))

  ;; 3

    (set! result (update-active-context result #:previous active-context)))

  ;; 4

  (if (json-array? local-context)

    (lambda (context)

      (match context

        ;; 5.1

         (unless (or override-protected?

                     (null? (filter

                              term-definition-protected?

           (let ((value (assoc-ref context "@base")))

             (cond

               ;; 5.7.2

               ;; 5.7.3

               ((absolute-iri? value)

                (set! result (update-active-context result #:base value)))

               (else

                 (let ((iri (resolve-iri (active-context-base result) value)))

                   (if (and (absolute-iri? iri)

                     ;; 5.7.4

                     (set! result (update-active-context result #:base iri))

                     ;; 5.7.5

         (when (json-has-key? context "@vocab")

           ;; 5.8.1

           (let ((value (assoc-ref context "@vocab")))

               ;; 5.8.2

               (set! result (update-active-context result #:vocab #f))

               ;; 5.8.3

         (when (json-has-key? context "@language")

           ;; 5.9.1

           (let ((value (assoc-ref context "@language")))

               ;; 5.9.2

               (set! result (update-active-context result #:language #f))

               ;; 5.9.3

           (when (processing-mode-1.0? (jsonld-options-processing-mode options))

             (throw 'invalid-context-entry))

           (let ((value (assoc-ref context "@direction")))

               ;; 5.10.2

               (set! result (update-active-context result #:direction #f))

               ;; 5.10.3

(define-module (jsonld context)

  #:use-module (ice-9 match)

  #:use-module (srfi srfi-9)

  #:export (make-active-context

            active-context?

                 (vocab         #f)

                 (language      #f)

                 (direction     #f)

  (make-active-context definitions base original-base vocab language direction

                       previous))

                 (definition (new-term-definition #:protected? protected?)))

             (cond

               ;; 7

               ;; 8

               ((string? value)

                (set! value `(("@id" . ,value))))

                         ;; 13.5

                         (when (json-has-key? value "@container")

                           (let ((container (assoc-ref value "@container")))

                               (throw 'invalid-reverse-property))

                             (set! definition (update-term-definition definition

                                                #:container container))))

                     ((and (json-has-key? value "@id")

                           (not (equal? (assoc-ref value "@id") term)))

                      ;; 14.1

                        (set! definition (update-term-definition definition

                        ;; 14.2

                        (begin

                          ;; 14.2.1

                                          active-context local-context prefix defined)))

                            (set! defined (assoc-ref result "defined"))

                            (set! active-context (assoc-ref result "active-context"))))

                          ;; 15.2

                          (set! definition (update-term-definition definition

                                             #:iri (string-append

                      (set! definition (update-term-definition

                                         definition #:iri "@type")))

                     ;; 18

                      (set! definition (update-term-definition definition

                                         #:iri (string-append

                                                 (active-context-vocab active-context)

                                (not (json-has-key? value "@type")))

                       ;; 22.1

                       (let ((language (assoc-ref value "@language")))

                           (throw 'invalid-language-mapping))

                         ;; a warning should be thrown if not bcp-47 compliant

                         ;; 22.2

                                (not (json-has-key? value "@type")))

                       ;; 23.1

                       (let ((direction (assoc-ref value "@direction")))

                           (throw 'invalid-base-direction))

                         ;; 23.2

                         (set! definition (update-term-definition definition

                                      value))

                       (throw 'invalid-term-definition))

                     ;; 27

                                 (not (term-definition-protected? previous-definition)))

                       ;; 27.1

                       (unless (term-definition-equal?

(define* (deserialize-jsonld generate-blank-node node-map dataset

                             #:key produce-generalized-rdf? rdf-direction)

  ;; 1

  (for-each-pair

    (lambda (graph-name graph)

      ;; 1.1

                                                    rdf-direction item '()))

                                   (list-triples (assoc-ref res "list-triples"))

                                   (res (assoc-ref res "result")))

                                (set! triples

                                  (cons

                                    (make-rdf-triple subject property res)

  #:use-module (web response)

  #:use-module (web uri)

  #:use-module (rnrs bytevectors)

  #:use-module (srfi srfi-1)

  #:use-module (srfi srfi-9)

  #:use-module (sxml simple)

    ;; 13.7.1

    (set! expanded-value '())

    ;; 13.7.3

      (set! direction (term-definition-direction

                        (term-definition-ref active-context key)))

      (when (equal? direction #f)

        (for-each

          (lambda (item)

            ;; 13.7.4.2.1

              ;; 13.7.4.2.2

              (unless (string? item)

                (throw 'invalid-language-map-value))

                ;; TODO: if @language is not a bcp-47 one, we should issue a warning

                (when (equal? (expand-key active-context language) "@none")

                  (set! v (alist-remove v "@language")))

                  (set! v (alist-set v "@direction" direction)))

                (set! expanded-value

                  (append expanded-value (list v))))))

  (set! expanded-value '())

  ;; 13.8.2

  (let ((index-key

              (or (term-definition-index

                    (term-definition-ref active-context key))

                  "@index")

              "@index"))

    ;; 13.8.3

    (for-each-pair

      (lambda (index index-value)

        ;; 13.8.3.1

        (when (or (member "@id" container-mapping)

                  (member "@type" container-mapping))

        ;; 13.8.3.2

        (when (and (member "@type" container-mapping)

                   (not (equal? (term-definition-context

                                  (term-definition-ref map-context index))

                                #f)))

                                  (term-definition-ref map-context index))

                                #:options options)))

        ;; 13.8.3.3

          (set! map-context active-context))

        ;; 13.8.3.4

        (set! expanded-index (assoc-ref

         ;; 13.4.7.2

         (begin

           (unless (or (scalar? value)

                       (and (jsonld-options-frame-expansion? options)

                            (or (equal? value '())

                                (scalar-array? value))))

       (when (scalar? expanded-value)

         (set! expanded-value #(,expanded-value))))

     ;; 13.4.7.4

       (set! continue? #f)

    ;; 13.4.8

    ((equal? expanded-property "@language")

     (unless (or (string? value)

       (throw 'invalid-@index-value)))

    ;; 13.4.11

    ((equal? expanded-property "@list")

       ;; 13.4.11.1

       (set! continue? #f)

       (begin

                                     #:options options))))

  ;; 13.4.16

  (unless (or (not continue?)

                   (equal? expanded-property "@value")

                   (equal? input-type "@json")))

    (set! result (alist-set result expanded-property expanded-value)))

                                          #:vocab? #t

                                          #:options options)

                           "iri"))

              ;; whether we continue evaluating this key or not.  #f means go

              ;; immediately to processing the next key-value pair.

              (continue? #t)

              (container-mapping #f))

          (cond

            ;; 13.3

                 (not (or (json-keyword? expanded-property)

                          (string-index expanded-property #\:))))

             (set! continue? #f))

                (let* ((def (term-definition-ref active-context key))

                       (container (and (term-definition? def)

                                       (term-definition-container def))))

                       (if (json-array? container)

                           (array->list container)

                           (if container (list container) '())))))

              (cond

                ;; 13.6

                ((and

                   (equal?

                     (term-definition-type

                       (term-definition-ref active-context key))

                               #:options options))))))

          ;; 13.10 and previous (via continue?): do we process further, or

          ;; go to the next key immediately?

            ;; 13.11

            (when (and container-mapping

                       (member "@list" container-mapping)

                  expanded-value))

              (set! expanded-value (list->array 1 expanded-value)))

            ;; 13.13

                     (term-definition-reverse?

                       (term-definition-ref active-context key)))

              ;; 13.13.1 and 13.13.2

See @url{https://www.w3.org/TR/2014/REC-json-ld-api-20140116}."

  ;; 3

  (define property-scoped-context

        (term-definition-context (term-definition-ref

                                   active-context active-property))

        #f))

    (set! options (update-jsonld-options options #:frame-expansion? #f)))

  (cond

    ;; 1

    ;; 4

    ((scalar? element)

       ;; 4.1

       (begin

         ;; 4.2

         (unless (equal? property-scoped-context #f)

                                           #:options options)))

             ;; 5.2.2

             (when (and

                     (term-definition-container (term-definition-ref active-context active-property))

                     (member "@list" (array->list (term-definition-container (term-definition-ref active-context active-property))))

                     (json-array? expanded-item))

             ;; 5.2.3

             (if (json-array? expanded-item)

               (set! result (append result (array->list expanded-item)))

                 (set! result (append result (list expanded-item)))))))

         (array->list element))

       ;; 5.3

    ;; 6

    (else

      ;; 7

        (let ((previous (active-context-previous active-context)))

          (unless (or from-map? (json-key-expanded-to? active-context element "@value")

                      (and

      (let ((type-scoped-context active-context)

            (result '())

            (nests '())

            (found-first-entry? #f))

        ;; 11

        (for-each-pair

              ;; 12

              (unless found-first-entry?

                (match value

                   (set! input-type (car (reverse (array->list value)))))

                  (_ (set! input-type value)))

                (set! input-type

              ;; 11.2

              (for-each

                (lambda (term)

                             (not (equal?

                                    (term-definition-context

                                      (term-definition-ref type-scoped-context term))

             ;; 15.2

             (unless (equal? (assoc-ref result "@type") "@json")

               ;; 15.3

               ;; 15.4

               (unless (or

                         (string? (assoc-ref result "@value"))

          ((and (json-has-key? result "@language")

                (null? (filter (lambda (p) (not (equal? (car p) "@language")))

                               result)))

          ;; 19

           (if (or (equal? result '())

                   (json-has-key? result "@value")

                   (json-has-key? result "@list"))

               (when (and

                       (not (jsonld-options-frame-expansion? options))

                       (json-has-key? result "@id")

                       (null? (filter (lambda (p) (not (equal? (car p) "@id")))

                                      result)))

          ;; 20

          (else #t))

        result))))

  (define* (generate-blank-node-identifier identifier)

      ;; 1

               (json-has-key? identifier-map identifier))

       (assoc-ref identifier-map identifier)

       (let ((blank-node-identifier

               (string-append "_:b" (number->string counter))))

         (set! counter (+ counter 1))

           (set! identifier-map

             (alist-set identifier-map identifier blank-node-identifier)))

         blank-node-identifier)))

  (let ((result '())

        (default-language "@none"))

    ;; 2

      (set! default-language (string-downcase (active-context-language

                                                active-context))))

    ;; 3

    (for-each-pair

      (lambda (term term-definition)

        ;; 3.1

          ;; 3.2

          (let ((container "@none")

                ;; 3.3

              ;; 3.14

              ((not (equal? (term-definition-language term-definition) #f))

               (let ((language

                           (string-downcase

                             (term-definition-language term-definition))

                           "@null")))

              ;; 3.15

              ((not (equal? (term-definition-direction term-definition) #f))

               (let ((direction

                           (string-append

                             "_"

                             (string-downcase

                       (string-downcase

                         (string-append

                           default-language "_"

                               "")))))

                 (unless (json-has-key? language-map lang-dir)

                   (set! language-map

  ;; in that case we iri-compact each part of it and return an array.

  (cond

    ;; 2

    ((json-array? var)

     (list->array 1

       (map

    (else

     (begin

       (let ((result #f))

         ;; 2

         (when (and vocab? (json-has-key? inverse-context var))

           (let ((default-language

                   ;; 2.1

                       (string-append

                         "_"

                       "@none"))

                 ;; 2.3

                 (containers '())

                ;; 2.7.2

                (let ((lst (array->list (assoc-ref value "@list")))

                      ;; 2.7.3

                  (when (null? lst)

                    (set! common-language default-language))

                  ;; 2.7.4

                            ;; 2.7.4.3

                            (set! item-type "@id"))

                        ;; 2.7.4.4

                            (set! common-language item-language)

                            (unless (or (equal? common-language item-language)

                                        (not (json-has-key? item "@value")))

                              (set! common-language "@none")))

                        ;; 2.7.4.6

                            (set! common-type item-type)

                            (unless (equal? common-type item-type)

                              (set! common-type "@none")))))

                    lst)

                  ;; 2.7.5

                    (set! common-language "@none"))

                    (set! common-type "@none"))

                  (if (not (equal? common-type "@none"))

                      (begin

                                         value)))

                 (set! containers (append containers '("@language" "@language@set")))))

             ;; 2.13

               (set! type/language-value "@null"))

             ;; 2.15

             (when (equal? type/language-value "@reverse")

                                                     #:vocab? #t

                                                     #:processing-mode processing-mode))

                      (def (term-definition-ref active-context compacted-iri))

                 (if (equal? iri (assoc-ref value "@id"))

                     (set! preferred-values

                       (append preferred-values '("@vocab" "@id" "@none")))

                                         (string-index s #\_))

                                       preferred-values))

                    (underscore (if (null? underscore-vals) #f (car underscore-vals))))

                 (set! preferred-values

                   (append

                     preferred-values

                         (cons "" (cdr (string-split underscore #\_))) "_"))))))

             ;; 2.20

             (let ((term (term-selection inverse-context var containers type/language preferred-values)))

                 (set-cond! result term)))))

         ;; 3

           (let ((vocab (active-context-vocab active-context)))

             (when (and (>= (string-length var) (string-length vocab))

                        (equal? (substring var 0 (string-length vocab)) vocab))

               (let ((suffix (substring var (string-length vocab))))

                   (set-cond! result suffix))))))

         ;; 4

           ;; 5

           (for-each-pair

             (lambda (term def)

               ;; 5.1

                           (equal? (term-definition-iri def) var)

                           (not (string? var))

                           (< (string-length var) (string-length (term-definition-iri def)))

                                                   (string-length

                                                     (term-definition-iri def))))))

                   ;; 5.3

                             (< (string-length candidate) (string-length compact-iri))

                             (and (= (string-length candidate)

                                     (string-length compact-iri))

                                  (string<=? candidate compact-iri)))

                     (let ((def (term-definition-ref active-context candidate)))

                                      (equal? (term-definition-iri def) var)))

                         (set! compact-iri candidate)))))))

             (active-context-definitions active-context))

           ;; 6

             (set-cond! result compact-iri)))

         ;; 7

         (unless result

                 (throw 'iri-confused-with-prefix)))))

         ;; 8

         (unless vocab?

             (set-cond! result

               (make-relative-iri var (active-context-base active-context)))))

         ;; 9

  ;; 2

  (when (and (keyword-form? iri) (not (json-keyword? iri)))

    ;; Should give a warning and return null, we only return null without warning

  ;; if not 1 or 2

    ;; 3

    (when (and local-context (json-has-key? local-context iri))

      (let ((def (assoc-ref defined iri)))

             ;; 6.4

             (if (and

                   (term-definition? (term-definition-ref active-context prefix))

                   (term-definition-prefix? (term-definition-ref active-context prefix)))

               (set! iri

                 (string-append (term-definition-iri

                 ((absolute-iri? iri)

                  (set! iri iri))

                 ;; 7

                                           iri)))

                 (else

                       ;; 8

                       (set! iri (resolve-iri (or

                                                (active-context-base active-context)

                       ;; 9

                       (set! iri iri)))))))))

      ;; 7

       (set! iri (string-append (active-context-vocab active-context)

                                iri)))

      (else

          ;; 8

          (set! iri (resolve-iri (or

                                   (active-context-base active-context)

            json-array?

            json-has-key?

            json-keyword?

            json-object?

            jsonld-error->string

            keyword-form?

            make-jsonld-options

            merge-json

            node-object?

            processing-mode-1.0?

            relative-iri?

            same-json?

  "Whether a value is a Json array."

  (and (array? v) (not (string? v))))

(define (json-object? v)

  "Whether a value is a Json object."

(define (json-has-key? obj key)

  "Whether a Json object @var{obj} has a @var{key}."

  #:export (list-to-rdf))

(define* (list-to-rdf generate-blank-node rdf-direction lst list-triples)

    (if (null? lst)

        ;; 1

        (set! result (rdf-iri "nil"))

        ;; 2

        (let ((bnodes (map

                        (lambda _

                        lst)))

          ;; 3

          (let loop ((bnodes bnodes) (lst lst))

                     (object (assoc-ref res "result"))

                     (embedded-triples (assoc-ref res "list-triples")))

                ;; 3.3

                  (set! list-triples

                    (cons (make-rdf-triple subject (rdf-iri "first") object)

                          list-triples)))

(define (get-node-map-generation generate-blank-node)

  (define* (node-map-generation element node-map

                                #:key (active-graph "@default")

    ;; 1

    (if (json-array? element)

      (for-each

            (set! lst (assoc-ref res "list"))))

        (array->list element))

      ;; 2: otherwise

                               '()

             (types (assoc-ref element "@type"))

             (types (if (json-array? types)

                        (array->list types)

             ;; 3

             (types

               (map

            (set! element (alist-set element "@type" (car types)))))

        ;; 4

        (when (json-has-key? element "@value")

              (begin

                ;; 4.1.1

                (unless (json-has-key? subject-node active-property)

              (set! result (assoc-ref res "list"))

              (set! node-map (assoc-ref res "node-map"))

              (set! graph (assoc-ref node-map active-graph))

                ;; 5.3

                (begin

                  (set! subject-node

                        (if (blank-node? (assoc-ref element "@id"))

                            (generate-blank-node (assoc-ref element "@id"))

                            (assoc-ref element "@id"))

            ;; 6.3

              (set! graph

                (alist-set graph id `(("@id" . ,id))))

              (set! node-map (alist-set node-map active-graph graph)))

            ;; 6.4

              (cond

                ;; 6.5

                ((json-object? active-subject)

                     ;; 6.5.1

                     (set! node

                       (alist-set node active-property `#(,active-subject))))

                   (set! graph (alist-set graph id node)))

                 (set! node-map (alist-set node-map active-graph graph)))

                ;; 6.6

                 ;; 6.6.1

                 (let ((reference `(("@id" . ,id))))

                       ;; 6.6.2

                       (begin

                         (if (json-has-key? subject-node active-property)

              (when (json-has-key? element "@type")

                (set! node

                  (append-if-not-in node "@type" (assoc-ref element "@type")))

                  (set! graph (alist-set graph id node)))

                (set! node-map (alist-set node-map active-graph graph)))

              ;; 6.8

                                       #:active-property property)))

                            (set! node-map (assoc-ref res "node-map"))

                            (set! graph (assoc-ref node-map active-graph))

                                                   '()))

                              (set! node (assoc-ref graph id)))))

                        (array->list values)))

                    reverse-map)

                             #:active-graph id)))

                  (set! node-map (assoc-ref res "node-map"))

                  (set! graph (assoc-ref node-map active-graph))

                    (set! node (assoc-ref graph id))))

                (set! element (alist-remove element "@graph")))

              ;; 6.11

                             #:active-graph active-graph)))

                  (set! node-map (assoc-ref res "node-map"))

                  (set! graph (assoc-ref node-map active-graph))

                    (set! node (assoc-ref graph id))))

                (set! element (alist-remove element "@included")))

              ;; 6.12

                  ;; 6.12.2

                  (unless (json-has-key? node property)

                    (set! node (alist-set node property #()))

                      (set! graph (alist-set graph id node)))

                    (set! node-map (alist-set node-map active-graph graph)))

                  ;; 6.12.3

                               #:active-property property)))

                    (set! node-map (assoc-ref res "node-map"))

                    (set! graph (assoc-ref node-map active-graph))

                      (set! node (assoc-ref graph id)))))

                (alist-sort-by-key element))

                (set! graph (alist-set graph id node))))))

        (when (string? active-subject)

          (set! graph (alist-set graph active-subject subject-node)))

(define (canonical-json value)

  (cond

     value)

    ((string? value) value)

    ((number? value)

        #f)))

(define* (object-to-rdf generate-blank-node rdf-direction item list-triples)

    (cond

      ;; 1

      ((and (node-object? item) (not (well-formed? (assoc-ref item "@id"))))

      ;; 2

      ((node-object? item)

       (set! result (assoc-ref item "@id")))

      (else

        ;; 4

        (let ((value (assoc-ref item "@value"))

          (cond

            ;; 6

                    (not (well-formed? datatype)))

            ;; 7

            ((and

               (json-has-key? item "@language")

               (not (well-formed-language-tag? (assoc-ref item "@language"))))

            (else

              ;; 8

              (when (equal? datatype "@json")

              (cond

                ;; 9

                ((boolean? value)

                   (set! datatype (xsd-iri "boolean")))

                 (set! value (if value "true" "false")))

                ;; 10

                      (or (not (integer? (inexact->exact value)))

                          (>= (abs value) (expt 10 21))

                          (equal? datatype (xsd-iri "double"))))

                   (set! datatype (xsd-iri "double")))

                 (set! value (canonical-double value)))

                ;; 11

                ((number? value)

                 (set! value (number->string (inexact->exact value)))

                   (set! datatype (xsd-iri "integer"))))

                ;; 12

                 (set! datatype

                   (if (json-has-key? item "@language")

                       (rdf-iri "langString")

                       (xsd-iri "string")))))

              (if (and (json-has-key? item "@direction") (not (equal? rdf-direction #f)))

                  ;; 13

                         (language (string-downcase language)))

                    (if (equal? rdf-direction "i18n-datatype")

                        ;; 13.2

                        ;; 13.3

                        (when (equal? rdf-direction "compound-literal")

                          (let ((literal (blank-node->rdf-blank-node

                            ;; 13.3.2

                            (set! list-triples

                              (cons

      (let ((result '())

            (converted-value (rdf-literal-lexical-form value))

            (datatype (rdf-literal-type value))

        (cond

          ;; 2.4

          (use-native-types?

        ;; 2.9

        (set! result (alist-set result "@value" converted-value))

        ;; 2.10

          (set! result (alist-set result "@type" type)))

        ;; 2.11

        result)))

(define* (term-selection inverse-context var containers type/language

                         preferred-values)

  (let ((container-map (assoc-ref inverse-context var))

    ;; 2

    (for-each

      (lambda (container)

            (for-each

              (lambda (item)

                (when (json-has-key? value-map item)

                    (set! result (assoc-ref value-map item)))))

              preferred-values))))

      containers)

(define (container-mapping active-context active-property)

  (let* ((def (term-definition-ref active-context active-property))

         (container-mapping

    (if (json-array? container-mapping)

        (array->list container-mapping)

        (list container-mapping))))

  (let* ((result value)