anchor.diff:  (defvar *js-true-value* t
     "The value used when translating true from JavaScript to Lisp.")
   (export '*js-true-value*)
  -
  -(defvar *js-function-value* :function
  -  "The value used when translating function values from JavaScript to Lisp.
  -Likely to get deprecated.")
   
   (defvar *js-array-type* :list
     "The Lisp data type used when translating arrays from JavaScript to Lisp.")
  
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:                                       (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)))))
  