anchor.diff:                        :duration "0.5s"
                         :iteration-count "1"
                         :timeing-function "ease-in")
  -           (style :height (if (@ cell-data :is-focused)
  -                              (* side 1.05)
  -                              side)
  -                  :width (if (@ cell-data :is-focused)
  -                             (* side 1.05)
  -                             side)
  +           (style :height side
  +                  :width side
                     :margin-left 0
                     :margin-right 0
                     :margin-top 0
  
positive.code:                                    (side cell-side))))
                    group-data :this this)))
  
  (def-widget-1 sudoku-board ((cell-side :attribute)
                              (cell-margin :attribute)
                              (group-margin :attribute)
                              ;; states
                              (focused-group :state)
                              (focused-cell :state)
                              (data :state (map (lambda (x)
                                                  (map (lambda (y)
                                                         (create :group x
                                                                 :seq y
                                                                 :is-focused false
                                                                 :fixed (< ((@ *math random)) 0.5)
                                                                 :digit (1+ (rand-int 9))))
                                                       '(0 1 2 3 4 5 6 7 8)))
                                                '(0 1 2 3 4 5 6 7 8))))
    (labels ((update-focused-cell (group seq)
               (let ((new-data (funcall (@ (:state data) slice))))
                 (when (:state focused-cell)
                   (setf (aref new-data 
                               (@ (:state focused-cell) :group)
                               (@ (:state focused-cell) :seq)
                               :is-focused)
                         false))
                 (setf (@ (aref new-data group seq) :is-focused)
                       true)
                 (setf (@ (aref new-data group seq) :digit)
                       (1+ (rand-int 9)))
                 (update-state focused-cell (create :group group
                                                    :seq seq)
                               data new-data))))
      (:div ()
            (:grid-3x3 ((cell-margin group-margin))
                       (map (lambda (x)
                              (:sudoku-group ((group-data (aref (:state data) x))
                                              (on-focus (llambda ()
                                                                 (update-state focused-group x)))
                                              (on-cell-focus (@ this update-focused-cell))
                                              (cell-margin (if (= x (:state focused-group))
                                                               (- cell-margin 1)
                                                               cell-margin))
                                              (cell-side cell-side))))
                            '(0 1 2 3 4 5 6 7 8) :this this)))))
  
               
  
  
negative.code:                         :cursor "pointer"
                          :font-weight "bold"))
                  (if (@ cell-data :is-focused)
                      (:span ((animation :keyframe ("0%" :background "rgba(114, 145,156, 0)")
                                         :keyframe ("100%" :background "rgba(114, 145, 156, 1)")
                                         :direction "alternate"
                                         :delay "0.3s"
                                         :duration "0.5s"
                                         :iteration-count "infinite"))
                             (if (= (@ cell-data :digit) 0)
                                 "_"
                                 (@ cell-data :digit)))
                      (:span () (unless (= (@ cell-data :digit) 0)
                                  (@ cell-data :digit))))))))
  
  
  
  