anchor.diff:           ;; indexed-pattern may be used as a design in the rectangular-tile. If
            ;; it is bigger than our pattern we return +transparent-ink+.
            (element (if (array-in-bounds-p array y x)
  -                      (elt (pattern-designs pattern)
  -                           (aref (pattern-array pattern) y x))
  +                      (elt (pattern-designs pattern) (aref array y x))
                         +transparent-ink+)))
       (if (patternp element)
           ;; If design is a pattern we delegate the question
  
positive.code:   ((array :type (simple-array (unsigned-byte 32) 2)))
    (:documentation "Helper class of RGBA result of another pattern."))
  
  (defun %rgba-value (element)
    "Helper function collapsing uniform design into 4-byte RGBA value."
    (flet ((transform (parameter)
             (logand (logand (truncate (* parameter 255)) 255))))
      (etypecase element
        ((unsigned-byte 32) element)
        ;; Uniform-compositium is a masked-compositum rgb + opacity
        ((or color opacity uniform-compositum)
         (multiple-value-bind (red green blue opacity)
             (color-rgba element)
           (logior (ash (transform red)   24)
                   (ash (transform green) 16)
                   (ash (transform blue)   8)
                   (transform opacity))))
        (indirect-ink (%rgba-value (indirect-ink-ink element))))))
  
  (defgeneric %pattern-rgba-value (pattern x y)
    (:documentation "Returns a collapsed RGBA value for position [X, Y].")
    (:method ((pattern %rgba-pattern) (x fixnum) (y fixnum))
      (let ((array (pattern-array pattern)))
        (if (array-in-bounds-p array y x)
            (aref (pattern-array pattern) y x)
            #x00000000)))
    (:method ((pattern indirect-ink) x y)
      (%rgba-value (design-ink pattern x y)))
    (:method (design x y) ;; fallback method
      (%rgba-value (design-ink design x y))))
  
  (defmethod design-ink ((pattern %rgba-pattern) x y)
    (let ((array (pattern-array pattern)))
      (if (array-in-bounds-p array y x)
          (let ((elt (aref (pattern-array pattern) y x)))
            (make-uniform-compositum (make-rgb-color (float (/ (ldb (byte 8 24) elt) 255))
                                                     (float (/ (ldb (byte 8 16) elt) 255))
                                                     (float (/ (ldb (byte 8 08) elt) 255)))
                                     (float (/ (ldb (byte 8 00) elt) 255))))
          +transparent-ink+)))
  
  (defgeneric %collapse-pattern (pattern)
  
negative.code: ;;;    implement bounding-rectangle protocol. In case of rectangular-tile it
  ;;;    should work on its base design size (and a transformation).
  ;;;
  ;;; A: This is implied by the fact that it is advised to use TRANSFORM-REGION on
  ;;;    a pattern in order to transform it. See 14.5.
  ;;;
  ;;; Q: Should a pattern which is not transformed have a starting position?
  