;;;; Copyright (C) 2019, 2020 Julien Lepiller <julien@lepiller.eu>

;;;; 

;;;; This library is free software; you can redistribute it and/or

;;;; modify it under the terms of the GNU Lesser General Public

;;;; License as published by the Free Software Foundation; either

;;;; version 3 of the License, or (at your option) any later version.

;;;; 

;;;; This library is distributed in the hope that it will be useful,

;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of

;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

;;;; Lesser General Public License for more details.

;;;; 

;;;; You should have received a copy of the GNU Lesser General Public

;;;; License along with this library; if not, write to the Free Software

;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

;;;; 

(define-module (jsonld expansion)

  #:use-module (jsonld context)

  #:use-module (jsonld context-processing)

  #:use-module (jsonld iri-expansion)

  #:use-module (jsonld value-expansion)

  #:use-module (jsonld json)

  #:use-module (jsonld options)

  #:use-module (ice-9 match)

  #:use-module (srfi srfi-1)

  #:use-module (web uri)

  #:export (expansion))

;; 13.7

(define* (execute-when-language active-context key value expanded-property

                                active-property expanded-value result options)

  ;; 13.7.2

  (let ((direction (active-context-direction active-context)))

    ;; 13.7.1

    (set! expanded-value '())

    ;; 13.7.3

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

      (set! direction (term-definition-direction

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

      (when (equal? direction #f)

        (set! direction (active-context-direction active-context))))

    ;; 13.7.4

    (for-each-pair

      (lambda (language language-value)

        ;; 13.7.4.1

        (if (json-array? language-value)

          (set! language-value (array->list language-value))

          (set! language-value (list language-value)))

        ;; 13.7.4.2

        (for-each

          (lambda (item)

            ;; 13.7.4.2.1

            (unless (equal? item #nil)

              ;; 13.7.4.2.2

              (unless (string? item)

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

              ;; 13.7.4.2.3

              (let ((v `(("@value" . ,item)

                         ("@language" . ,(string-downcase language)))))

                ;; 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")))

                (when direction

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

                (set! expanded-value

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

          language-value))

      (if (jsonld-options-ordered? options)

        (alist-sort-by-key value)

        value))

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

  `(("expanded-value" . ,expanded-value)))

;; 13.8

(define* (execute-when-index active-context key value expanded-property

                             active-property expanded-value result

                             container-mapping base-url options)

  ;; 13.8.1

  (set! expanded-value '())

  ;; 13.8.2

  (let ((index-key

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

              (or (term-definition-index

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

                  "@index")

              "@index"))

        ;; Should not be #nil, if it fails because of that, there's a weird corner case

        (map-context #nil)

        (expanded-index #nil))

    ;; 13.8.3

    (for-each-pair

      (lambda (index index-value)

        ;; 13.8.3.1

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

                  (member "@type" container-mapping))

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

                                active-context)))

        ;; 13.8.3.2

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

                   (term-definition-ref map-context index)

                   (not (equal? (term-definition-context

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

                                #f)))

          (set! map-context

            (context-processing map-context

                                (term-definition-context

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

                                (term-definition-base-url

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

                                #:options options)))

        ;; 13.8.3.3

        (when (equal? map-context #nil)

          (set! map-context active-context))

        ;; 13.8.3.4

        (set! expanded-index (assoc-ref

                               (iri-expansion active-context index

                                              ; XXX: or map-context?

                                              #:vocab? #t

                                              #:options options)

                               "iri"))

        ;; 13.8.3.5

        (unless (json-array? index-value)

          (set! index-value `#(,index-value)))

        ;; 13.8.3.6

        (set! index-value (expansion map-context key index-value base-url

                                     #:options options))

        ;; 13.8.3.7

        (for-each

          (lambda (item)

            ;; 13.8.3.7.1

            (when (member "@graph" container-mapping)

              (set! item

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

                    item

                    `(("@graph" . ,(if (json-array? item) item `#(,item)))))))

            (cond

              ;; 13.8.3.7.2

              ((and (member "@index" container-mapping)

                    (not (equal? index-key "@index"))

                    (not (equal? expanded-index "@none")))

               (let* (;; 13.8.3.7.2.1

                      (re-expanded-index (value-expansion active-context index-key index))

                      ;; 13.8.3.7.2.2

                      (expanded-index-key

                        (assoc-ref

                          (iri-expansion active-context index-key

                                         #:vocab? #t

                                         #:options options)

                          "iri"))

                      ;; 13.8.3.7.2.3

                      (index-key-values (assoc-ref item expanded-index-key))

                      (index-key-values (or index-key-values #()))

                      (index-key-values (if (json-array? index-key-values)

                                            (array->list index-key-values)

                                            (list index-key-values)))

                      (index-property-values

                        (cons re-expanded-index index-key-values)))

                 (set! item

                   (alist-set item expanded-index-key

                              (list->array 1 index-property-values)))

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

                   (unless (null? (filter

                                    (lambda (kv)

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

                                    item))

                     (throw 'invalid-value-object)))))

              ;; 13.8.3.7.3

              ((and (member "@index" container-mapping)

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

                    (not (equal? expanded-index "@none")))

               (set! item (alist-set item "@index" index)))

              ;; 13.8.3.7.4

              ((and (member "@id" container-mapping)

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

                    (not (equal? expanded-index "@none")))

               (set! expanded-index

                 (assoc-ref

                   (iri-expansion active-context index

                                  #:vocab? #f

                                  #:document-relative? #t

                                  #:options options)

                   "iri"))

               (set! item (alist-set item "@id" expanded-index)))

              ;; 13.8.3.7.5

              ((member "@type" container-mapping)

               (let* ((types (assoc-ref item "@type"))

                      (types (or types #()))

                      (types (if (json-array? types)

                                 (array->list types)

                                 (list types)))

                      (types (if (equal? expanded-index "@none")

                                 types

                                 (cons expanded-index types))))

                 (unless (equal? (length types) 0)

                   (set! item (alist-set item "@type" (list->array 1 types))))))

              (else #t))

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

          (array->list index-value)))

      (if (jsonld-options-ordered? options)

        (alist-sort-by-key value)

        value))

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

  `(("expanded-value" . ,expanded-value))))

;; 13.4

(define (execute-when-keyword active-context key value expanded-property

                              active-property expanded-value continue? result

                              type-scoped-context input-type nests base-url options)

  (cond

    ;; 13.4.1

    ((equal? active-property "@reverse")

     (throw 'invalid-reverse-property-map))

    ;; 13.4.2

    ((and (json-has-key? result expanded-property)

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

              (not (member expanded-property '("@included" "@type")))))

     (throw 'colliding-keywords))

    ;; 13.4.3

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

     (unless (or (string? value)

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

                      (or (equal? value '())

                          (not (equal? value #()))

                          (string-array? value))))

       (throw 'invalid-@id-value))

     (cond

       ((string? value)

        (set! expanded-value (assoc-ref

                               (iri-expansion active-context value

                                              #:document-relative? #t

                                              #:options options)

                               "iri"))

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

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

       ((equal? value '())

        ;; XXX: is the the right thing to do?

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

       ((json-array? value)

        (set! expanded-value

          (map

            (lambda (v)

              (assoc-ref

                (iri-expansion active-context v

                               #:document-relative? #t

                               #:options options)

                "iri"))

            (array->list value)))

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

    ;; 13.4.4

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

     ;; 13.4.4.1

     (unless (or (string? value)

                 (string-array? value)

                 (and

                   (jsonld-options-frame-expansion? options)

                   (or

                     (equal? value '())

                     (and (json-object? value)

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

       (throw 'invalid-type-value))

     (cond

       ;; 13.4.4.2

       ((equal? value '())

        (set! expanded-value '()))

       ;; 13.4.4.3

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

        (let ((iri (assoc-ref

                     (iri-expansion type-scoped-context (assoc-ref value "@default")

                                    #:vocab? #t

                                    #:document-relative? #t

                                    #:options options)

                     "iri")))

          (unless (absolute-iri? iri)

            (throw 'invalid-type-value))

          (set! expanded-value (alist-set value "@default" iri))))

       ;; 13.4.4.4

       ((string? value)

        (set! expanded-value

          (assoc-ref

            (iri-expansion type-scoped-context value

                           #:vocab? #t

                           #:document-relative? #t

                           #:options options)

            "iri")))

       ((string-array? value)

        (set! expanded-value

          (list->array 1

            (map

              (lambda (v)

                (assoc-ref

                  (iri-expansion type-scoped-context v

                                 #:vocab? #t

                                 #:document-relative? #t

                                 #:options options)

                  "iri"))

              (array->list value))))))

     ;; 13.4.4.5

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

       (set! expanded-value

         (list->array 1 (append

                          (array->list

                            (if (json-array? (assoc-ref result "@type"))

                                (assoc-ref result "@type")

                                `#(,(assoc-ref result "@type"))))

                          (array->list

                            (if (json-array? expanded-value)

                                expanded-value

                                `#(,expanded-value))))))))

    ;; 13.4.5

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

     (set! expanded-value (expansion active-context "@graph" value base-url

                                     #:options options))

     (unless (json-array? expanded-value)

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

    ;; 13.4.6

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

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

       (set! continue? #f))

       (begin

         ;; 13.4.6.2

         (set! expanded-value

           (expansion active-context active-property value base-url

                      #:options options))

         (if (json-array? expanded-value)

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

             (set! expanded-value (list expanded-value)))

         ;; 13.4.6.3

         (unless (null? (filter

                          (lambda (v)

                            (not (node-object? v)))

                          expanded-value))

           (throw 'invalid-@included-value))

         ;; 13.4.6.4

         (set! expanded-value

           (append

             (if (json-has-key? result "@included")

                 (array->list (assoc-ref result "@included"))

                 '())

             expanded-value))

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

    ;; 13.4.7

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

     ;; 13.4.7.1

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

         (begin

           (set! expanded-value value)

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

             (throw 'invalid-value-object-value)))

         ;; 13.4.7.2

         (begin

           (unless (or (scalar? value)

                       (equal? value #nil)

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

                            (or (equal? value '())

                                (scalar-array? value))))

             (throw 'invalid-value-object-value))))

     ;; 13.4.7.3

     (set! expanded-value value)

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

       (when (equal? expanded-value '())

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

       (when (scalar? expanded-value)

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

     ;; 13.4.7.4

     (when (equal? expanded-value #nil)

       (set! continue? #f)

       (set! result (alist-set result "@value" #nil))))

    ;; 13.4.8

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

     (unless (or (string? value)

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

                      (or (string-array? value)

                          (equal? value '()))))

       (throw 'invalid-language-tagged-string))

     ;; TODO: warning when value is to bcp-47 compliant

     (cond

       ((string? value)

        (set! expanded-value (string-downcase value))

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

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

       ((equal? value '())

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

       ((string-array? value)

        (set! expanded-value value))))

    ;; 13.4.9

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

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

       (set! continue? #f)

       (begin

         (unless (or (equal? value "ltr") (equal? value "rtl")

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

                          (or (string-array? value)

                              (equal? value '()))))

           (throw 'invalid-base-direction))

         (cond

           ((string? value)

            (set! expanded-value value)

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

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

           ((equal? value '())

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

           ((string-array? value)

            (set! expanded-value value))))))

    ;; 13.4.10

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

     (if (string? value)

       (set! expanded-value value)

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

    ;; 13.4.11

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

     (if (or (equal? active-property "@graph") (equal? active-property #nil))

       ;; 13.4.11.1

       (set! continue? #f)

       (begin

         ;; 13.4.11.2

         (set! expanded-value

           (expansion active-context active-property value base-url

                      #:options options))

         ;; Not in spec, but expected from the tests and implemented elsewhere

         (unless (json-array? expanded-value)

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

    ;; 13.4.12

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

     (set! expanded-value (expansion active-context active-property value base-url

                                  #:options options)))

    ;; 13.4.13

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

     (unless (json-object? value)

       (throw 'invalid-@reverse-value))

     ;; 13.4.13.2

     (set! expanded-value (expansion active-context "@reverse" value base-url

                                     #:options options))

     ;; 13.4.13.3

     (when (json-has-key? expanded-value "@reverse")

       (for-each-pair

         (lambda (property item)

           (if (json-has-key? result property)

             (set! result

               (alist-set result property

                          (list->array 1

                            (append

                              (array->list (assoc-ref result property))

                              (list item)))))

             (set! result

               (alist-set result property

                          (if (json-array? item) item `#(,item))))))

         (assoc-ref expanded-value "@reverse")))

     ;; 13.4.13.4

     (unless (null? (filter

                      (lambda (p) (not (equal? (car p) "@reverse")))

                      expanded-value))

       ;; 13.4.13.4.1 and 13.4.13.4.2

       (let ((reverse-map

               (if (json-has-key? result "@reverse")

                   (assoc-ref result "@reverse")

                   '())))

         (for-each-pair

           ;; 13.4.13.4.3

           (lambda (property items)

             (unless (equal? property "@reverse")

               (for-each

                 ;; 13.4.13.4.3.1

                 (lambda (item)

                   ;; 13.4.13.4.3.1.1

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

                     (throw 'invalid-reverse-property-value))

                   (when (json-has-key? item "@list")

                     (throw 'invalid-reverse-property-value))

                   (if (json-has-key? reverse-map property)

                     ;; 13.4.13.4.3.1.2

                     (set! reverse-map

                       (alist-set reverse-map property

                                  (list->array 1

                                    (append

                                      (array->list

                                        (assoc-ref reverse-map property))

                                      (list item)))))

                     ;; 13.4.13.4.3.1.3

                     (set! reverse-map

                       (alist-set reverse-map property `#(,item)))))

                 (array->list items))))

           expanded-value)

         (set! result (alist-set result "@reverse" reverse-map))))

     ;; 13.4.13.5

     (set! continue? #f))

    ;; 13.4.14

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

     (set! nests (cons key (or nests '())))

     (set! continue? #f))

    ;; 13.4.15

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

          (member expanded-property '("@explicit" "@default" "@embed"

                                      "@omitDefault" "@requireAll")))

     (set! expanded-value (expansion active-context active-property value base-url

                                     #:options options))))

  ;; 13.4.16

  (unless (or (not continue?)

              (and (equal? expanded-value #nil)

                   (equal? expanded-property "@value")

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

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

  `(("result" . ,result) ("nests" . ,nests)))

(define (execute-13 active-context active-property element property-scoped-context

                    type-scoped-context result nests input-type base-url options)

  (for-each-pair

    (lambda (key value)

      ;; 13.1: skip is @context

      (unless (equal? key "@context")

        ;; 13.2

        (let ((expanded-property

                (assoc-ref (iri-expansion active-context key

                                          #:vocab? #t

                                          #:options options)

                           "iri"))

              (expanded-value #nil)

              ;; 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

            ((or (equal? expanded-property #nil)

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

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

             (set! continue? #f))

            ;; 13.4

            ((json-keyword? expanded-property)

             (let ((exec-result (execute-when-keyword

                                  active-context key value expanded-property

                                  active-property expanded-value continue? result

                                  type-scoped-context input-type nests base-url

                                  options)))

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

               (set! nests (assoc-ref exec-result "nests")))

             (set! continue? #f))

            ;; 13.5

            (else

              (set! container-mapping

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

                       (container (and (term-definition? def)

                                       (term-definition-container def))))

                  (and def

                       (if (json-array? container)

                           (array->list container)

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

              (cond

                ;; 13.6

                ((and

                   (term-definition-ref active-context key)

                   (equal?

                     (term-definition-type

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

                     "@json"))

                 (set! expanded-value `(("@value" . ,value) ("@type" . "@json"))))

                ;; 13.7

                ((and container-mapping

                      (member "@language" container-mapping)

                      (json-object? value))

                 (let ((exec-result (execute-when-language

                                      active-context key value expanded-property

                                      active-property expanded-value result

                                      options)))

                   (set! expanded-value (assoc-ref exec-result "expanded-value"))))

                ;; 13.8

                ((and container-mapping

                      (or

                        (member "@index" container-mapping)

                        (member "@type" container-mapping)

                        (member "@id" container-mapping))

                      (json-object? value))

                 (let ((exec-result (execute-when-index

                                      active-context key value expanded-property

                                      active-property expanded-value result

                                      container-mapping base-url options)))

                   (set! expanded-value (assoc-ref exec-result "expanded-value"))))

                ;; 13.9

                (else

                  (set! expanded-value

                    (expansion active-context key value base-url

                               #:options options))))))

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

          ;; go to the next key immediately?

          (when (and continue? (not (equal? expanded-value #nil)))

            ;; 13.11

            (when (and container-mapping

                       (member "@list" container-mapping)

                       (not (json-has-key? expanded-value "@list")))

              (set! expanded-value

                `(("@list" . ,(if (json-array? expanded-value)

                                  expanded-value

                                  `#(,expanded-value))))))

            ;; 13.12

            (when (and container-mapping

                       (member "@graph" container-mapping)

                       (not (member "@id" container-mapping))

                       (not (member "@index" container-mapping)))

              (if (json-array? expanded-value)

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

                (set! expanded-value (list expanded-value)))

              (set! expanded-value

                (map

                  (lambda (ev)

                    `(("@graph" . ,(if (json-array? ev) ev `#(,ev)))))

                  expanded-value))

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

            ;; 13.13

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

                     (term-definition-reverse?

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

              ;; 13.13.1 and 13.13.2

              (let ((reverse-map

                      (if (json-has-key? result "@reverse")

                          (assoc-ref result "@reverse")

                          '())))

                (for-each

                  ;; 13.13.4

                  (lambda (item)

                    ;; 13.13.4.1

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

                      (throw 'invalid-reverse-property-value))

                    ;; 13.13.4.1

                    (when (json-has-key? item "@list")

                      (throw 'invalid-reverse-property-value))

                    ;; 13.13.4.2 and 13.13.4.3

                    (set! reverse-map

                      (alist-set reverse-map expanded-property

                                 (list->array 1

                                   (append

                                     (array->list

                                       (if (json-has-key? reverse-map expanded-property)

                                           (assoc-ref reverse-map expanded-property)

                                           #()))

                                     (list item))))))

                  ;; 13.13.3

                  (if (json-array? expanded-value)

                    (array->list expanded-value)

                    (list expanded-value)))

                (set! result (alist-set result "@reverse" reverse-map)))

              ;; 13.14

              (set! result

                (alist-set result expanded-property

                           (list->array 1

                             (if (json-array? expanded-value)

                               (append

                                 (array->list

                                   (if (json-has-key? result expanded-property)

                                       (assoc-ref result expanded-property)

                                       #()))

                                 (array->list expanded-value))

                               (append

                                 (array->list

                                   (if (json-has-key? result expanded-property)

                                       (assoc-ref result expanded-property)

                                       #()))

                                 (list expanded-value)))))))))))

    (if (jsonld-options-ordered? options)

        (alist-sort-by-key element)

        element))

  `(("result" . ,result)

    ("nests" . ,nests)))

(define (execute-14 active-context active-property element property-scoped-context

                    type-scoped-context result nests input-type base-url options)

  ;; 14

  (for-each

    (lambda (nesting-key)

      ;; 14.1

      (let ((nested-values (assoc-ref element nesting-key)))

        (unless (json-array? nested-values)

          (set! nested-values `#(,nested-values)))

        ;; 14.2

        (for-each

          (lambda (nested-value)

            ;; 14.2.1

            (unless (and (json-object? nested-value)

                         ;; XXX: "expand to @value"

                         (not (json-key-expanded-to? active-context nested-value "@value")))

              (throw 'invalid-@nest-value))

            ;; 14.2.2

            (let ((exec-result

                    (execute-13 active-context active-property

                                nested-value property-scoped-context

                                type-scoped-context result '()

                                input-type base-url options)))

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

              (set! nests (assoc-ref exec-result "nests"))

              (let ((exec-result

                      (execute-14 active-context active-property

                                  nested-value property-scoped-context

                                  type-scoped-context result nests input-type

                                  base-url options)))

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

          (array->list nested-values))))

    ;; nests was built with cons, so we have to reverse it

    (reverse nests))

  `(("result" . ,result)))

(define* (expansion active-context active-property element base-url

                    #:key (from-map? #f) (options (new-jsonld-options)))

  "Expand a JsonLD document.  This is an implementation of the expansion

algorithm defined in the JsonLD API specification.

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

  ;; 3

  (define property-scoped-context

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

        ;; can be #nil, so we cannot use `or` here

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

                                   active-context active-property))

        #f))

  ;; 2

  (when (equal? active-property "@default")

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

  (cond

    ;; 1

    ((equal? element #nil) #nil)

    ;; 4

    ((scalar? element)

     (if (member active-property '(#nil "@graph"))

       ;; 4.1

       #nil

       (begin

         ;; 4.2

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

           (set! active-context

             (context-processing active-context property-scoped-context base-url)))

         ;; 4.3

         (value-expansion active-context active-property element #:options options))))

    ;; 5

    ((array? element)

     ;; 5.1

     (let ((result '()))

       ;; 5.2

       (for-each

         (lambda (item)

           ;; 5.2.1

           (let ((expanded-item (expansion active-context active-property item base-url

                                           #:from-map? from-map?

                                           #:options options)))

             ;; 5.2.2

             (when (and

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

                     (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))

               (set! expanded-item `(("@list" . ,expanded-item))))

             ;; 5.2.3

             (if (json-array? expanded-item)

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

               (unless (equal? expanded-item #nil)

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

         (array->list element))

       ;; 5.3

       (list->array 1 result)))

    ;; 6

    (else

      ;; 7

      (when (active-context-previous active-context)

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

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

                      (and

                        (= (length element) 1)

                        (json-key-expanded-to? previous element "@id")))

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

      ;; 8

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

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

               (base-url

                 (if (term-definition? def)

                     (term-definition-base-url def)

                     base-url)))

          (set! active-context

            (context-processing active-context property-scoped-context base-url

                                #:override-protected? #t

                                #:options options))))

      ;; 9

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

        (set! active-context

          (context-processing active-context (assoc-ref element "@context")

                              base-url #:options options)))

      ;; 10, 12