espresso.elc

;ELC
;;; Compiled by shant@ultraio on Sat Sep 27 19:36:32 2014
;;; from file /home/shant/.emacs.d/espresso.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310\311\312#\210\300\313\311\312#\207" [require cc-mode font-lock newcomment imenu etags thingatpt easymenu moz nil t json] 4)
#@67 Matches the first character of a Espresso identifier. No grouping
(defconst espresso--name-start-re "[a-zA-Z_$]" (#$ . 737))
(defconst espresso--stmt-delim-chars "^;{}?:")
#@47 Matches a Javascript identifier. No grouping.
(defconst espresso--name-re (concat espresso--name-start-re "\\(?:\\s_\\|\\sw\\)*") (#$ . 915))
#@41 Matches a Javascript object field start
(defconst espresso--objfield-re (concat espresso--name-re ":") (#$ . 1063))
#@54 Matches a dot-separated sequence of Javascript names
(defconst espresso--dotted-name-re (concat espresso--name-re "\\(?:\\." espresso--name-re "\\)*") (#$ . 1185))
#@31 Matches a C preprocessor name
(defconst espresso--cpp-name-re espresso--name-re (#$ . 1355))
#@177 Regexp matching the prefix of a cpp directive including the directive
name, or nil in languages without preprocessor support.  The first
submatch surrounds the directive name.
(defconst espresso--opt-cpp-start "^\\s-*#\\s-*\\([[:alnum:]]+\\)" (#$ . 1455))
#@187 Regexp matching an old-fashioned explicit prototype "method"
  declaration. Group 1 is a (possibly-dotted) class name, group 2
  is a method name, and group 3 is the 'function' keyword.
(defconst espresso--plain-method-re (concat "^\\s-*?\\(" espresso--dotted-name-re "\\)\\.prototype" "\\.\\(" espresso--name-re "\\)\\s-*?=\\s-*?\\(function\\)\\_>") (#$ . 1718))
#@117 Regexp matching an old-fashioned explicit prototype "class"
  declaration, as in Class.prototype = { method1: ...} 
(defconst espresso--plain-class-re (concat "^\\s-*\\(" espresso--dotted-name-re "\\)\\.prototype" "\\s-*=\\s-*{") (#$ . 2089))
#@34 var NewClass = BaseClass.extend(
(defconst espresso--mp-class-decl-re (concat "^\\s-*var\\s-+" #1="\\(" espresso--name-re "\\)" "\\s-*=\\s-*" #1# espresso--dotted-name-re "\\)\\.extend\\(?:Final\\)?\\s-*(\\s-*{?\\s-*$") (#$ . 2338))
#@31 var NewClass = Class.create()
(defconst espresso--prototype-obsolete-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" espresso--dotted-name-re "\\)" "\\s-*=\\s-*Class\\.create()") (#$ . 2577))
(defconst espresso--prototype-objextend-class-decl-re-1 (concat "^\\s-*Object\\.extend\\s-*(" "\\(" espresso--dotted-name-re "\\)" "\\s-*,\\s-*{"))
(defconst espresso--prototype-objextend-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" espresso--dotted-name-re "\\)" "\\s-*=\\s-*Object\\.extend\\s-*("))
#@31 var NewClass = Class.create({
(defconst espresso--prototype-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" espresso--name-re "\\)" "\\s-*=\\s-*Class\\.create\\s-*(\\s-*" "\\(?:\\(" espresso--dotted-name-re "\\)\\s-*,\\s-*\\)?{?") (#$ . 3093))
(defconst espresso--dojo-class-decl-re (concat "^\\s-*dojo\\.declare\\s-*(\"\\(" espresso--dotted-name-re "\\)"))
#@35 ExtJS class declaration (style 1)
(defconst espresso--extjs-class-decl-re-1 (concat "^\\s-*Ext\\.extend\\s-*(" "\\s-*\\(" espresso--dotted-name-re #1="\\)" "\\s-*,\\s-*\\(" espresso--dotted-name-re #1#) (#$ . 3463))
#@35 ExtJS class declaration (style 2)
(defconst espresso--extjs-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" #1="\\(" espresso--name-re #2="\\)" "\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*" #1# espresso--dotted-name-re #2#) (#$ . 3685))
#@29 MochiKit class declaration?
(defconst espresso--mochikit-class-re (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*" "\\(" espresso--dotted-name-re "\\)") (#$ . 3921))
(defconst espresso--dummy-class-style '(:name "[Automatically Generated Class]"))
#@761 A list of class definition styles.

A class definition style is a plist with the following keys:

:name is a human-readable name of the class type

:class-decl is a regular expression giving the start of the
class. Its first group must match the name of its class. If there
is a parent class, the second group should match, and it should
be the name of the class.

If :prototype is present and non-nil, the parser will merge
declarations for this constructs with others at the same lexical
level that have the same name. Otherwise, multiple definitions
will create multiple top-level entries. Don't use :prototype
unnecessarily: it has an associated cost in performance.

If :strip-prototype is present and non-nil, then if the class
name as matched contains

(defconst espresso--class-styles (byte-code "\306\307\310\311BBBB\306\312\310	\313BBBB\306\314\310\n\315BBBB\306\316\310\317BBBB\306\320\310\f\321BBBB\306\322\310
\323BBBB\306\324\310\325BBBB\306\326\310\327BBBB\306\330\310\331BBBB\306\332\310\333BBBB\257\n\207" [espresso--plain-class-re espresso--mochikit-class-re espresso--prototype-obsolete-class-decl-re espresso--prototype-class-decl-re espresso--prototype-objextend-class-decl-re-1 espresso--prototype-objextend-class-decl-re-2 :name "Plain" :class-decl (:prototype t :contexts (toplevel) :framework javascript) "MochiKit" (:prototype t :contexts (toplevel) :framework mochikit) "Prototype (Obsolete)" (:contexts (toplevel) :framework prototype) "Prototype (Modern)" (:contexts (toplevel) :framework prototype) "Prototype (Object.extend)" (:prototype t :contexts (toplevel) :framework prototype) "Prototype (Object.extend) 2" (:prototype t :contexts (toplevel) :framework prototype) "Dojo" (:contexts (toplevel) :framework dojo) "ExtJS (style 1)" (:prototype t :contexts (toplevel) :framework extjs) "ExtJS (style 2)" (:contexts (toplevel) :framework extjs) "Merrill Press" (:contexts (toplevel) :framework merrillpress) espresso--dojo-class-decl-re espresso--extjs-class-decl-re-1 espresso--extjs-class-decl-re-2 espresso--mp-class-decl-re] 14) (#$ . 4179))
#@38 List of available frameworks symbols
(defconst espresso--available-frameworks (byte-code "\305	\305\305\305\n:\203+\n@\306\307\"\f>\203 \202%\fC\244\nA\202\n-\207" [available-frameworks espresso--class-styles #1=#:--cl-var-- style framework nil plist-get :framework] 3) (#$ . 6272))
#@104 Regular expression matching the start of a function header. Match group 1
is the name of the function.
(defconst espresso--function-heading-1-re (concat "^\\s-*function\\s-+\\(" espresso--name-re "\\)") (#$ . 6579))
#@129 Regular expression matching the start of a function entry in
  an associative array. Match group 1 is the name of the function.
(defconst espresso--function-heading-2-re (concat "^\\s-*\\(" espresso--name-re "\\)\\s-*:\\s-*function\\_>") (#$ . 6802))
#@78 Matches a line in the form var MUMBLE = function. Match group
  1 is MUMBLE.
(defconst espresso--function-heading-3-re (concat "^\\s-*\\(?:var\\s-+\\)?\\(" espresso--dotted-name-re "\\)" "\\s-*=\\s-*function\\_>") (#$ . 7059))
#@126 Regular expression matching a CPP macro definition up to the opening
parenthesis. Match group 1 is the name of the function.
(defconst espresso--macro-decl-re (concat "^\\s-*#\\s-*define\\s-+\\(" espresso--cpp-name-re "\\)\\s-*(") (#$ . 7293))
#@88 Like regexp-opt, but surround the optimized regular expression
with `\\_<' and `\\_>'.
(defalias 'espresso--regexp-opt-symbol #[(list) "\301\302\303\"\304Q\207" [list "\\_<" regexp-opt t "\\_>"] 4 (#$ . 7543)])
#@53 Regular expression matching any JavaScript keyword.
(defconst espresso--keyword-re (espresso--regexp-opt-symbol '("abstract" "break" "case" "catch" "class" "const" "continue" "debugger" "default" "delete" "do" "else" "enum" "export" "extends" "final" "finally" "for" "function" "goto" "if" "implements" "import" "in" "instanceof" "interface" "native" "new" "package" "private" "protected" "public" "return" "static" "super" "switch" "synchronized" "throw" "throws" "transient" "try" "typeof" "var" "void" "let" "yield" "volatile" "while" "with")) (#$ . 7761))
#@64 Regular expression matching any predefined type in JavaScript.
(defconst espresso--basic-type-re (espresso--regexp-opt-symbol '("boolean" "byte" "char" "double" "float" "int" "long" "short" "void")) (#$ . 8327))
#@70 Regular expression matching any future reserved words in JavaScript.
(defconst espresso--constant-re (espresso--regexp-opt-symbol '("false" "null" "undefined" "Infinity" "NaN" "true" "arguments" "this")) (#$ . 8545))
#@22 Level one font lock.
(defconst espresso--font-lock-keywords-1 (byte-code "\303\304	E\n\304	EE\207" [espresso--function-heading-1-re font-lock-function-name-face espresso--function-heading-2-re "\\_<import\\_>" 1] 5) (#$ . 8768))
#@22 Level two font lock.
(defconst espresso--font-lock-keywords-2 (byte-code "\306	\307\nE\310\311\312\312\307\302D\257\fB
BF\"\207" [espresso--font-lock-keywords-1 espresso--keyword-re font-lock-keyword-face espresso--basic-type-re font-lock-type-face espresso--constant-re append 1 "\\_<for\\_>" "\\s-+\\(each\\)\\_>" nil font-lock-constant-face] 9) (#$ . 9004))
(byte-code "\301\302\303\304#\210\305\203\301\302\306\307\310!!#\210)\301\207" [file put espresso--pitem-children compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-children (car cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-children #[(cl-x) "@\207" [cl-x] 1])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--pitem-children gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--pitem-children] 3] espresso--pitem-paren-depth compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-paren-depth (nth 1 cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-paren-depth #[(cl-x) "\3018\207" [cl-x 1] 2])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--pitem-paren-depth gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--pitem-paren-depth] 3] espresso--pitem-type compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-type (nth 2 cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-type #[(cl-x) "\3018\207" [cl-x 2] 2])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--pitem-type gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--pitem-type] 3] espresso--pitem-h-begin compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-h-begin (nth 3 cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-h-begin #[(cl-x) "\3018\207" [cl-x 3] 2])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--pitem-h-begin gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--pitem-h-begin] 3] espresso--pitem-name compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-name (nth 4 cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-name #[(cl-x) "\3018\207" [cl-x 4] 2])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--pitem-name gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--pitem-name] 3] espresso--pitem-b-end compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--pitem-b-end (nth 5 cl-x)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--pitem-b-end #[(cl-x) "\3018\207" [cl-x 5] 2])
(defalias 'copy-espresso--pitem #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\203\301\302\306\307\310!!#\210)\301\207" [file put make-espresso--pitem compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>A@\311>A@\312>A@\313>A@\203V@\314>\203>AA\202S\315>A@\203L\316\202S\317\320@\"\210\202()\321\322\323\316\316	\n\f
&.\207" [#1# children paren-depth type h-begin name :children :paren-depth :type :h-begin :name :b-end (:children :paren-depth :type :h-begin :name :b-end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:children :paren-depth :type :h-begin :name :b-end)" cl--defsubst-expand (children paren-depth type h-begin name b-end) (cl-block make-espresso--pitem (list children paren-depth type h-begin name b-end)) b-end #:--cl-keys-- cl-whole] 12 "\n\n(fn CL-WHOLE &cl-quote &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)"] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@58 

(fn &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-espresso--pitem #[(&rest #1=#:--cl-rest--) "\306>A@\307>A@\310>A@\311>A@\312>A@\313>A@\203V@\314>\203>AA\202S\315>A@\203L\316\202S\317\320@\"\210\202()	\n\f
\257.\207" [#1# children paren-depth type h-begin name :children :paren-depth :type :h-begin :name :b-end (:children :paren-depth :type :h-begin :name :b-end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:children :paren-depth :type :h-begin :name :b-end)" b-end #2=#:--cl-keys--] 6 (#$ . 13831)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\311#\210\302\313\314\315#\210\302\316\314\315#\210\302\317\314\315#\210\302\320\314\315#\210\302\321\314\315#\210\302\322\314\315#\210\302\323\314\315#\210\302\324\314\315#\207" [cl-struct-espresso--pitem-tags cl-struct-espresso--pitem put espresso--pitem cl-struct-slots ((children nil :read-only t) (paren-depth nil :read-only t) (type nil :read-only t) (h-begin nil :read-only t) (name nil :read-only t) (b-end nil)) cl-struct-type (list nil) cl-struct-include nil cl-struct-print make-espresso--pitem side-effect-free t copy-espresso--pitem espresso--pitem-b-end espresso--pitem-name espresso--pitem-h-begin espresso--pitem-type espresso--pitem-paren-depth espresso--pitem-children] 4)
#@33 The pitem we start parsing with
(defconst espresso--initial-pitem (list nil most-negative-fixnum 'toplevel nil nil nil) (#$ . 15223))
(byte-code "\301\302\303\304\305\306\307\310&\210\311\312\313\314\315\316\307\302&\210\311\317\320\321\315\316\307\302&\210\311\322\323\324\315\325\307\302&\210\311\326\303\327\315\325\307\302&\210\311\330\331\332\315\333\307\302&\210\311\334\300\335\315\336\337\340\"B\307\302&\210\311\341\342\343\315\325\307\302&\210\311\344\345\346\315\347\307\302&\210\311\350\351\352\315\316\307\302&\207" [espresso--available-frameworks custom-declare-group espresso nil "Customization variables for `espresso-mode'." :tag "JavaScript - Espresso-Mode" :group languages custom-declare-variable espresso-indent-level 4 "Number of spaces for each indentation step." :type integer espresso-expr-indent-offset 0 "Number of additional spaces used for indentation of continued\nexpressions. The value must be no less than minus\n`espresso-indent-level'." espresso-auto-indent-flag t "Automatic indentation with punctuation characters. If non-nil, the\ncurrent line is indented when certain punctuations are inserted." boolean espresso-flat-functions "Treat nested functions as if they were top-level functions for\nfunction movement, marking, and so on." espresso-comment-lineup-func #'c-lineup-C-comments "cc-mode-style lineup function for C comments" function espresso-enabled-frameworks "Select which frameworks espresso-mode will recognize.\n\nTurn off some frameworks you seldom use to improve performance.\nThe set of recognized frameworks can also be overriden on a\nper-buffer basis." set mapcar #[(x) "\301D\207" [x const] 2] espresso-js-switch-tabs (and (memq system-type '(darwin)) t) "Non-nil if Emacs should display tabs while selecting them.\n  Useful only if the windowing system has a good mechanism for\n  preventing Firefox from stealing the keyboard focus." espresso-js-tmpdir "~/.emacs.d/espresso/js" "Temporary directory used for communicating with Mozilla. It\n  must be readable and writable by both Mozilla and Emacs." directory espresso-js-timeout 5 "Wait this many seconds for a reply from Mozilla when executing\ncommands. Increase this value if you are getting timeout\nmessages."] 9)
#@26 Keymap for espresso-mode
(defvar espresso-mode-map (byte-code "\301 \302\303\304\"\210\305\306\307#\210\305\310\311#\210\305\312\313#\210\305\314\315#\210\316\317\320\321$\210)\207" [keymap make-sparse-keymap mapc #[(key) "\302	\303#\207" [keymap key define-key espresso-insert-and-indent] 4] ("+" "-" "*" "{" "}" "(" ")" ":" ";" ",") define-key [(control 99) (meta 58)] espresso-js-eval [(control 99) (control 106)] espresso-set-js-context [(control meta 120)] espresso-eval-defun [(meta 46)] espresso-find-symbol easy-menu-do-define nil "Espresso Menu" ("Javascript" ["Select new Mozilla context…" espresso-set-js-context (fboundp #'inferior-moz-process)] ["Evaluate expression in Mozilla context…" espresso-js-eval (fboundp #'inferior-moz-process)] ["Send current function to Mozilla…" espresso-eval-defun (fboundp #'inferior-moz-process)])] 5) (#$ . 17471))
#@120 Runs the command bound to KEY in the global keymap, and if
we're not in a string or comment, indents the current line.
(defalias 'espresso-insert-and-indent #[(key) "\303\304\305 \"!\210\214~\210\306 )\307	8?\205\n\206%\310	8\205%i\311 T=\205*\312 )\207" [key syntax espresso-auto-indent-flag call-interactively lookup-key current-global-map syntax-ppss 8 4 current-indentation indent-according-to-mode] 4 (#$ . 18354) (list (this-command-keys))])
#@37 Syntax table used in Espresso mode.
(defvar espresso-mode-syntax-table (byte-code "\301 \302!\210\303\304\305#\210)\207" [table make-syntax-table c-populate-syntax-table modify-syntax-entry 36 "_"] 4) (#$ . 18815))
#@61 Autogenerated regular expression to match buffer constructs
(defvar espresso--quick-match-re nil (#$ . 19040))
#@75 Autogenerated regular expression to match buffer constructs
and functions
(defvar espresso--quick-match-re-func nil (#$ . 19157))
(byte-code "\300\301!\210\300\302!\207" [make-variable-buffer-local espresso--quick-match-re espresso--quick-match-re-func] 2)
#@54 Last place in the buffer the function cache is valid
(defvar espresso--cache-end 1 (#$ . 19420))
(make-variable-buffer-local 'espresso--cache-end)
#@54 Last place we parsed up to in espresso--ensure-cache
(defvar espresso--last-parse-pos nil (#$ . 19573))
(make-variable-buffer-local 'espresso--last-parse-pos)
#@36 pstate at espresso--last-parse-pos
(defvar espresso--state-at-last-parse-pos nil (#$ . 19738))
(make-variable-buffer-local 'espresso--state-at-last-parse-pos)
(defalias 'espresso--flatten-list #[(list) "\304\304	:\203)	@\n:\203\305\n!\202\n\205\nC\237\244	A\202\237+\207" [list #1=#:--cl-var-- item #2=#:--cl-var-- nil espresso--flatten-list] 2])
#@264 If LIST contains any element that is not nil, return its
non-nil elements, separated by SEPARATOR, prefixed by PREFIX, and
ended with SUFFIX as with `concat'. Otherwise, if LIST is empty,
return nil. If any element in LIST is itself a list, flatten that
element.
(defalias 'espresso--maybe-join #[(prefix separator suffix &rest list) "\304!\205	\305\306\n#Q\207" [list prefix separator suffix espresso--flatten-list mapconcat identity] 5 (#$ . 20110)])
#@80 Update espresso--quick-match-re based on the current set of
enabled frameworks
(defalias 'espresso--update-quick-match-re #[nil "\303\304\305\306\307\310>\205\f\311\312>\205\313\303\314\305\315\312>\205\316\310>\205%\311\317>\205,\320&\321>\2055\322\323>\205<\324\303\325\305\306\326>\205G\327$&\n\330	P\211\207" [espresso-enabled-frameworks espresso--quick-match-re espresso--quick-match-re-func espresso--maybe-join "^[ 	]*\\(?:" "\\|" "\\)" "#define[ 	]+[a-zA-Z_]" extjs "Ext\\.extend" prototype "Object\\.extend" "\\(?:var[ 	]+\\)?[a-zA-Z_$0-9.]+[ 	]*=[ 	]*\\(?:" "\\)[ 	]*(" "Class\\.create" merrillpress "[a-zA-Z_$0-9]+\\.extend\\(?:Final\\)?" dojo "dojo\\.declare[ 	]*(" mochikit "MochiKit\\.Base\\.update[ 	]*(" "[a-zA-Z_$0-9.]+\\.prototype\\(?:" javascript ("\\.[a-zA-Z_$0-9]+[ 	]*=[ 	]*function[ 	]*(" "[ 	]*=[ 	]*{") "function\\|"] 16 (#$ . 20576)])
#@181 Move over the next value of PROPNAME in the buffer. If found,
return that value and leave point after the character having that
value, otherwise return nil and leave point at EOB.
(defalias 'espresso--forward-text-property #[(propname) "\302`\"	\203\303u\210\202&\304`\303d$b\210m\203\202&\302`\"\303u\210	)\207" [propname next-value get-text-property nil next-single-property-change] 5 (#$ . 21465)])
#@193 Move over the previous value of PROPNAME in the buffer. If found,
return that value and leave point just before the character that
has that value, otherwise return nil and leave point at BOB.
(defalias 'espresso--backward-text-property #[(propname) "o\203\302\2021\303`S\"	\203\304u\210\202/\305`\302e$b\210o\203'\202/\304u\210\303`\"	)\207" [propname prev-value nil get-text-property -1 previous-single-property-change] 5 (#$ . 21885)])
(defalias 'espresso--forward-pstate #[nil "\300\301!\207" [espresso--forward-text-property espresso--pstate] 2])
(put 'espresso--forward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'espresso--backward-pstate #[nil "\300\301!\207" [espresso--backward-text-property espresso--pstate] 2])
(put 'espresso--backward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'espresso--pitem-goto-h-end #[(pitem) "\3018b\210\302 \207" [pitem 3 espresso--forward-pstate] 2])
#@55 Auxiliary function for `espresso--re-search-forward'.
(defalias 'espresso--re-search-forward-inner #[(regexp &optional bound count) "\306\306\212\307 \205\f\310 \210`)\311V\203\204\312\f
\"\210\313 \314\n8\211\203@	\315=\203.\316\312\317\320	!P\212\306\210`)\315#\210\202\201\321\n8\203L\306y\210\202\201\322\n8\206^`Sf\316=\205^\306f\323=\203h\312\324!\210\202\201\205o`X?\205u\307 \203~\310 \210\202\201S\202+`\207" [orig-macro-end str-terminator parse count regexp bound nil espresso--beginning-of-macro c-end-of-macro 0 re-search-forward syntax-ppss 3 t 47 "\\([^\\]\\|^\\)" string 7 4 42 "\\*/"] 4 (#$ . 22833)])
#@255 Search forward but ignore strings, cpp macros, and comments.
Invokes `re-search-forward' but treats the buffer as if strings,
cpp macros, and comments have been removed.

If invoked while inside a macro, treat the contents of the macro
as normal text.


(defalias 'espresso--re-search-forward #[(regexp &optional bound noerror count) "`?\203\n\303\202\304W\203\305\202\304V\205\306\307\310\311\217*\207" [count search-expr saved-point (espresso--re-search-forward-inner regexp bound 1) 0 (espresso--re-search-backward-inner regexp bound (- count)) (espresso--re-search-forward-inner regexp bound count) err (eval search-expr) ((search-failed (byte-code "b\210	\203\303\202\304\305\n!!\207" [saved-point noerror err nil error error-message-string] 3)))] 3 (#$ . 23487)])
#@56 Auxiliary function for `espresso--re-search-backward'.
(defalias 'espresso--re-search-backward-inner #[(regexp &optional bound count) "\306\306\212\307 \205	`)\310V\203\221\311\f
\"\210`eV\205&\212\312u\210\313\314!)\203,\306u\210\315 \316\n8\211\203Q	\317=\203?\320\311\321\322	!P\212\323 \210`)\317#\210\202\216\324\n8\203_\325\n8b\210\202\216\326\n8\206q`Sf\320=\205q\306f\327=\203{\311\330!\210\202\216\205\202`Y?\205\210\307 \204\216S\202
+`\207" [orig-macro-start str-terminator parse count regexp bound nil espresso--beginning-of-macro 0 re-search-backward -1 looking-at "/[/*]" syntax-ppss 3 t 47 "\\([^\\]\\|^\\)" string beginning-of-line 7 8 4 42 "/\\*"] 4 (#$ . 24282)])
#@256 Search backward but ignore strings, preprocessor macros, and
comments. Invokes `re-search-backward' but treats the buffer as
if strings, preprocessor macros, and comments have been removed.

If inside a macro when called, treat the macro as normal text.

(defalias 'espresso--re-search-backward #[(regexp &optional bound noerror count) "`?\203\n\303\202\304W\203\305\202\304V\205\306\307\310\311\217*\207" [count search-expr saved-point (espresso--re-search-backward-inner regexp bound 1) 0 (espresso--re-search-forward-inner regexp bound (- count)) (espresso--re-search-backward-inner regexp bound count) err (eval search-expr) ((search-failed (byte-code "b\210	\203\303\202\304\305\n!!\207" [saved-point noerror err nil error error-message-string] 3)))] 3 (#$ . 24999)])
#@120 Move forward over a whole expression. Doesn't move over
expressions continued across lines, but we don't actually care
(defalias 'espresso--forward-expression #[nil "l\206\f\301!\210\302f\303>?\203\304 \210\202\302f\305=\205$\212\302u\210\306 )\203*\202\302\207" [most-positive-fixnum forward-comment nil (44 59 93 41 125) forward-sexp 10 espresso--continued-expression-p] 2 (#$ . 25798)])
#@258 Move forward over a function declaration with point at the
'function' keyword. Return no-nil if this is a
syntactically-correct non-expression function, nil otherwise.
Specifically, return the name of the function, or t if the name
could not be determined.
(defalias 'espresso--forward-function-decl #[nil "\303\304!\204\f\305\306\307C\"\210\310\311v\210\312	!\210\303\n!\203#\313\314!\314\225b\210\312	!\210\311f\315=\205A\311\316\317\217\205A\312	!\210\311f\320=\205A)\207" [name most-positive-fixnum espresso--name-re looking-at #1="\\_<function\\_>" signal cl-assertion-failed (looking-at #1#) t nil forward-comment match-string-no-properties 0 40 (byte-code "\300 \210\301\207" [forward-list t] 1) ((error)) 123] 3 (#$ . 26205)])
#@231 Return the start of the function prologue that contains POS,
or nil if we're not in a function prologue. A function prologue
is everything from start of the definition up to and including
the opening brace. POS defaults to point.
(defalias 'espresso--function-prologue-beginning #[(&optional pos) "\305\212	\203
	b\210\202`\212\306y\210\307\n!\206\307!)\203-\310\224	X\203-\306\225b\210\311\312!\210\307\313!\206<\314\313\305\315#\205[\316 \317\216\306\224b\210\320 ))\205[	`X\205[\206[\306\224))\207" [prologue-begin pos espresso--function-heading-2-re espresso--function-heading-3-re save-match-data-internal nil 0 looking-at 1 skip-syntax-backward "w_" "\\_<function\\_>" espresso--re-search-backward t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) espresso--forward-function-decl] 4 (#$ . 26955)])
#@184 Internal helper for espresso--beginning-of-defun. Go to
previous defun-beginning and return the parse state for it, or
nil if we went all the way back to bob and don't find anything.
(defalias 'espresso--beginning-of-defun-raw #[nil "\301 \210\302\303 \211\205\304\305@8=?\203\202o?\205)\207" [pstate espresso--ensure-cache nil espresso--backward-pstate function 2] 3 (#$ . 27834)])
#@101 If PSTATE represents a non-empty top-level defun, return the
top-most pitem. Otherwise, return nil.
(defalias 'espresso--pstate-is-toplevel-defun #[(pstate) "\305\306\305	:\203#	@\307\310\n8=\203T\n	A\202\311=\205*\f,\207" [pstate #1=#:--cl-var-- pitem func-depth func-pitem nil 0 function 2 1] 3 (#$ . 28236)])
#@114 Internal helper for espresso--beginning-of-defun. Returns the
pitem of the function we went to the beginning of.
(defalias 'espresso--beginning-of-defun-nested #[nil "\306 \307\310\307:\205-@\311\312	8=\205\313	!\203,\314	8b\210	\307\211\202-\310\2036A\202	,\206m\307\307\310\307\315 \f\205d\316\f!\211\203c\314
8b\210
\307\211\202d\310\203j\202E,\207" [#1=#:--cl-var-- pitem #2=#:--cl-var-- #3=#:--cl-var-- pstate #4=#:--cl-var-- espresso--parse-state-at-point nil t function 2 espresso--inside-pitem-p 3 espresso--backward-pstate espresso--pstate-is-toplevel-defun #5=#:--cl-var-- #6=#:--cl-var--] 3 (#$ . 28572)])
#@50 Internal helper for espresso--beginning-of-defun
(defalias 'espresso--beginning-of-defun-flat #[nil "\301 \205\f\302@8b)\207" [pstate espresso--beginning-of-defun-raw 3] 2 (#$ . 29234)])
#@37 Used as beginning-of-defun-function
(defalias 'espresso--beginning-of-defun #[(&optional arg) "\206\303m?\205\304W\203=T	?\205\"\305 \306=\206\"\307 \203(\310 \210\311\312\313\314#\2037\307 b\210\202:db\210\202\304V\205uS`Sf\315=\203Q\316u\210\307 \n\205[\n`W\203d\nb\210\202q	\203n\317 \210\202q\320 \210)\202=\207" [arg espresso-flat-functions prologue-begin 1 0 espresso-syntactic-context function espresso--function-prologue-beginning espresso--end-of-defun espresso--re-search-forward "\\_<function\\_>" nil t 125 -1 espresso--beginning-of-defun-flat espresso--beginning-of-defun-nested] 4 (#$ . 29431)])
#@99 Flush syntax cache info after position BEG. BEG defaults to
point-min, flushing the entire cache.
(defalias 'espresso--flush-caches #[(&optional beg ignored) "\206	\214~\210e)	^\211\207" [beg espresso--cache-end] 2 (#$ . 30076) nil])
(defalias 'espresso--debug '(macro . #[(&rest arguments) "\300\207" [nil] 1]))
(defalias 'espresso--ensure-cache--pop-if-ended #[(open-items paren-depth) "@\n\304	8X\2036\305`S\306\"?\204\307\310\311C\"\210\312`S`\313	$\210\314	\233`\240\210)\315\316!	\"\317!B)\207" [open-items top-item paren-depth #1=#:c 1 get-text-property espresso-pend signal cl-assertion-failed (not (get-text-property (1- (point)) 'espresso-pend)) put-text-property espresso--pend 5 espresso--pitem-add-child second cddr] 5])
#@207 Helper for use inside espresso--ensure-cache. Updates parsing
information up to point. Refers to parse, prev-parse-point,
goal-point, and open-items bound lexically in the body of
`espresso--ensure-cache'.
(defalias 'espresso--ensure-cache--update-parse '(macro . #[nil "\300\207" [(progn (setq goal-point (point)) (goto-char prev-parse-point) (while (progn (setq open-items (espresso--ensure-cache--pop-if-ended open-items (car parse))) (assert (> (nth 0 parse) (espresso--pitem-paren-depth (car open-items)))) (setq parse (parse-partial-sexp prev-parse-point goal-point (espresso--pitem-paren-depth (car open-items)) nil parse)) (setq prev-parse-point (point)) (< (point) goal-point))) (setq open-items (espresso--ensure-cache--pop-if-ended open-items (car parse))))] 1 (#$ . 30833)]))
(defalias 'espresso--show-cache-at-point #[nil "\306\307!\210\310`\311\"	r\312\313!q\210p\314 \210\n\315\315\316\316\316\317 \210\320\321!\210*)\307!\322!\210+)\207" [prop default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list require pp get-text-property espresso--pstate get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook internal-temp-output-buffer-show inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 3 nil nil])
#@160 Splits a name into its dot-separated parts. Also removes any
prototype parts from the split name (unless the name is just
"prototype" to start with, that is).
(defalias 'espresso--split-name #[(string) "\303 \304\216\305	\306\307#))\nG\310U\205\n@\311\232\203\312\202%\313\311\n\"\211)\207" [save-match-data-internal string name match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) split-string "\\." t 1 "prototype" nil remove] 4 (#$ . 32167)])
#@58 Secondary out-variable for espresso--guess-function-name
(defvar espresso--guess-function-name-start nil (#$ . 32671))
#@382 Guess the name of the function at POSITION, which should be
the just after the end of the word 'function'. Return the name of
the function or nil if the name could not be guessed. Clobbers
match data. If in guessing the function name we find the preamble
begins earlier than expected, set `espresso--guess-function-name-start'
to that position, otherwise set that variable to nil.
(defalias 'espresso--guess-function-name #[(position) "\304\212	b\210\305y\210\306\n!\203#\305\225	=\205 \307\224\211\205 \310\307!\202:\306!\205:\305\225	=\205:\307\224\211\205:\310\307!)\207" [espresso--guess-function-name-start position espresso--function-heading-3-re espresso--function-heading-2-re nil 0 looking-at 1 match-string-no-properties] 2 (#$ . 32797)])
(defalias 'espresso--clear-stale-cache #[nil "\302\212\303\304!\211\203\305\233	\302\240\210)\202))\306`d\307#\207" [end-prop #1=#:c nil espresso--forward-text-property espreso--pend 5 remove-text-properties (espresso--pstate t espresso--pend t)] 4])
#@250 Ensures brace cache is valid up to the character before LIMIT.
LIMIT defaults to point. If STOP-ON-END is non-nil, it must be a
pitem instance, and espresso--ensure-cache will return when the
given item ends instead of parsing all the way to LIMIT.
(defalias 'espresso--ensure-cache #[(&optional limit stop-on-end) "\206`	W\205p\306 \307\307\307\3103\3104\3105\3106\3107\310\3108\3109\310:\310;\310<\310=\310>\310?\310@\310A\310B\311\216CD\310E\310FD:\203yD@E\312E\313\"G>\203qEFBFDAD\202TF\237+?\212\214~\210	b\210o\203\215\202\275\314`S\315\"\203\234\202\275\316`\315\310e$b\210o\203\253\202\275\314`S\315\"\204\275\317\320\321C\"\210\203\305\202\312HC\322 ;`<\323 \210e}\210\3108\3109\310:\310I\324J\310\307#\203\325\224b8\325\2259`A<b\210\326;@\"\325;8\327@8V\204
\317\320\330C\"\210\331<A\327@8\310;%;`<`AW\2036
\202\375\326;@\"\325;8:\332;8\203P
\310\202\253\333\334!\205[
\335 \211=\203\256
=\307=\203
\3369!==\203|
K\203y
K8\202
\307=\310f\337=\204\214
\317\320\340C\"\210\310u\210\341\342:\3438\344\345\346=\307=\203\245
=\202\251
\347=!&\202\253\333L!\203\350 \210`A<b\210\326;@\"\325;8\327@8V\204\333
\317\320\330C\"\210\331<A\327@8\310;%;`<`AW\203\370
\202\277
\326;@\"\341\342\325;8\3438\344\351\346\352\327!C&\202\253\333M!\203J\353\224b\210\354 N\355\216\335 ))\205G\310u\210\341\342:\3438\344\345\346\347\352\327!!\352\356!C\244&\202\253\357!O?P\310Q\307R\310SP:\205\235P@QO\312Q\360\">\205z\333\312Q\361\"!\203\234\325\225b\210\341\342:\3438\344Q\346\347\352\327!!&S\310\211R\202\235\307\203\250PAP\202]S-\211I\203
`A<b\210\326;@\"\325;8\327@8V\204\324\317\320\330C\"\210\331<A\327@8\310;%;`<`AW\203\361\202\270\326;@\"IB\362`S`\315$\210\2029b\210\202\344,b\210`A<b\210\326;@\"\325;8\327@8V\204;\317\320\330C\"\210\331<A\327@8\310;%;`<`AW\203X\202\326;@\"T\211U))).\207" [limit espresso--cache-end modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks buffer-modified-p t nil ((byte-code "?\203\301 \203\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) plist-get :framework get-text-property espresso--pstate previous-single-property-change signal cl-assertion-failed open-items syntax-ppss espresso--clear-stale-cache re-search-forward 0 espresso--ensure-cache--pop-if-ended 1 (> (nth 0 parse) (espresso--pitem-paren-depth (car open-items))) parse-partial-sexp 8 looking-at "\\_<function\\_>" espresso--forward-function-decl espresso--guess-function-name 123 (eq (char-after) 123) make-espresso--pitem :paren-depth :h-begin :type function :name espresso--split-name c-end-of-macro macro match-string-no-properties 3 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) 2 espresso--syntactic-context-from-pstate :contexts :class-decl put-text-property before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename orig-match-start orig-match-end orig-depth parse prev-parse-point name case-fold-search filtered-class-styles new-item goal-point end-prop espresso--class-styles #1=#:--cl-var-- style #2=#:--cl-var-- espresso-enabled-frameworks espresso--initial-pitem #3=#:--cl-var-- espresso--quick-match-re-func espresso--guess-function-name-start espresso--macro-decl-re espresso--plain-method-re save-match-data-internal syntactic-context #4=#:--cl-var-- class-style #5=#:--cl-var-- #6=#:--cl-var-- espresso--last-parse-pos espresso--state-at-last-parse-pos] 11 (#$ . 33823)])
#@44 Internal helper for espresso--end-of-defun
(defalias 'espresso--end-of-defun-flat #[nil "\303\304\303\305\306\303\304#\2050\307 \210\310`S\311\"\211\203/\312\3138=\203+\304\303\211\202,\304\2020\304\2036\202	\203Adb\210\303\202B\n+\207" [#1=#:--cl-var-- #2=#:--cl-var-- #3=#:--cl-var-- nil t espresso--re-search-forward "}" espresso--ensure-cache get-text-property espresso--pend function 2] 4 (#$ . 37532)])
#@44 Internal helper for espresso--end-of-defun
(defalias 'espresso--end-of-defun-nested #[nil "\303\304!\210\305\212\306 \211\205\307!\205\310u\210\311 \210`)\305	\205&`	W\203.	b\202P\312\313\305\314#\205?\315\224b\210\316 \211?\203E\202.\n\203N\311 \202Pdb+\207" [pitem this-end found message "test" nil espresso--beginning-of-defun-nested espresso--pitem-goto-h-end -1 forward-list espresso--re-search-forward "\\_<function\\_>" t 0 espresso--forward-function-decl] 4 (#$ . 37964)])
#@31 Used as end-of-defun-function
(defalias 'espresso--end-of-defun #[(&optional arg) "\206\305o?\205\306W\203,\307\307T\310 \210\310 \210o\203%\202(\311 \210*\202\306V\205gS\203?\312 \210\202d\313 \f\205I\f`X\203`\fb\210\314\315!\210\306\224b\210\316 \210\317 \210\202c\320 \210)\202,\207" [arg point orig-pos espresso-flat-functions prologue-begin 1 0 nil espresso--beginning-of-defun espresso--end-of-defun espresso--end-of-defun-flat espresso--function-prologue-beginning re-search-forward "\\_<function" espresso--forward-function-decl forward-list espresso--end-of-defun-nested] 2 (#$ . 38469)])
(defalias 'espresso--beginning-of-macro #[(&optional lim) "`\214	\203	d}\210\303 \210`SSf\304=\203\305y\210\202\306 \210`X\205)\307\n!\2030\310\2024b\210\311))\207" [here lim espresso--opt-cpp-start beginning-of-line 92 -1 back-to-indentation looking-at t nil] 2])
#@50 Simple implementation of c-backward-syntactic-ws
(defalias 'espresso--backward-syntactic-ws #[(&optional lim) "\214\203	d}\210\212\304 )`\n\203\202\304 \210\305!\210`	`U?\205*\202*)\207" [lim pos in-macro most-negative-fixnum espresso--beginning-of-macro forward-comment] 3 (#$ . 39378)])
#@49 Simple implementation of c-forward-syntactic-ws
(defalias 'espresso--forward-syntactic-ws #[(&optional lim) "\214\203	e}\210`\303\n!\210\304f\305=\203\306 \210`	`U?\205%\202))\207" [lim pos most-positive-fixnum forward-comment nil 35 c-end-of-macro] 3 (#$ . 39687)])
#@61 Like (up-list -1), but only considers lists that end nearby
(defalias 'espresso--up-nearby-list #[nil "\214e`\300Z]`}\210\301\302!)\207" [500 up-list -1] 3 (#$ . 39970)])
#@63 Return non-nil iff point is inside a function parameter list.
(defalias 'espresso--inside-param-list-p #[nil "\300\301\302\217\207" [nil (byte-code "\212\300 \210\301\302!\205\303\304!\210\301\305!\206\303\304!\210\301\305!)\207" [espresso--up-nearby-list looking-at "(" forward-symbol -1 "function"] 2) ((error))] 3 (#$ . 40147)])
#@77 Return non-nil iff point is inside a Dojo multiple-inheritance
class block.
(defalias 'espresso--inside-dojo-class-list-p #[nil "\300\301\302\217\207" [nil (byte-code "\212\302 \210`\303y\210\304	!\205 \303\225b\205 \304\305!\205 \303\225T=))\207" [list-begin espresso--dojo-class-decl-re espresso--up-nearby-list 0 looking-at "\"\\s-*,\\s-*\\["] 2) ((error))] 3 (#$ . 40489)])
(defalias 'espresso--syntax-begin-function #[nil "`W\203e]b\210\302\303 @\211\205\304\305	8=?\203!\202
	\205)\306	8b)\207" [espresso--cache-end pitem nil espresso--backward-pstate 0 1 3] 3])
#@160 Create a byte-compiled function that only matches the given
regular expressions (that concatenation of REGEXPS) if FRAMEWORK
is in espresso-enabled-frameworks
(defalias 'espresso--make-framework-matcher #[(framework &rest regexps) "\302\303\"\304\305\306\307\310\311	D\312BB\313\314BBEE!\207" [regexps framework apply concat byte-compile lambda (limit) when memq quote (espresso-enabled-frameworks) re-search-forward (limit t)] 8 (#$ . 41081)])
(defvar espresso--tmp-location nil)
(make-variable-buffer-local 'espresso--tmp-location)
#@205 Move forward over a destructuring spec. If FUNC is supplied,
call it with no arguments before every variable name in the spec.
Return true iff this was actually a spec. FUNC must preserve the
match data.
(defalias 'espresso--forward-destructuring-spec #[(&optional func) "\304\305f\306\"\203P\305u\210\307!\210\305f\310>\203\311	!\202<\305f\312=\203*\305u\210\313\202<\314\n!\205<	\2037	 \210\315\225b\210\313\203B\202\305f\316=\205M\305u\210\313\202\263\304\305f\317\"\205\263\305u\210\307!\210\314!\205\242\315\225b\210\307!\210\305f\320>\203z\311	!\202\214\314\n!\205\214	\203\207	 \210\315\225b\210\313\205\242\307!\210\305f\312=\205\242\305u\210\307!\210\313\203\250\202_\305f\321=\205\263\305u\210\313\207" [most-positive-fixnum func espresso--name-re espresso--objfield-re eql nil 91 forward-comment (91 123) espresso--forward-destructuring-spec 44 t looking-at 0 93 123 (91 123) 125] 3 (#$ . 41625)])
#@221 Font-lock matcher for variable names in a variable
declaration. This is a cc-mode-style matcher that *always* fails,
from the point of view of font-lock. It applies highlighting
directly with `font-lock-apply-higlight'.
(defalias 'espresso--variable-decl-matcher #[(limit) "\300\301\302\217\210\300\207" [nil (byte-code "\214e}\210\304\305\n!\210	\206\306f\307=\205\306u\210\305\n!\210\304\205;\310!\2031\311\312!\210\313\225b\202;\212\314 )\205;\314\315!\203X\305\n!\210\306f\316=\203S\306u\210\317 \210\305\n!\210\306\202))\306\207" [limit first most-positive-fixnum espresso--name-re t forward-comment nil 44 looking-at font-lock-apply-highlight (0 font-lock-variable-name-face) 0 espresso--forward-destructuring-spec #[nil "\300\301!\207" [font-lock-apply-highlight (0 font-lock-variable-name-face)] 2] 61 espresso--forward-expression] 2) ((scan-error) (end-of-buffer))] 3 (#$ . 42571)])
#@24 Level three font lock.
(defconst espresso--font-lock-keywords-3 (byte-code "\306	\307\310\311\n\312Q\313BB\310\311\n\312Q\314BB\315\316\317\320\311\321\322\323&\324B\316\317\320\311\325%\326\327\330R\331BB\316\317\332\333$\311\321\334R\335BB\336\fP\337\340\340\340FD\341\321Q\342\343DD\344\321Q\342\343DD\345\n\346
R\311\n\347Q\350\351\352FD\332\n\353Q\n\354\355\356FD\257\f#\207" [cpp-font-lock-keywords espresso--font-lock-keywords-2 espresso--name-re espresso--dotted-name-re espresso--basic-type-re espresso--name-start-re append ("\\.\\(prototype\\)\\_>" (1 font-lock-constant-face)) espresso--class-decl-matcher "\\(" "\\)\\(?:\\.\\|.*$\\)" ((goto-char (match-beginning 1)) nil (1 font-lock-type-face)) ((if (match-beginning 2) (progn (setq espresso--tmp-location (match-end 2)) (goto-char espresso--tmp-location) (insert "=") (goto-char (match-beginning 2))) (setq espresso--tmp-location nil) (goto-char (point-at-eol))) (when espresso--tmp-location (save-excursion (goto-char espresso--tmp-location) (delete-char 1))) (1 font-lock-type-face)) (espresso--class-decl-matcher (2 font-lock-type-face nil t)) espresso--make-framework-matcher dojo "^\\s-*dojo\\.declare\\s-*(\"" "\\)" "\\(?:\"\\s-*,\\s-*\\(" "\\)\\)?" ((1 font-lock-type-face t) (2 font-lock-type-face nil t)) "\\)\"\\s-*,\\s-*\\[" "[[,]\\s-*\\(" "\\)\\s-*" "\\(?:\\].*$\\)?" ((backward-char) (end-of-line) (1 font-lock-type-face)) "^\\s-*" "\\s-*[],]" "\\s-*\\(?:\\].*$\\)?" ((if (save-excursion (backward-char) (espresso--inside-dojo-class-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (1 font-lock-type-face)) "\\_<\\(const\\|var\\|let\\)\\_>\\|" espresso--variable-decl-matcher nil "\\_<new\\_>\\s-+\\(" 1 font-lock-type-face "\\_<instanceof\\_>\\s-+\\(" "\\_<function\\_>\\(\\s-+" "\\)?\\s-*(\\s-*" "\\)\\(\\s-*).*\\)?" (backward-char) (end-of-line) (1 font-lock-variable-name-face) "\\s-*[,)]" (if (save-excursion (backward-char) (espresso--inside-param-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (0 font-lock-variable-name-face)] 19) (#$ . 43485))
#@65 Return whether point is inside the given pitem's header or body
(defalias 'espresso--inside-pitem-p #[(pitem) "\301 \210\3028\204\303\304\305C\"\210\3068\204\303\304\307C\"\210`\3028V\205/\3108?\206/\3108`V\207" [pitem espresso--ensure-cache 3 signal cl-assertion-failed (espresso--pitem-h-begin pitem) 1 (espresso--pitem-paren-depth pitem) 5] 3 (#$ . 45552)])
#@150 Get a list of espresso--pitem instances that apply to point,
most specific first. In the worst case, the current toplevel
instance will be returned.
(defalias 'espresso--parse-state-at-point #[nil "\212\214~\210\304 \210m\203`\202`T\212\305 )\206	C\306\n@\3078\310=\206,\311!?\2039\n\nA@\210\202)\n*))\207" [bound espresso--initial-pitem pstate pitem espresso--ensure-cache espresso--backward-pstate nil 2 toplevel espresso--inside-pitem-p] 2 (#$ . 45931)])
#@54 Return the syntactic context corresponding to PSTATE
(defalias 'espresso--syntactic-context-from-pstate #[(pstate) "\302@8	\303>\203	\202	:\203\304\202\305)\207" [pstate type 2 #'macro class toplevel] 2 (#$ . 46412)])
#@113 Get the current syntactic context of point. When called
interatively, also display a message with that context.
(defalias 'espresso-syntactic-context #[nil "\301\302 !\303 \203\304\305\"\210)\207" [syntactic-context espresso--syntactic-context-from-pstate espresso--parse-state-at-point interactive-p message "Syntactic context: %s"] 3 (#$ . 46647) nil])
#@47 Fontifies according to espresso--class-styles
(defalias 'espresso--class-decl-matcher #[(limit) "\306\307\306\310!\210\311\f\307#\205\214\312\225\312\224b\210
\306\306\307\306:\205k@\313\314\"\313\315\">\205Y\316 \313\317\">\205Y\205Y\320!\203j\312\225b\210\307\306\211\202k\307\203vA\202(-\203\204\307\306\211\202\214\307\205\214b\210\307\203\222\202\n\n+\207" [orig-end #1=#:--cl-var-- #2=#:--cl-var-- limit espresso--quick-match-re espresso--class-styles nil t espresso--ensure-cache re-search-forward 0 plist-get :class-decl :framework espresso-syntactic-context :contexts looking-at #3=#:--cl-var-- style decl-re #4=#:--cl-var-- #5=#:--cl-var-- espresso-enabled-frameworks] 4 (#$ . 47013)])
#@27 See `font-lock-keywords'.
(defconst espresso--font-lock-keywords '(espresso--font-lock-keywords-3 espresso--font-lock-keywords-1 espresso--font-lock-keywords-2 espresso--font-lock-keywords-3) (#$ . 47778))
#@122 Match a regular expression literal. Match groups 1 and 2 are
the characters forming the beginning and end of the literal
(defconst espresso--regexp-literal "[=(,:]\\(?:\\s-\\|\n\\)*\\(/\\)\\(?:\\\\/\\|[^/*]\\)\\(?:\\\\/\\|[^/]\\)*\\(/\\)" (#$ . 47991))
#@84 Highlighting of regular expressions. See also the variable
  `font-lock-keywords'.
(defconst espresso--font-lock-syntactic-keywords (byte-code "\301BC\207" [espresso--regexp-literal ((1 "|") (2 "|"))] 2) (#$ . 48250))
#@90 Regular expression matching keywords that are optionally
  followed by an opening brace.
(defconst espresso--possibly-braceless-keyword-re (espresso--regexp-opt-symbol '("catch" "do" "else" "finally" "for" "if" "try" "while" "with" "each")) (#$ . 48475))
#@91 Regular expression matching operators that affect indentation
  of continued expressions.
(defconst espresso--indent-operator-re (byte-code "\300\301\302!P\207" ["[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|" espresso--regexp-opt-symbol ("in" "instanceof")] 3) (#$ . 48736))
#@74 Return non-nil if text after point is an operator (that is not
a comma).
(defalias 'espresso--looking-at-operator-p #[nil "\302 \303\216\304	!\205\304\305!?\206\212\306\307\310\311#\205\304\312!)))\207" [save-match-data-internal espresso--indent-operator-re match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) looking-at ":" espresso--re-search-backward "[?:{]\\|\\_<case\\_>" nil t "?"] 4 (#$ . 49009)])
#@62 Returns non-nil if the current line continues an expression.
(defalias 'espresso--continued-expression-p #[nil "\212\300 \210\301 \206:\302\303\304\305#\205:\306\304x\210o\204\307u\210`eV\205:\212\307u\210\310\311!?)\205:\301 \205:\307u\210\310\312!?)\207" [back-to-indentation espresso--looking-at-operator-p espresso--re-search-backward "\n" nil t " 	" -1 looking-at "[/*]/" "++\\|--\\|/[/*]"] 4 (#$ . 49472)])
#@233 Returns non-nil if word after point is `while' of a do-while
statement, else returns nil. A braceless do-while statement
spanning several lines requires that the start of the loop is
indented to the same column as the current line.
(defalias 'espresso--end-of-do-while-loop-p #[nil "\212\302 \303\216\304\305!\205_\212\306\307x\210\304\306!)\203'\212\310 \210\311\312!\210\304\313!)\202_\314\313\315 \316#\210\304\313!\206_\317 \314\320\307\316#\205D\317 	U?\203J\2027\304\321!\205^\322\323\324 \316#?\205^\317 	U))))\207" [save-match-data-internal saved-indent match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) looking-at "\\s-*\\_<while\\_>" "[ 	\n]*}" nil backward-list forward-symbol -1 "\\_<do\\_>" espresso--re-search-backward point-at-bol t current-indentation "^\\s-*\\_<" "\\s-*\\_<do\\_>" espresso--re-search-forward "\\_<while\\_>" point-at-eol] 4 (#$ . 49899) nil])
#@131 Returns the proper indentation of the current line if it
starts the body of a control statement without braces, else
returns nil.
(defalias 'espresso--ctrl-statement-indentation #[nil "\212\302 \210\212\303 e=?\205=\304\305!?\205=\306\307\310\311#\210m\204!\310u\210`Sf\312U\203,\313 \210\314\315!\210\314\316!\210\304!\205=\317 ?)\205K\212\320\224b\210\321 	\\))\207" [espresso--possibly-braceless-keyword-re espresso-indent-level back-to-indentation point-at-bol looking-at "[{]" espresso--re-search-backward "[[:graph:]]" nil t 41 backward-list skip-syntax-backward " " "w_" espresso--end-of-do-while-loop-p 0 current-indentation] 4 (#$ . 50842)])
(defalias 'espresso--get-c-offset #[(symbol anchor) "\304BC\305\nBC!)\207" [espresso-comment-lineup-func c-offsets-alist symbol anchor c c-get-syntactic-indentation] 3])
#@53 Return the proper indentation for the current line.
(defalias 'espresso--proper-indentation #[(parse-status) "\212\305 \210\3068\203\307\310\3118\"\202\235\3118\203\312\202\235\313 \206\235\314f\315=\203-\312\202\235\212\316 )\2038\306\202\235\3178\203\221\320\321!\322 \3178b\210\320\323!\203~\324\325!\210`Sf\326U\203_\327 \210\305 \210\n\203ji\202{	\203x\330i\331_\f#\202{i\\\202\215\n\203\205\202\214\314u\210\332\314w\210i*\202\235\322 \203\234\f\\\202\235\312)\207" [parse-status continued-expr-p same-indent-p espresso-indent-level espresso-expr-indent-offset back-to-indentation 4 espresso--get-c-offset c 8 0 espresso--ctrl-statement-indentation nil 35 espresso--beginning-of-macro 1 looking-at "[]})]\\|\\_<case\\_>\\|\\_<default\\_>" espresso--continued-expression-p "[({[]\\s-*\\(/[/*]\\|$\\)" skip-syntax-backward " " 41 backward-list + 2 " 	"] 4 (#$ . 51679)])
#@52 Indent the current line as JavaScript source text.
(defalias 'espresso-indent-line #[nil "\214~\210\212\302\303 !)i\304 Z\305\306!!\210	\307V\205	u*)\207" [parse-status offset syntax-ppss point-at-bol current-indentation indent-line-to espresso--proper-indentation 0] 3 (#$ . 52594) nil])
#@42 Fill the paragraph with c-fill-paragraph
(defalias 'espresso-c-fill-paragraph #[(&optional justify) "\306\307\310\311\312!\203\312K\202\313\311\314!\203\314K\202\313\311\315!\203+\315K\202,\313\316\216\n\313=\203<\317\312!\210\202@\312\nM\210	\313=\203M\317\314!\210\202Q\314	M\210\313=\203^\317\315!\210\202b\315M\210\320\320!)).\207" [#1=#:vnew #2=#:vnew #3=#:vnew #4=#:old #5=#:old #6=#:old #[(&optional limit) "\301!\207" [limit espresso--forward-syntactic-ws] 2] #[(&optional limit) "\301!\207" [limit espresso--backward-syntactic-ws] 2] #[(&optional limit) "\301!\207" [limit espresso--beginning-of-macro] 2] fboundp c-beginning-of-macro cl--unbound c-backward-sws c-forward-sws ((byte-code "\303=\203
\304\305!\210\202\305M\210	\303=\203\304\306!\210\202\"\306	M\210\n\303=\203/\304\307!\210\2023\307\nM\210\303\207" [#4# #5# #6# cl--unbound fmakunbound c-beginning-of-macro c-backward-sws c-forward-sws] 2)) fmakunbound c-fill-paragraph fill-paragraph-function justify] 2 (#$ . 52894) "*P"])
(defalias 'espresso--pitem-format #[(pitem) "\3038\3048\305\306\n	:?\203	\202\307	\310\"#*\207" [pitem type name 4 2 format "name:%S type:%S" plist-get :name] 6])
#@196 Internal helper for espresso--splice-into-items. Return a new
item that is the result of merging CHILD into ITEM. NAME-PARTS is
a list of parts of the name of CHILD that we haven't consumed
yet.
(defalias 'espresso--make-merged-item #[(item child name-parts) "\3048:\203\n\202%\305\306C\307\304	8:?\203\n\202\304	8\310\311!&A\2034\312@	A#\202I\304	8:?\203C	@B\202I\313	@@\"AB\207" [item child espresso--dummy-class-style name-parts 2 make-espresso--pitem :children :type :name espresso--pitem-strname espresso--splice-into-items append] 8 (#$ . 54114)])
#@54 Last part of the name of PITEM as a string or symbol
(defalias 'espresso--pitem-strname #[(pitem) "\3028	:\203\303	!@\202	)\207" [pitem name 4 last] 2 (#$ . 54695)])
#@266 Non-destructively inserts CHILD into the item list ITEMS in
the proper place as given by NAME-PARTS. If a class doesn't
exist in the tree, create it. Return the new items list.
NAME-PARTS is a list of strings given the broken-down class
name of the item to insert.
(defalias 'espresso--splice-into-items #[(items child name-parts) "@	\306\306\306\306;\204\307\310\311C\"\210G\312V\204)\307\310\313C\"\210\205r\314@!\232\203W\315@#AB\f\203Q\f\241\210\202S\306\202r@\306B\f\203h\f\241\210\202jA\211\203x\202)\203\201
\202\236A\203\232\316\317\320\306A#\321\322&\202\234	B.\207" [name-parts items item new-cons last-new-item new-items nil signal cl-assertion-failed (stringp top-name) 0 (> (length top-name) 0) espresso--pitem-strname espresso--make-merged-item make-espresso--pitem :children espresso--splice-into-items :type :name item-ptr top-name child espresso--dummy-class-style] 7 (#$ . 54874)])
#@85 Copy espresso--pitem PITEM and while copying, push CHILD onto
its list of children.
(defalias 'espresso--pitem-add-child #[(pitem child) "\3068\250\204
\307\310\311C\"\210\3128:\203>\3128\313\314	:\205(	@\n;\211\2031	A\202\2039\314\202:\313+\202?\314\204H\307\310\315C\"\210\3128\3168
\243\203_\317@
#\202\205\f:\205h\320\f\321\"\203\200
:\204v\307\310\322C\"\210\317@
#\202\205@B*AB\207" [child #1=#:--cl-var-- part #2=#:--cl-flag-- type name 3 signal cl-assertion-failed (integerp (espresso--pitem-h-begin child)) 4 nil t (if (consp (espresso--pitem-name child)) (loop for part in (espresso--pitem-name child) always (stringp part)) t) 2 espresso--splice-into-items plist-get :prototype (consp name) pitem] 4 (#$ . 55852)])
#@50 Make LOCATION into a marker if imenu-use-markers
(defalias 'espresso--maybe-make-marker #[(location) "\203\f\302 	\303\223\202
	\207" [imenu-use-markers location make-marker nil] 3 (#$ . 56625)])
#@47 Convert list of pitems PITEMS to imenu format
(defalias 'espresso--pitems-to-imenu #[(pitems unknown-ctr) "\306\306\306\306\306

A@\211\203\231\3078\310!	\311=\2033\312\313@\314\\\240)\"\n\315>\203S\3168\250\204F\317\320\321C\"\210	\322\3168!B\fB\202\226\n:\203\221\323@\"\203l	B\fB\202\216\3168\203\216\3168\250\204\317\320\324C\"\210\325\322\3168!BC	B\fB\202\226\326\327\n\"\210\202\n\f-\207" [subitems pitem-name pitem-type pitem imenu-items pitems nil 2 espresso--pitem-strname t format "[unknown %s]" 1 #'macro 3 signal cl-assertion-failed (integerp (espresso--pitem-h-begin pitem)) espresso--maybe-make-marker espresso--pitems-to-imenu (integerp (espresso--pitem-h-begin pitem)) "[empty]" error "Unknown item type: %S" unknown-ctr #1=#:v] 5 (#$ . 56830)])
#@47 Creates an imenu index for the current buffer
(defalias 'espresso--imenu-create-index #[nil "\212\214~\210db\210\304 \210edU\206`=\204\305\306\307C\"\210\205N	\310\311BA\203:\312\313!@\"\314!B\202&G\315U\204G\305\306\316C\"\210\317@@\n\"*))\207" [espresso--last-parse-pos espresso--state-at-last-parse-pos unknown-ctr state espresso--ensure-cache signal cl-assertion-failed (or (= (point-min) (point-max)) (eq espresso--last-parse-pos (point))) -1 nil espresso--pitem-add-child second cddr 1 (= (length state) 1) espresso--pitems-to-imenu] 3 (#$ . 57647)])
(defalias 'espresso--which-func-joiner #[(parts) "\301\302\303#\207" [parts mapconcat identity "."] 4])
(defalias 'espresso--imenu-to-flat #[(items prefix symbols) "\306	:\203Q	@\307\n!\203 \310\nA\n@\311Q\f#\210\202K\n@P
\312\313\f\"\203B\314\315
T\211#\202+\316\nA\f#\210+	A\202\306*\207" [items #1=#:--cl-var-- item prefix symbols name nil imenu--subalist-p espresso--imenu-to-flat "." 0 gethash format "%s<%d>" puthash name2 ctr] 5])
#@231 Get a hash table of all relevant Javascript symbols across all
espresso-mode buffers. Each key is the name of a symbol (possibly
disambiguated with <N>, where N > 1), and each value is a marker
giving the location of that symbol.
(defalias 'espresso--get-all-known-symbols #[nil "\306\307\310\"\311\312 \313\313\n:\2030\n@rq\210
\314=\205\"\315 )\316\f\317#\210\nA\202-\207" [symbols imenu-use-markers #1=#:--cl-var-- buffer imenu-index major-mode make-hash-table :test equal t buffer-list nil espresso-mode espresso--imenu-create-index espresso--imenu-to-flat ""] 4 (#$ . 58698)])
#@39 History of entered Javascript symbols
(defvar espresso--symbol-history nil (#$ . 59301))
#@295 Read a symbol from SYMBOLS-TABLE, which is a hash table like
the one from `espresso--get-all-known-symbols'. Return value is a
cons of (SYMBOL-NAME . LOCATION), where SYMBOL-NAME is a string
and LOCATION is a marker.

Prompt is PROMPT.

If INITIAL-INPUT is not nil, use it as the initial input
(defalias 'espresso--read-symbol #[(symbols-table prompt &optional initial-input) "\203\202\300\306!\210\300\307!\210\310	\307\311\312\"\210\n\237)\307\306\f\313&
\314
\"B)\207" [ido-mode prompt #1=#:--cl-var-- symbols-table initial-input choice t nil ido-completing-read maphash #[(key #2=#:--cl-var--) "	B\211\207" [key #1#] 2] espresso--symbol-history gethash] 7 (#$ . 59397)])
(defalias 'espresso--guess-symbol-at-point #[nil "\302\303!\205%\212@b\210`Sf\304=\203\305u\210	`\240\210))@A{)\207" [bounds #1=#:v bounds-of-thing-at-point symbol 46 -1] 2])
#@182 Jump to a Javascript symbol we read in from the user. With
prefix argument, restrict symbols to those from the current
buffer. Pushes a mark onto the tag ring just like `find-tag'.
(defalias 'espresso-find-symbol #[(&optional arg) "\304\304\n?\203\305 \202\306\307\310\"\311\312 \313	#\210\314	\315\316 #A\317\320 \"\210\321\322!!\210\323 \210b*\207" [marker symbols arg find-tag-marker-ring nil espresso--get-all-known-symbols make-hash-table :test equal espresso--imenu-to-flat espresso--imenu-create-index "" espresso--read-symbol "Jump to: " espresso--guess-symbol-at-point ring-insert point-marker switch-to-buffer marker-buffer push-mark] 4 (#$ . 60276) "P"])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\306\302\307#\210\300\306\304\310#\207" [put espresso-moz-bad-rpc error-conditions (error timeout) error-message "Mozilla RPC Error" espresso-js-error (error js-error) "Javascript Error"] 4)
#@251 Wait TIMEOUT seconds for PROCESS to output something that
matches REGEXP. On timeout, return nil. On success, return t with
match data set. If START is non-nil, look for output starting
from START. Otherwise, use the current value of `process-mark'.
(defalias 'espresso--wait-for-matching-output #[(process regexp timeout &optional start) "r\306!q\210	\206\307\310!!\311 \\\312\313\312\f\311 Zdb\210\314\n\"\2037\313\312\211\2028\313\205>
\315V\203P\316
\312\313$\210\310!b\210\202\203c\317\320\321\322\"C\"\210\312\202e-)\207" [process start start-pos timeout end-time time-left process-buffer marker-position process-mark float-time nil t looking-back 0 accept-process-output signal espresso-moz-bad-rpc format "Timed out waiting for output matching %S" #1=#:--cl-var-- #2=#:--cl-var-- regexp] 5 (#$ . 61210)])
(byte-code "\301\302\303\304#\210\305\203\301\302\306\307\310!!#\210)\301\207" [file put espresso--js-handle-id compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--js-handle-id (or (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-espresso--js-handle-tags)) (error "%s accessing a non-%s" 'espresso--js-handle-id 'espresso--js-handle)) (aref cl-x 1)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--js-handle-id #[(cl-x) "\302!\205G\303Y\205\304H	>\204\305\306\307\310#\210\311H\207" [cl-x cl-struct-espresso--js-handle-tags vectorp 3 0 error "%s accessing a non-%s" espresso--js-handle-id espresso--js-handle 1] 4])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--js-handle-id gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--js-handle-id] 3] espresso--js-handle-process compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--js-handle-process (or (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-espresso--js-handle-tags)) (error "%s accessing a non-%s" 'espresso--js-handle-process 'espresso--js-handle)) (aref cl-x 2)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--js-handle-process #[(cl-x) "\302!\205G\303Y\205\304H	>\204\305\306\307\310#\210\311H\207" [cl-x cl-struct-espresso--js-handle-tags vectorp 3 0 error "%s accessing a non-%s" espresso--js-handle-process espresso--js-handle 2] 4])
(byte-code "\301\302\303\304#\210\301\305\306\307#\210\310\203\301\305\311\312\313!!#\210)\301\207" [file put espresso--js-handle-process gv-expander #[(_cl-do _cl-x) "\300\301\302\"\207" [error "%s is a read-only slot" espresso--js-handle-process] 3] espresso--js-handle-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\304\304&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block espresso--js-handle-p (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-espresso--js-handle-tags) t)) nil] 7] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'espresso--js-handle-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-espresso--js-handle-tags vectorp 3 0 t] 2])
(defalias 'copy-espresso--js-handle #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\203\301\302\306\307\310!!#\210)\301\207" [file put make-espresso--js-handle compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\305>A@\306>A@\2036@\307>\203 AA\2023\310>A@\203-\311\2023\312\313@\"\210\202)\314\315\316\311\f\311	\n&*\207" [#1# id process #:--cl-keys-- cl-whole :id :process (:id :process :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:id :process)" cl--defsubst-expand (id process) (cl-block make-espresso--js-handle (vector 'cl-struct-espresso--js-handle id process))] 8 "\n\n(fn CL-WHOLE &cl-quote &key ID PROCESS)"] "/home/shant/.emacs.d/espresso.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@24 

(fn &key ID PROCESS)
(defalias 'make-espresso--js-handle #[(&rest #1=#:--cl-rest--) "\304>A@\305>A@\2036@\306>\203 AA\2023\307>A@\203-\310\2023\311\312@\"\210\202)\313\314	\n#*\207" [#1# id process #2=#:--cl-keys-- :id :process (:id :process :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:id :process)" vector cl-struct-espresso--js-handle] 4 (#$ . 65408)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\313#\210\302\317\315\320#\210\302\321\315\313#\210\302\322\315\313#\207" [cl-struct-espresso--js-handle-tags cl-struct-espresso--js-handle put espresso--js-handle cl-struct-slots ((cl-tag-slot) (id nil :read-only t) (process nil :read-only t)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t make-espresso--js-handle side-effect-free copy-espresso--js-handle espresso--js-handle-p error-free espresso--js-handle-process espresso--js-handle-id] 4)
(defalias 'espresso--js-handle-expired-p #[(x) "\302!\205G\303Y\205\304H	>\204\305\306\307\310#\210\311H\312 =?\207" [x cl-struct-espresso--js-handle-tags vectorp 3 0 error "%s accessing a non-%s" espresso--js-handle-process espresso--js-handle 2 inferior-moz-process] 4])
#@62 Maps Elisp Javascript proxy objects to their Javascript IDs.
(defvar espresso--js-references nil (#$ . 66714))
#@40 The last MozRepl process object we saw
(defvar espresso--js-process nil (#$ . 66831))
#@49 Idle timer for cleaning up JS object references
(defvar espresso--js-gc-idle-timer nil (#$ . 66923))
#@33 Last number of gcs we GCed with
(defvar espresso--js-last-gcs-done nil (#$ . 67030))
#@63 String to set MozRepl up into a simple-minded evaluation mode
(defconst espresso--moz-interactor (replace-regexp-in-string "[ \n]+" " " "(function(repl) {\n  repl.defineInteractor('espresso', {\n    onStart: function onStart(repl) {\n      if(!repl._espressoObjects) {\n        repl._espressoObjects = {};\n        repl._espressoLastID = 0;\n        repl._espressoGC = this._espressoGC;\n      }\n      this._input = '';\n    },\n\n    _espressoGC: function _espressoGC(ids_in_use) {\n      var objects = this._espressoObjects;\n      var keys = [];\n      var num_freed = 0;\n\n      for(var pn in objects) {\n        keys.push(Number(pn));\n      }\n\n      keys.sort(function(x, y) x - y);\n      ids_in_use.sort(function(x, y) x - y);\n      var i = 0;\n      var j = 0;\n\n      while(i < ids_in_use.length && j < keys.length) {\n        var id = ids_in_use[i++];\n        while(j < keys.length && keys[j] !== id) {\n          var k_id = keys[j++];\n          delete objects[k_id];\n          ++num_freed;\n        }\n        ++j;\n      }\n\n      while(j < keys.length) {\n        var k_id = keys[j++];\n        delete objects[k_id];\n        ++num_freed;\n      }\n\n      return num_freed;\n    },\n\n    _mkArray: function _mkArray() {\n      var result = [];\n      for(var i = 0; i < arguments.length; ++i) {\n        result.push(arguments[i]);\n      }\n      return result;\n    },\n\n    _parsePropDescriptor: function _parsePropDescriptor(parts) {\n      if(typeof parts === 'string') {\n        parts = [ parts ];\n      }\n\n      var obj = parts[0];\n      var start = 1;\n\n      if(typeof obj === 'string') {\n        obj = window;\n        start = 0;\n      } else if(parts.length < 2) {\n        throw new Error('expected at least 2 arguments');\n      }\n\n      for(var i = start; i < parts.length - 1; ++i) {\n        obj = obj[parts[i]];\n      }\n\n      return [obj, parts[parts.length - 1]];\n    },\n\n    _getProp: function _getProp(/*...*/) {\n      if(arguments.length === 0) {\n        throw new Error('no arguments supplied to getprop');\n      }\n\n      if(arguments.length === 1 &&\n         (typeof arguments[0]) !== 'string')\n      {\n        return arguments[0];\n      }\n\n      var [obj, propname] = this._parsePropDescriptor(arguments);\n      return obj[propname];\n    },\n\n    _putProp: function _putProp(properties, value) {\n      var [obj, propname] = this._parsePropDescriptor(properties);\n      obj[propname] = value;\n    },\n\n    _delProp: function _delProp(propname) {\n      var [obj, propname] = this._parsePropDescriptor(arguments);\n      delete obj[propname];\n    },\n\n    _typeOf: function _typeOf(thing) {\n      return typeof thing;\n    },\n\n    _callNew: function(constructor) {\n      if(typeof constructor === 'string')\n      {\n        constructor = window[constructor];\n      } else if(constructor.length === 1 &&\n                typeof constructor[0] !== 'string')\n      {\n        constructor = constructor[0];\n      } else {\n        var [obj,propname] = this._parsePropDescriptor(constructor);\n        constructor = obj[propname];\n      }\n\n      /* Hacky, but should be robust */\n      var s = 'new constructor(';\n      for(var i = 1; i < arguments.length; ++i) {\n        if(i != 1) {\n          s += ',';\n        }\n\n        s += 'arguments[' + i + ']';\n      }\n\n      s += ')';\n      return eval(s);\n    },\n\n    _callEval: function(thisobj, js) {\n      return eval.call(thisobj, js);\n    },\n\n    getPrompt: function getPrompt(repl) {\n      return 'EVAL>'\n    },\n\n    _lookupObject: function _lookupObject(repl, id) {\n      if(typeof id === 'string') {\n        switch(id) {\n        case 'global':\n          return window;\n        case 'nil':\n          return null;\n        case 't':\n          return true;\n        case 'false':\n          return false;\n        case 'undefined':\n          return undefined;\n        case 'repl':\n          return repl;\n        case 'interactor':\n          return this;\n        case 'NaN':\n          return NaN;\n        case 'Infinity':\n          return Infinity;\n        case '-Infinity':\n          return -Infinity;\n        default:\n          throw new Error('No object with special id:' + id);\n        }\n      }\n\n      var ret = repl._espressoObjects[id];\n      if(ret === undefined) {\n        throw new Error('No object with id:' + id + '(' + typeof id + ')');\n      }\n      return ret;\n    },\n\n    _findOrAllocateObject: function _findOrAllocateObject(repl, value) {\n      if(typeof value !== 'object'  && typeof value !== 'function') {\n        throw new Error('_findOrAllocateObject called on non-object('\n                        + typeof(value) + '): '\n                        + value)\n      }\n\n      for(var id in repl._espressoObjects) {\n        id = Number(id);\n        var obj = repl._espressoObjects[id];\n        if(obj === value) {\n          return id;\n        }\n      }\n\n      var id = ++repl._espressoLastID;\n      repl._espressoObjects[id] = value;\n      return id;\n    },\n\n    _fixupList: function _fixupList(repl, list) {\n      for(var i = 0; i < list.length; ++i) {\n        if(list[i] instanceof Array) {\n          this._fixupList(repl, list[i]);\n        } else if(typeof list[i] === 'object') {\n          var obj = list[i];\n          if(obj.funcall) {\n            var parts = obj.funcall;\n            this._fixupList(repl, parts);\n            var [thisobj, func] = this._parseFunc(parts[0]);\n            list[i] = func.apply(thisobj, parts.slice(1));\n          } else if(obj.objid) {\n            list[i] = this._lookupObject(repl, obj.objid);\n          } else {\n            throw new Error('Unknown object type: ' + obj.toSource());\n          }\n        }\n      }\n    },\n\n    _parseFunc: function(func) {\n      var thisobj = null;\n\n      if(typeof func === 'string') {\n        func = window[func];\n      } else if(func instanceof Array) {\n        if(func.length === 1 && typeof func[0] !== 'string') {\n          func = func[0];\n        } else {\n          [thisobj, func] = this._parsePropDescriptor(func);\n          func = thisobj[func];\n        }\n      }\n\n      return [thisobj,func];\n    },\n\n    _encodeReturn: function(value, array_as_mv) {\n      var ret;\n\n      if(value === null) {\n        ret = ['special', 'null'];\n      } else if(value === true) {\n        ret = ['special', 'true'];\n      } else if(value === false) {\n        ret = ['special', 'false'];\n      } else if(value === undefined) {\n        ret = ['special', 'undefined'];\n      } else if(typeof value === 'number') {\n        if(isNaN(value)) {\n          ret = ['special', 'NaN'];\n        } else if(value === Infinity) {\n          ret = ['special', 'Infinity'];\n        } else if(value === -Infinity) {\n          ret = ['special', '-Infinity'];\n        } else {\n          ret = ['atom', value];\n        }\n      } else if(typeof value === 'string') {\n        ret = ['atom', value];\n      } else if(array_as_mv && value instanceof Array) {\n        ret = ['array', value.map(this._encodeReturn, this)];\n      } else {\n        ret = ['objid', this._findOrAllocateObject(repl, value)];\n      }\n\n      return ret;\n    },\n\n    _handleInputLine: function _handleInputLine(repl, line) {\n      var ret;\n      var array_as_mv = false;\n\n      try {\n        if(line[0] === '*') {\n          array_as_mv = true;\n          line = line.substring(1);\n        }\n        var parts = eval(line);\n        this._fixupList(repl, parts);\n        var [thisobj, func] = this._parseFunc(parts[0]);\n        ret = this._encodeReturn(\n          func.apply(thisobj, parts.slice(1)),\n          array_as_mv);\n      } catch(x) {\n        ret = ['error', x.toString() ];\n      }\n\n      var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);\n      repl.print(JSON.encode(ret));\n      repl._prompt();\n    },\n\n    handleInput: function handleInput(repl, chunk) {\n      this._input += chunk;\n      var match, line;\n      while(match = this._input.match(/.*\\n/)) {\n        line = match[0];\n\n        if(line === 'EXIT\\n') {\n          repl.popInteractor();\n          repl._prompt();\n          return;\n        }\n\n        this._input = this._input.substring(line.length);\n        this._handleInputLine(repl, line);\n      }\n    }\n  });\n})\n") (#$ . 67121))
#@193 Marshall the given value for JS. Strings and numbers get
JSON-encoded. Lists (including nil) are made into Javascript
array literals and their contents encoded with
espresso--js-encode-value.
(defalias 'espresso--js-encode-value #[(x) ";\203\302!\202\223\247\203\303!\202\2239\203$\304\305\306!\"\202\223\307!\205:G\310Y\205:\311H	>\205:\312\203k\313!\203G\314\315!\210\304\316\307!\205[G\310Y\205[\311H	>\204d\314\317\320\321#\210\322H\"\202\223\323!\203\217\242\324=\203\204\304\325\326\327A\330#\"\202\214\331\326\327\330#\332Q\202\223\314\333\"\207" [x cl-struct-espresso--js-handle-tags json-encode-string json-encode-number format "{objid:%S}" symbol-name vectorp 3 0 t espresso--js-handle-expired-p error "Stale JS handle" "{objid:%s}" "%s accessing a non-%s" espresso--js-handle-id espresso--js-handle 1 sequencep espresso--funcall "{funcall:[%s]}" mapconcat espresso--js-encode-value "," "[" "]" "Unrecognized item: %S"] 6 (#$ . 75583)])
(defconst espresso--js-prompt-regexp "\\(repl[0-9]*\\)> $")
(defconst espresso--js-repl-prompt-regexp "^EVAL>$")
(defvar espresso--js-repl-depth 0)
(defalias 'espresso--js-wait-for-eval-prompt #[nil "\302\303 	\212\304y\210`)$\207" [espresso--js-repl-prompt-regexp espresso-js-timeout espresso--wait-for-matching-output inferior-moz-process 0] 5])
(defalias 'espresso--js-enter-repl #[nil "\306 \210rq\210db\210\306 	=\203\2026\306 \307\310\311\312\313$\314\315	\f\"\210\315	\316
\317Q\"\210\320\306 #\210\321\212\314y\210`)\"\203E\314\314V\203Q\322 \210\202f\323\324!\325\261\210\326\327\313\"\210\320\306 #\210T\211)\207" [inferior-moz-buffer espresso--js-process espresso--js-references espresso--js-repl-depth espresso--moz-interactor moz-repl-name inferior-moz-process make-hash-table :test eq :weakness t 0 comint-send-string "(" ")\n" espresso--wait-for-matching-output looking-back espresso--js-wait-for-eval-prompt match-string-no-properties 1 ".pushInteractor('espresso')" comint-send-input nil espresso--js-prompt-regexp espresso-js-timeout espresso--js-repl-prompt-regexp] 5])
(defalias 'espresso--js-leave-repl #[nil "\304V\204\f\305\306\307C\"\210\304S\211U\205.r	q\210db\210\310 \210\311c\210\312\313\314\"\210\315\316 \n#)\207" [espresso--js-repl-depth inferior-moz-buffer espresso--js-prompt-regexp espresso-js-timeout 0 signal cl-assertion-failed (> espresso--js-repl-depth 0) espresso--js-wait-for-eval-prompt "EXIT" comint-send-input nil t espresso--wait-for-matching-output inferior-moz-process] 4])
(defalias 'espresso--js-not #[(value) "\301>\207" [value (nil false undefined)] 2])
(put 'espresso--js-not 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'espresso--js-true #[(value) "\301!?\207" [value espresso--js-not] 2])
(put 'espresso--js-true 'byte-optimizer 'byte-compile-inline-expand)
#@59 Convert immediate js< and js! references to deferred ones
(defalias 'espresso--optimize-arglist #[(arglist) "\306\306	:\203\247	@\n\242\307=\203%\310\311\312\313E\314\nA!\"B\202\241\n\242\315=\203X\310\311\316\317E\320\n!:?\203@\320\n!C\202L\310\311\321\322E\314\320\n!!\"C\314\323\n!!#B\202\241\n\242\324=\203\235\n\fA\203n\f\fA@\202u\325\326\306\fGD\"\f\fA@\310\311\327:\203\217\311\314!B\202\221E\314\f!\"+B\202\241\nB	A\202\237+\207" [arglist #1=#:--cl-var-- item #2=#:--cl-var-- body ignored nil js< append list 'espresso--funcall (list 'interactor "_getProp") espresso--optimize-arglist js> 'espresso--funcall (list 'interactor "_putProp") cadr 'espresso--funcall (list 'interactor "_mkArray") cddr js! signal wrong-number-of-arguments 'espresso--funcall function] 7 (#$ . 78433)])
(defalias 'espresso--js-get-service '(macro . #[(class-name interface-name) "\302\303\304\305BBB\306\303\307	FE\207" [class-name interface-name js! "Components" "classes" ("getService") js< "interfaces"] 6]))
(defalias 'espresso--js-create-instance '(macro . #[(class-name interface-name) "\302\303\304\305BBB\306\303\307	FE\207" [class-name interface-name js! "Components" "classes" ("createInstance") js< "interfaces"] 6]))
(defalias 'espresso--js-qi '(macro . #[(object interface-name) "\302\303B\304\305\306	FE\207" [object interface-name js! ("QueryInterface") js< "Components" "interfaces"] 6]))
#@237 Runs FORMS with the Mozilla repl set up for espresso commands.
Inside the lexical scope of `with-espresso-js', `js?', `js!',
`js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
`js-create-instance', and `js-qi' are defined.
(defalias 'with-espresso-js '(macro . #[(&rest forms) "\301\302\303\304\305BB\306BBE\207" [forms progn (espresso--js-enter-repl) unwind-protect macrolet ((js\? (&rest body) `(espresso--js-true ,@body)) (js! (function &rest body) `(espresso--js-funcall ,(if (consp function) (cons 'list (espresso--optimize-arglist function)) function) ,@(espresso--optimize-arglist body))) (js-new (function &rest body) `(espresso--js-new ,(if (consp function) (cons 'list (espresso--optimize-arglist function)) function) ,@body)) (js-eval (thisobj js) `(espresso--js-eval ,@(espresso--optimize-arglist (list thisobj js)))) (js-list (&rest args) `(espresso--js-list ,@(espresso--optimize-arglist args))) (js-get-service (&rest args) `(espresso--js-get-service ,@(espresso--optimize-arglist args))) (js-create-instance (&rest args) `(espresso--js-create-instance ,@(espresso--optimize-arglist args))) (js-qi (&rest args) `(espresso--js-qi ,@(espresso--optimize-arglist args))) (js< (&rest body) `(espresso--js-get ,@(espresso--optimize-arglist body))) (js> (props value) `(espresso--js-funcall '(interactor "_putProp") ,(if (consp props) (cons 'list (espresso--optimize-arglist props)) props) ,@(espresso--optimize-arglist (list value)))) (js-handle\? (arg) `(espresso--js-handle-p ,arg))) ((espresso--js-leave-repl))] 6 (#$ . 79875)]))
#@144 If bound to t and a function returns an Array, return the
elements of that Array as a list instead of returning the whole
Array as a JS symbol
(defvar espresso--js-array-as-list nil (#$ . 81438))
(defalias 'espresso--js-decode-retval #[(result) "\303\304!!\305	\306\"\203\307!\202n\305	\310\"\203\"\303\307!!\202n\305	\311\"\2032\312\313\307!\"\202n\305	\314\"\203T\315\307!\n\"\206Q\316\307!\317\320\307!\321\322 $\n#\202n\305	\323\"\203e\324\325\307!C\"\202n\323\326	\327#\205n\330)\207" [result #1=#:--cl-var-- espresso--js-references intern first eql atom second special array mapcar espresso--js-decode-retval objid gethash puthash make-espresso--js-handle :id :process inferior-moz-process error signal espresso-js-error "cl-ecase failed: %s, %s" (atom special array objid error) nil] 7])
#@507 Call the Mozilla function FUNCTION with arguments ARGUMENTS.
If function is a string, look it up as a property on the global
object and use the global object for `this'; if FUNCTION is a
list with one element, use that element as the function with the
global object for `this', except that if that single element is a
string, look it up on the global object. If FUNCTION is a list
with more than one argument, use the list up to the last value as
a property descriptor and the last argument as a function.
(defalias 'espresso--js-funcall #[(function &rest arguments) "\306 \210\307\216\310	B!rq\210\f\203\311c\210\nc\210\312\313\314\"\210\315\316 \317
#\210b\210\320\321 db\210\322!*)))\207" [function arguments argstr inferior-moz-buffer espresso--js-array-as-list espresso-js-timeout espresso--js-enter-repl ((espresso--js-leave-repl)) espresso--js-encode-value "*" comint-send-input nil t espresso--wait-for-matching-output inferior-moz-process "EVAL>" list json-read espresso--js-decode-retval comint-last-input-end json-array-type result] 4 (#$ . 82262)])
#@151 Call CONSTRUCTOR as a constructor (as with new), with the
given arguments ARGUMENTS. CONSTRUCTOR is a JS handle, a string,
or a list of these things.
(defalias 'espresso--js-new #[(constructor &rest arguments) "\302\303\304	$\207" [constructor arguments apply espresso--js-funcall (interactor "_callNew")] 5 (#$ . 83343)])
(defalias 'espresso--js-eval #[(thisobj js) "\302\303	#\207" [thisobj js espresso--js-funcall (interactor "_callEval")] 4])
#@90 Return a Lisp array that is the result of evaluating each of
  the elements of ARGUMENTS
(defalias 'espresso--js-list #[(&rest arguments) "\302\303\304\305	#)\207" [espresso--js-array-as-list arguments t apply espresso--js-funcall (interactor "_mkArray")] 4 (#$ . 83798)])
(defalias 'espresso--js-get #[(&rest props) "\301\302\303#\207" [props apply espresso--js-funcall (interactor "_getProp")] 4])
(defalias 'espresso--js-put #[(props value) "\302\303	#\207" [props value espresso--js-funcall (interactor "_putProp")] 4])
#@120 Tell the repl about any objects we don't reference anymore.
With argument, run even if no intervening GC has happened.
(defalias 'espresso-js-gc #[(&optional force) "\203\306\n\306\306\205:\307\310!\205:\311!\205:	
=?\205:rq\210\212db\210\312\212\313y\210`)\"))\205a\306\314\315\"\210\237)\316\317\f\206R\320\"
\321 \203`\322\323\"\210+\207" [force espresso--js-last-gcs-done gcs-done num keys this-gcs-done nil boundp inferior-moz-buffer buffer-live-p looking-back 0 maphash #[(x #1=#:--cl-var--) "	B\211\207" [x #2=#:--cl-var--] 2] espresso--js-funcall (repl "_espressoGC") [] interactive-p message "Cleaned %s entries" espresso--js-references espresso--js-prompt-regexp #2#] 3 (#$ . 84332) nil])
(run-with-idle-timer 30 t 'espresso-js-gc)
#@170 Evaluate the Javascript contained in JS and return the
JSON-decoded result. eval must be called using this function
because it is special to the Javascript interpreter.
(defalias 'espresso-js-eval #[(js) "\303 \210\304\216\305\306 !\307	\"\310 \203\311\312\313\314\n\"\"\210\n*)\207" [content-window js result espresso--js-enter-repl ((espresso--js-leave-repl)) espresso--js-content-window espresso--get-js-context espresso--js-eval interactive-p message "%s" espresso--js-funcall "String"] 5 (#$ . 85116) "MJavascript to evaluate: "])
#@328 Enumerate all the contexts available. Each one is a list:

   The list is (TITLE URL BROWSER TAB TABBROWSER) for content documents
   The list is (TITLE URL WINDOW) for windows

   All tabs of a given window are grouped together. The most
   recent window is first. Within each window, the tabs are
   returned left-to-right.

(defalias 'espresso--get-tabs #[nil "\306 \210\307\216\310\311\312\313\314\315F\316\317\320D\312\321\322\257\"\311	\323D\310\"\310\310\324\311\n\325D!!\203p\311\n\326D!\327\316\317\320D\330\331\257\316\332\333ED\316\317\320D\334F\316\317\320D\335F%\324\fAAA@!\206c\336\f!\337=\203i\202m\fB\202#,\310\310\3100\3101
:\203 

@\340\f!\341\f!\fAA@E0B0\342\343\"1\3441!\205\2671G\345Y\205\2671\346H2>\205\267\347\203
\3463\3421\350\351#4\310534W\203
\327\316\317\320D1\3503\352\331\257\3161\3503\353\332\333\257D\316\317\320D1\3503\257\3161\354\355\356F3E1%5B53\357\\3\202\3105\237+\2370\2440
A\202}0\237-))\207" [windows window-mediator enumerator window window-info #1=#:--cl-var-- espresso--js-enter-repl ((espresso--js-leave-repl)) nil espresso--js-funcall "Components" "classes" "@mozilla.org/appshell/window-mediator;1" "getService" espresso--funcall interactor "_getProp" "interfaces" "nsIWindowMediator" "getEnumerator" espresso--js-true "hasMoreElements" "getNext" espresso--js-list "document" "title" "location" "toString" "closed" "windowState" fifth 2 first second espresso--js-get "gBrowser" vectorp 3 0 t "browsers" "length" "contentDocument" "contentWindow" "tabContainer" "childNodes" "item" 1 #2=#:--cl-var-- gbrowser cl-struct-espresso--js-handle-tags x #3=#:--cl-var-- #4=#:--cl-var--] 9 (#$ . 85664)])
(defvar espresso-read-tab-history nil)
#@186 Read a Mozilla tab with prompt PROMPT. Return a cons of (TYPE . OBJECT).
TYPE is either 'window or 'tab, and OBJECT is a Javascript handle
to a ChromeWindow or a browser, respectively.
(defalias 'espresso--read-tab #[(prompt) "\203\202\300\306!\210\300\307!\210\310 \210\311\216\312\313!\312\314!\312\315!\312\316!\f
\317 L\210)22\307L\210)\n33\307L\210)	44\307L\210)\f55\320\321\322\"6\fJ7\3078\3079\307:\307;7:\203\2667@8\323\324\3258!\3268!#99<6=\327<\330<=\331#\332\\=#*::\333V\203\244\323\3349:#998B;B;7A7\202b;\237.L\210)\312\335!\312\336!\312\337!\312\340!>?@AABB\307L\210)@CC\307L\210)?DD\307L\210)>EE\307L\210)AFF\341\342\343\344\345D\344>D\344?D\344@D\344AD\344	D\344\nD\344D\344\fD\346\257EL\210)@GG\341\342\343\344\347D\344>D\344?D\344@D\344AD\344	D\344\nD\344D\344\fD\346\257EL\210)?HH\350L\210)>II\341\342\343\344\351D\344>D\344?D\344@D\344AD\344	D\344\nD\344D\344\fD\346\257EL\210)\352\216JJAJKBK\353L\354\355\fJ\"\307\306\307\356&)L\210))\357\356J\"\210\nMM\fJN\3078\306O\307PN:\205\354
N@88@J\232\203\353
8AP\307\211O\202\354
\306\203\367
NAN\202\313
P,L\210)\nJAAA@\203\360\nJAA@B\202\361\nJAA@B,,)\207" [ido-mode #1=#:--cl-prev-hitab-- #2=#:--cl-selected-tab-- #3=#:--cl-selected-tab-cname-- #4=#:--cl-tabs-- #5=#:v t nil espresso--js-enter-repl ((espresso--js-leave-repl)) make-symbol "--tabs--" "--selected-tab-cname--" "--selected-tab--" "--prev-hitab--" espresso--get-tabs make-hash-table :test equal format "%s (%s)" second first puthash gethash -1 1 0 "%s <%d>" "----cl-setup-hook----" "----cl-command-hook----" "----cl-mogrify-highlighting----" "----cl-find-tab-by-cname----" lambda (&rest --cl-rest--) apply quote #[(#6=#:G79306 #7=#:G79307 #8=#:G79308 #9=#:G79309 #10=#:G79310 #11=#:G79311 #12=#:G79312 #13=#:G79313) "J	@!\n\205 \nAAA@?\205 \306\307\nAA@\310\311\312F\313\"\232\203x\314\nAA@\315\316#\317	\320\320\321\320
:\205j
@J!AAA@=\203i\322\"\321\320\211\202j\321\203s
A\202<\210.)\323\324J\321\321$\207" [#6# ido-matches matched-tab tab-to-match index #14=#:--cl-var-- "navigator:browser" espresso--js-funcall "document" "documentElement" "getAttribute" "windowtype" espresso--js-get "gBrowser" "selectedTab" 0 nil t ido-chop add-hook post-command-hook match candidate-tab #15=#:--cl-var-- #16=#:--cl-var-- ido-cur-list #8#] 6] --cl-rest-- #[(#17=#:G79314 #18=#:G79315 #19=#:G79316 #20=#:G79317 #21=#:G79318 #22=#:G79319 #23=#:G79320 #24=#:G79321) "J	@!J\n\fJ\"\210\f
\nL))\207" [#17# ido-matches tab #18# #21# #25=#:v] 3] #[(hitab unhitab) "\304	AAA@\203\305B\306B\n\203\307B\202(	AA@\203(\310BAAA@\203;\311B\312B\202FAA@\203F\313B\314\315\316\237BD!)\207" [cmds hitab espresso-js-switch-tabs unhitab nil (js! ((fourth hitab) "setAttribute") "style" "color: red; font-weight: bold") (js! ((third hitab) "setAttribute") "style" "border: 8px solid red") (js> ((fifth hitab) "selectedTab") (fourth hitab)) (js! ((third hitab) "document" "documentElement" "setAttribute") "style" (concat "-moz-appearance: none;" "border: 8px solid red;")) (js! ((fourth unhitab) "setAttribute") "style" #26="") (js! ((third unhitab) "setAttribute") "style" #26#) (js! ((third unhitab) "document" "documentElement" "setAttribute") "style" #26#) eval with-espresso-js js-list] 4] #[(#27=#:G79322 #28=#:G79323 #29=#:G79324 #30=#:G79325 #31=#:G79326 #32=#:G79327 #33=#:G79328 #34=#:G79329 cname) "J\306\307\306	:\205\"	@\n@
\232\203!\nA\306\211\202\"\307\203+	A\202	\f,\207" [#34# #35=#:--cl-var-- tab #36=#:--cl-var-- #37=#:--cl-var-- cname nil t] 2] ((byte-code "J\203	J\303J\"\210\n\303L\210)\303\207" [#1# #38=#:--cl---cl-mogrify-highlighting---- #39=#:v nil] 3)) ido-completing-read mapcar car espresso-read-tab-history add-to-history browser window #40=#:v #41=#:v #42=#:v #43=#:v tab-names #44=#:--cl-var-- tab cname num #45=#:--cl-var-- #46=#:v #47=#:v #48=#:--cl---cl-find-tab-by-cname---- #38# #49=#:--cl---cl-command-hook---- #50=#:--cl---cl-setup-hook---- #51=#:v #52=#:v #53=#:v #54=#:v #55=#:v #56=#:v #57=#:v #58=#:v #59=#:v ido-minibuffer-setup-hook prompt #60=#:v #61=#:--cl-var-- #62=#:--cl-var-- #63=#:--cl-var--] 14 (#$ . 87425)])
#@186 Internal helper for `espresso-eval-defun'. Returns a list (NAME . CLASSPARTS),
where CLASSPARTS is a list of strings making up the class name
and NAME is the name of the function part.
(defalias 'espresso--guess-eval-defun-info #[(pstate) "G\302U\205+\303!\304	8)\305=\205+\303!\306	8)G\307U\205+\310!\304	8):\203F\311\310!\306	8)\303\303!\306	8)!C\"\202xG\304U\205W\303!\304	8)\305=\203u\311\312\303!\306	8)!\313\303!\306	8)!@C\"\202x\314\315!\207" [pstate cl-x 3 first 2 function 4 1 second append butlast last error "Function not a toplevel defun or class member"] 5 (#$ . 91724)])
#@128 The current JS context. This is a cons like the one returned
from `espresso--read-tab'. Change with
`espresso-set-js-context'.
(defvar espresso--js-context nil (#$ . 92342))
(defconst espresso--js-inserter "(function(func_info,func) {\n    func_info.unshift('window');\n    var obj = window;\n    for(var i = 1; i < func_info.length - 1; ++i) {\n      var next = obj[func_info[i]];\n      if(typeof next !== 'object' && typeof next !== 'function') {\n        next = obj.prototype && obj.prototype[func_info[i]];\n        if(typeof next !== 'object' && typeof next !== 'function') {\n          alert('Could not find ' + func_info.slice(0, i+1).join('.') +\n                ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');\n          return;\n        }\n\n        func_info.splice(i+1, 0, 'prototype');\n        ++i;\n      }\n    }\n\n    obj[func_info[i]] = func;\n    alert('Successfully updated '+func_info.join('.'));\n  })")
#@77 Set the Javascript context to CONTEXT, reading from the user
if interactive
(defalias 'espresso-set-js-context #[(context) "\211\207" [context espresso--js-context] 2 (#$ . 93288) (list (espresso--read-tab "Javascript Context: "))])
#@98 Return a valid JS context. If one hasn't been set, or if it's
stale, ask the user for a new one.
(defalias 'espresso--get-js-context #[nil "\301 \210\302\216?\206@\303A!\206@\304@\305\"\203#\306\307A\310\"!\202@\304@\311\"\2036\306\307A\312\"!?\202@\313\314@\315#\205@\316\203G\317\320!)\207" [espresso--js-context espresso--js-enter-repl ((espresso--js-leave-repl)) espresso--js-handle-expired-p eql window espresso--js-true espresso--js-get "closed" browser "contentDocument" error "cl-ecase failed: %s, %s" (window browser) nil espresso--read-tab "Javascript Context: "] 4 (#$ . 93529)])
(defalias 'espresso--js-content-window #[(context) "\301 \210\302\216\303@\304\"\203A\202-\303@\305\"\203#\306A\307\310#\202-\311\312@\313#\205-\314)\207" [context espresso--js-enter-repl ((espresso--js-leave-repl)) eql window browser espresso--js-get "contentWindow" "wrappedJSObject" error "cl-ecase failed: %s, %s" (window browser) nil] 4])
(defalias 'espresso--make-nsilocalfile #[(path) "\302 \210\303\216\304\305\306\307\310F\311\312\313D\305\314\315\257\"\304\316D	\"\210))\207" [file path espresso--js-enter-repl ((espresso--js-leave-repl)) espresso--js-funcall "Components" "classes" "@mozilla.org/file/local;1" "createInstance" espresso--funcall interactor "_getProp" "interfaces" "nsILocalFile" "initWithPath"] 7])
(defalias 'espresso--js-add-resource-alias #[(alias path) "\306 \210\307\216\310\311\312\313\314F\315\316\317D\311\320\321\257\"\310\322D\323\"\310	\324D\315\316\317D\311\320\325\257\"\326\n!\310\327D\"\310	\330D
\f#-)\207" [io-service res-prot path path-file path-uri alias espresso--js-enter-repl ((espresso--js-leave-repl)) espresso--js-funcall "Components" "classes" "@mozilla.org/network/io-service;1" "getService" espresso--funcall interactor "_getProp" "interfaces" "nsIIOService" "getProtocolHandler" "resource" "QueryInterface" "nsIResProtocolHandler" espresso--make-nsilocalfile "newFileURI" "setSubstitution"] 7])
#@68 Update some Mozilla tab with defun containing point or after
point
(defalias 'espresso-eval-defun #[nil "\300\301\215\207" [--cl-block-espresso-eval-defun-- (byte-code "\212\306\306\306\306\306\306\307 \210`\310 \210\311 \210\312\313!\210\314\224\315 ?\206*`\fV\2031\316\317!\210\320!\321
\f\"@\322@\323\324#\210\325\216\326\327\330\331\332\n\333#\"!\203T\202]\334\335!\210\336\337\306\"\210))\340
\f\"\341A\342\"\210\343\344A\"\210\345A\346P\306\347#\350\216\351 \210\352\216\353\354!BrBq\210\355\216Cc\210\356c\210\357\n!c\210\360c\210c\210\361c\210\362ed	\306\363%\210)))\364\365 !D\366D\367\"E\370\366E\371\"!\203\320\366\372E\373D\374E\314\"\202\325\366E\375\"F\376E\377D\201H\201I#G\376G\201JD\201K\201L#\210\376G\201JD\201M\327\201N\201O	!\"#\210\376F\201PDG\"\210\376D\201QD\201R\372\201S\201T\201U\201V#C\201W	!E\201X$\210\306\211,)).)\207" [defun-body temp-name defun-info pstate end begin nil espresso--end-of-defun espresso--ensure-cache espresso--beginning-of-defun re-search-forward "\\_<function\\_>" 0 espresso--forward-pstate error "Could not locate function definition" espresso--guess-eval-defun-info make-overlay overlay-put face highlight ((delete-overlay overlay)) y-or-n-p format "Send %s to Mozilla? " mapconcat identity "." message "" throw --cl-block-espresso-eval-defun-- buffer-substring-no-properties make-directory t espresso--js-add-resource-alias "espresso" make-temp-file "/espresso-" ".js" ((byte-code "\203\301!\210\301\207" [temp-name delete-file] 2)) espresso--js-enter-repl ((espresso--js-leave-repl)) generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) "(" json-encode-list ",\n" "\n)" write-region 1 espresso--js-content-window espresso--get-js-context espresso--js-get "document" espresso--js-true "body" espresso--funcall "getElementsByTagName" "head" "documentElement" espresso--js-funcall "createElementNS" overlay espresso-js-tmpdir #1# espresso--js-inserter content-window content-document head elem "http://www.w3.org/1999/xhtml" "script" "setAttribute" "type" "text/javascript" "src" "resource://espresso/%s" file-name-nondirectory "appendChild" "addEventListener" "unload" espresso--js-new "Function" "file" "return function() { file.remove(false) }" espresso--make-nsilocalfile false] 8)] 2 (#$ . 95519) nil])
#@85 Major mode for editing JavaScript source text.

Key bindings:

\{espresso-mode-map}
(defalias 'espresso-mode #[nil "\306 \210\307!\210\310	!\210\311\312!\313L\210\311\314!\315L\210\311\316!\317L\210\311\320!\321L\210\311\322!\n\321\321\321\321\323\257L\210\311\324!\325L\210\311\326!\325L\210\311\327!\330L\210\331\332\311\333!\334L\210\335\336\337\325\325$\210\340 \210\321\311\341!\342L\210\3432\3443\3454\3465\3466\3477\3508\3519\352:\325;\353 \210)\311\354!\355L\210\356 \210\321<\357 \210)\360\361!\207" [espresso-mode-map espresso-mode-syntax-table espresso--font-lock-keywords comment-start comment-end imenu-case-fold-search kill-all-local-variables use-local-map set-syntax-table make-local-variable indent-line-function espresso-indent-line beginning-of-defun-function espresso--beginning-of-defun end-of-defun-function espresso--end-of-defun open-paren-in-column-0-is-defun-start nil font-lock-defaults (font-lock-syntactic-keywords . espresso--font-lock-syntactic-keywords) parse-sexp-ignore-comments t parse-sexp-lookup-properties which-func-imenu-joiner-function espresso--which-func-joiner "// " "" fill-paragraph-function espresso-c-fill-paragraph add-hook before-change-functions espresso--flush-caches espresso--update-quick-match-re imenu-create-index-function espresso--imenu-create-index espresso-mode "Espresso" "//+\\|\\**" "$" "* " "//" "/[*/]\\|\\s!" "\\(//+\\|/\\*+\\)\\s *" c-setup-paragraph-variables syntax-begin-function espresso--syntax-begin-function font-lock-set-defaults font-lock-fontify-buffer run-mode-hooks espresso-mode-hook major-mode mode-name c-comment-prefix-regexp c-paragraph-start c-paragraph-separate c-block-comment-prefix c-line-comment-starter c-comment-start-regexp comment-start-skip c-buffer-is-cc-mode font-lock-keywords] 7 (#$ . 97923) nil])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\307\310!\207" [eval-after-load hideshow (add-to-list 'hs-special-modes-alist '(espresso-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning)) folding (when (fboundp 'folding-add-to-marks-list) (folding-add-to-marks-list 'espresso-mode "// {{{" "// }}}")) speedbar (speedbar-add-supported-extension ".js") provide espresso] 3)