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



(byte-code "\300\301!\210\300\302!\207" [require map subr-x] 2)
#@243 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.  Ordering
is maintained for `alist' and `plist', but not for `hash-table'.
(defvar json-object-type 'alist (#$ . 149))
#@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 (#$ . 442))
#@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 (#$ . 644))
#@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 (#$ . 1221))
#@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 (#$ . 1512))
#@53 Value to use as an element separator when encoding.
(defvar json-encoding-separator "," (#$ . 1793))
#@173 String used for a single indentation level during encoding.
This value is repeated for each further nested element.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json-encoding-default-indentation "  " (#$ . 1901))
#@107 String used to start indentation during encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json--print-indentation-prefix "\n" (#$ . 2140))
#@161 Current indentation level during encoding.
Dictates repetitions of `json-encoding-default-indentation'.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json--print-indentation-depth 0 (#$ . 2310))
#@58 String used to separate key-value pairs during encoding.
(defvar json--print-keyval-separator ":" (#$ . 2529))
#@70 If non-nil, then the output of `json-encode' will be pretty-printed.
(defvar json-encoding-pretty-print nil (#$ . 2646))
#@242 If non-nil, delimiters ] and } will be formatted Lisp-style.
This means they will be placed on the same line as the last
element of the respective array or object, without indentation.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json-encoding-lisp-style-closings nil (#$ . 2774))
#@267 Sorting predicate for JSON object keys during encoding.
If nil, no sorting is performed.  Else, JSON object keys are
ordered by the specified sort predicate during encoding.  For
instance, setting this to `string<' will have JSON object keys
ordered alphabetically.
(defvar json-encoding-object-sort-predicate nil (#$ . 3081))
#@193 If non-nil, a function to call before reading a JSON array or object.
It is called by `json-read-array' and `json-read-object',
respectively, with one argument, which is the current JSON key.
(defvar json-pre-element-read-function nil (#$ . 3415))
#@161 If non-nil, a function to call after reading a JSON array or object.
It is called by `json-read-array' and `json-read-object',
respectively, with no arguments.
(defvar json-post-element-read-function nil (#$ . 3670))
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias json-join string-join nil make-obsolete "28.1"] 4)
#@70 Non-nil if and only if LIST is an alist with simple keys.

(fn LIST)
(defalias 'json-alist-p #[257 "\211\242:\203\211@@:\204\211A\211\262\204\211?\207" [] 3 (#$ . 4010)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put json-alist-p pure t side-effect-free error-free] 5)
#@70 Non-nil if and only if LIST is a plist with keyword keys.

(fn LIST)
(defalias 'json-plist-p #[257 "\300
\242!\203\211A:\203\211AA\211\262\204\211?\207" [keywordp] 3 (#$ . 4316)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put json-plist-p pure t side-effect-free error-free] 5)
#@220 Return PLIST in reverse order.
Unlike `nreverse', this keeps the ordering of each property
relative to its value intact.  Like `nreverse', this function may
destructively modify PLIST to produce the result.

(fn PLIST)
(defalias 'json--plist-nreverse #[257 "\300
AA\211\203 A\241\210\262\211\262\211AA\262
A\241\210\202\266\207" [nil] 5 (#$ . 4632)])
#@128 Eval BODY in a temporary buffer bound to `standard-output'.
Return the resulting buffer contents as a string.

(fn &rest BODY)
(defalias 'json--with-output-to-string '(macro . #[128 "\300\301\302\303BBBD\207" [with-output-to-string with-current-buffer standard-output (setq-local inhibit-modification-hooks t)] 6 (#$ . 5001)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put json--with-output-to-string lisp-indent-function 0 put edebug-form-spec t] 5)
#@244 Eval BODY with the JSON encoding nesting incremented by one step.
This macro sets up appropriate variable bindings for
`json--print-indentation' to produce the correct indentation when
`json-encoding-pretty-print' is non-nil.

(fn &rest BODY)
(defalias 'json--with-indentation '(macro . #[128 "\300\301BB\207" [let ((json--print-indentation-prefix (if json-encoding-pretty-print json--print-indentation-prefix "")) (json--print-keyval-separator (if json-encoding-pretty-print ": " ":")) (json--print-indentation-depth (1+ json--print-indentation-depth)))] 4 (#$ . 5481)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put json--with-indentation edebug-form-spec t function-put lisp-indent-function 0] 4)
#@114 Insert the current indentation for JSON encoding at point.
Has no effect if `json-encoding-pretty-print' is nil.
(defalias 'json--print-indentation #[0 "\205	c\210\n\304\211W\205\305c\266\211T\262
\202	\266\202\207" [json-encoding-pretty-print json--print-indentation-prefix json--print-indentation-depth json-encoding-default-indentation 0 nil] 4 (#$ . 6209)])
#@163 Advance N characters forward, or 1 character if N is nil.
On reaching the end of the accessible region of the buffer, stop
and signal an error.

(fn &optional N)
(defalias 'json-advance #[256 "\211u\207" [] 2 (#$ . 6587)])
(byte-code "\300\301\302\303#\300\207" [function-put json-advance compiler-macro json-advance--inliner] 4)
#@33 

(fn INLINE--FORM &optional N)
(defalias 'json-advance--inliner #[513 "\3002\301
D0\207" [inline--just-use forward-char] 4 (#$ . 6923)])
#@93 Return the character at point.
At the end of the accessible region of the buffer, return 0.
(defalias 'json-peek #[0 "g\207" [] 1 (#$ . 7069)])
(byte-code "\300\301\302\303#\300\207" [function-put json-peek compiler-macro json-peek--inliner] 4)
#@21 

(fn INLINE--FORM)
(defalias 'json-peek--inliner #[257 "\3002\301C0\207" [inline--just-use following-char] 2 (#$ . 7320)])
#@114 Advance past the character at point, returning it.
Signal `json-end-of-file' if called at the end of the buffer.
(defalias 'json-pop #[0 "\300f\206	\301\302\300\"\300u\210\207" [nil signal json-end-of-file] 3 (#$ . 7453)])
(byte-code "\300\301\302\303#\300\207" [function-put json-pop compiler-macro json-pop--inliner] 4)
#@21 

(fn INLINE--FORM)
(defalias 'json-pop--inliner #[257 "\3002\301\302\303C\304\305\306D\307EE\310CE0\207" [inline--just-use prog1 or char-after signal quote json-end-of-file nil json-advance] 7 (#$ . 7782)])
#@36 Skip past the whitespace at point.
(defalias 'json-skip-whitespace #[0 "\300\301w\207" ["	\n
 " nil] 2 (#$ . 7998)])
(byte-code "\300\301\302\303#\300\207" [function-put json-skip-whitespace compiler-macro json-skip-whitespace--inliner] 4)
#@21 

(fn INLINE--FORM)
(defalias 'json-skip-whitespace--inliner #[257 "\3002\301\302D0\207" [inline--just-use skip-chars-forward "	\n
 "] 3 (#$ . 8244)])
(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#\210\300\321\322\301#\210\300\323\324\325#\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" json-array-format "Bad JSON array" json-end-of-file "End of file while parsing JSON" (end-of-file json-error)] 4)
#@108 Keeps track of the path during recursive calls to `json-read'.
Used internally by `json-path-to-position'.
(defvar json--path nil (#$ . 9070))
#@96 Record the KEY to the current JSON path.
Used internally by `json-path-to-position'.

(fn KEY)
(defalias 'json--record-path #[257 "`
BB\211\207" [json--path] 3 (#$ . 9219)])
#@117 Check if the last parsed JSON structure passed POSITION.
Used internally by `json-path-to-position'.

(fn POSITION)
(defalias 'json--check-position #[257 "@@\301
`T#\203\302\303\304\305\306\"\237\307\310`\257\"\210\210\211A\242\207" [json--path < throw :json-path :path mapcar cdr :match-start :match-end] 10 (#$ . 9402)])
#@721 Return the path to the JSON element at POSITION.

When STRING is provided, return the path to the position in the
string, else to the position in the current buffer.

The return value is a property list with the following
properties:

:path        -- A list of strings and numbers forming the path to
                the JSON element at the given position.  Strings
                denote object names, while numbers denote array
                indices.

:match-start -- Position where the matched JSON element begins.

:match-end   -- Position where the matched JSON element ends.

This can, for instance, be useful to determine the path to a JSON
element in a deeply nested structure.

(fn POSITION &optional STRING)
(defalias 'json-path-to-position #[513 "\212\211\204eb\210\303\304\305\306\"\3072\"\211\203\310
!\202!\311 0\312
\313\"\205*\211+\262
)\207" [json--path json-pre-element-read-function json-post-element-read-function nil json--record-path make-closure #[0 "\301\300!\207" [V0 json--check-position] 2] :json-path json-read-from-string json-read plist-get :path] 6 (#$ . 9741)])
#@24 List of JSON keywords.
(defconst json-keywords '("true" "false" "null") (#$ . 10854))
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [make-obsolete-variable json-keywords "it is no longer used." "28.1" put json--post-value rx-definition ((| (in "	\n
 ,]}") eos))] 4)
#@56 Read the expected JSON KEYWORD at point.

(fn KEYWORD)
(defalias 'json-read-keyword #[257 "\211\303\267\202\304\202\202	\202\305\306C\"
\304\307
!)\262
\204+\305\306\310\311!C\"\210
Gu\210\312\304\307
!)\262
\204C\305\306\310\311!C\"\210\313\314w\210\207" [json-false json-null inhibit-changing-match-data #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("true" 6 "false" 10 "null" 14)) t signal json-unknown-keyword looking-at thing-at-point word "[]	\n
 ,}]\\|\\'" "	\n
 " nil] 6 (#$ . 11136)])
#@47 Encode KEYWORD as a JSON value.

(fn KEYWORD)
(defalias 'json-encode-keyword #[257 "\211\302=\203\303\207\211=\203\304\207\211	=\205\305\207" [json-false json-null t "true" "false" "null"] 3 (#$ . 11693)])
(byte-code "\300\301\302\303#\300\207" [function-put json-encode-keyword side-effect-free t] 4)
#@115 Insert KEYWORD as a JSON value at point.
Return nil if KEYWORD is not recognized as a JSON keyword.

(fn KEYWORD)
(defalias 'json--print-keyword #[257 "\300
!\211\262
\203

c\210\207" [json-encode-keyword] 3 (#$ . 12009)])
(put 'json--number 'rx-definition '((: (32 45) (| (: (in "1-9") (* digit)) 48) (32 46 (+ digit)) (32 (in "Ee") (32 (in 43 45)) (+ digit)))))
#@60 Read the JSON number following point.

(fn &optional SIGN)
(defalias 'json-read-number #[256 "\301\302!\204\f\303\304`C\"\210\305\225b\210\306\307\305!!\310\311\301
!)\262
\204'\303\304`C\"\210\312\313w\210\207" [inhibit-changing-match-data looking-at "-?\\(?:[1-9][[:digit:]]*\\|0\\)\\(?:\\.[[:digit:]]+\\)?\\(?:[Ee][+-]?[[:digit:]]+\\)?" signal json-number-format 0 string-to-number match-string "[]	\n
 ,}]\\|\\'" t "	\n
 " nil] 5 (#$ . 12381)])
(byte-code "\300\301\302\303#\210\304\305\306\302#\210\307\305\306\303#\207" [set-advertised-calling-convention json-read-number nil "28.1" defalias json-encode-number json-encode make-obsolete] 4)
#@70 Characters which are escaped in JSON, with their Elisp counterparts.
(defconst json-special-chars '((34 . 34) (92 . 92) (98 . 8) (102 . 12) (110 . 10) (114 . 13) (116 . 9)) (#$ . 13037))
#@89 Return the code point represented by the UTF-16 surrogates HIGH and LOW.

(fn HIGH LOW)
(defalias 'json--decode-utf-16-surrogates #[514 "\300\301Z\302\"
\303Z\\\304\\\207" [ash 55296 10 56320 65536] 5 (#$ . 13230)])
#@50 Read the JSON string escaped character at point.
(defalias 'json-read-escaped-char #[0 "\301u\210\301f\206\f\302\303\301\"\301u\210\211\236A\206J\211\304U\204\207\305\306!\2035\307u\210\310\311\312\313!\314\"\311\312\315!\314\"\"\207\305\316!\203E\317u\210\311\312\320!\314\"\207\302\321`C\"\207" [json-special-chars nil signal json-end-of-file 117 looking-at "\\([Dd][89ABab][[:xdigit:]]\\{2\\}\\)\\\\u\\([Dd][C-Fc-f][[:xdigit:]]\\{2\\}\\)" 10 json--decode-utf-16-surrogates string-to-number match-string 1 16 2 "[[:xdigit:]]\\{4\\}" 4 0 json-string-escape] 6 (#$ . 13453)])
#@32 Read the JSON string at point.
(defalias 'json-read-string #[0 "\300u\210\300g\211\301U\204>\211\302W\203%\211\303U\203\304\305\300\"\210\202%\304\306C\"\210\211\307U\2030\310 \2024\300u\210\211B\262g\262
\202\300u\210
\203J
\237\260
\207\311\207" [nil 34 32 0 signal json-end-of-file json-string-format 92 json-read-escaped-char ""] 5 (#$ . 14042)])
#@139 Insert a JSON representation of STRING at point.
FROM is the index of STRING to start from and defaults to 0.

(fn STRING &optional FROM)
(defalias 'json--print-string #[513 "\301c\210`\302!\210b\210\211\203\303
!\210\304\305\306\307#\2033h\303\310!\210\311\312\"@\206,\313\314\"\261\266\202\301c\210
\207" [json-special-chars 34 princ delete-char re-search-forward "[\"\\[:cntrl:]]" nil move -1 92 rassq format "u%04x"] 7 (#$ . 14413)])
#@54 Return a JSON representation of STRING.

(fn STRING)
(defalias 'json-encode-string #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-string buffer-string] 4 (#$ . 14869)])
#@120 Insert OBJECT encoded as a JSON string at point.
Return nil if OBJECT cannot be encoded as a JSON string.

(fn OBJECT)
(defalias 'json--print-stringlike #[257 "\211;\203	\300
!\207\301
!\203\300\302!\303\"\207\2119\205 \300\302!!\207" [json--print-string keywordp symbol-name 1] 4 (#$ . 15252)])
#@129 Insert a JSON key representation of OBJECT at point.
Signal `json-key-format' if it cannot be encoded as a string.

(fn OBJECT)
(defalias 'json--print-key #[257 "\300
!\206\301\302C\"\207" [json--print-stringlike signal json-key-format] 4 (#$ . 15561)])
#@146 Return a JSON representation of OBJECT.
If the resulting JSON object isn't a valid JSON object key,
this signals `json-key-format'.

(fn OBJECT)
(defalias 'json-encode-key #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-key buffer-string] 4 (#$ . 15825)])
(make-obsolete 'json-encode-key 'json-encode "28.1")
#@118 Create a new Elisp object corresponding to an empty JSON object.
Please see the documentation of `json-object-type'.
(defalias 'json-new-object #[0 "\301=\205\n\302\303\304\"\207" [json-object-type hash-table make-hash-table :test equal] 3 (#$ . 16347)])
#@251 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'.

(fn OBJECT KEY VALUE)
(defalias 'json-add-to-object #[771 "\206	\302\267\202\303\202\304\202\305\202\306\211\307\267\2020
\2021\310!\2021\310\311P!\2021\306\262	\312\267\202S\313#\210\202T

BB\202T

BB\202T\306)\207" [json-key-type json-object-type #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hash-table 10 alist 14 plist 18)) string symbol keyword nil #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 30 symbol 34 keyword 40)) intern ":" #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hash-table 57 alist 67 plist 75)) puthash] 8 (#$ . 16611)])
#@32 Read the JSON object at point.
(defalias 'json-read-object #[0 "\303u\210\304\303w\210\305 \303\211g\306U\204n\304\303w\210\307 \262\304\303w\210g\310U\203)\303u\210\2020\311\312\313gD\"\210\304\303w\210\203<!\210\314 \262
	\203G	 \210\315#\262\304\303w\210g\306U\204g\316U\203d\303u\210\202\311\312\317gD\"\210\202\303u\210\n\320\267\202~\237\207\321!\207\207" [json-pre-element-read-function json-post-element-read-function json-object-type nil "	\n
 " json-new-object 125 json-read-string 58 signal json-object-format ":" json-read json-add-to-object 44 "," #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (alist 119 plist 122)) json--plist-nreverse] 7 (#$ . 17545)])
#@126 Insert JSON representation of KEY-VAL pair at point.
This always inserts a trailing `json-encoding-separator'.

(fn KEY VAL)
(defalias 'json--print-pair #[514 "\302 \210\303!\210c\210\304
!\210	c\207" [json--print-keyval-separator json-encoding-separator json--print-indentation json--print-key json--print] 4 (#$ . 18284)])
#@104 Insert JSON object representation of MAP at point.
This works for any MAP satisfying `mapp'.

(fn MAP)
(defalias 'json--print-map #[257 "\306c\210\307
!\2043\203	\202\310\203\311\202\312\nT\313\314\"\210\315\fG[!\210+
\2043\316 \210\317c\207" [json-encoding-pretty-print json--print-indentation-prefix json--print-indentation-depth json--print-keyval-separator json-encoding-separator json-encoding-lisp-style-closings 123 map-empty-p "" ": " ":" map-do json--print-pair delete-char json--print-indentation 125] 4 (#$ . 18618)])
#@182 Like `json--print-map', but optionally sort MAP first.
If `json-encoding-object-sort-predicate' is non-nil, this first
transforms an unsortable MAP into a sortable alist.

(fn MAP)
(defalias 'json--print-unordered-map #[257 "\203\301
!\204\302\303!\304\"\207\305
!\207" [json-encoding-object-sort-predicate map-empty-p json--print-alist map-pairs t json--print-map] 4 (#$ . 19170)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias json-encode-hash-table json-encode nil make-obsolete "28.1"] 4)
#@203 Insert a JSON representation of ALIST at point.
Sort ALIST first if `json-encoding-object-sort-predicate' is
non-nil.  Sorting can optionally be DESTRUCTIVE for speed.

(fn ALIST &optional DESTRUCTIVE)
(defalias 'json--print-alist #[513 "\301\203\203\302\203\202\303!\304\"\202!\207" [json-encoding-object-sort-predicate json--print-map sort copy-sequence #[514 "@@\"\207" [json-encoding-object-sort-predicate] 5 "\n\n(fn A B)"]] 6 (#$ . 19696)])
#@52 Return a JSON representation of ALIST.

(fn ALIST)
(defalias 'json-encode-alist #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-alist buffer-string] 4 (#$ . 20168)])
#@52 Return a JSON representation of PLIST.

(fn PLIST)
(defalias 'json-encode-plist #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-unordered-map buffer-string] 4 (#$ . 20546)])
#@67 Like `json-encode-list', but insert the JSON at point.

(fn LIST)
(defalias 'json--print-list #[257 "\300
!\203\n\301
!\207\302
!\203\303
!\207\211<\203\304
!\207\305\306C\"\207" [json-alist-p json--print-alist json-plist-p json--print-unordered-map json--print-array signal json-error] 4 (#$ . 20932)])
#@143 Return a JSON representation of LIST.
Tries to DWIM: alists and plists become JSON objects, while
simple lists become JSON arrays.

(fn LIST)
(defalias 'json-encode-list #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-list buffer-string] 4 (#$ . 21249)])
(make-obsolete 'json-encode-list 'json-encode "28.1")
#@31 Read the JSON array at point.
(defalias 'json-read-array #[0 "\303u\210\304\303w\210\303\305g\306U\204L\304\303w\210\203
!\210\211T\262
\307 B\262	\203,	 \210\304\303w\210g\306U\204	g\310U\203B\303u\210\202	\311\312\313gD\"\210\202	\303u\210\n\314\267\202]\315!\237\207
\237\207\303\207" [json-pre-element-read-function json-post-element-read-function json-array-type nil "	\n
 " 0 93 json-read 44 signal json-array-format "," #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (vector 85 list 90)) vconcat] 6 (#$ . 21770)])
#@69 Like `json-encode-array', but insert the JSON at point.

(fn ARRAY)
(defalias 'json--print-array #[257 "\305c\210\306
\307\"\2047\203	\202\310\203\311\202\312\nT\313 \210\314C\315\316\317\"\"\266+\f\2047\313 \210\320c\207" [json-encoding-pretty-print json--print-indentation-prefix json--print-indentation-depth json--print-keyval-separator json-encoding-lisp-style-closings 91 length= 0 "" ": " ":" json--print-indentation t mapc make-closure #[257 "\300\242\203\f\300\302\240\210\202	c\210\303 \210\304
!\207" [V0 json-encoding-separator nil json--print-indentation json--print] 3 "\n\n(fn ELT)"] 93] 6 (#$ . 22349)])
#@78 Return a JSON representation of ARRAY.
ARRAY can also be a list.

(fn ARRAY)
(defalias 'json-encode-array #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print-array buffer-string] 4 (#$ . 22996)])
#@99 Dispatch reader function for CHAR at point.
If CHAR is nil, signal `json-end-of-file'.

(fn CHAR)
(defalias 'json-readtable-dispatch '(macro . #[257 "\300
!\203\n\211\202
\301\302!\303\304\305\306\307\"\310\311D\312\313D\314\315D\316\317\320BB\321\317\322BB\323\317\324BB\325\326\327\"BBBBBB\"\330\331\332DED\333B\"B
=\203K\207\334DC\"\207" [macroexp-const-p make-symbol "char" cond append map-apply make-closure #[514 "\301\300E
D\207" [V0 eq] 5 "\n\n(fn KEY EXPR)"] 34 json-read-string 91 json-read-array 123 json-read-object 110 json-read-keyword ("null") 102 ("false") 116 ("true") mapcar #[257 "\211\300D\207" [json-read-number] 3 "\n\n(fn C)"] (45 48 49 50 51 52 53 54 55 56 57) signal 'json-readtable-error list ((t (signal 'json-end-of-file nil))) macroexp-let*] 15 (#$ . 23400)]))
(put 'json-readtable-dispatch 'edebug-form-spec t)
#@297 Parse and return the JSON object following point.
Advances point just past JSON object.

If called with the following JSON after point

  {"a": [1, 2, {"c": false}],
   "b": "foo"}

you will get the following structure returned:

  ((a .
      [1 2
         ((c . :json-false))])
   (b . "foo"))
(defalias 'json-read #[0 "\300\301w\210\301f\211\302\267\202B\303 \207\304 \207\305 \207\306\307!\207\306\310!\207\306\311!\207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\312 \207\211\203L\313\314C\"\207\313\315\301\"\207" ["	\n
 " nil #s(hash-table size 17 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (34 12 91 15 123 18 110 21 102 25 116 29 45 33 48 36 49 39 50 42 51 45 52 48 53 51 54 54 55 57 56 60 57 63)) json-read-string json-read-array json-read-object json-read-keyword "null" "false" "true" json-read-number signal json-readtable-error json-end-of-file] 4 (#$ . 24260)])
#@70 Read the JSON object contained in STRING and return it.

(fn STRING)
(defalias 'json-read-from-string #[257 "\300\301\302\"r\211q\210\303\304\"\216
c\210eb\210\305 *\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] json-read] 5 (#$ . 25213)])
#@72 Read the first JSON object contained in FILE and return it.

(fn FILE)
(defalias 'json-read-file #[257 "\300\301\302\"r\211q\210\303\304\"\216\305!\210\306 *\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents json-read] 5 (#$ . 25532)])
#@73 Like `json-encode', but insert or print the JSON at point.

(fn OBJECT)
(defalias 'json--print #[257 "\300
!\2067\211<\203\301
!\207\302
!\2067\211\247\203\303
!\207\304
!\203(\305
!\207\306
!\2032\307
!\207\310\311C\"\207" [json--print-keyword json--print-list json--print-stringlike prin1 arrayp json--print-array hash-table-p json--print-unordered-map signal json-error] 4 (#$ . 25865)])
#@217 Return a JSON representation of OBJECT as a string.

OBJECT should have a structure like one returned by `json-read'.
If an error is detected during encoding, an error based on
`json-error' is signaled.

(fn OBJECT)
(defalias 'json-encode #[257 "\302\303\304\"\305\216rq\210\306\301!\210\304\307
!\210*rq\210\310 +\207" [standard-output inhibit-modification-hooks generate-new-buffer " *string-output*" t #[0 "\301!\207" [standard-output kill-buffer] 2] make-local-variable json--print buffer-string] 4 (#$ . 26272)])
#@107 Pretty-print current buffer.
With prefix argument MINIMIZE, minimize it instead.

(fn &optional MINIMIZE)
(defalias 'json-pretty-print-buffer #[256 "\300ed#\207" [json-pretty-print] 5 (#$ . 26804) "P"])
#@184 Maximum time for `json-pretty-print's comparison.
The function `json-pretty-print' uses `replace-region-contents'
(which see) passing the value of this variable as argument
MAX-SECS.
(defvar json-pretty-print-max-secs 2.0 (#$ . 27015))
#@118 Pretty-print selected region.
With prefix argument MINIMIZE, minimize it instead.

(fn BEGIN END &optional MINIMIZE)
(defalias 'json-pretty-print #[770 "\211?\305\306\307p\310C\311\312\313\"r\211q\210\314\315\"\216pq\210\316\314\317$\f\320%\266*\210\211\242\205C\321
\242@\242A\",\207" [json-key-type json-object-type json-null json-encoding-pretty-print json-pretty-print-max-secs :json-null alist string nil generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] replace-region-contents #[0 "`\303\211\203E\3041)``\305\306w\\{\307 `\262\302q\210
\310!\261\210\300q\266\2020\210\202\306\262\300q\210\311\302d#\210\211@\312=?\205@\301
\240\266\202\302\207" [V0 V1 V2 t (t) " 	\n" nil json-read json-encode append-to-buffer json-end-of-file] 7] 64 signal] 19 (#$ . 27258) "r\nP"])
#@132 Pretty-print current buffer with object keys ordered.
With prefix argument MINIMIZE, minimize it instead.

(fn &optional MINIMIZE)
(defalias 'json-pretty-print-buffer-ordered #[256 "\301\302
!)\207" [json-encoding-object-sort-predicate string< json-pretty-print-buffer] 3 (#$ . 28138) "P"])
#@138 Pretty-print the region with object keys ordered.
With prefix argument MINIMIZE, minimize it instead.

(fn BEGIN END &optional MINIMIZE)
(defalias 'json-pretty-print-ordered #[770 "\301\302#)\207" [json-encoding-object-sort-predicate string< json-pretty-print] 7 (#$ . 28437) "r\nP"])
(provide 'json)