HOME

Mini Shell 1.0
DIR:/proc/self/root/proc/thread-self/root/usr/share/emacs/26.1/lisp/
Current File : //proc/self/root/proc/thread-self/root/usr/share/emacs/26.1/lisp/json.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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.

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


(require 'map)
#@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 (#$ . 424))
#@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 (#$ . 717))
#@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 (#$ . 919))
#@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 (#$ . 1496))
#@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 (#$ . 1787))
#@53 Value to use as an element separator when encoding.
(defvar json-encoding-separator "," (#$ . 2068))
#@101 The default indentation level for encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json-encoding-default-indentation "  " (#$ . 2176))
#@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" (#$ . 2343))
#@70 If non-nil, then the output of `json-encode' will be pretty-printed.
(defvar json-encoding-pretty-print nil (#$ . 2542))
#@81 If non-nil, ] and } closings will be formatted lisp-style,
without indentation.
(defvar json-encoding-lisp-style-closings nil (#$ . 2669))
#@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 (#$ . 2815))
#@207 Function called (if non-nil) by `json-read-array' and
`json-read-object' right before reading a JSON array or object,
respectively.  The function is called with one argument, which is
the current JSON key.
(defvar json-pre-element-read-function nil (#$ . 3149))
#@132 Function called (if non-nil) by `json-read-array' and
`json-read-object' right after reading a JSON array or object,
respectively.
(defvar json-post-element-read-function nil (#$ . 3418))
#@54 Join STRINGS with SEPARATOR.

(fn STRINGS SEPARATOR)
(defalias 'json-join #[514 "\300\301#\207" [mapconcat identity] 6 (#$ . 3612)])
#@71 Non-null if and only if LIST is an alist with simple keys.

(fn LIST)
(defalias 'json-alist-p #[257 "\211:\203\211@:\203\211@@:\204\211A\202\300\262\202\211?\207" [not-alist] 2 (#$ . 3753)])
#@71 Non-null if and only if LIST is a plist with keyword keys.

(fn LIST)
(defalias 'json-plist-p #[257 "\211:\203\300@!\203\211A:\203\211AA\202\301\262\202\211?\207" [keywordp not-plist] 3 (#$ . 3961)])
#@116 Return a copy of PLIST in reverse order.
Unlike `reverse', this keeps the property-value pairs intact.

(fn PLIST)
(defalias 'json--plist-reverse #[257 "\300\203\211A\262\242\211A\262\242\211B\262B\266\203\202\211\207" [nil] 6 (#$ . 4180)])
#@67 Return an alist of the property-value pairs in PLIST.

(fn PLIST)
(defalias 'json--plist-to-alist #[257 "\300\203\211A\262\242\211A\262\242BB\266\203\202\211\237\207" [nil] 6 (#$ . 4440)])
#@13 

(fn BODY)
(defalias 'json--with-indentation '(macro . #[257 "\300\301E\207" [let ((json--encoding-current-indentation (if json-encoding-pretty-print (concat json--encoding-current-indentation json-encoding-default-indentation) "")))] 4 (#$ . 4647)]))
#@49 Advance N characters forward.

(fn &optional N)
(defalias 'json-advance #[256 "\211u\207" [] 2 (#$ . 4907)])
(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\301D0\207" [inline--just-use forward-char] 4 (#$ . 5129)])
#@32 Return the character at point.
(defalias 'json-peek #[0 "g\207" [] 1 (#$ . 5275)])
(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 (#$ . 5465)])
#@52 Advance past the character at point, returning it.
(defalias 'json-pop #[0 "g\211\300U\203\301\302\303\"\202\303u\210\211\207" [0 signal json-end-of-file nil] 4 (#$ . 5597)])
(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\303CDC\304\305\302D\306\307\310D\311E\312C\302\257E0\207" [inline--just-use let char json-peek if zerop signal quote json-end-of-file nil json-advance] 8 (#$ . 5881)])
#@36 Skip past the whitespace at point.
(defalias 'json-skip-whitespace #[0 "\300\301w\207" ["	
\n " nil] 2 (#$ . 6128)])
(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 (#$ . 6374)])
(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\323#\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-end-of-file "End of file while parsing JSON" (end-of-file json-error)] 4)
#@109 Used internally by `json-path-to-position' to keep track of
the path during recursive calls to `json-read'.
(defvar json--path nil (#$ . 7144))
#@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 (#$ . 7294)])
#@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 (#$ . 7477)])
#@719 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
                indexes.

: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 apply-partially json--check-position :json-path json-read-from-string json-read plist-get :path] 6 (#$ . 7816)])
#@24 List of JSON keywords.
(defvar json-keywords '("true" "false" "null") (#$ . 8902))
#@78 Read a JSON keyword at point.
KEYWORD is the keyword expected.

(fn KEYWORD)
(defalias 'json-read-keyword #[257 "\211\235\204\f\303\304C\"\210\305\306\"\210\307\310w\210\311\312!\204)\303\304\212\313\314!\210\315\316!)C\"\210\211\317\230\2031\320\207\211\321\230\2039	\207\211\322\230\205@\n\207" [json-keywords json-false json-null signal json-unknown-keyword mapc #[257 "\211gU\204\300\301\212\302\303!\210\304\305!)C\"\210\306u\207" [signal json-unknown-keyword backward-word-strictly 1 thing-at-point word nil] 5 "\n\n(fn CHAR)"] "	
\n " nil looking-at "\\([],}]\\|$\\)" backward-word-strictly 1 thing-at-point word "true" t "false" "null"] 5 (#$ . 8991)])
#@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 (#$ . 9668)])
#@213 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.

(fn &optional SIGN)
(defalias 'json-read-number #[256 "\300\204g\301U\203\302u\210\303\304![\202I\204(g\305U\203(\302u\210\303\304!\202I\306!\203D\307\224\2048\310\224\203D\311\225b\210\312\313\311!!\202I\314\315`C\"\207" ["\\([0-9]+\\)?\\(\\.[0-9]+\\)?\\([Ee][+-]?[0-9]+\\)?" 45 nil json-read-number t 43 looking-at 1 2 0 string-to-number match-string signal json-number-format] 5 (#$ . 9887)])
#@54 Return a JSON representation of NUMBER.

(fn NUMBER)
(defalias 'json-encode-number #[257 "\300\301\"\207" [format "%s"] 4 (#$ . 10496)])
#@70 Characters which are escaped in JSON, with their elisp counterparts.
(defvar json-special-chars '((34 . 34) (92 . 92) (98 . 8) (102 . 12) (110 . 10) (114 . 13) (116 . 9)) (#$ . 10640))
#@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\301\302Z\303\"\304Z\305#\207" [+ lsh 55296 10 56320 65536] 6 (#$ . 10831)])
#@50 Read the JSON string escaped character at point.
(defalias 'json-read-escaped-char #[0 "\301u\210g\211\302U\203\303\304\301\"\202\301u\210\211\262\211\236\211\203#\211A\202a\305=\204-\202a\306\307!\203G\310u\210\311\312\313\314!\315\"\312\313\316!\315\"\"\202a\306\317!\203\\\313\302!\320u\210\312\315\"\262\202a\303\321`C\"\207" [json-special-chars nil 0 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 json-string-escape] 7 (#$ . 11057)])
#@32 Read the JSON string at point.
(defalias 'json-read-string #[0 "g\300U\204\f\301\302\303C\"\210\304u\210\304g\211\300U\204N\211\305W\203%\301\302\306!C\"\210\211\307U\2030\310 \202Dg\211\311U\203>\301\312\304\"\202B\304u\210\211\262B\262g\262\202\304u\210\203\\\237\260\202]\313\207" [34 signal json-string-format "doesn't start with `\"'!" nil 32 prin1-char 92 json-read-escaped-char 0 json-end-of-file ""] 6 (#$ . 11690)])
#@54 Return a JSON representation of STRING.

(fn STRING)
(defalias 'json-encode-string #[257 "\211G\301\302\211\303\304#\211\262\203>H\305\"OB\262\211\203-\306\307@\"\2021\310\311\"B\262T\262\266\202OB\262\312B\262\313\314\312\237#\207" [json-special-chars 0 nil string-match "[\"\\[:cntrl:]]" rassq string 92 format "\\u%04x" "\"" apply concat] 10 (#$ . 12140)])
#@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 "\300!\301!;\204\302\303C\"\210\211\207" [json-encode json-read-from-string signal json-key-format] 5 (#$ . 12541)])
#@111 Create a new Elisp object corresponding to a JSON object.
Please see the documentation of `json-object-type'.
(defalias 'json-new-object #[0 "\301\267\202\302\303\304\"\207\305\207" [json-object-type #s(hash-table size 1 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hash-table 6)) make-hash-table :test equal nil] 3 (#$ . 12848)])
#@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\236A\211\303\267\202!\202\"\304!\202\"\304\305P!\202\"\306\262	\307\267\202D\310#\210\202EBB\202EBB\202E\306)\207" [json-key-type json-object-type ((hash-table . string) (alist . symbol) (plist . keyword)) #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 15 symbol 19 keyword 25)) intern ":" nil #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (hash-table 42 alist 52 plist 60)) puthash] 8 (#$ . 13209)])
#@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\202\237\202\203\321!\202\203\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 124)) json--plist-reverse] 7 (#$ . 14024)])
#@62 Return a JSON representation of HASH-TABLE.

(fn HASH-TABLE)
(defalias 'json-encode-hash-table #[257 "\203\306\307\310\"!\207\311\312\313\314C	\203\nP\202\315\316\317\320\321\322\323!\324\"\325\326%\"\210)\211\242\262\f\"	\203=
\203A\315\202B\n#\207" [json-encoding-object-sort-predicate json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator json-encoding-lisp-style-closings json-encode-alist map-into list format "{%s%s}" json-join nil "" maphash make-byte-code 514 "\300\303	\203\n\304\202\305\n\306!\307!$\300\242B\240\207" vconcat vector [json-encoding-pretty-print json--encoding-current-indentation format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 9 "\n\n(fn K V)"] 12 (#$ . 14774)])
#@52 Return a JSON representation of ALIST.

(fn ALIST)
(defalias 'json-encode-alist #[257 "\203\n\306\307\"\262\310\311\312	\203\nP\202\313\314\315\")\f\"	\203(
\203,\313\202-\n#\207" [json-encoding-object-sort-predicate json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator json-encoding-lisp-style-closings sort #[514 "@@\"\207" [json-encoding-object-sort-predicate] 5 "\n\n(fn A B)"] format "{%s%s}" json-join "" mapcar #[257 "\302\203	\303\202\n\304	\305@!\306A!$\207" [json-encoding-pretty-print json--encoding-current-indentation format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 7 "\n\n(fn CONS)"]] 7 (#$ . 15570)])
#@52 Return a JSON representation of PLIST.

(fn PLIST)
(defalias 'json-encode-plist #[257 "\203\n\306\307!!\207\310	\203\nP\202\311\203;\n\312@!	\203(\313\202)\314\315A@!RB\262AA\262\202)\316\317\237\f\"	\203N
\204N\n\202O\311\320R\207" [json-encoding-object-sort-predicate json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator json-encoding-lisp-style-closings json-encode-alist json--plist-to-alist nil "" json-encode-key ": " ":" json-encode "{" json-join "}"] 7 (#$ . 16290)])
#@143 Return a JSON representation of LIST.
Tries to DWIM: simple lists become JSON arrays, while alists and plists
become JSON objects.

(fn LIST)
(defalias 'json-encode-list #[257 "\211\204\300\207\301!\203\302!\207\303!\203\304!\207\211<\203#\305!\207\306\307C\"\207" ["null" json-alist-p json-encode-alist json-plist-p json-encode-plist json-encode-array signal json-error] 4 (#$ . 16865)])
#@31 Read the JSON array at point.
(defalias 'json-read-array #[0 "\303u\210\304\303w\210\303g\305U\204G\304\303w\210\203G!\210\306 B\262	\203(	 \210\304\303w\210g\305U\204g\307U\203>\303u\210\202\310\311\312C\"\210\202\303u\210\n\313\267\202\\\314!\237\202]\211\237\202]\303\207" [json-pre-element-read-function json-post-element-read-function json-array-type nil "	
\n " 93 json-read 44 signal json-error bleah #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (vector 80 list 87)) vconcat] 4 (#$ . 17273)])
#@52 Return a JSON representation of ARRAY.

(fn ARRAY)
(defalias 'json-encode-array #[257 "\2036\211G\305V\2036\203	\nP\202\306\307\310	\"\311\312\313\"\307\314	#\"P)\307\315\f\2032\306\2023	\"P\207\316\317\313#\320Q\207" [json-encoding-pretty-print 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 "]"] 8 (#$ . 17839)])
#@47 Dispatch reader function for CHAR.

(fn CHAR)
(defalias 'json-readtable-dispatch '(macro . #[257 "\300\301\302\211\203\211@\211\303DB\262A\266\202\202\210\211\203:\211@\211@A\211\304	EDB\262\266A\266\202\202\210\305\306\307\310\311\312	DEDC\"B\207" [((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)) nil (45 43 46 48 49 50 51 52 53 54 55 56 57) json-read-number eq cond append t signal 'json-readtable-error list] 12 (#$ . 18329)]))
(put 'json-readtable-dispatch 'edebug-form-spec '(symbolp))
#@89 Parse and return the JSON object following point.
Advances point just past JSON object.
(defalias 'json-read #[0 "\300\301w\210g\211\302U\203\303\304\301\"\202\211\305\267\202z\306 \202\307 \202\310 \202\311\312!\202\311\313!\202\311\314!\202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\315 \202\303\316C\"\207" ["	
\n " nil 0 signal json-end-of-file #s(hash-table size 19 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (34 24 91 29 123 34 110 39 102 45 116 51 45 57 43 62 46 67 48 72 49 77 50 82 51 87 52 92 53 97 54 102 55 107 56 112 57 117)) json-read-string json-read-array json-read-object json-read-keyword "null" "false" "true" json-read-number json-readtable-error] 4 (#$ . 18963)])
#@70 Read the JSON object contained in STRING and return it.

(fn STRING)
(defalias 'json-read-from-string #[257 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210eb\210\311 *\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 json-read] 8 (#$ . 19785)])
#@72 Read the first JSON object contained in FILE and return it.

(fn FILE)
(defalias 'json-read-file #[257 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311!\210eb\210\312 *\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents json-read] 8 (#$ . 20130)])
#@66 Return a JSON representation of OBJECT as a string.

(fn OBJECT)
(defalias 'json-encode #[257 "\211\302	E>\203
\303!\207\211;\203\304!\207\305!\203%\304\306!\307\310O!\207\2119\2030\304\306!!\207\211\247\2039\311!\207\312!\203C\313!\207\314!\203M\315!\207\211<\203V\316!\207\317\320C\"\207" [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] 5 (#$ . 20495)])
#@30 Pretty-print current buffer.
(defalias 'json-pretty-print-buffer #[0 "\300ed\"\207" [json-pretty-print] 3 (#$ . 21037) nil])
#@47 Pretty-print selected region.

(fn BEGIN END)
(defalias 'json-pretty-print #[514 "\306 \307\211\307C\310\311\312\313\314	\"\315\"\316$\216\317!\210\320\321\322		\"\323\324!!c\210*\266\211\320\240,\207" [most-positive-fixnum undo-strong-limit undo-limit undo-outer-limit json-object-type json-encoding-pretty-print prepare-change-group nil make-byte-code 0 "\301\242\203	\302\300!\207\303\300!\207" vconcat vector [accept-change-group cancel-change-group] 2 activate-change-group t alist delete-and-extract-region json-encode json-read-from-string] 14 (#$ . 21168) "r"])
#@55 Pretty-print current buffer with object keys ordered.
(defalias 'json-pretty-print-buffer-ordered #[0 "\301\302 )\207" [json-encoding-object-sort-predicate string< json-pretty-print-buffer] 1 (#$ . 21764) nil])
#@67 Pretty-print the region with object keys ordered.

(fn BEGIN END)
(defalias 'json-pretty-print-ordered #[514 "\301\302\")\207" [json-encoding-object-sort-predicate string< json-pretty-print] 5 (#$ . 21982) "r"])
(provide 'json)