anchor.diff:                                        (list (intern (string-upcase (first property)) :keyword)
                                               (second property)))
                                       properties)))))))))
  +
  +(defmethod lisp-to-jsc-value ((value t) &optional (context (jsc-context-get-current)))
  +  (declare (ignore value))
  +  (jsc-value-new-undefined context))
  +
  +(defmethod lisp-to-jsc-value ((number real) &optional (context (jsc-context-get-current)))
  +  (jsc-value-new-number context (coerce number 'double-float)))
  +
  +(defmethod lisp-to-jsc-value ((string string) &optional (context (jsc-context-get-current)))
  +  (jsc-value-new-string context string))
  +
  +(defmethod lisp-to-jsc-value ((symbol symbol) &optional (context (jsc-context-get-current)))
  +  (cond
  +    ((eq symbol *js-null-value*) (jsc-value-new-null context))
  +    ((eq symbol *js-undefined-value*) (jsc-value-new-undefined context))
  +    ((eq symbol *js-true-value*) (jsc-value-new-boolean context t))
  +    ((eq symbol *js-false-value*) (jsc-value-new-boolean context nil))
  +    (t (call-next-method (symbol-name symbol) context))))
  +
  +(defmethod lisp-to-jsc-value ((list list) &optional (context (jsc-context-get-current)))
  +  (jsc-value-new-array-from-list
  +   context (mapcar (lambda (value) (lisp-to-jsc-value value context)) list)))
  +
  +(defmethod lisp-to-jsc-value ((vector vector) &optional (context (jsc-context-get-current)))
  +  (jsc-value-new-array-from-list
  +   context (map 'list (lambda (value) (lisp-to-jsc-value value context)) vector)))
  +
  +(defmethod lisp-to-jsc-value ((hash-table hash-table) &optional (context (jsc-context-get-current)))
  +  (let (json-alist)
  +    (maphash
  +     (lambda (key value)
  +       (push (list key (jsc-value-to-json (lisp-to-jsc-value value context) 0)) json-alist))
  +     hash-table)
  +    (jsc-value-new-from-json context (format nil "{~{~s:~a~}~:{,~s:~a~}}" (first json-alist) (rest json-alist)))))
  
positive.code:   (return-type :pointer))
  (export 'jsc-value-new-function-variadic)
  
  (defcfun "jsc_value_function_callv" (g-object jsc-value)
    (value (g-object jsc-value))
    (n-parameters :uint)
  
negative.code:          (if (eq array-type :list)
               elements
               (coerce elements 'vector))))
        ((jsc-value-is-function jsc-value)
         (lambda (&rest args)
           (jsc-value-to-lisp
            (jsc-value-function-callv
             jsc-value
             (length args)
             (if args
                 (cffi:foreign-alloc :pointer
                                     :initial-contents
                                     (mapcar #'pointer
                                             (mapcar (lambda (arg)
                                                       (lisp-to-jsc-value
                                                        arg (jsc-value-get-context jsc-value)))
                                                     args))
                                     :count (length args))
                 (null-pointer))))))
        ((jsc-value-is-object jsc-value)
         (let ((properties (drain-properties jsc-value nil)))
           (case object-type
  