;ELC
;;; Compiled
;;; in Emacs version 24.5.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias json-encode-char0 encode-char json-decode-char0 decode-char] 3)
#@168 Type to convert JSON objects to.
Must be one of `alist', `plist', or `hash-table'.  Consider let-binding
this around your call to `json-read' instead of `setq'ing it.
(defvar json-object-type 'alist (#$ . 535))
#@152 Type to convert JSON arrays to.
Must be one of `vector' or `list'.  Consider let-binding this around
your call to `json-read' instead of `setq'ing it.
(defvar json-array-type 'vector (#$ . 753))
#@533 Type to convert JSON keys to.
Must be one of `string', `symbol', `keyword', or nil.

If nil, `json-read' will guess the type based on the value of
`json-object-type':

    If `json-object-type' is:   nil will be interpreted as:
      `hash-table'                `string'
      `alist'                     `symbol'
      `plist'                     `keyword'

Note that values other than `string' might behave strangely for
Sufficiently Weird keys.  Consider let-binding this around your call to
`json-read' instead of `setq'ing it.
(defvar json-key-type nil (#$ . 955))
#@241 Value to use when reading JSON `false'.
If this has the same value as `json-null', you might not be able to tell
the difference between `false' and `null'.  Consider let-binding this
around your call to `json-read' instead of `setq'ing it.
(defvar json-false :json-false (#$ . 1532))
#@241 Value to use when reading JSON `null'.
If this has the same value as `json-false', you might not be able to
tell the difference between `false' and `null'.  Consider let-binding
this around your call to `json-read' instead of `setq'ing it.
(defvar json-null nil (#$ . 1823))
#@53 Value to use as an element separator when encoding.
(defvar json-encoding-separator "," (#$ . 2104))
#@101 The default indentation level for encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json-encoding-default-indentation "  " (#$ . 2212))
#@133 Internally used to keep track of the current indentation level of encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json--encoding-current-indentation "\n" (#$ . 2379))
#@70 If non-nil, then the output of `json-encode' will be pretty-printed.
(defvar json-encoding-pretty-print nil (#$ . 2578))
#@81 If non-nil, ] and } closings will be formatted lisp-style,
without indentation.
(defvar json-encoding-lisp-style-closings nil (#$ . 2705))
#@30 Join STRINGS with SEPARATOR.
(defalias 'json-join #[(strings separator) "\302\303	#\207" [strings separator mapconcat identity] 4 (#$ . 2850)])
#@60 Non-null if and only if LIST is an alist with simple keys.
(defalias 'json-alist-p #[(list) ":\203 @:\203\211@@\262
:\204A\202\301\211\202
?\207" [list not-alist] 3 (#$ . 3001)])
#@42 Non-null if and only if LIST is a plist.
(defalias 'json-plist-p #[(list) ":\203!\301@!\203A:\203\211AA\262
\202\302\211\202
?\207" [list keywordp not-plist] 3 (#$ . 3200)])
(defalias 'json--with-indentation '(macro . #[(body) "\301\302E\207" [body let ((json--encoding-current-indentation (if json-encoding-pretty-print (concat json--encoding-current-indentation json-encoding-default-indentation) "")))] 3]))
#@39 Skip past the following N characters.
(defalias 'json-advance #[(&optional n) "u\207" [n] 1 (#$ . 3632)])
(byte-code "\300\301\302\303#\207" [put json-advance byte-optimizer byte-compile-inline-expand] 4)
#@32 Return the character at point.
(defalias 'json-peek #[nil "`f\211\206\301)\207" [char :json-eof] 2 (#$ . 3844)])
(byte-code "\300\301\302\303#\207" [put json-peek byte-optimizer byte-compile-inline-expand] 4)
#@52 Advance past the character at point, returning it.
(defalias 'json-pop #[nil "`f\211\206\302)\211\302=\203\303\304\305\"\202\305\211u)\210)\207" [char n :json-eof signal end-of-file nil] 4 (#$ . 4062)])
(byte-code "\300\301\302\303#\207" [put json-pop byte-optimizer byte-compile-inline-expand] 4)
#@36 Skip past the whitespace at point.
(defalias 'json-skip-whitespace #[nil "\300\301w\207" ["	
\n\f " nil] 2 (#$ . 4376)])
(byte-code "\300\301\302\"\210\300\303\304\301#\210\300\305\306\301#\210\300\307\310\301#\210\300\311\312\301#\210\300\313\314\301#\210\300\315\316\301#\210\300\317\320\301#\207" [define-error json-error "Unknown JSON error" json-readtable-error "JSON readtable error" json-unknown-keyword "Unrecognized keyword" json-number-format "Invalid number format" json-string-escape "Bad Unicode escape" json-string-format "Bad string format" json-key-format "Bad JSON object key" json-object-format "Bad JSON object"] 4)
#@24 List of JSON keywords.
(defvar json-keywords '("true" "false" "null") (#$ . 5018))
#@64 Read a JSON keyword at point.
KEYWORD is the keyword expected.
(defalias 'json-read-keyword #[(keyword) "	\235\204\f\304\305C\"\210\306\307\"\210\310\311!\204$\304\305\212\312v\210\313\314!)C\"\210\315\230\203,\316\207\317\230\2034\n\207\320\230\205;\207" [keyword json-keywords json-false json-null signal json-unknown-keyword mapc #[(char) "\302`f\211\206\n\303)\"\204\304\305\212\306v\210\307\310!)C\"\210\311\211u)\207" [char n char-equal :json-eof signal json-unknown-keyword -1 thing-at-point word nil] 5] looking-at "\\(\\s-\\|[],}]\\|$\\)" -1 thing-at-point word "true" t "false" "null"] 4 (#$ . 5107)])
#@33 Encode KEYWORD as a JSON value.
(defalias 'json-encode-keyword #[(keyword) "\303=\203\304\207	=\203\305\207\n=\205\306\207" [keyword json-false json-null t "true" "false" "null"] 2 (#$ . 5743)])
#@192 Read the JSON number following point.
The optional SIGN argument is for internal use.

N.B.: Only numbers which can fit in Emacs Lisp's native number
representation will be parsed correctly.
(defalias 'json-read-number #[(&optional sign) "\304	\204\"\305`f\211\206\306)\307\"\203\"\310\211u)\210\311\312![\202b	\204A\305`f\211\206/\306)\313\"\203A\310\211u)\210\311\312!\202b\314!\203]\315\224\204Q\316\224\203]\317\225b\210\320\321\317!!\202b\322\323`C\")\207" [number-regexp sign char n "\\([0-9]+\\)?\\(\\.[0-9]+\\)?\\([Ee][+-]?[0-9]+\\)?" char-equal :json-eof 45 nil json-read-number t 43 looking-at 1 2 0 string-to-number match-string signal json-number-format] 4 (#$ . 5954)])
#@41 Return a JSON representation of NUMBER.
(defalias 'json-encode-number #[(number) "\301\302\"\207" [number format "%s"] 3 (#$ . 6662)])
#@70 Characters which are escaped in JSON, with their elisp counterparts.
(defvar json-special-chars '((34 . 34) (92 . 92) (47 . 47) (98 . 8) (102 . 12) (110 . 10) (114 . 13) (116 . 9)) (#$ . 6804))
#@50 Read the JSON string escaped character at point.
(defalias 'json-read-escaped-char #[nil "\305\211u)\210`f\211\206\306)\211\306=\203\307\310\305\"\202$\305\211u)\210	)\211\n\236\211\2033A\202]	\311=\204=	\202]\312\313!\203X\314\315!\316\211u)\210\317\320\321\f\322\"\")\202]\307\323`C\"*\207" [n char json-special-chars special hex nil :json-eof signal end-of-file 117 looking-at "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]" match-string 0 4 json-decode-char0 ucs string-to-number 16 json-string-escape] 6 (#$ . 7004)])
#@32 Read the JSON string at point.
(defalias 'json-read-string #[nil "\303`f\211\206	\304)\305\"\204\306\307\310C\"\210\311\211u)\210\311`f\211\206$\304)\303\305\"\204i\303\312\"\203:\313 \202Y`f\211\206B\304)\211\304=\203Q\306\314\311\"\202X\311\211u)\210)\nB`f\211\206d\304)\202'\311\211u)\210\n\203{\315\316\n\237\"\202|\317*\207" [char n characters char-equal :json-eof 34 signal json-string-format "doesn't start with '\"'!" nil 92 json-read-escaped-char end-of-file apply string ""] 4 (#$ . 7552)])
#@31 Encode CHAR as a JSON string.
(defalias 'json-encode-char #[(char) "\303\304\"\305	\"@\211\203\306\307\n\"\202-\310V\203)\311W\203)\306\312\"\202-\306\313\")\207" [char json-special-chars control-char json-encode-char0 ucs rassoc format "\\%c" 31 127 "%c" "\\u%04x"] 4 (#$ . 8088)])
#@41 Return a JSON representation of STRING.
(defalias 'json-encode-string #[(string) "\301\302\303\304\305#\"\207" [string format "\"%s\"" mapconcat json-encode-char ""] 6 (#$ . 8391)])
#@133 Return a JSON representation of OBJECT.
If the resulting JSON object isn't a valid JSON object key,
this signals `json-key-format'.
(defalias 'json-encode-key #[(object) "\302!\303	!;\204\304\305C\"\210	)\207" [object encoded json-encode json-read-from-string signal json-key-format] 3 (#$ . 8581)])
#@111 Create a new Elisp object corresponding to a JSON object.
Please see the documentation of `json-object-type'.
(defalias 'json-new-object #[nil "\301=\203\302\303\304\"\207\305\207" [json-object-type hash-table make-hash-table :test equal nil] 3 (#$ . 8893)])
#@228 Add a new KEY -> VALUE association to OBJECT.
Returns the updated object, which you should save, e.g.:
    (setq obj (json-add-to-object obj "foo" "bar"))
Please see the documentation of `json-object-type' and `json-key-type'.
(defalias 'json-add-to-object #[(object key value) "\305=\203
	\306\236A\202\211\307=\203\n\2020\310=\203%\311\n!\2020\312=\2050\311\313\nP!	\314=\203A\315\n\f#\210\f\202Z	\316=\203O\nB\fB\202Z	\317=\205Z\n\fBB)\207" [json-key-type json-object-type key value object nil ((hash-table . string) (alist . symbol) (plist . keyword)) string symbol intern keyword ":" hash-table puthash alist plist] 5 (#$ . 9162)])
#@32 Read the JSON object at point.
(defalias 'json-read-object #[nil "\305\211u)\210\306 \210\307 \305\211\310`f\211\206\311)\312\"\204\224\306 \210\313 \306 \210\310`f\211\2061\311)\314\"\203@\305\211u)\210\202O\315\316\317`f\211\206K\311)D\"\210\320 \321\n	#\306 \210\310`f\211\206d\311)\312\"\204\310`f\211\206s\311)\322\"\203\202\305\211u)\210\202\315\316\323`f\211\206\215\311)D\"\210\202\305\211u)\210+\207" [n value key elements char nil json-skip-whitespace json-new-object char-equal :json-eof 125 json-read-string 58 signal json-object-format ":" json-read json-add-to-object 44 ","] 6 (#$ . 9828)])
#@45 Return a JSON representation of HASH-TABLE.
(defalias 'json-encode-hash-table #[(hash-table) "\306\307\310\311	\203\nP\202\312\313\314\f\"\210))
\"	\203$
\203(\312\202)\n#\207" [r json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation hash-table json-encoding-separator format "{%s%s}" json-join nil "" maphash #[(k v) "\305\203	\306\202\n\307	\310\n!\311!$\fB\211\207" [json-encoding-pretty-print json--encoding-current-indentation k v r format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 6] json-encoding-lisp-style-closings] 6 (#$ . 10475)])
#@40 Return a JSON representation of ALIST.
(defalias 'json-encode-alist #[(alist) "\306\307\310\203
	\nP\202\311\312\313\")\f\"\203
\203\"\311\202#	#\207" [json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation alist json-encoding-separator json-encoding-lisp-style-closings format "{%s%s}" json-join "" mapcar #[(cons) "\303\203	\304\202\n\305	\306\n@!\307\nA!$\207" [json-encoding-pretty-print json--encoding-current-indentation cons format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 6]] 6 (#$ . 11090)])
#@40 Return a JSON representation of PLIST.
(defalias 'json-encode-plist #[(plist) "\306	\203\f\nP\202
\307\f\2037\n\310\f@!	\203\311\202 \312\313\f\211A@\262
!RB\f\211AA\262
\211\204)\314\315\237
\"	\203K\204K\n\202L\307\316R)\207" [result json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation plist json-encoding-separator nil "" json-encode-key ": " ":" json-encode "{" json-join "}" json-encoding-lisp-style-closings] 7 (#$ . 11661)])
#@132 Return a JSON representation of LIST.
Tries to DWIM: simple lists become JSON arrays, while alists and plists
become JSON objects.
(defalias 'json-encode-list #[(list) "\204\301\207\302!\203\303!\207\304!\203\305!\207<\203#\306!\207\307\310C\"\207" [list "null" json-alist-p json-encode-alist json-plist-p json-encode-plist json-encode-array signal json-error] 3 (#$ . 12164)])
#@31 Read the JSON array at point.
(defalias 'json-read-array #[nil "\304\211u)\210\305 \210\304\306`f\211\206\307)\310\"\204R\311 	B\305 \210\306`f\211\206+\307)\310\"\204\306`f\211\206:\307)\312\"\203I\304\211u)\210\202\313\314\315C\"\210\202\304\211u)\210\316	\237\")\207" [n elements char json-array-type nil json-skip-whitespace char-equal :json-eof 93 json-read 44 signal json-error bleah apply] 4 (#$ . 12563)])
#@40 Return a JSON representation of ARRAY.
(defalias 'json-encode-array #[(array) "\2036	G\306V\2036\203\nP\202\307\310\311\n\"\312\313\314	\"\310\315\f\n#\"P)\310\316
\2032\307\2023\n\"P\207\317\320\314	\f#\321Q\207" [json-encoding-pretty-print array json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator json-encoding-lisp-style-closings 0 "" format "[%s" json-join mapcar json-encode "%s%s" "%s]" "[" mapconcat "]"] 7 (#$ . 13004)])
#@28 Readtable for JSON reader.
(defvar json-readtable (byte-code "\301\302\303\304\"\210)\207" [table ((116 json-read-keyword "true") (102 json-read-keyword "false") (110 json-read-keyword "null") (123 json-read-object) (91 json-read-array) (34 json-read-string)) mapc #[(char) "\302D	B\211\207" [char table json-read-number] 2] (45 43 46 48 49 50 51 52 53 54 55 56 57)] 3) (#$ . 13493))
#@89 Parse and return the JSON object following point.
Advances point just past JSON object.
(defalias 'json-read #[nil "\303 \210`f\211\206\304)\211\304=\2040	\236A\305\n@!\203(\306\n@\nA\"\202,\307\310\n\")\2024\307\311\312\")\207" [char json-readtable record json-skip-whitespace :json-eof functionp apply signal json-readtable-error end-of-file nil] 4 (#$ . 13887)])
#@57 Read the JSON object contained in STRING and return it.
(defalias 'json-read-from-string #[(string) "\302\303!rq\210\304\216	c\210eb\210\305 +\207" [#1=#:temp-buffer string generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) json-read] 2 (#$ . 14269)])
#@61 Read the first JSON object contained in FILE and return it.
(defalias 'json-read-file #[(file) "\302\303!rq\210\304\216\305	!\210eb\210\306 +\207" [#1=#:temp-buffer file generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) insert-file-contents json-read] 2 (#$ . 14588)])
#@53 Return a JSON representation of OBJECT as a string.
(defalias 'json-encode #[(object) "\303	\nE>\203
\304!\207;\203\305!\207\306!\203%\305\307!\310\311O!\2079\2030\305\307!!\207\247\2039\312!\207\313!\203C\314!\207\315!\203M\316!\207<\203V\317!\207\320\321C\"\207" [object json-null json-false t json-encode-keyword json-encode-string keywordp symbol-name 1 nil json-encode-number arrayp json-encode-array hash-table-p json-encode-hash-table json-encode-list signal json-error] 4 (#$ . 14925)])
#@30 Pretty-print current buffer.
(defalias 'json-pretty-print-buffer #[nil "\300ed\"\207" [json-pretty-print] 3 (#$ . 15452) nil])
#@31 Pretty-print selected region.
(defalias 'json-pretty-print #[(begin end) "\306 \307\211\307\310\216\311
!\210\312\313\"\314\315!!c\210*\312\211.\207" [most-positive-fixnum #1=#:--change-group-success-- undo-strong-limit undo-limit undo-outer-limit #2=#:--change-group-handle-- prepare-change-group nil ((byte-code "\203\302	!\210\202\303	!\210\302\207" [#1# #2# accept-change-group cancel-change-group] 2)) activate-change-group t delete-and-extract-region json-encode json-read-from-string begin end txt json-encoding-pretty-print] 5 (#$ . 15585) "r"])
(provide 'json)