emacsd/elpa/skewer-mode-20180706.1807/skewer-mode.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.

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\307\310\311\312\313\314%\207" [require cl-lib json url-util simple-httpd js2-mode cache-table custom-declare-group skewer nil "Live browser JavaScript interaction." :group languages] 6)
#@25 Keymap for skewer-mode.
(defvar skewer-mode-map (byte-code "\300 \211\301\302\303#\210\301\304\305#\210\301\306\307#\210\207" [make-sparse-keymap define-key "" skewer-eval-last-expression [134217752] skewer-eval-defun "" skewer-load-buffer] 6) (#$ . 685))
#@50 Location of data files needed by impatient-mode.
(defvar skewer-data-root (file-name-directory load-file-name) (#$ . 954))
#@346 Hook to run when skewer.js is being served to the browser.

When hook functions are called, the current buffer is the buffer
to be served to the client (a defservlet), with skewer.js script
already inserted. This is the chance for other packages to insert
their own JavaScript to extend skewer in the browser, such as
adding a new type handler.
(defvar skewer-js-hook nil (#$ . 1084))
#@180 Hook to run when a response arrives from the browser. Used for
catching messages from the browser with no associated
callback. The response object is passed to the hook function.
(defvar skewer-response-hook nil (#$ . 1476))
#@61 Maximum time to wait on the browser to respond, in seconds.
(defvar skewer-timeout 3600 (#$ . 1707))
#@40 Browsers awaiting JavaScript snippets.
(defvar skewer-clients nil (#$ . 1814))
#@41 Maps evaluation IDs to local callbacks.
(defvar skewer-callbacks (cache-table-create skewer-timeout :test 'equal) (#$ . 1899))
#@34 Queued messages for the browser.
(defvar skewer-queue nil (#$ . 2032))
#@88 Timestamp of the last browser response. Use
`skewer-last-seen-seconds' to access this.
(defvar skewer--last-timestamp 0 (#$ . 2109))
#@72 compiler-macro for inlining `skewer-client-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'skewer-client-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block skewer-client-p (and (memq (type-of cl-x) cl-struct-skewer-client-tags) t)) nil] 9 (#$ . 2248)])
(put 'skewer-client-p 'compiler-macro 'skewer-client-p--cmacro)
#@13 

(fn CL-X)
(defalias 'skewer-client-p #[257 "\301
!>\205	\302\207" [cl-struct-skewer-client-tags type-of t] 3 (#$ . 2600)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put skewer-client-p side-effect-free error-free put skewer-client cl-deftype-satisfies] 5)
#@75 compiler-macro for inlining `skewer-client-proc'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'skewer-client-proc--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block skewer-client-proc (or (skewer-client-p cl-x) (signal 'wrong-type-argument (list 'skewer-client cl-x))) (aref cl-x 1)) nil] 9 (#$ . 2886)])
(put 'skewer-client-proc 'compiler-macro 'skewer-client-proc--cmacro)
#@63 Access slot "proc" of `skewer-client' struct CL-X.

(fn CL-X)
(defalias 'skewer-client-proc #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-skewer-client-tags type-of signal wrong-type-argument skewer-client 1] 5 (#$ . 3293)])
(byte-code "\300\301\302\303#\300\207" [function-put skewer-client-proc side-effect-free t] 4)
#@76 compiler-macro for inlining `skewer-client-agent'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'skewer-client-agent--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block skewer-client-agent (or (skewer-client-p cl-x) (signal 'wrong-type-argument (list 'skewer-client cl-x))) (aref cl-x 2)) nil] 9 (#$ . 3640)])
(put 'skewer-client-agent 'compiler-macro 'skewer-client-agent--cmacro)
#@64 Access slot "agent" of `skewer-client' struct CL-X.

(fn CL-X)
(defalias 'skewer-client-agent #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-skewer-client-tags type-of signal wrong-type-argument skewer-client 2] 5 (#$ . 4052)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put skewer-client-agent side-effect-free t defalias copy-skewer-client copy-sequence] 4)
#@92 compiler-macro for inlining `make-skewer-client'.

(fn CL-WHOLE &cl-quote &key PROC AGENT)
(defalias 'make-skewer-client--cmacro #[385 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :proc :agent (:proc :agent :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:proc :agent)" cl--defsubst-expand (proc agent) (cl-block make-skewer-client (record 'skewer-client proc agent))] 12 (#$ . 4454)])
(put 'make-skewer-client 'compiler-macro 'make-skewer-client--cmacro)
#@72 Constructor for objects of type `skewer-client'.

(fn &key PROC AGENT)
(defalias 'make-skewer-client #[128 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :proc :agent (:proc :agent :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:proc :agent)" record skewer-client] 7 (#$ . 5077)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put make-skewer-client side-effect-free t cl-struct-define skewer-client "A client connection awaiting a response." cl-structure-object record nil ((cl-tag-slot) (proc) (agent)) cl-struct-skewer-client-tags] 11)
#@38 Send all queued messages to clients.
(defalias 'skewer-process-queue #[0 "\205t	\205t\211A\242\304	\203h\3051`	\211A\242\306
!\n>\204*\307\310\311D\"\210\211\312H\262
\313\314!r\211q\210\315\316\317\320\321!\322\"\323$\216\324!c\210\325\326\327\330\331\332\333&\210*\266\334 \335\211\2620\202d\210\202\210\202\211\204p
B\266\336 \207" [skewer-queue skewer-clients cl-struct-skewer-client-tags skewer--last-timestamp nil (error) type-of signal wrong-type-argument skewer-client 1 generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 json-encode httpd-send-header "text/plain" 200 :Cache-Control "no-cache" :Access-Control-Allow-Origin "*" float-time t skewer-process-queue] 12 (#$ . 5806)])
#@46 Prepare client list for tabulated-list-mode.
(defalias 'skewer-clients-tabulate #[0 "\302\211:\203g@\262\303!	>\204\304\305\306D\"\210
\307H\303!	>\204-\304\305\306D\"\210\310H\311!\211G\310U\203C\211
A\262\242\202J\304\312\302GD\"
@\313\314\315\"#D\266\203\266\202
B\262
A\262\202\211\237\207" [skewer-clients cl-struct-skewer-client-tags nil type-of signal wrong-type-argument skewer-client 1 2 process-contact wrong-number-of-arguments vector format "%d"] 14 (#$ . 6596)])
(defvar skewer-clients-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [skewer-clients-mode-hook variable-documentation put "Hook run after entering skewer-clients mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp skewer-clients-mode-map definition-name skewer-clients-mode] 4)
(defvar skewer-clients-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [skewer-clients-mode-abbrev-table skewer-clients-mode-map variable-documentation put purecopy "Keymap for `skewer-clients-mode'." boundp skewer-clients-mode-syntax-table definition-name skewer-clients-mode (lambda (#1=#:def-tmp-var) (defvar skewer-clients-mode-syntax-table #1#)) make-syntax-table "Syntax table for `skewer-clients-mode'." (lambda (#1#) (defvar skewer-clients-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `skewer-clients-mode'." derived-mode-parent tabulated-list-mode] 5)
#@278 Mode for listing browsers attached to Emacs for skewer-mode.

In addition to any hooks its parent mode `tabulated-list-mode' might have run,
this mode runs the hook `skewer-clients-mode-hook', as the final or penultimate step
during initialization.

\{skewer-clients-mode-map}
(defalias 'skewer-clients-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\331\332 \333 \210)\334\335!\207" [delay-mode-hooks major-mode mode-name skewer-clients-mode-map skewer-clients-mode-syntax-table skewer-clients-mode-abbrev-table make-local-variable t tabulated-list-mode skewer-clients-mode "skewer-clients" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table [("Host" 12 t) ("Port" 5 t) ("User Agent" 0 t)] skewer-clients-tabulate tabulated-list-init-header run-mode-hooks skewer-clients-mode-hook local-abbrev-table tabulated-list-format tabulated-list-entries] 5 (#$ . 8375) nil])
(define-key skewer-clients-mode-map "g" #[0 "\300 \210\301 \207" [skewer-ping revert-buffer] 1 nil nil])
#@43 Revert the client list, due to an update.
(defalias 'skewer-update-list-buffer #[0 "\300 \301\302\303\304\305!\306\"\307$\216\310\311!\211\205r\211q\210\312 )\262
)\207" [current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 get-buffer "*skewer-clients*" revert-buffer] 7 (#$ . 9710)])
#@41 List the attached browsers in a buffer.
(defalias 'list-skewer-clients #[0 "\300\301\302!!\210\303 \210\304 \207" [pop-to-buffer get-buffer-create "*skewer-clients*" skewer-clients-mode tabulated-list-print] 3 (#$ . 10057) nil])
#@66 Add a client to the queue, given the HTTP header.

(fn PROC REQ)
(defalias 'skewer-queue-client #[514 "\301\302\"A@\303\304#B\210\305 \210\306 \207" [skewer-clients assoc "User-Agent" record skewer-client skewer-update-list-buffer skewer-process-queue] 7 (#$ . 10292)])
#@22 

(fn PROC &rest G4)
(defalias 'httpd/skewer #[385 "
\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316p\317\320\321\"!\210db\210\322\323!\210*\f?\2053\324\325\326#*\262
\207" [major-mode httpd-current-proc standard-output skewer-data-root httpd--header-sent generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 httpd-buffer insert-file-contents expand-file-name "skewer.js" run-hooks skewer-js-hook httpd-send-header "text/javascript; charset=UTF-8" 200] 10 (#$ . 10573)])
#@39 

(fn PROC PATH QUERY REQ &rest ARGS)
(defalias 'httpd/skewer/get #[1156 "\300\"\207" [skewer-queue-client] 8 (#$ . 11138)])
#@39 

(fn PROC PATH QUERY REQ &rest ARGS)
(defalias 'httpd/skewer/post #[1156 "\303\304\305\"A@!\304\306\"A\307
\"\310 \211\203\211!\210
\203*\311\"\210\202H\312\313!r\211q\210\314\315\316\317\320!\321\"\322$\216\323	\324\325\326\327%\210*\210\n\211\205Z\211@\211!\210
A\266\202\202I\262
\207" [skewer-callbacks skewer--last-timestamp skewer-response-hook json-read-from-string assoc "Content" id cache-table-get float-time skewer-queue-client generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 httpd-send-header "text/plain" 200 :Access-Control-Allow-Origin "*"] 15 (#$ . 11271)])
#@61 Source file name or buffer for `httpd/skewer/demo' servlet.
(defvar skewer-demo-source (expand-file-name "example.html" skewer-data-root) (#$ . 11943))
#@22 

(fn PROC &rest G5)
(defalias 'httpd/skewer/demo #[385 "
\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316p\317!\203'\320!\210\2029;\2033\321!\210\2029\322\323\324#\210*\f?\205D\325\326\327#*\262
\207" [major-mode httpd-current-proc standard-output skewer-demo-source httpd--header-sent generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 httpd-buffer bufferp insert-buffer-substring insert-file-contents error "cl-etypecase failed: %s, %s" (buffer string) httpd-send-header "text/html; charset=UTF-8" 200] 10 (#$ . 12101)])
#@48 Return T if result was a success.

(fn RESULT)
(defalias 'skewer-success-p #[257 "\300\301\"A\302\232\207" [assoc status "success"] 4 (#$ . 12728)])
(defvar skewer-error-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [skewer-error-mode-hook variable-documentation put "Hook run after entering skewer-error mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp skewer-error-mode-map definition-name skewer-error-mode] 4)
(defvar skewer-error-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\210\303\311\323\324#\207" [skewer-error-mode-abbrev-table skewer-error-mode-map variable-documentation put purecopy "Keymap for `skewer-error-mode'." boundp skewer-error-mode-syntax-table definition-name skewer-error-mode (lambda (#1=#:def-tmp-var) (defvar skewer-error-mode-syntax-table #1#)) make-syntax-table "Syntax table for `skewer-error-mode'." (lambda (#1#) (defvar skewer-error-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `skewer-error-mode'." derived-mode-parent special-mode custom-mode-group skewer] 5)
#@517 Major mode derived from `special-mode' by `define-derived-mode'.
It inherits all of the parent's attributes, but has its own keymap,
abbrev table and syntax table:

  `skewer-error-mode-map', `skewer-error-mode-abbrev-table' and `skewer-error-mode-syntax-table'

which more-or-less shadow special-mode's corresponding tables.

In addition to any hooks its parent mode might have run,
this mode runs the hook `skewer-error-mode-hook', as the final or penultimate step
during initialization.

\{skewer-error-mode-map}
(defalias 'skewer-error-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\307)\331\332!\207" [delay-mode-hooks major-mode mode-name skewer-error-mode-map skewer-error-mode-syntax-table skewer-error-mode-abbrev-table make-local-variable t special-mode skewer-error-mode "skewer-error" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks skewer-error-mode-hook local-abbrev-table truncate-lines] 5 (#$ . 14162) nil])
(custom-declare-face 'skewer-error-face '((((class color) (background light)) :foreground "red" :underline t) (((class color) (background dark)) :foreground "red" :underline t)) "Face for JavaScript errors." :group 'skewer)
#@61 Return STRING propertized as an error message.

(fn STRING)
(defalias 'skewer--error #[257 "\300
\206\301\302\303#\207" [propertize "<unknown>" font-lock-face skewer-error-face] 5 (#$ . 15691)])
#@68 Report results in the minibuffer or the error buffer.

(fn RESULT)
(defalias 'skewer-post-minibuffer #[257 "\301
!\203'\302\303\"A\302\304\"A\211\203\"\211\305V\203\"\306\307#\202&\306\310\"\207r\311\312\313!!q\210\314\302\315\"A
\316 \210\317 \210\320\302\321\"A!\322\261\210\302\306\"A\206Q\323\324\261\210\302\325\"A\206^\323\324\261\210\326\327\302\330\"A\203q\331\202r\323\"\302\332\"A\261\210eb)\266\202)\207" [inhibit-read-only skewer-success-p assoc value time 1.0 message "%s (%.3f seconds)" "%s" pop-to-buffer get-buffer-create "*skewer-error*" t error erase-buffer skewer-error-mode skewer--error name ": " "" "\n\n" stack format "Expression: %s\n\n" strict "(strict)" eval] 8 (#$ . 15894)])
#@388 Evaluate STRING in the waiting browsers, giving the result to CALLBACK.

:VERBOSE -- if T, the return will try to be JSON encoded
:STRICT  -- if T, expression is evaluated with 'use strict'
:TYPE    -- chooses the JavaScript handler (default: eval)
:EXTRA   -- additional alist keys to append to the request object

(fn STRING &optional CALLBACK &key VERBOSE STRICT (TYPE "eval") EXTRA)
(defalias 'skewer-eval #[641 "\304
\305\"A@\304\306\"A@\304\307\"\206\310A@\304\311\"A@\211\203H\211@\312>\2030\211AA\262
\202\313>A@\203?\314\262
\202\315\316@\"\210\202\210\317\320\321!\"\322B\323	B\324B\325B\326BBBBBB\211	\327
!\210\330\331 
B\332!\n>\204\206\333\334\335D\"\210\336H#\266\337C\"\340 \210\266\202\207" [most-positive-fixnum skewer-callbacks cl-struct-cache-table-tags skewer-queue plist-member :verbose :strict :type (nil "eval") :extra (:verbose :strict :type :extra :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:verbose :strict :type :extra)" format "%x" random type eval id verbose strict cache-table-clear-expired puthash float-time type-of signal wrong-type-argument cache-table 2 append skewer-process-queue] 19 (#$ . 16629)])
#@115 Just like `skewer-eval' but synchronously, so don't provide a
callback. Use with caution.

(fn STRING &rest ARGS)
(defalias 'skewer-eval-synchronously #[385 "\300C\301\302\303\304\305\306\307!\310\"\311\312%$\210\211\242\204\"\313\300\314\"\210\202\211\242\207" [nil apply skewer-eval make-byte-code 257 "\300
\240\207" vconcat vector [] 3 "\n\n(fn V)" accept-process-output 0.01] 12 (#$ . 17850)])
#@291 Synchronously apply FUNCTION in the browser with the supplied
arguments, returning the result. All ARGS must be printable by
`json-encode'. For example,

    (skewer-apply "Math.atan2" '(1 -2)) ; => 2.677945044588987

Uncaught exceptions propagate to Emacs as an error.

(fn FUNCTION ARGS)
(defalias 'skewer-apply #[514 "\300\301\302\303\304#\305R\306
\307\310#\311\312\"A\313!\203:\311
\"\203)\311
\"A\202H\31414\315
!0\202H
\262
\202H\316\317\311\320\311\321\"A\"AC\"\266\203\207" [(("undefined") ("NaN" . 0.0e+NaN) ("Infinity" . 1.0e+INF) ("-Infinity" . -1.0e+INF)) "(" mapconcat json-encode ", " ")" skewer-eval-synchronously :verbose t assoc value skewer-success-p (json-readtable-error) json-read-from-string signal javascript message error] 13 (#$ . 18263)])
#@260 Synchronously call FUNCTION with the supplied ARGS. All ARGS
must be printable by `json-read-from-string. For example,

    (skewer-funcall "Math.sin" 0.5)  ; => 0.479425538604203

Uncaught exceptions propagate to Emacs as an error.

(fn FUNCTION &rest ARGS)
(defalias 'skewer-funcall #[385 "\300\"\207" [skewer-apply] 5 (#$ . 19050)])
#@84 Return a function that calls F with point at the current point.

(fn F &rest ARGS)
(defalias 'skewer--save-point #[385 "`\300\301\302\303\304#\305\"\306\307%\207" [make-byte-code 128 "\212\302b\210\303\300\304\301\"\")\207" vconcat vector [apply append] 6 "\n\n(fn &rest MORE)"] 11 (#$ . 19394)])
#@49 Ping the browser to test that it's still alive.
(defalias 'skewer-ping #[0 "\205
\301\302\303 !\304\305\306$\207" [skewer-clients skewer-eval prin1-to-string float-time nil :type "ping"] 5 (#$ . 19704)])
#@63 Return the number of seconds since the browser was last seen.
(defalias 'skewer-last-seen-seconds #[0 "\301 \210\302 Z\207" [skewer--last-timestamp skewer-ping float-time] 2 (#$ . 19916)])
#@52 Return T if buffer contents indicates strict mode.
(defalias 'skewer-mode-strict-p #[0 "\212\214~\210eb\210\301 \210\302u\210\303\304 \305\306!\306
!\307!>\204'\310\311\312D\"\210
\313H\\\262
\"\211\235\2055\314\266\203*\207" [cl-struct-js2-node-tags js2-forward-sws 1 ("\"use strict\"" "'use strict'") js2-node-at-point buffer-substring-no-properties js2-node-abs-pos type-of signal wrong-type-argument js2-node 3 t] 10 (#$ . 20112)])
#@83 Temporarily highlight region from START to END.

(fn START END &optional TIMEOUT)
(defalias 'skewer-flash-region #[770 "\300\"\301
\302\303#\210\304\206\305\306\307$\207" [make-overlay overlay-put face secondary-selection run-with-timer 0.2 nil delete-overlay] 9 (#$ . 20562)])
#@82 Return the JavaScript expression before the point as a
list: (string start end).
(defalias 'skewer-get-last-expression #[0 "\212\303 \210\304u\210\305\306\307\"\310\211!	>\204\311\312\313D\"\210\314H!	>\204>\311\312\313\310!	>\2048\311\312\313D\"\210\314HD\"\210\310!	>\204M\311\312\313D\"\210
\314H\315H=\203j\310
!	>\204e\311\312\313D\"\210\211\314H\262
\310
!\n>\203v\316\317!\210\320
!
\320
!\310!	>\204\214\311\312\313D\"\210
\321H\\\262
\322\"E\266\202\262
)\207" [js2-FUNCTION cl-struct-js2-node-tags cl-struct-js2-ast-root-tags js2-backward-sws -1 js2-node-at-point nil t type-of signal wrong-type-argument js2-node 5 1 error "no expression found" js2-node-abs-pos 3 buffer-substring-no-properties] 9 (#$ . 20852)])
#@178 Evaluate the JavaScript expression before the point in the
waiting browser. If invoked with a prefix argument, insert the
result into the current buffer.

(fn &optional PREFIX)
(defalias 'skewer-eval-last-expression #[256 "\211\203\301 \207\203\302\303\304!!\207\305 \211G\306U\203#\211
A\262\242\202*\307\310\311GD\"
\211A\262\242@\312\"\210\313\314\"\207" [js2-mode-buffer-dirty-p skewer-eval-print-last-expression js2-mode-wait-for-parse skewer--save-point skewer-eval-last-expression skewer-get-last-expression 3 signal wrong-number-of-arguments nil skewer-flash-region skewer-eval skewer-post-minibuffer] 8 (#$ . 21609) "P"])
#@91 Return the toplevel JavaScript expression around the point as
a list: (string start end).
(defalias 'skewer-get-defun #[0 "\212\302 \210\303u\210\304\305\306\"\307
!>\203\310\311!\210\307
!	>\204&\312\313\314D\"\210\211\315H\203\\\307\211!	>\204<\312\313\314D\"\210
\315H!>\204\\\307
!	>\204T\312\313\314D\"\210\211\315H\262
\202\316
!
\316
!\307!	>\204r\312\313\314D\"\210
\317H\\\262
\320\"E\266\202\262
)\207" [cl-struct-js2-ast-root-tags cl-struct-js2-node-tags js2-backward-sws -1 js2-node-at-point nil t type-of error "no expression found" signal wrong-type-argument js2-node 5 js2-node-abs-pos 3 buffer-substring-no-properties] 8 (#$ . 22260)])
#@77 Evaluate the JavaScript expression before the point in the
waiting browser.
(defalias 'skewer-eval-defun #[0 "\203\n\301\302\303!!\207\304 \211G\305U\203\211
A\262\242\202#\306\307\310GD\"
\211A\262\242@\311\"\210\312\313\"\207" [js2-mode-buffer-dirty-p js2-mode-wait-for-parse skewer--save-point skewer-eval-defun skewer-get-defun 3 signal wrong-number-of-arguments nil skewer-flash-region skewer-eval skewer-post-minibuffer] 7 (#$ . 22940) nil])
#@50 A mapping of evaluation IDs to insertion points.
(defvar skewer-eval-print-map (cache-table-create skewer-timeout :test 'equal) (#$ . 23406))
#@61 Insert the result after its source expression.

(fn RESULT)
(defalias 'skewer-post-print #[257 "\301
!\204\n\302
!\207\303\304\"A\305
\"\211\205)r\211@q\210\211Ab\210\303\306\"A\307\261)\207" [skewer-eval-print-map skewer-success-p skewer-post-minibuffer assoc id cache-table-get value "\n"] 6 (#$ . 23554)])
#@122 Evaluate the JavaScript expression before the point in the
waiting browser and insert the result in the buffer at point.
(defalias 'skewer-eval-print-last-expression #[0 "\203\n\303\304\305!!\207\306 \211G\307U\203\211
A\262\242\202#\310\311\312GD\"
\211A\262\242@\313\"\210\314c\210\315\316\317\320$\321\322\"Ap`B
	\323
!\210\324\325 B\326!\n>\204]\310\327\330D\"\210\331H#\266\202\266\203\207" [js2-mode-buffer-dirty-p skewer-eval-print-map cl-struct-cache-table-tags js2-mode-wait-for-parse skewer--save-point skewer-eval-print-last-expression skewer-get-defun 3 signal wrong-number-of-arguments nil skewer-flash-region "\n" skewer-eval skewer-post-print :verbose t assoc id cache-table-clear-expired puthash float-time type-of wrong-type-argument cache-table 2] 16 (#$ . 23876) nil])
#@31 Map of hosted scripts to IDs.
(defvar skewer-hosted-scripts (cache-table-create skewer-timeout) (#$ . 24690))
#@83 Host script STRING from the script servlet, returning the script ID.

(fn STRING)
(defalias 'skewer-host-script #[257 "\303!\211
	\304
!\210\305\306 B\307!\n>\204!\310\311\312D\"\210\313H#\266\207" [most-positive-fixnum skewer-hosted-scripts cl-struct-cache-table-tags random cache-table-clear-expired puthash float-time type-of signal wrong-type-argument cache-table 2] 12 (#$ . 24806)])
#@150 Load the entire current buffer into the browser. A snapshot of
the buffer is hosted so that browsers visiting late won't see an
inconsistent buffer.
(defalias 'skewer-load-buffer #[0 "\300\301 !\302 \303\304\305\306!#\307\310\311\312\313!\314\"\315\316%\317\320$\207" [skewer-host-script buffer-string buffer-name skewer-eval format "/skewer/script/%d/%s" url-hexify-string make-byte-code 257 "\301\302\300\"\207" vconcat vector [message "%s loaded"] 4 "\n\n(fn _)" :type "script"] 10 (#$ . 25212) nil])
#@27 

(fn PROC PATH &rest G6)
(defalias 'httpd/skewer/script #[642 "\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316p\317\320\321\322\"8!\323
\324#c\266*\f?\2056\325\326\327#*\262
\207" [major-mode httpd-current-proc standard-output skewer-hosted-scripts httpd--header-sent generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 httpd-buffer string-to-number 3 split-string "/" cache-table-get "" httpd-send-header "text/javascript; charset=UTF-8" 200] 11 (#$ . 25726)])
#@91 Non-nil if Skewer mode is enabled.
Use the command `skewer-mode' to change this variable.
(defvar skewer-mode nil (#$ . 26288))
(make-variable-buffer-local 'skewer-mode)
#@64 Minor mode for interacting with a browser.

(fn &optional ARG)
(defalias 'skewer-mode #[256 "\301 
\302=\203
?\202\303!\304V\305\306\203\307\202\310\"\210\311\312!\203B\301 \2032\211\301 \232\203B\313\314\315\203=\316\202>\317#\266\210\320 \210\207" [skewer-mode current-message toggle prefix-numeric-value 0 run-hooks skewer-mode-hook skewer-mode-on-hook skewer-mode-off-hook called-interactively-p any " in current buffer" message "Skewer mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 26464) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar skewer-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\211%\207" [skewer-mode-map skewer-mode-hook variable-documentation put "Hook run after entering or leaving `skewer-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode skewer-mode " skewer" nil] 6)
#@301 Attach a browser to Emacs for a skewer JavaScript REPL. Uses
`browse-url' to launch a browser.

With a prefix arugment (C-u), it will ask the filename of the
root document.  With two prefix arguments (C-u C-u), it will use
the contents of the current buffer as the root document.

(fn &optional ARG)
(defalias 'run-skewer #[256 "\211\302\267\202\303\304!\202p\305 \210\306\307\310	\"!\207" [skewer-demo-source httpd-port #s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (4 6 16 13)) read-file-name "Skewer filename: " httpd-start browse-url format "http://127.0.0.1:%d/skewer/demo"] 5 (#$ . 27453) "p"])
#@35 Path to the phantomjs executable.
(defvar phantomjs-program-name "/usr/bin/phantomjs" (#$ . 28106))
#@50 List of phantomjs processes connected to Skewer.
(defvar skewer-phantomjs-processes nil (#$ . 28212))
#@49 Cleanup after phantomjs exits.

(fn PROC EVENT)
(defalias 'skewer-phantomjs-sentinel #[514 "\300\301\302\303\304\305!\306\"\307\310%\311\"\205\312\313\314\"!\207" [cl-some make-byte-code 257 "\211\300\302\303\304#)\207" vconcat vector [inhibit-changing-match-data nil t string-match] 8 "\n\n(fn S)" ("finished" "abnormal" "killed") delete-file process-get tempfile] 9 (#$ . 28320)])
#@73 Connect an inferior PhantomJS process to Skewer, returning the process.
(defalias 'skewer-run-phantomjs #[0 "\303 \210\304\305!\306\307\"\310\311!r\211q\210\312\313\314\315\316!\317\"\320$\216\306\321\"c\210\322\323\211\323\313%\210\324\325\323	$\211
\nB\326\327#\210\330\331\"\210\262
*\262
\207" [httpd-port phantomjs-program-name skewer-phantomjs-processes httpd-start make-temp-file "phantomjs-" format "http://0:%d/skewer/demo" generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "require('webpage').create().open('%s')" write-region nil start-process "phantomjs" process-put tempfile set-process-sentinel skewer-phantomjs-sentinel] 9 (#$ . 28718) nil])
#@60 Kill all inferior phantomjs processes connected to Skewer.
(defalias 'skewer-phantomjs-kill #[0 "\301\302\"\210\303\211\207" [skewer-phantomjs-processes mapc delete-process nil] 3 (#$ . 29463) nil])
(provide 'skewer-mode)