;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:26 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

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

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

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305\306\307#\210\300\310\306\307#\207" [require cc-mode newcomment thingatpt imenu moz nil t json] 4)
#@73 Regexp matching the start of a JavaScript identifier, without grouping.
(defconst js--name-start-re "[a-zA-Z_$]" (#$ . 726))
(defconst js--stmt-delim-chars "^;{}?:")
#@60 Regexp matching a JavaScript identifier, without grouping.
(defconst js--name-re (concat js--name-start-re "\\(?:\\s_\\|\\sw\\)*") (#$ . 898))
#@57 Regexp matching the start of a JavaScript object field.
(defconst js--objfield-re (concat js--name-re ":") (#$ . 1047))
#@63 Regexp matching a dot-separated sequence of JavaScript names.
(defconst js--dotted-name-re (concat js--name-re "\\(?:\\." js--name-re "\\)*") (#$ . 1173))
#@40 Regexp matching a C preprocessor name.
(defconst js--cpp-name-re js--name-re (#$ . 1334))
#@182 Regexp matching the prefix of a cpp directive.
This includes the directive name, or nil in languages without
preprocessor support.  The first submatch surrounds the directive
name.
(defconst js--opt-cpp-start "^\\s-*#\\s-*\\([[:alnum:]]+\\)" (#$ . 1431))
#@180 Regexp matching an explicit JavaScript 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 js--plain-method-re (concat "^\\s-*?\\(" js--dotted-name-re "\\)\\.prototype" "\\.\\(" js--name-re "\\)\\s-*?=\\s-*?\\(function\\)\\_>") (#$ . 1693))
#@129 Regexp matching a JavaScript explicit prototype "class" declaration.
An example of this is "Class.prototype = { method1: ...}".
(defconst js--plain-class-re (concat "^\\s-*\\(" js--dotted-name-re "\\)\\.prototype" "\\s-*=\\s-*{") (#$ . 2039))
(defconst js--mp-class-decl-re (concat "^\\s-*var\\s-+" #1="\\(" js--name-re "\\)" "\\s-*=\\s-*" #1# js--dotted-name-re "\\)\\.extend\\(?:Final\\)?\\s-*(\\s-*{?\\s-*$"))
(defconst js--prototype-obsolete-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" js--dotted-name-re "\\)" "\\s-*=\\s-*Class\\.create()"))
(defconst js--prototype-objextend-class-decl-re-1 (concat "^\\s-*Object\\.extend\\s-*(" "\\(" js--dotted-name-re "\\)" "\\s-*,\\s-*{"))
(defconst js--prototype-objextend-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" js--dotted-name-re "\\)" "\\s-*=\\s-*Object\\.extend\\s-*("))
(defconst js--prototype-class-decl-re (concat "^\\s-*\\(?:var\\s-+\\)?" "\\(" js--name-re "\\)" "\\s-*=\\s-*Class\\.create\\s-*(\\s-*" "\\(?:\\(" js--dotted-name-re "\\)\\s-*,\\s-*\\)?{?"))
(defconst js--dojo-class-decl-re (concat "^\\s-*dojo\\.declare\\s-*(\"\\(" js--dotted-name-re "\\)"))
#@55 Regexp matching an ExtJS class declaration (style 1).
(defconst js--extjs-class-decl-re-1 (concat "^\\s-*Ext\\.extend\\s-*(" "\\s-*\\(" js--dotted-name-re #1="\\)" "\\s-*,\\s-*\\(" js--dotted-name-re #1#) (#$ . 3182))
#@55 Regexp matching an ExtJS class declaration (style 2).
(defconst js--extjs-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?" #1="\\(" js--name-re #2="\\)" "\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*" #1# js--dotted-name-re #2#) (#$ . 3406))
#@47 Regexp matching a MochiKit class declaration.
(defconst js--mochikit-class-re (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*" "\\(" js--dotted-name-re "\\)") (#$ . 3644))
(defconst js--dummy-class-style '(:name "[Automatically Generated Class]"))
#@774 List of JavaScript 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 js--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" [js--plain-class-re js--mochikit-class-re js--prototype-obsolete-class-decl-re js--prototype-class-decl-re js--prototype-objextend-class-decl-re-1 js--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) js--dojo-class-decl-re js--extjs-class-decl-re-1 js--extjs-class-decl-re-2 js--mp-class-decl-re] 14) (#$ . 3902))
#@50 List of available JavaScript frameworks symbols.
(defconst js--available-frameworks (byte-code "\301\211\211:\203&@\262\302\303\"\262

>\204\211C\244\262
A\262\202\207" [js--class-styles nil plist-get :framework] 7) (#$ . 5942))
#@103 Regexp matching the start of a JavaScript function header.
Match group 1 is the name of the function.
(defconst js--function-heading-1-re (concat "^\\s-*function\\s-+\\(" js--name-re "\\)") (#$ . 6192))
#@115 Regexp matching the start of a function entry in an associative array.
Match group 1 is the name of the function.
(defconst js--function-heading-2-re (concat "^\\s-*\\(" js--name-re "\\)\\s-*:\\s-*function\\_>") (#$ . 6402))
#@97 Regexp matching a line in the JavaScript form "var MUMBLE = function".
Match group 1 is MUMBLE.
(defconst js--function-heading-3-re (concat "^\\s-*\\(?:var\\s-+\\)?\\(" js--dotted-name-re "\\)" "\\s-*=\\s-*function\\_>") (#$ . 6633))
#@112 Regexp matching a CPP macro definition, up to the opening parenthesis.
Match group 1 is the name of the macro.
(defconst js--macro-decl-re (concat "^\\s-*#\\s-*define\\s-+\\(" js--cpp-name-re "\\)\\s-*(") (#$ . 6874))
#@79 Like `regexp-opt', but surround the result with `\\_<' and `\\_>'.

(fn LIST)
(defalias 'js--regexp-opt-symbol #[257 "\300\301\302\"\303Q\207" ["\\_<" regexp-opt t "\\_>"] 5 (#$ . 7098)])
#@41 Regexp matching any JavaScript keyword.
(defconst js--keyword-re (js--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")) (#$ . 7293))
#@64 Regular expression matching any predefined type in JavaScript.
(defconst js--basic-type-re (js--regexp-opt-symbol '("boolean" "byte" "char" "double" "float" "int" "long" "short" "void")) (#$ . 7835))
#@70 Regular expression matching any future reserved words in JavaScript.
(defconst js--constant-re (js--regexp-opt-symbol '("false" "null" "undefined" "Infinity" "NaN" "true" "arguments" "this")) (#$ . 8041))
#@45 Level one font lock keywords for `js-mode'.
(defconst js--font-lock-keywords-1 (byte-code "\303\304	E\n\304	EE\207" [js--function-heading-1-re font-lock-function-name-face js--function-heading-2-re "\\_<import\\_>" 1] 5) (#$ . 8252))
#@45 Level two font lock keywords for `js-mode'.
(defconst js--font-lock-keywords-2 (byte-code "\306	\307\nE\310\311\312\211\307\302D\257\fB
BF\"\207" [js--font-lock-keywords-1 js--keyword-re font-lock-keyword-face js--basic-type-re font-lock-type-face js--constant-re append 1 "\\_<for\\_>" "\\s-+\\(each\\)\\_>" nil font-lock-constant-face] 9) (#$ . 8493))
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put js--pitem-children compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-children (car cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-children #[257 "\211@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--pitem-children gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--pitem-children] 5 "\n\n(fn CL-DO CL-X)"] js--pitem-paren-depth compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-paren-depth (nth 1 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-paren-depth #[257 "\211A@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--pitem-paren-depth gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--pitem-paren-depth] 5 "\n\n(fn CL-DO CL-X)"] js--pitem-type compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-type (nth 2 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-type #[257 "\300
8\207" [2] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--pitem-type gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--pitem-type] 5 "\n\n(fn CL-DO CL-X)"] js--pitem-h-begin compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-h-begin (nth 3 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-h-begin #[257 "\300
8\207" [3] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--pitem-h-begin gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--pitem-h-begin] 5 "\n\n(fn CL-DO CL-X)"] js--pitem-name compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-name (nth 4 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-name #[257 "\300
8\207" [4] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--pitem-name gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--pitem-name] 5 "\n\n(fn CL-DO CL-X)"] js--pitem-b-end compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-b-end (nth 5 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--pitem-b-end #[257 "\300
8\207" [5] 3 "\n\n(fn CL-X)"])
(defalias 'copy-js--pitem #[257 "\300
!\207" [copy-sequence] 3 "\n\n(fn X)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put make-js--pitem compiler-macro #[385 "\300
>A@\301>A@\302>A@\303>A@\304>A@\305>A@\211\203L\211@\306>\2034\211AA\262
\202!\307>A@\203C\310\262
\202!\311\312@\"\210\202!\210\313\314\315\310\310&\207" [: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-js--pitem (list children paren-depth type h-begin name b-end))] 20 "\n\n(fn CL-WHOLE &cl-quote &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
#@58 

(fn &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-js--pitem #[128 "\300
>A@\301>A@\302>A@\303>A@\304>A@\305>A@\211\203L\211@\306>\2034\211AA\262
\202!\307>A@\203C\310\262
\202!\311\312@\"\210\202!\210\257\207" [: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)"] 13 (#$ . 13290)])
(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-js--pitem-tags cl-struct-js--pitem put js--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-js--pitem side-effect-free t copy-js--pitem js--pitem-b-end js--pitem-name js--pitem-h-begin js--pitem-type js--pitem-paren-depth js--pitem-children] 4)
(defconst js--initial-pitem (byte-code "\301\302\301\211\211\257\207" [most-negative-fixnum nil toplevel] 6))
(byte-code "\301\302\303\304\305\306\307\310&\210\311\312\313\314\315DD\316\317\320\321\322\307\302&	\210\311\323\313\314\324DD\325\317\320\321\322\307\302&	\210\311\326\313\314\327DD\330\317\320\321\322\307\302\331\332&\210\311\333\313\314\334DD\335\317\320\321\322\307\302\331\332&\210\311\336\313\314\337DD\340\317\320\321\322\307\302\331\332&\210\311\341\313\314\342DD\343\317\344\307\302&\210\311\345\313\314\346DD\347\317\344\307\302&\210\311\350\313\314\351DD\352\317\314\307\302&\210\311\353\313\314\354DD\355\317\356\357\360\"B\307\302&\210\311\361\313\314\362DD\363\317\344\307\302&\210\311\364\313\314\365DD\366\317\367\307\302&\210\311\370\313\314\371DD\372\317\320\307\302&\207" [js--available-frameworks custom-declare-group js nil "Customization variables for JavaScript mode." :tag "JavaScript" :group languages custom-declare-variable js-indent-level funcall function #[0 "\300\207" [4] 1 "\n\n(fn)"] "Number of spaces for each indentation step in `js-mode'." :type integer :safe integerp js-expr-indent-offset #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of additional spaces for indenting continued expressions.\nThe value must be no less than minus `js-indent-level'." js-paren-indent-offset #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of additional spaces for indenting expressions in parentheses.\nThe value must be no less than minus `js-indent-level'." :version "24.1" js-square-indent-offset #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of additional spaces for indenting expressions in square braces.\nThe value must be no less than minus `js-indent-level'." js-curly-indent-offset #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of additional spaces for indenting expressions in curly braces.\nThe value must be no less than minus `js-indent-level'." js-auto-indent-flag #[0 "\300\207" [t] 1 "\n\n(fn)"] "Whether to automatically indent when typing punctuation characters.\nIf non-nil, the characters {}();,: also indent the current line\nin Javascript mode." boolean js-flat-functions #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Treat nested functions as top-level functions in `js-mode'.\nThis applies to function movement, marking, and so on." js-comment-lineup-func #[0 "\300\207" [c-lineup-C-comments] 1 "\n\n(fn)"] "Lineup function for `cc-mode-style', for C comments in `js-mode'." js-enabled-frameworks #[0 "\207" [js--available-frameworks] 1 "\n\n(fn)"] "Frameworks recognized by `js-mode'.\nTo improve performance, you may turn off some frameworks you\nseldom use, either globally or on a per-buffer basis." set mapcar #[257 "\300
D\207" [const] 3 "\n\n(fn X)"] js-js-switch-tabs #[0 "\301>\205\302\207" [system-type (darwin) t] 2 "\n\n(fn)"] "Whether `js-mode' should display tabs while selecting them.\nThis is useful only if the windowing system has a good mechanism\nfor preventing Firefox from stealing the keyboard focus." js-js-tmpdir #[0 "\300\207" ["~/.emacs.d/js/js"] 1 "~/.emacs.d/js/js\n\n(fn)"] "Temporary directory used by `js-mode' to communicate with Mozilla.\nThis directory must be readable and writable by both Mozilla and Emacs." directory js-js-timeout #[0 "\300\207" [5] 1 "\n\n(fn)"] "Reply timeout for executing commands in Mozilla via `js-mode'.\nThe value is given in seconds.  Increase this value if you are\ngetting timeout messages."] 12)
#@23 Keymap for `js-mode'.
(defvar js-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\312\313\314\315$\210\211\207" [make-sparse-keymap define-key [(control 99) (meta 58)] js-eval [(control 99) (control 106)] js-set-js-context [(control meta 120)] js-eval-defun [(meta 46)] js-find-symbol easy-menu-do-define nil "Javascript Menu" ("Javascript" ["Select New Mozilla Context..." js-set-js-context (fboundp #'inferior-moz-process)] ["Evaluate Expression in Mozilla Context..." js-eval (fboundp #'inferior-moz-process)] ["Send Current Function to Mozilla..." js-eval-defun (fboundp #'inferior-moz-process)])] 6) (#$ . 17934))
#@29 Syntax table for `js-mode'.
(defvar js-mode-syntax-table (byte-code "\300 \301
!\210\302\303\304#\210\211\207" [make-syntax-table c-populate-syntax-table modify-syntax-entry 36 "_"] 5) (#$ . 18610))
#@68 Autogenerated regexp used by `js-mode' to match buffer constructs.
(defvar js--quick-match-re nil (#$ . 18816))
#@75 Autogenerated regexp used by `js-mode' to match constructs and functions.
(defvar js--quick-match-re-func nil (#$ . 18934))
(byte-code "\300\301!\210\300\302!\207" [make-variable-buffer-local js--quick-match-re js--quick-match-re-func] 2)
#@62 Last valid buffer position for the `js-mode' function cache.
(defvar js--cache-end 1 (#$ . 19179))
(make-variable-buffer-local 'js--cache-end)
#@54 Latest parse position reached by `js--ensure-cache'.
(defvar js--last-parse-pos nil (#$ . 19328))
(make-variable-buffer-local 'js--last-parse-pos)
#@38 Parse state at `js--last-parse-pos'.
(defvar js--state-at-last-parse-pos nil (#$ . 19481))
(make-variable-buffer-local 'js--state-at-last-parse-pos)
(defalias 'js--flatten-list #[257 "\211\300\211:\203)@\262
:\203\301!\202
\205
C\237
\244\262
A\262\202\211\237\207" [nil js--flatten-list] 6 "\n\n(fn LIST)"])
#@356 Helper function for `js--update-quick-match-re'.
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.

(fn PREFIX SEPARATOR SUFFIX &rest LIST)
(defalias 'js--maybe-join #[899 "\300
!\262
\211\205\301\302#Q\207" [js--flatten-list mapconcat identity] 9 (#$ . 19812)])
#@157 Internal function used by `js-mode' for caching buffer constructs.
This updates `js--quick-match-re', based on the current set of
enabled frameworks.

(fn)
(defalias 'js--update-quick-match-re #[0 "\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" [js-enabled-frameworks js--quick-match-re js--quick-match-re-func js--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 (#$ . 20304)])
#@197 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.

(fn PROPNAME)
(defalias 'js--forward-text-property #[257 "\300`\"\211\203\301u\210\202#\302`\301d$b\210m\204#\300`\"\262
\301u\210\211\207" [get-text-property nil next-single-property-change] 7 (#$ . 21238)])
#@208 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.

(fn PROPNAME)
(defalias 'js--backward-text-property #[257 "o?\205,\300`S\"\211\203\301u\210\202)\302`\303e$b\210o\204)\301u\210\300`\"\262
\211\262
\207" [get-text-property -1 previous-single-property-change nil] 7 (#$ . 21643)])
(defalias 'js--forward-pstate #[0 "\300\301!\207" [js--forward-text-property js--pstate] 2 "\n\n(fn)"])
(put 'js--forward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'js--backward-pstate #[0 "\300\301!\207" [js--backward-text-property js--pstate] 2 "\n\n(fn)"])
(put 'js--backward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'js--pitem-goto-h-end #[257 "\300
8b\210\301\302!\207" [3 js--forward-text-property js--pstate] 3 "\n\n(fn PITEM)"])
#@81 Helper function for `js--re-search-forward'.

(fn REGEXP &optional BOUND COUNT)
(defalias 'js--re-search-forward-inner #[769 "\300\211\212\301 \205\f\302 \210`)\303V\203\202\304\"\210\305 \262\3068\211\262\203>
\307=\2030\310\262\304\311\312!P\313 \307#\210\202
\3148\203J\300y\210\202
\3158\204_`Sf\310=\203f\300f\316=\203f\304\317!\210\202
\211\203p`
X\204{\301 \203{\302 \210\202
S\262\202
\266`\207" [nil js--beginning-of-macro c-end-of-macro 0 re-search-forward syntax-ppss 3 t 47 "\\([^\\]\\|^\\)" string point-at-eol 7 4 42 "\\*/"] 10 (#$ . 22558)])
#@314 Search forward, ignoring strings, cpp macros, and comments.
This function invokes `re-search-forward', but treats the buffer
as if strings, cpp macros, and comments have been removed.

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

(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 'js--re-search-forward #[1025 "\211C\211@\204\211\300\240\210`
@\301W\203
\211@[\240\210\302\202)
@\301V\203(\303\202)\304\305\306\307\301\310\311\312

\n$\313\"\314\315%D\316\306\307\317\320\311\312
\"\321\"\314\322%\305EDC\217\266\202\207" [1 0 js--re-search-backward-inner js--re-search-forward-inner ignore #1=#:err funcall make-byte-code "\303\300\301\302@#\207" vconcat vector [] 4 "\n\n(fn)" search-failed 257 "\301b\210\300?\205\302
@A\"\207" [signal] "\n\n(fn ERR)"] 18 (#$ . 23153)])
#@85 Auxiliary function for `js--re-search-backward'.

(fn REGEXP &optional BOUND COUNT)
(defalias 'js--re-search-backward-inner #[769 "\300\211\212\301 \205	`)\302V\203\217\303\"\210`eV\203+\212\304u\210\305\306!)\203+\300u\210\307 \262\3108\211\262\203O
\311=\203A\312\262\303\313\314!P\315 \311#\210\202\n\3168\203]\3178b\210\202\n\3208\204r`Sf\312=\203y\300f\321=\203y\303\322!\210\202\n\211\203\203`
Y\204\210\301 \204\nS\262\202\n\266`\207" [nil js--beginning-of-macro 0 re-search-backward -1 looking-at "/[/*]" syntax-ppss 3 t 47 "\\([^\\]\\|^\\)" string point-at-bol 7 8 4 42 "/\\*"] 10 (#$ . 23994)])
#@314 Search backward, ignoring strings, preprocessor macros, and comments.

This function invokes `re-search-backward' but treats the buffer
as if strings, preprocessor macros, and comments have been
removed.

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

(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 'js--re-search-backward #[1025 "\300\203
[\202\301$\207" [js--re-search-forward -1] 9 (#$ . 24639)])
#@124 Move forward over a whole JavaScript expression.
This function doesn't move over expressions continued across
lines.

(fn)
(defalias 'js--forward-expression #[0 "l\204\301!\210\302f\303>\204\304 \210\202\302f\305=\203&\212\302u\210\306 )\204\302\207" [most-positive-fixnum forward-comment nil (44 59 93 41 125) forward-sexp 10 js--continued-expression-p] 2 (#$ . 25078)])
#@263 Move forward over a JavaScript function declaration.
This puts point at the 'function' keyword.

If this is a syntactically-correct non-expression function,
return the name of the function, or t if the name could not be
determined.  Otherwise, return nil.

(fn)
(defalias 'js--forward-function-decl #[0 "\302\303!\204\f\304\305\306C\"\210\307\310v\210\311!\210\302	!\203#\312\313!\262
\313\225b\210\311!\210\310f\314=\205I\315\316\317D\320\316\321\315EDC\217\205I\311!\210\310f\322=\205I\211\207" [most-positive-fixnum js--name-re looking-at #1="\\_<function\\_>" signal cl-assertion-failed (looking-at #1#) t nil forward-comment match-string-no-properties 0 40 #2=#:err funcall #[0 "\300 \210\301\207" [forward-list t] 1 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] 123] 7 (#$ . 25467)])
#@266 Return the start of the JavaScript function prologue containing POS.
A function prologue is everything from start of the definition up
to and including the opening brace.  POS defaults to point.
If POS is not in a function prologue, return nil.

(fn &optional POS)
(defalias 'js--function-prologue-beginning #[256 "\302\212
\203\f
b\210\202`\262\212\303y\210\304!\206\304	!)\203.\305\224\262
\211X\203.\303\225b\210\306\307!\210\304\310!\204@\311\310\302\312#\205k\313 \314\315\303\316\317\320!\321\"\322\323%DC\216\303\224b\210\324 )\262
\205k
`X\205k\211\206k\303\224)\207" [js--function-heading-2-re js--function-heading-3-re nil 0 looking-at 1 skip-syntax-backward "w_" "\\_<function\\_>" js--re-search-backward t match-data funcall make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\n\n(fn)" js--forward-function-decl] 10 (#$ . 26289)])
#@185 Helper function for `js-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.

(fn)
(defalias 'js--beginning-of-defun-raw #[0 "\300 \210\301\302\303!\211\262\203\304
@8\305=\203o?\205\211\207" [js--ensure-cache nil js--backward-text-property js--pstate 2 function] 3 (#$ . 27186)])
#@168 Helper function for `js--beginning-of-defun-nested'.
If PSTATE represents a non-empty top-level defun, return the
top-most pitem.  Otherwise, return nil.

(fn PSTATE)
(defalias 'js--pstate-is-toplevel-defun #[257 "\211\300\301\300:\203#@\262\3028\303=\203
T\262\262
A\262\202
\304=\205*\211\207" [nil 0 2 function 1] 7 (#$ . 27582)])
#@115 Helper function for `js--beginning-of-defun'.
Return the pitem of the function we went to the beginning of.

(fn)
(defalias 'js--beginning-of-defun-nested #[0 "\300 \301\302\301:\2036@\262\3038\304=\203+\305!\203+\3068b\210\262
\301\211\262\202,\302\2036A\262\202\266\203\206f\301\211\302\301\307\310!\262\203d\311!\211\262\203`\3068b\210\262
\301\211\262\202a\302\204?\266\203\207" [js--parse-state-at-point nil t 2 function js--inside-pitem-p 3 js--backward-text-property js--pstate js--pstate-is-toplevel-defun] 6 (#$ . 27937)])
#@52 Helper function for `js-beginning-of-defun'.

(fn)
(defalias 'js--beginning-of-defun-flat #[0 "\300 \211\205\301
@8b\207" [js--beginning-of-defun-raw 3] 3 (#$ . 28504)])
#@75 Value of `beginning-of-defun-function' for `js-mode'.

(fn &optional ARG)
(defalias 'js-beginning-of-defun #[256 "\211\206\301\262
m\204=\211\302W\203=\211T\262
\204(\303 \304=\204%\305 \203(\306 \210\307\310\311\312#\2037\305 b\210\202db\210\202\211\302V\205u\211S\262
`Sf\313=\203R\314u\210\305 \211\203d\211`W\203d\211b\210\202q\203n\315 \210\202q\316 \210\210\202=\207" [js-flat-functions 1 0 js-syntactic-context function js--function-prologue-beginning js-end-of-defun js--re-search-forward "\\_<function\\_>" nil t 125 -1 js--beginning-of-defun-flat js--beginning-of-defun-nested] 5 (#$ . 28682)])
#@146 Flush the `js-mode' syntax cache after position BEG.
BEG defaults to `point-min', meaning to flush the entire cache.

(fn &optional BEG IGNORED)
(defalias 'js--flush-caches #[512 "
\206	\214~\210e)\262^\211\207" [js--cache-end] 4 (#$ . 29316) nil])
(defalias 'js--debug '(macro . #[128 "\300\207" [nil] 2 "\n\n(fn &rest ARGUMENTS)"]))
(defalias 'js--ensure-cache--pop-if-ended #[514 "
@

A@X\203:\301`S\302\"\203\303\304\305C\"\210\306`S`\307$\210\310
\233\211`\240\266\311\211A@)\"\211AA)B\262\210
\207" [x get-text-property js-pend signal cl-assertion-failed (not (get-text-property (1- (point)) 'js-pend)) put-text-property js--pend 5 js--pitem-add-child] 9 "\n\n(fn OPEN-ITEMS PAREN-DEPTH)"])
#@203 Helper function for `js--ensure-cache'.
Update parsing information up to point, referring to parse,
prev-parse-point, goal-point, and open-items bound lexically in
the body of `js--ensure-cache'.

(fn)
(defalias 'js--ensure-cache--update-parse '(macro . #[0 "\300\207" [(progn (setq goal-point (point)) (goto-char prev-parse-point) (while (progn (setq open-items (js--ensure-cache--pop-if-ended open-items (car parse))) (cl-assert (> (nth 0 parse) (js--pitem-paren-depth (car open-items)))) (setq parse (parse-partial-sexp prev-parse-point goal-point (js--pitem-paren-depth (car open-items)) nil parse)) (setq prev-parse-point (point)) (< (point) goal-point))) (setq open-items (js--ensure-cache--pop-if-ended open-items (car parse))))] 1 (#$ . 30036)]))
(defalias 'js--show-cache-at-point #[0 "\306\307!\210\310`\311\"r\312\313!q\210p\314 \210
\315\211\316\211\316\317 \210\320\321!\210+\211\307!\322!\210)\266\202\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only require pp get-text-property js--pstate get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook internal-temp-output-buffer-show standard-output] 7 "\n\n(fn)" nil])
#@179 Split a JavaScript name into its dot-separated parts.
This also removes any prototype parts from the split name
(unless the name is just "prototype" to start with).

(fn STRING)
(defalias 'js--split-name #[257 "\300 \301\302\303\304\305\306!\307\"\310\311%DC\216\312\313\314#)\262
\211G\315U\205&\211@\316\232?\2051\317\316\"\211\262\207" [match-data funcall make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\n\n(fn)" split-string "\\." t 1 "prototype" remove] 9 (#$ . 31303)])
(defvar js--guess-function-name-start nil)
#@422 Guess the name of the JavaScript function at POSITION.
POSITION should be just after the end of the word "function".
Return the name of the function, or nil if the name could not be
guessed.

This function clobbers match data.  If we find the preamble
begins earlier than expected while guessing the function name,
set `js--guess-function-name-start' to that position; otherwise,
set that variable to nil.

(fn POSITION)
(defalias 'js--guess-function-name #[257 "\303\212\211b\210\304y\210\305	!\203#\304\225
=\205:\306\224\211\205:\307\306!\202:\305\n!\205:\304\225
=\205:\306\224\211\205:\307\306!)\207" [js--guess-function-name-start js--function-heading-3-re js--function-heading-2-re nil 0 looking-at 1 match-string-no-properties] 3 (#$ . 31872)])
(defalias 'js--clear-stale-cache #[0 "\300\212\301\302!\211\262\203\303
\233\211\300\240\266\202)\210\304`d\305#\207" [nil js--forward-text-property js--pend 5 remove-text-properties (js--pstate t js--pend t)] 4 "\n\n(fn)"])
#@111 Ensures brace cache is valid up to the character before LIMIT.
LIMIT defaults to point.

(fn &optional LIMIT)
(defalias 'js--ensure-cache #[256 "\211\206`\262

W\205 \306 \307\211\307\310\211\310\211:;\310\211<\310\211\211\211=\310\211\311\312\313\314\315\316\f!\317\"\320\321%DC\216>\310\211:\203_@\262\322\323\"?>\203X

B\262
A\262\202@\211\237\266\203\262\212\214~\210b\210o\204\230\324`S\325\"\262\204\230\326`\325\310e$b\210o\204\230\324`S\325\"\262\204\230\327\330\331C\"\210\204\241@C\262\332 \262`\262\333 \210e}\210\310\211\211\211\334A\310\307#\203\313\313\224b\262\313\225\262`\262b\210\335\n\n@\"\262\n@\n@A@V\204\350\327\330\336C\"\210\337\f@A@\310
%\262	`\262`W\204\315\335\n\n@\"\262\n@\262\340	8\203
\310\202i\341\342!\203v
\343 \211\262\203v
\307=\203H
\344!\262\203E
B\203H
B\262\202H
\307\262\310f\345=\204U
\327\330\346C\"\210\310u\210\347\350\351\352\353\354\307=\203m
\202q
\355!&\202i\341C!\203\330
\356 \210`\262b\210\335\n\n@\"\262\n@\n@A@V\204\242
\327\330\336C\"\210\337\f@A@\310
%\262	`\262`W\204\207
\335\n\n@\"\262\n\347\350\n@\351\352\357\354\360\361!C&\202i\341D!\203\362\224b\210\363 \311\312\313\364\315\316!\365\"\362\321%DC\216\343 )\262
\205i\310u\210\347\350\351\352\353\354\355\360\361!!\360\320!C\244&\202i\366\n!\310\307\310:\203g@\262\322\367\">\203\\\341\322\370\"!\203\\\313\225b\210\347\350\351\f\352\354\355\360\361!!&\262
\310\211\262\202]\307\203gA\262\202\"\266\204\211\262\203\305`\262b\210\335\n\n@\"\262\n@\n@A@V\204\221\327\330\336C\"\210\337\f@A@\310
%\262	`\262`W\204v\335\n\n@\"\262\n\211\nB\262\n\371`S`\325
$\210\202\264b\210\202\264\266b\210`\262
b\210\335@\"\262@@A@V\204\361\327\330\336C\"\210\337@A@\310	%\262`\262`
W\204\327\335@\"\262E\211F.\f\266\207\207" [js--cache-end buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil funcall make-byte-code 0 "\300?\205
\301 \205
\302\303!\207" vconcat vector [buffer-modified-p set-buffer-modified-p nil] 2 "\n\n(fn)" plist-get :framework get-text-property js--pstate previous-single-property-change signal cl-assertion-failed open-items syntax-ppss js--clear-stale-cache re-search-forward js--ensure-cache--pop-if-ended (> (nth 0 parse) (js--pitem-paren-depth (car open-items))) parse-partial-sexp 8 looking-at "\\_<function\\_>" js--forward-function-decl js--guess-function-name 123 (eq (char-after) 123) make-js--pitem :paren-depth :h-begin :type function :name js--split-name c-end-of-macro macro match-string-no-properties 1 3 match-data "\301\300\302\"\207" [set-match-data evaporate] js--syntactic-context-from-pstate :contexts :class-decl put-text-property deactivate-mark buffer-file-name buffer-file-truename case-fold-search js--class-styles js-enabled-frameworks js--initial-pitem js--quick-match-re-func js--guess-function-name-start js--macro-decl-re js--plain-method-re js--last-parse-pos js--state-at-last-parse-pos] 29 (#$ . 32873)])
#@46 Helper function for `js-end-of-defun'.

(fn)
(defalias 'js--end-of-defun-flat #[0 "\300\301\300\302\303\300\301#\203/\304 \210\305`S\306\"\211\262\203+\3078\310=\203\301\262
\300\211\262\202,\301\204
\203:db\210\300\202;\211\207" [nil t js--re-search-forward "}" js--ensure-cache get-text-property js--pend 2 function] 7 (#$ . 36033)])
#@46 Helper function for `js-end-of-defun'.

(fn)
(defalias 'js--end-of-defun-nested #[0 "\300\301!\210\302\212\303 \211\262\205\304
!\205\305u\210\306 \210`)\302
\203,`W\203,
b\202K\307\310\302\311#\203@\312\224b\210\313 \211\262\203,\211\203I\306 \202Kdb\207" [message "test" nil js--beginning-of-defun-nested js--pitem-goto-h-end -1 forward-list js--re-search-forward "\\_<function\\_>" t 0 js--forward-function-decl] 7 (#$ . 36387)])
#@69 Value of `end-of-defun-function' for `js-mode'.

(fn &optional ARG)
(defalias 'js-end-of-defun #[256 "\211\206\301\262
o\204%\211\302W\203%\211T\262
\303 \210\303 \210o\204\304 \210\202\211\302V\205`\211S\262
\2039\305 \210\202%\306 \211\203Y\211`X\203Y\211b\210\307\310!\210\302\224b\210\311 \210\312 \210\202\\\313 \210\210\202%\207" [js-flat-functions 1 0 js-beginning-of-defun js-end-of-defun js--end-of-defun-flat js--function-prologue-beginning re-search-forward "\\_<function" js--forward-function-decl forward-list js--end-of-defun-nested] 4 (#$ . 36840)])
(defalias 'js--beginning-of-macro #[256 "`\214
\203\n
d}\210\301 \210`SSf\302=\203\303y\210\202
\304 \210`
X\203/\305!\203/\306\2023\211b\210\307)\207" [js--opt-cpp-start beginning-of-line 92 -1 back-to-indentation looking-at t nil] 4 "\n\n(fn &optional LIM)"])
#@87 Simple implementation of `c-backward-syntactic-ws' for `js-mode'.

(fn &optional LIM)
(defalias 'js--backward-syntactic-ws #[256 "\214\211\203	\211d}\210\212\301 )`
\204\301 \210\302!\210`
`\262U?\205&\202\266\202)\207" [most-negative-fixnum js--beginning-of-macro forward-comment] 6 (#$ . 37697)])
#@86 Simple implementation of `c-forward-syntactic-ws' for `js-mode'.

(fn &optional LIM)
(defalias 'js--forward-syntactic-ws #[256 "\214\211\203	e
}\210`\301!\210\302f\303=\203\304 \210`
`\262U?\205%\202\n\262
)\207" [most-positive-fixnum forward-comment nil 35 c-end-of-macro] 5 (#$ . 38010)])
(defalias 'js--up-nearby-list #[0 "\214e`\300Z]`}\210\301\302!)\207" [500 up-list -1] 3 "\n\n(fn)"])
#@65 Return non-nil iff point is in a function parameter list.

(fn)
(defalias 'js--inside-param-list-p #[0 "\300\301\302D\303\301\304\300EDC\217\207" [#1=#:err funcall #[0 "\212\300 \210\301\302!\205\303\304!\210\301\305!\206\303\304!\210\301\305!)\207" [js--up-nearby-list looking-at "(" forward-symbol -1 "function"] 2 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 6 (#$ . 38415)])
#@79 Return non-nil iff point is in a Dojo multiple-inheritance class block.

(fn)
(defalias 'js--inside-dojo-class-list-p #[0 "\300\301\302D\303\301\304\300EDC\217\207" [#1=#:err funcall #[0 "\212\301 \210`\302y\210\303!\205\302\225b\205\303\304!\205\302\225
T=\262
)\207" [js--dojo-class-decl-re js--up-nearby-list 0 looking-at "\"\\s-*,\\s-*\\["] 3 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 6 (#$ . 38823)])
(defalias 'js--syntax-begin-function #[0 "`W\203e]b\210\301\302\303!@\211\262\203\211A@\304=\203\f\211\205&\305
8b\207" [js--cache-end nil js--backward-text-property js--pstate 0 3] 3 "\n\n(fn)"])
#@212 Helper function for building `js--font-lock-keywords'.
Create a byte-compiled function for matching a concatenation of
REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'.

(fn FRAMEWORK &rest REGEXPS)
(defalias 'js--make-framework-matcher #[385 "\300\301\"\262
\302\303\304\305\306\307D\310BB\311\312BBEE!\207" [apply concat byte-compile lambda (limit) when memq quote (js-enabled-frameworks) re-search-forward (limit t)] 10 (#$ . 39471)])
(defvar js--tmp-location nil)
(make-variable-buffer-local 'js--tmp-location)
#@239 Move forward over a JavaScript 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.

(fn &optional FUNC)
(defalias 'js--forward-destructuring-spec #[256 "\303f\211\304=\203L\303u\210\305!\210\303f\306>\203\307!\202;\303f\310=\203)\303u\210\202\311	!\203>
\2036
 \210\312\225b\210\313\204\303f\314=\205\255\303u\210\313\202\255\211\315=\203\254\303u\210\305!\210\311\n!\203\236\312\225b\210\305!\210\303f\316>\203t\307!\202\206\311	!\203\236
\203\201
 \210\312\225b\210\313\203\236\305!\210\303f\310=\203\236\303u\210\305!\210\202Y\303f\317=\205\255\303u\210\313\202\255\303\207" [most-positive-fixnum js--name-re js--objfield-re nil 91 forward-comment (91 123) js--forward-destructuring-spec 44 looking-at 0 t 93 123 (91 123) 125] 4 (#$ . 40010)])
#@235 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-highlight'.

(fn LIMIT)
(defalias 'js--variable-decl-matcher #[257 "\300\301\302\303\304\305\306!\307\"\310\311%D\312\301\313\300ED\314\301\315\300EDD\217\210\316\207" [#1=#:err funcall make-byte-code 0 "\214e\300}\210\306\307	!\210\211\204\310f\311=\205
\310u\210\307	!\210\312\n!\203\343\313\211@\211\224\f\225 \3148!
\204E\3158\206\333\316\317\f#\202\333\320A@!\211\"\242\321=\203k\322
 \"\211#AA)#\210\"\211#A@)\"\"\204{!\306=\204{\310\202\332!\204\225\323
 \321\310$\206\332\324
 \321\"$\202\332!\306=\203\247\324
 \321\"$\202\332!\325=\203\271\326
 \321\"$\202\332!\327=\203\313\330
 \321\"$\202\332!\331=\205\332\332
 \321\"$)-\210\333\225b\202\355\212\334 )\205
\334\335!\205
\307	!\210\310f\336=\203
\310u\210\337 \210\307	!\210\310\262
\202\n\262
)\207" vconcat vector [most-positive-fixnum js--name-re highlight match start t forward-comment nil 44 looking-at (0 font-lock-variable-name-face) 2 3 error #2="No match %d in highlight %S" eval face add-text-properties text-property-not-all put-text-property prepend font-lock-prepend-text-property append font-lock-append-text-property keep font-lock-fillin-text-property 0 js--forward-destructuring-spec #[0 "\306\211@\211\224	\225\3078\n\204!\3108\206\240\311\312	#\202\240\313A@!\211\242\314=\203B\315\n
\211AA)#\210
\211A@)
\204P\f\316=\204P\317\202\237\f\204f\320\n\314\317$\206\237\321\n\314
$\202\237\f\316=\203u\321\n\314
$\202\237\f\322=\203\204\323\n\314
$\202\237\f\324=\203\223\325\n\314
$\202\237\f\326=\205\237\327\n\314
$)-\207" [highlight match start end override val (0 font-lock-variable-name-face) 2 3 error #2# eval face add-text-properties t nil text-property-not-all put-text-property prepend font-lock-prepend-text-property append font-lock-append-text-property keep font-lock-fillin-text-property x] 6 "\n\n(fn)"] 61 js--forward-expression end override val x] 7 "\n\n(fn)" scan-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] end-of-buffer #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] nil] 9 (#$ . 40929)])
#@38 Level three font lock for `js-mode'.
(defconst js--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\211\211FD\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 js--font-lock-keywords-2 js--name-re js--dotted-name-re js--basic-type-re js--name-start-re append ("\\.\\(prototype\\)\\_>" (1 font-lock-constant-face)) js--class-decl-matcher "\\(" "\\)\\(?:\\.\\|.*$\\)" ((goto-char (match-beginning 1)) nil (1 font-lock-type-face)) ((if (match-beginning 2) (progn (setq js--tmp-location (match-end 2)) (goto-char js--tmp-location) (insert "=") (goto-char (match-beginning 2))) (setq js--tmp-location nil) (goto-char (point-at-eol))) (when js--tmp-location (save-excursion (goto-char js--tmp-location) (delete-char 1))) (1 font-lock-type-face)) (js--class-decl-matcher (2 font-lock-type-face nil t)) js--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) (js--inside-dojo-class-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (1 font-lock-type-face)) "\\_<\\(const\\|var\\|let\\)\\_>\\|" js--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) (js--inside-param-list-p)) (forward-symbol -1) (end-of-line)) (end-of-line) (0 font-lock-variable-name-face)] 19) (#$ . 43239))
#@78 Return whether point is inside the given pitem's header or body.

(fn PITEM)
(defalias 'js--inside-pitem-p #[257 "\300 \210\301
8\204\302\303\304C\"\210\211A@\204\302\303\305C\"\210`\3018V\205/\306
8?\206/\306
8`V\207" [js--ensure-cache 3 signal cl-assertion-failed (js--pitem-h-begin pitem) (js--pitem-paren-depth pitem) 5] 4 (#$ . 45218)])
#@201 Parse the JavaScript program state at point.
Return a list of `js--pitem' instances that apply to point, most
specific first.  In the worst case, the current toplevel instance
will be returned.

(fn)
(defalias 'js--parse-state-at-point #[0 "\212\214~\210\301 \210\212\302\303!)\206C\304
@\262
\305
8\306=\204.\307
!\204.
\211A\262@\210\202\210\211\262
*\207" [js--initial-pitem js--ensure-cache js--backward-text-property js--pstate nil 2 toplevel js--inside-pitem-p] 4 (#$ . 45574)])
#@79 Return the JavaScript syntactic context corresponding to PSTATE.

(fn PSTATE)
(defalias 'js--syntactic-context-from-pstate #[257 "\300
@8\211\301>\203\211\202\211:\203\302\202\303\207" [2 #'macro class toplevel] 4 (#$ . 46073)])
#@126 Return the JavaScript syntactic context at point.
When called interactively, also display a message with that
context.

(fn)
(defalias 'js-syntactic-context #[0 "\300\301 !\302\303!\203\304\305\"\210\211\207" [js--syntactic-context-from-pstate js--parse-state-at-point called-interactively-p interactive message "Syntactic context: %s"] 4 (#$ . 46317) nil])
#@112 Font lock function used by `js-mode'.
This performs fontification according to `js--class-styles'.

(fn LIMIT)
(defalias 'js--class-decl-matcher #[257 "\303\304\303\305!\210\306\304#\203w\307\225\262\307\224b\210	\303\211\304\303:\203a@\262\310\311\"\262\310\312\"\n>\203V\313 \310\314\">\203V\203V\315!\203V\307\225b\210\304\262
\303\211\262\202W\304\203aA\262\202\266\204\203p\304\262
\303\211\262\202tb\210\304\204\207" [js--quick-match-re js--class-styles js-enabled-frameworks nil t js--ensure-cache re-search-forward 0 plist-get :class-decl :framework js-syntactic-context :contexts looking-at] 13 (#$ . 46685)])
#@62 Font lock keywords for `js-mode'.  See `font-lock-keywords'.
(defconst js--font-lock-keywords '(js--font-lock-keywords-3 js--font-lock-keywords-1 js--font-lock-keywords-2 js--font-lock-keywords-3) (#$ . 47342))
(defalias 'js-syntax-propertize-regexp #[257 "\300\301 8\302=\205\303\304\305#\205\306`S`\307\310$\207" [3 syntax-ppss 47 re-search-forward "\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*/" move put-text-property syntax-table (7 . 47)] 6 "\n\n(fn END)"])
(defalias 'js-syntax-propertize #[514 "
b\210\300
!\210`

b\210`
W\205M\301\302\303#\205M\304\224\203\f\305u\210\306\224f\307>\203=\212\306\224b\210\310`[!\210`Sf\311>)\203\f\312\304\224\304\225\313\314$\210\300
!\210\202\f\207" [js-syntax-propertize-regexp re-search-forward "\\(?:^\\|[=([{,:;]\\)\\(?:[ 	]\\)*\\(/\\)[^/*]" t 1 -1 0 (32 9) forward-comment (61 40 123 91 44 58 59 nil) put-text-property syntax-table (7 . 47)] 9 "\n\n(fn START END)"])
#@67 Regexp matching keywords optionally followed by an opening brace.
(defconst js--possibly-braceless-keyword-re (js--regexp-opt-symbol '("catch" "do" "else" "finally" "for" "if" "try" "while" "with" "each")) (#$ . 48267))
#@77 Regexp matching operators that affect indentation of continued expressions.
(defconst js--indent-operator-re (byte-code "\300\301\302!P\207" ["[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|" js--regexp-opt-symbol ("in" "instanceof")] 3) (#$ . 48493))
#@80 Return non-nil if point is on a JavaScript operator, other than a comma.

(fn)
(defalias 'js--looking-at-operator-p #[0 "\301 \302\303\304\305\306\307!\310\"\311\312%DC\216\313!\205-\313\314!?\206-\212\315\316\317\320#\205,\313\321!))\207" [js--indent-operator-re match-data funcall make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\n\n(fn)" looking-at ":" js--re-search-backward "[?:{]\\|\\_<case\\_>" nil t "?"] 8 (#$ . 48740)])
#@67 Return non-nil if the current line continues an expression.

(fn)
(defalias 'js--continued-expression-p #[0 "\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 js--looking-at-operator-p js--re-search-backward "\n" nil t " 	" -1 looking-at "[/*]/" "++\\|--\\|/[/*]"] 4 (#$ . 49217)])
#@240 Return non-nil if point is on the "while" of a do-while statement.
Otherwise, return 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.

(fn)
(defalias 'js--end-of-do-while-loop-p #[0 "\212\300 \301\302\303\304\305\306!\307\"\310\311%DC\216\312\313!\205i\212\314\315x\210\312\314!)\2035\212\316 \210\317\320!\210\312\321!)\202i\322\321\323 \324#\210\312\321!\206i\325 \322\326\315\324#\203S\325 
U\203D\312\327!\205g\330\331\332 \324#?\205g\325 
U\262
)\262
)\207" [match-data funcall make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\n\n(fn)" looking-at "\\s-*\\_<while\\_>" "[ 	\n]*}" nil backward-list forward-symbol -1 "\\_<do\\_>" js--re-search-backward point-at-bol t current-indentation "^\\s-*\\_<" "\\s-*\\_<do\\_>" js--re-search-forward "\\_<while\\_>" point-at-eol] 8 (#$ . 49629) nil])
#@187 Helper function for `js--proper-indentation'.
Return the proper indentation of the current line if it starts
the body of a control statement without braces; otherwise, return
nil.

(fn)
(defalias 'js--ctrl-statement-indentation #[0 "\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" [js--possibly-braceless-keyword-re js-indent-level back-to-indentation point-at-bol looking-at "[{]" js--re-search-backward "[[:graph:]]" nil t 41 backward-list skip-syntax-backward " " "w_" js--end-of-do-while-loop-p 0 current-indentation] 4 (#$ . 50575)])
(defalias 'js--get-c-offset #[514 "\302BC\303BC!)\207" [js-comment-lineup-func c-offsets-alist c c-get-syntactic-indentation] 5 "\n\n(fn SYMBOL ANCHOR)"])
#@72 Return the proper indentation for the current line.

(fn PARSE-STATUS)
(defalias 'js--proper-indentation #[257 "\212\305 \210\306
8\203\307\310\3118\"\202\277\311
8\203\312\202\277\313 \206\277\314f\315=\203-\312\202\277\212\316 )\2038\306\202\277\211A@\203\263\317\320!\321 A@b\210\317\322!\203\242\323\324!\210`Sf\325=\203]\326 \210\305 \210
\203hi\202\256\211\203v\327i\330_	#\202\256\327iA@f\211\331=\203\207\n\202\234\211\332=\203\221\202\234\211\333=\203\233\f\202\234\314\262
#\202\256
\204\255\314u\210\334\314w\210i\266\202\202\277\321 \203\276	\\\202\277\312)\207" [js-indent-level js-expr-indent-offset js-paren-indent-offset js-square-indent-offset js-curly-indent-offset back-to-indentation 4 js--get-c-offset c 8 0 js--ctrl-statement-indentation nil 35 js--beginning-of-macro looking-at "[]})]\\|\\_<case\\_>\\|\\_<default\\_>" js--continued-expression-p "[({[]\\s-*\\(/[/*]\\|$\\)" skip-syntax-backward " " 41 backward-list + 2 40 91 123 " 	"] 9 (#$ . 51422)])
#@46 Indent the current line as JavaScript.

(fn)
(defalias 'js-indent-line #[0 "\214~\210\212\300\301 !)i\302 Z\303\304!!\210\211\305V\205\211u\266\202)\207" [syntax-ppss point-at-bol current-indentation indent-line-to js--proper-indentation 0] 5 (#$ . 52440) nil])
#@69 Fill the paragraph with `c-fill-paragraph'.

(fn &optional JUSTIFY)
(defalias 'js-c-fill-paragraph #[256 "\301\302\303\304K\305K\306K\307\310\311\312\313\314#\315\"\316\317%DC\216\304M\210\305M\210\306M\210\320\211!*\207" [fill-paragraph-function #[256 "\300
!\207" [js--forward-syntactic-ws] 3 "\n\n(fn &optional LIMIT)"] #[256 "\300
!\207" [js--backward-syntactic-ws] 3 "\n\n(fn &optional LIMIT)"] #[256 "\300
!\207" [js--beginning-of-macro] 3 "\n\n(fn &optional LIMIT)"] c-beginning-of-macro c-backward-sws c-forward-sws funcall make-byte-code 0 "\303\300M\210\304\301M\210\305\302M\207" vconcat vector [c-beginning-of-macro c-backward-sws c-forward-sws] 2 "\n\n(fn)" c-fill-paragraph] 17 (#$ . 52711) "*P"])
(defalias 'js--pitem-format #[257 "\300
8\3018\302\303:\204\202\304\305\"#\207" [4 2 format "name:%S type:%S" plist-get :name] 9 "\n\n(fn PITEM)"])
#@221 Helper function for `js--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.

(fn ITEM CHILD NAME-PARTS)
(defalias 'js--make-merged-item #[771 "\3018:\204%\302\303C\304\3018:\204\202\3018\305\306	!&\262\211A\2034\307@A#\202H\3018:\204B
@B\202H\310@@\"AB\207" [js--dummy-class-style 2 make-js--pitem :children :type :name js--pitem-strname js--splice-into-items append] 11 (#$ . 53600)])
#@68 Last part of the name of PITEM, as a string or symbol.

(fn PITEM)
(defalias 'js--pitem-strname #[257 "\300
8\211:\203\301
!@\202\211\207" [4 last] 4 (#$ . 54135)])
#@251 Splice CHILD into the `js--pitem' ITEMS at 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.

(fn ITEMS CHILD NAME-PARTS)
(defalias 'js--splice-into-items #[771 "\211@\301\211\211;\204\302\303\304C\"\210G\305V\204\302\303\306C\"\210\203h\307@!\232\203I\310@#AB\262

\203C

\241\210\202h\211\262\202h@\301B\262

\203Z

\241\210\202]\211\262\211\262A\211\262\204\203p\202\216A\203\211\311\312\313\301\n\nA#\314\315\n&\202\213B\207" [js--dummy-class-style nil signal cl-assertion-failed (stringp top-name) 0 (> (length top-name) 0) js--pitem-strname js--make-merged-item make-js--pitem :children js--splice-into-items :type :name] 15 (#$ . 54311)])
#@85 Copy `js--pitem' PITEM, and push CHILD onto its list of children.

(fn PITEM CHILD)
(defalias 'js--pitem-add-child #[514 "\300
8\250\204
\301\302\303C\"\210\304
8:\203;\304
8\305\306:\2031@\262
;\211\262\2031A\262\202\211\2056\306\266\203\202<\306\204E\301\302\307C\"\210\304
8\3108
\243\203Y\311@#\202}\211:\203y\312
\313\"\203y
:\204p\301\302\314C\"\210\311@#\202}@B\266\202AB\207" [3 signal cl-assertion-failed (integerp (js--pitem-h-begin child)) 4 nil t (if (consp (js--pitem-name child)) (cl-loop for part in (js--pitem-name child) always (stringp part)) t) 2 js--splice-into-items plist-get :prototype (consp name)] 8 (#$ . 55138)])
#@80 Return a marker for LOCATION if `imenu-use-markers' is non-nil.

(fn LOCATION)
(defalias 'js--maybe-make-marker #[257 "\203\n\301 
\302\223\207\207" [imenu-use-markers make-marker nil] 4 (#$ . 55815)])
#@93 Convert PITEMS, a list of `js--pitem' structures, to imenu format.

(fn PITEMS UNKNOWN-CTR)
(defalias 'js--pitems-to-imenu #[514 "\300\211\211\211\211\211A\262@\211\262\203\235\3018\262\302!\262
\303=\2030\304\305\211
@T\240\262
\"\262\306>\203R\3078\250\204C\310\311\312C\"\210
\313\3078!BB\262\202:\203\225\314@\"\262
\211\203m

BB\262\202\3078\203\3078\250\204\200\310\311\315C\"\210\316\313\3078!BC\262


BB\262\202\317\320\"\210\202\207" [nil 2 js--pitem-strname t format "[unknown %s]" #'macro 3 signal cl-assertion-failed (integerp (js--pitem-h-begin pitem)) js--maybe-make-marker js--pitems-to-imenu (integerp (js--pitem-h-begin pitem)) "[empty]" error "Unknown item type: %S"] 12 (#$ . 56025)])
#@53 Return an imenu index for the current buffer.

(fn)
(defalias 'js--imenu-create-index #[0 "\212\214~\210db\210\303 \210edU\204`=\204\304\305\306C\"\210\205T	\307\310B
A\203?\311\211A@)@\"\211AA)B\262\202$
G\312U\204L\304\305\313C\"\210\314@@\"\266\202*\207" [js--last-parse-pos js--state-at-last-parse-pos x js--ensure-cache signal cl-assertion-failed (or (= (point-min) (point-max)) (eq js--last-parse-pos (point))) -1 nil js--pitem-add-child 1 (= (length state) 1) js--pitems-to-imenu] 6 (#$ . 56783)])
(defalias 'js--which-func-joiner #[257 "\300\301\302#\207" [mapconcat identity "."] 5 "\n\n(fn PARTS)"])
(defalias 'js--imenu-to-flat #[771 "\300
:\203K
@\262
\301
!\203\302
A@\303Q#\210\202D
@P\211\304\305\"\203;\306\307T\211\262#\262\202%\310A#\266
A\262\202\300\207" [nil imenu--subalist-p js--imenu-to-flat "." 0 gethash format "%s<%d>" puthash] 13 "\n\n(fn ITEMS PREFIX SYMBOLS)"])
#@244 Return a hash table of all JavaScript symbols.
This searches all existing `js-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.

(fn)
(defalias 'js--get-all-known-symbols #[0 "\301\302\303\"\304\305 \306\211:\2030@\262r
q\210\307\310!\205\311 )\262
\312
\313#\210A\262\202\n)\207" [imenu-use-markers make-hash-table :test equal t buffer-list nil derived-mode-p js-mode js--imenu-create-index js--imenu-to-flat ""] 8 (#$ . 57727)])
#@40 History of entered JavaScript symbols.
(defvar js--symbol-history nil (#$ . 58286))
#@346 Helper function for `js-find-symbol'.
Read a symbol from SYMBOLS-TABLE, which is a hash table like the
one from `js--get-all-known-symbols', using prompt PROMPT and
initial input INITIAL-INPUT.  Return a cons of (SYMBOL-NAME
. LOCATION), where SYMBOL-NAME is a string and LOCATION is a
marker.

(fn SYMBOLS-TABLE PROMPT &optional INITIAL-INPUT)
(defalias 'js--read-symbol #[770 "\204\f\300\301!\210\300\302!\210\303\304C\305\306\307\310\311\312!\313\"\314\315%\"\210\211@\237\262
\304\316\317&\211\320\"B\207" [ido-mode 1 -1 ido-completing-read nil maphash make-byte-code 514 "\300\300@B\240\207" vconcat vector [] 5 "\n\n(fn KEY --CL-VAR--)" t js--symbol-history gethash] 13 (#$ . 58377)])
(defalias 'js--guess-symbol-at-point #[0 "\300\301!\211\205#\212\211@b\210`Sf\302=\203\303u\210\211\211`\240\266)\211@
A{\207" [bounds-of-thing-at-point symbol 46 -1] 4 "\n\n(fn)"])
#@192 Read a JavaScript symbol and jump to it.
With a prefix argument, restrict symbols to those from the
current buffer.  Pushes a mark onto the tag ring just like
`find-tag'.

(fn &optional ARG)
(defalias 'js-find-symbol #[256 "\301\302!\210\303\211\204\304 \262\202\305\306\307\"\262\310\311 \312#\210\313\314\315 #A\262
\316\317 \"\210\320\321!!\210\322 \210\211b\207" [find-tag-marker-ring require etags nil js--get-all-known-symbols make-hash-table :test equal js--imenu-to-flat js--imenu-create-index "" js--read-symbol "Jump to: " js--guess-symbol-at-point ring-insert point-marker switch-to-buffer marker-buffer push-mark] 7 (#$ . 59274) "P"])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\306\302\307#\210\300\306\304\310#\207" [put js-moz-bad-rpc error-conditions (error timeout) error-message "Mozilla RPC Error" js-js-error (error js-error) "Javascript Error"] 4)
#@287 Wait TIMEOUT seconds for PROCESS to output a match for 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'.

(fn PROCESS REGEXP TIMEOUT &optional START)
(defalias 'js--wait-for-matching-output #[1027 "r\300!q\210\211\206\301\302!!\303 \\\304\305\304\303 Z\262db\210\306\"\2032\305\262
\304\211\262\2023\305\203M\307V\203M\310	\304\305$\210\302	!b\210\202
\203_\311\312\313\314\"C\"\210\304\202`\211\266\205)\207" [process-buffer marker-position process-mark float-time nil t looking-back 0 accept-process-output signal js-moz-bad-rpc format "Timed out waiting for output matching %S"] 14 (#$ . 60176)])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put js--js-handle-id compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-id (or (and (memq (aref cl-x 0) cl-struct-js--js-handle-tags)) (error "%s accessing a non-%s" 'js--js-handle-id 'js--js-handle)) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--js-handle-id #[257 "\211\301H>\204\302\303\304\305#\210\211\306H\207" [cl-struct-js--js-handle-tags 0 error "%s accessing a non-%s" js--js-handle-id js--js-handle 1] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--js-handle-id gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--js-handle-id] 5 "\n\n(fn CL-DO CL-X)"] js--js-handle-process compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-process (or (and (memq (aref cl-x 0) cl-struct-js--js-handle-tags)) (error "%s accessing a non-%s" 'js--js-handle-process 'js--js-handle)) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--js-handle-process #[257 "\211\301H>\204\302\303\304\305#\210\211\306H\207" [cl-struct-js--js-handle-tags 0 error "%s accessing a non-%s" js--js-handle-process js--js-handle 2] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\307\211\203\300\304\310\311\312!!#\210\207" [put js--js-handle-process gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" js--js-handle-process] 5 "\n\n(fn CL-DO CL-X)"] js--js-handle-p compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-p (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-js--js-handle-tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'js--js-handle-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-js--js-handle-tags vectorp 3 0 t] 3 "\n\n(fn CL-X)"])
(defalias 'copy-js--js-handle #[257 "\300
!\207" [copy-sequence] 3 "\n\n(fn X)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put make-js--js-handle compiler-macro #[385 "\300
>A@\301>A@\211\2035\211@\302>\203\211AA\262
\202\303>A@\203,\304\262
\202\305\306@\"\210\202\210\307\310\311\304\304&\207" [: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-js--js-handle (vector 'cl-struct-js--js-handle id process))] 12 "\n\n(fn CL-WHOLE &cl-quote &key ID PROCESS)"] "/builddir/build/BUILD/emacs-24.3/lisp/progmodes/js.el" compiler-macro-file purecopy file-name-nondirectory] 7)
#@24 

(fn &key ID PROCESS)
(defalias 'make-js--js-handle #[128 "\300
>A@\301>A@\211\2035\211@\302>\203\211AA\262
\202\303>A@\203,\304\262
\202\305\306@\"\210\202\210\307\310#\207" [:id :process (:id :process :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:id :process)" vector cl-struct-js--js-handle] 7 (#$ . 64061)])
(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-js--js-handle-tags cl-struct-js--js-handle put js--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-js--js-handle side-effect-free copy-js--js-handle js--js-handle-p error-free js--js-handle-process js--js-handle-id] 4)
(defalias 'js--js-handle-expired-p #[257 "\211\301H>\204\302\303\304\305#\210\211\306H\307 =?\207" [cl-struct-js--js-handle-tags 0 error "%s accessing a non-%s" js--js-handle-process js--js-handle 2 inferior-moz-process] 5 "\n\n(fn X)"])
#@62 Maps Elisp JavaScript proxy objects to their JavaScript IDs.
(defvar js--js-references nil (#$ . 65227))
#@41 The most recent MozRepl process object.
(defvar js--js-process nil (#$ . 65338))
#@50 Idle timer for cleaning up JS object references.
(defvar js--js-gc-idle-timer nil (#$ . 65425))
(defvar js--js-last-gcs-done nil)
#@64 String to set MozRepl up into a simple-minded evaluation mode.
(defconst js--moz-interactor (replace-regexp-in-string "[ \n]+" " " "(function(repl) {\n  repl.defineInteractor('js', {\n    onStart: function onStart(repl) {\n      if(!repl._jsObjects) {\n        repl._jsObjects = {};\n        repl._jsLastID = 0;\n        repl._jsGC = this._jsGC;\n      }\n      this._input = '';\n    },\n\n    _jsGC: function _jsGC(ids_in_use) {\n      var objects = this._jsObjects;\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._jsObjects[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._jsObjects) {\n        id = Number(id);\n        var obj = repl._jsObjects[id];\n        if(obj === value) {\n          return id;\n        }\n      }\n\n      var id = ++repl._jsLastID;\n      repl._jsObjects[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") (#$ . 65561))
#@198 Marshall the given value for JS.
Strings and numbers are JSON-encoded.  Lists (including nil) are
made into JavaScript array literals and their contents encoded
with `js--js-encode-value'.

(fn X)
(defalias 'js--js-encode-value #[257 "\211;\203	\301
!\207\211\247\203\302
!\207\2119\203\303\304\305!\"\207\306
!\203R\211G\307Y\203R\211\310H>\203R\311
!\203=\312\313!\210\303\314\310H>\204M\312\315\316\317#\210\320H\"\207\321
!\203r\211\242\322=\203i\303\323\324\325A\326#\"\207\327\324\325\326#\330Q\207\312\331\"\207" [cl-struct-js--js-handle-tags json-encode-string json-encode-number format "{objid:%S}" symbol-name vectorp 3 0 js--js-handle-expired-p error "Stale JS handle" "{objid:%s}" "%s accessing a non-%s" js--js-handle-id js--js-handle 1 sequencep js--funcall "{funcall:[%s]}" mapconcat js--js-encode-value "," "[" "]" "Unrecognized item: %S"] 7 (#$ . 73934)])
(defconst js--js-prompt-regexp "\\(repl[0-9]*\\)> $")
(defconst js--js-repl-prompt-regexp "^EVAL>$")
(defvar js--js-repl-depth 0)
(defalias 'js--js-wait-for-eval-prompt #[0 "\302\303 	\212\304y\210`)$\207" [js--js-repl-prompt-regexp js-js-timeout js--wait-for-matching-output inferior-moz-process 0] 5 "\n\n(fn)"])
(defalias 'js--js-enter-repl #[0 "\306 \210rq\210db\210\306 	=\2043\306 \307\310\311\312\313$\314\315	\f\"\210\315	\316
\317Q\"\210\320\306 #\210\321\212\314y\210`)\"\203B\314\314V\203N\322 \210\202c\323\324!\325\261\210\326\327\313\"\210\320\306 #\210T\211)\207" [inferior-moz-buffer js--js-process js--js-references js--js-repl-depth js--moz-interactor moz-repl-name inferior-moz-process make-hash-table :test eq :weakness t 0 comint-send-string "(" ")\n" js--wait-for-matching-output looking-back js--js-wait-for-eval-prompt match-string-no-properties 1 ".pushInteractor('js')" comint-send-input nil js--js-prompt-regexp js-js-timeout js--js-repl-prompt-regexp] 5 "\n\n(fn)"])
(defalias 'js--js-leave-repl #[0 "\304V\204\f\305\306\307C\"\210S\211\304U\205.r	q\210db\210\310 \210\311c\210\312\313\314\"\210\315\316 \n#)\207" [js--js-repl-depth inferior-moz-buffer js--js-prompt-regexp js-js-timeout 0 signal cl-assertion-failed (> js--js-repl-depth 0) js--js-wait-for-eval-prompt "EXIT" comint-send-input nil t js--wait-for-matching-output inferior-moz-process] 4 "\n\n(fn)"])
(defalias 'js--js-not #[257 "\211\300>\207" [(nil null false undefined)] 3 "\n\n(fn VALUE)"])
(put 'js--js-not 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'js--js-true #[257 "\211\211\300>\262
?\207" [(nil null false undefined)] 4 "\n\n(fn VALUE)"])
(put 'js--js-true 'byte-optimizer 'byte-compile-inline-expand)
#@74 Convert immediate js< and js! references to deferred ones.

(fn ARGLIST)
(defalias 'js--optimize-arglist #[257 "\211\301\211:\203\240@\262
\242\302=\203$\303\304\305\306E\307A!\"
B\262
\202\231
\242\310=\203d\303\304\311\312E\211A@):\204D\211A@)C\202T\303\304\313\314E\307\211A@)!\"C\307\211AA)!#
B\262
\202\231
\242\315=\203\224
A\211@
A\211\303\304\316:\203\203\304\307!B\202\204E\307!\"\266\202\266\203
B\262
\202\231

B\262
A\262\202\211\237\207" [x nil js< append list 'js--funcall (list 'interactor "_getProp") js--optimize-arglist js> 'js--funcall (list 'interactor "_putProp") 'js--funcall (list 'interactor "_mkArray") js! 'js--funcall] 16 (#$ . 76581)])
(defalias 'js--js-get-service '(macro . #[514 "\300\301\302\303BBB\304\301\305FE\207" [js! "Components" "classes" ("getService") js< "interfaces"] 8 "\n\n(fn CLASS-NAME INTERFACE-NAME)"]))
(defalias 'js--js-create-instance '(macro . #[514 "\300\301\302\303BBB\304\301\305FE\207" [js! "Components" "classes" ("createInstance") js< "interfaces"] 8 "\n\n(fn CLASS-NAME INTERFACE-NAME)"]))
(defalias 'js--js-qi '(macro . #[514 "\300\301B\302\303\304FE\207" [js! ("QueryInterface") js< "Components" "interfaces"] 8 "\n\n(fn OBJECT INTERFACE-NAME)"]))
#@239 Run FORMS with the Mozilla repl set up for js commands.
Inside the lexical scope of `with-js', `js?', `js!',
`js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
`js-create-instance', and `js-qi' are defined.

(fn &rest FORMS)
(defalias 'with-js '(macro . #[128 "\300\301\302\303\304BB\305BBE\207" [progn (js--js-enter-repl) unwind-protect cl-macrolet ((js\? (&rest body) `(js--js-true ,@body)) (js! (function &rest body) `(js--js-funcall ,(if (consp function) (cons 'list (js--optimize-arglist function)) function) ,@(js--optimize-arglist body))) (js-new (function &rest body) `(js--js-new ,(if (consp function) (cons 'list (js--optimize-arglist function)) function) ,@body)) (js-eval (thisobj js) `(js--js-eval ,@(js--optimize-arglist (list thisobj js)))) (js-list (&rest args) `(js--js-list ,@(js--optimize-arglist args))) (js-get-service (&rest args) `(js--js-get-service ,@(js--optimize-arglist args))) (js-create-instance (&rest args) `(js--js-create-instance ,@(js--optimize-arglist args))) (js-qi (&rest args) `(js--js-qi ,@(js--optimize-arglist args))) (js< (&rest body) `(js--js-get ,@(js--optimize-arglist body))) (js> (props value) `(js--js-funcall '(interactor "_putProp") ,(if (consp props) (cons 'list (js--optimize-arglist props)) props) ,@(js--optimize-arglist (list value)))) (js-handle\? (arg) `(js--js-handle-p ,arg))) ((js--js-leave-repl))] 7 (#$ . 77837)]))
#@113 Whether to listify any Array returned by a Mozilla function.
If nil, the whole Array is treated as a JS symbol.
(defvar js--js-array-as-list nil (#$ . 79236))
(defalias 'js--js-decode-retval #[257 "\302
@!\211\303=\203
\211A@)\202z\211\304=\203$\302\211A@)!\202z\211\305=\2036\306\307\211A@)\"\202z\211\310=\203`\311\211A@)	\"\206z\312\211A@)\313\314\211A@)\315\316 $	#\202z\211\317=\203s\320\321\211A@)C\"\202z\211\317\322\"\262
\207" [x js--js-references intern atom special array mapcar js--js-decode-retval objid gethash puthash make-js--js-handle :id :process inferior-moz-process error signal js-js-error "Unmatched case in js--js-decode-retval: %S"] 10 "\n\n(fn RESULT)"])
#@538 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.

(fn FUNCTION &rest ARGUMENTS)
(defalias 'js--js-funcall #[385 "\305 \210\306\307DC\216\310B!rq\210	\203\311c\210\211c\210\312\313\314\"\210\315\316 \317\n#\210b\210\320\321 db\210\322
!)\262
)\262
)\207" [inferior-moz-buffer js--js-array-as-list js-js-timeout comint-last-input-end json-array-type js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--js-encode-value "*" comint-send-input nil t js--wait-for-matching-output inferior-moz-process "EVAL>" list json-read js--js-decode-retval] 7 (#$ . 79949)])
#@161 Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
CONSTRUCTOR is a JS handle, a string, or a list of these things.

(fn CONSTRUCTOR &rest ARGUMENTS)
(defalias 'js--js-new #[385 "\300\301\302$\207" [apply js--js-funcall (interactor "_callNew")] 7 (#$ . 81004)])
(defalias 'js--js-eval #[514 "\300\301#\207" [js--js-funcall (interactor "_callEval")] 6 "\n\n(fn THISOBJ JS)"])
#@88 Return a Lisp array resulting from evaluating each of ARGUMENTS.

(fn &rest ARGUMENTS)
(defalias 'js--js-list #[128 "\301\302\303\304#)\207" [js--js-array-as-list t apply js--js-funcall (interactor "_mkArray")] 5 (#$ . 81399)])
(defalias 'js--js-get #[128 "\300\301\302#\207" [apply js--js-funcall (interactor "_getProp")] 5 "\n\n(fn &rest PROPS)"])
(defalias 'js--js-put #[514 "\300\301#\207" [js--js-funcall (interactor "_putProp")] 6 "\n\n(fn PROPS VALUE)"])
#@142 Tell the repl about any objects we don't reference anymore.
With argument, run even if no intervening GC has happened.

(fn &optional FORCE)
(defalias 'js-gc #[256 "\211\203\305	\305\211\n\205g\306\303!\205g\307!\205g=?\205grq\210\212db\210\310\f\212\311y\210`)\"*\205g\305C\312\313\314\315\316\317!\320\"\321\322%\n\"\210\211@\237\262
\262\323\324\206V\320\"\262
\325\326!\203f\327\330\"\210\211\207" [js--js-last-gcs-done gcs-done js--js-references inferior-moz-buffer js--js-prompt-regexp nil boundp buffer-live-p looking-back 0 maphash make-byte-code 514 "\300\300@B\240\207" vconcat vector [] 5 "\n\n(fn X --CL-VAR--)" js--js-funcall (repl "_jsGC") called-interactively-p interactive message "Cleaned %s entries"] 12 (#$ . 81873) nil])
(run-with-idle-timer 30 t 'js-gc)
#@72 Evaluate the JavaScript in JS and return JSON-decoded result.

(fn JS)
(defalias 'js-eval #[257 "\300 \210\301\302DC\216\303\304 !\305
\"\306\307!\203\310\311\312\313\"\"\210\262
)\207" [js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--js-content-window js--get-js-context js--js-eval called-interactively-p interactive message "%s" js--js-funcall "String"] 8 (#$ . 82676) "MJavascript to evaluate: "])
#@312 Enumerate all JavaScript contexts available.
Each context is a list:
   (TITLE URL BROWSER TAB TABBROWSER) for content documents
   (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.

(fn)
(defalias 'js--get-tabs #[0 "\302 \210\303\304DC\216\305\306\307\310\311\312F\313\314\315D\307\316\317\257\"\306
\320D\305\"\305\211\306\321D!\211\211\322>\262
?\262
\203\201\306\323D!\262\324\313\314\315D\325\326\257\313\327\330ED\313\314\315D\331F\313\314\315D\332F%\262
\211AAA@\211\211\322>\262
?\262
\204!\211\333
8\262
\334=\204!\211B\262\202!\266\211\305\211\211\211:\203
@\262@\262\211A@)AA@EB\262\335\336\"\262
\337
!\203
\211G\340Y\203
\211\341H	>\203
\341\335\342\343#\305W\203\n
\324\313\314\315D\342\344\326\257\313\342\345\327\330\257D\313\314\315D\342	\257\313\346\347\350FE%
B\262
T\262\202\307\211\237\266\203\237\244\262A\262\202\210
\237\266\205\262
)\207" [x cl-struct-js--js-handle-tags js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] nil js--js-funcall "Components" "classes" "@mozilla.org/appshell/window-mediator;1" "getService" js--funcall interactor "_getProp" "interfaces" "nsIWindowMediator" "getEnumerator" "hasMoreElements" (nil null false undefined) "getNext" js--js-list "document" "title" "location" "toString" "closed" "windowState" 4 2 js--js-get "gBrowser" vectorp 3 0 "browsers" "length" "contentDocument" "contentWindow" "tabContainer" "childNodes" "item"] 19 (#$ . 83121)])
(defvar js-read-tab-history nil)
#@200 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.

(fn PROMPT)
(defalias 'js--read-tab #[257 "\204\f\300\303!\210\300\304!\210\305 \210\306\307DC\216\310 C\311\211\211C\312\313\314\"@\311\211\211\211:\203i@\262\315\316\211A@)@#\262\317\320\304#T#\266\202\262
\321V\203[\315\322#\262B
B\262
A\262\202&\211\237\266\206\240\210\311C\311C\311C\311\323\324\325\326\327
!\330\"\331\332%\240\210\333\240\210
\323\321\334\326\327\n\n\n#\335\"\336\337%\240\210\323\321\340\326\327\"\341\"\342\337%\262
\306\323\321\343\326\327\n	\"\344\"\345\337%DC\216\211\nB\346	\347\350@\"\311\351\311\352&)\262)\353\352\"\210@\311\351\311:\203\f
@\262@\232\203

A\262
\311\211\262\202
\351\203\f
A\262\202\345\266\203\262AAA@\203
\354\202
\355AA@B\266\204\266\204)\207" [ido-mode x ido-minibuffer-setup-hook 1 -1 js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--get-tabs nil make-hash-table :test equal format "%s (%s)" puthash gethash 0 "%s <%d>" make-byte-code 257 "\300@\301\302\301:\203+@\262@\232\203 A\262
\301\211\262\202!\302\203+A\262\202\207" vconcat vector [nil t] 7 "\n\n(fn CNAME)" #[514 "\301AAA@\203\302
B\262
\303
B\262
\203+\304
B\262
\202+AA@\203+\305
B\262

AAA@\203@\306
B\262
\307
B\262
\202L
AA@\203L\310
B\262
\311\312\313\237BD!\207" [js-js-switch-tabs nil (js! ((cl-fourth hitab) "setAttribute") "style" "color: red; font-weight: bold") (js! ((cl-third hitab) "setAttribute") "style" "border: 8px solid red") (js> ((cl-fifth hitab) "selectedTab") (cl-fourth hitab)) (js! ((cl-third hitab) "document" "documentElement" "setAttribute") "style" (concat "-moz-appearance: none;" "border: 8px solid red;")) (js! ((cl-fourth unhitab) "setAttribute") "style" #1="") (js! ((cl-third unhitab) "setAttribute") "style" #1#) (js! ((cl-third unhitab) "document" "documentElement" "setAttribute") "style" #1#) eval with-js js-list] 7 "\n\n(fn HITAB UNHITAB)"] "\301@@!\302@
\300@\"\210\300
\240\207" [ido-matches] 4 "\n\n(fn)" "\300@\n@!\211\203d\211AAA@\204d\304
AA@\305\306\307F\310\"\311\232\203d\312
AA@\313\314#\n\315\211\316\315:\203b@\262\300@!\262AAA@=\203W\317\"\316\262
\315\211\262\202X\316\203bA\262\202.\266\210\320\321\301@\316\211$\207" [ido-matches ido-cur-list js--js-funcall "document" "documentElement" "getAttribute" "windowtype" "navigator:browser" js--js-get "gBrowser" "selectedTab" nil t ido-chop add-hook post-command-hook] 10 "\300@\205\301@\302\300@\"\210\300\302\240\207" [nil] 3 ido-completing-read mapcar car t js-read-tab-history add-to-history browser window] 21 (#$ . 84779)])
#@192 Helper function for `js-eval-defun'.
Return 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.

(fn PSTATE)
(defalias 'js--guess-eval-defun-info #[257 "\211G\301U\2037\302
@8\303=\2037\304
@8G\305U\2037\302
\211A@)8:\2037\306\304\211A@)8\304@8@C\"\207\211G\302U\203X\302
@8\303=\203X\306\307\304@8!\310\304@8!@C\"\207\311\312!\207" [x 3 2 function 4 1 append butlast last error "Function not a toplevel defun or class member"] 7 (#$ . 87575)])
#@124 The current JavaScript context.
This is a cons like the one returned from `js--read-tab'.
Change with `js-set-js-context'.
(defvar js--js-context nil (#$ . 88121))
(defconst js--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  })")
#@101 Set the JavaScript context to CONTEXT.
When called interactively, prompt for CONTEXT.

(fn CONTEXT)
(defalias 'js-set-js-context #[257 "\211\211\207" [js--js-context] 3 (#$ . 89052) (byte-code "\300\301!C\207" [js--read-tab "Javascript Context: "] 2)])
#@106 Return a valid JavaScript context.
If one hasn't been set, or if it's stale, prompt for a new one.

(fn)
(defalias 'js--get-js-context #[0 "\301 \210\302\303DC\216\203P\304A!\204P@\211\305=\203,\306A\307\"\211\211\310>\262
?\262
\202K\211\311=\203D\306A\312\"\211\211\310>\262
?\262
?\202K\211\313\314\"\262
\262
\203T\315\316!)\207" [js--js-context js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--js-handle-expired-p window js--js-get "closed" (nil null false undefined) browser "contentDocument" error "Unmatched case in js--get-js-context: %S" js--read-tab "Javascript Context: "] 5 (#$ . 89313)])
(defalias 'js--js-content-window #[257 "\300 \210\301\302DC\216\211@\211\303=\203
A\202+\211\304=\203$\305A\306\307#\202+\211\310\311\"\262
\262
)\207" [js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] window browser js--js-get "contentWindow" "wrappedJSObject" error "Unmatched case in js--js-content-window: %S"] 6 "\n\n(fn CONTEXT)"])
(defalias 'js--make-nsilocalfile #[257 "\300 \210\301\302DC\216\303\304\305\306\307F\310\311\312D\304\313\314\257\"\303
\315D\"\210\211\262
)\207" [js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--js-funcall "Components" "classes" "@mozilla.org/file/local;1" "createInstance" js--funcall interactor "_getProp" "interfaces" "nsILocalFile" "initWithPath"] 8 "\n\n(fn PATH)"])
(defalias 'js--js-add-resource-alias #[514 "\300 \210\301\302DC\216\303\304\305\306\307F\310\311\312D\304\313\314\257\"\303
\315D\316\"\303
\317D\310\311\312D\304\313\320\257\"\321!\303\322D\"\303\323D#\266\205)\207" [js--js-enter-repl funcall #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] js--js-funcall "Components" "classes" "@mozilla.org/network/io-service;1" "getService" js--funcall interactor "_getProp" "interfaces" "nsIIOService" "getProtocolHandler" "resource" "QueryInterface" "nsIResProtocolHandler" js--make-nsilocalfile "newFileURI" "setSubstitution"] 11 "\n\n(fn ALIAS PATH)"])
#@65 Update a Mozilla tab using the JavaScript defun at point.

(fn)
(defalias 'js-eval-defun #[0 "\300\301\302D\215\207" [--cl-block-js-eval-defun-- funcall #[0 "\212\302\211\211\211\211C\302\303 \210`\262\304 \210\305 \210\306\307!\210\310\224\262\311\312!\262\203+`V\203/\313\314!\210\315!\262\316\"\317
\320\321#\210\322\323\310\324\325\326!\327\"\330\331%DC\216\332\333\334\335\336\337#\"!\204h\340\341!\210\342\343\302\"\210)\210\344\"\262
\345\346\"\210\347\350\"\210
\351\352P\302\353#\240\210\322\323\310\354\325\326!\355\"\330\331%DC\216\356 \210\322\357DC\216\360\361!r\211q\210\322\323\310\362\325\326!\363\"\330\331%DC\216	c\210\364c\210\365!c\210\366c\210
c\210\367c\210\370ed@\302\371%\210*\210\372\373 !\374
\375\"\374
\376\"\211\211\377>\262
?\262
\203
\374\201@\201AD\201BE\310\"\202
\374
\201C\"\201D\201ED\201F\201G#\201D
\201HD\201I\201J#\210\201D
\201HD\201K\333\201L\201M@!\"#\210\201D\201ND\"\210\201D\201OD\201P\201@\201Q\201R\201S\201T#C\201U@!E\201V$\210\302\240\266\204*\266\206)\207" [js-js-tmpdir js--js-inserter nil js-end-of-defun js--ensure-cache js-beginning-of-defun re-search-forward "\\_<function\\_>" 0 js--forward-text-property js--pstate error "Could not locate function definition" js--guess-eval-defun-info make-overlay overlay-put face highlight funcall make-byte-code "\301\300!\207" vconcat vector [delete-overlay] 2 "\n\n(fn)" y-or-n-p format "Send %s to Mozilla? " mapconcat identity "." message "" throw --cl-block-js-eval-defun-- buffer-substring-no-properties make-directory t js--js-add-resource-alias "js" make-temp-file "/js-" ".js" "\300@\205	\301\300@!\207" [delete-file] js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1 "\n\n(fn)"] generate-new-buffer " *temp*" "\301\300!\205	\302\300!\207" [buffer-name kill-buffer] "(" json-encode-list ",\n" "\n)" write-region 1 js--js-content-window js--get-js-context js--js-get "document" "body" (nil null false undefined) js--funcall "getElementsByTagName" "head" "documentElement" js--js-funcall "createElementNS" "http://www.w3.org/1999/xhtml" "script" "setAttribute" "type" "text/javascript" "src" "resource://js/%s" file-name-nondirectory "appendChild" "addEventListener" "unload" js--js-new "Function" "file" "return function() { file.remove(false) }" js--make-nsilocalfile false] 18 "\n\n(fn)"]] 3 (#$ . 91352) nil])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [js-mode-hook variable-documentation put purecopy "Hook run when entering Javascript mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp js-mode-map definition-name js-mode] 5)
(defvar js-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [js-mode-map variable-documentation put purecopy "Keymap for `js-mode'." boundp js-mode-syntax-table definition-name js-mode] 5)
(defvar js-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [js-mode-syntax-table variable-documentation put purecopy "Syntax table for `js-mode'." js-mode-abbrev-table definition-name js-mode] 5)
(defvar js-mode-abbrev-table (progn (define-abbrev-table 'js-mode-abbrev-table nil) js-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [js-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `js-mode'." js-mode derived-mode-parent prog-mode custom-mode-group js] 5)
#@209 Major mode for editing JavaScript.

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

\{js-mode-map}

(fn)
(defalias 'js-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
@=\204R\326
\325@C#\210\327!\210\330\f!\210
@\306\331!\210\332\306\333!\210\334\306\335!\210\336\306\337!\210\340\306\341!\210AC!\306\342!\210\343\"\306\344!\210\307$\306\345!\210\307%\306\346!\210\347&\306\350!\210\351(\306\352!\210\353*\306\354!\210\355,\356\357\360\307\211$\210\361 \210\340B\306\362!\210\3632\364C\365\211DE\366F\367G\370H\371I\306\372!\210\373\374:\":\306\375!\210\376=\307J\306\377!\210\306\201L!\210\306\201M!\210\306\201N!\210\306\201O!\210\201P \210)\306\201K!\210\201QK\201Rd!\210)\201S\201T!\207" [delay-mode-hooks major-mode mode-name js-mode-map js-mode-syntax-table js-mode-abbrev-table make-local-variable t prog-mode js-mode "Javascript" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table indent-line-function js-indent-line beginning-of-defun-function js-beginning-of-defun end-of-defun-function js-end-of-defun open-paren-in-column-0-is-defun-start nil font-lock-defaults syntax-propertize-function js-syntax-propertize parse-sexp-ignore-comments parse-sexp-lookup-properties which-func-imenu-joiner-function js--which-func-joiner comment-start "// " comment-end "" fill-paragraph-function js-c-fill-paragraph add-hook before-change-functions js--flush-caches js--update-quick-match-re imenu-create-index-function js--imenu-create-index "//+\\|\\**" "$" "* " "//" "/[*/]\\|\\s!" "\\(//+\\|/\\*+\\)\\s *" electric-indent-chars append "{}():;," electric-layout-rules ((59 . after) (123 . after) (125 . before)) paragraph-start local-abbrev-table js--font-lock-keywords imenu-case-fold-search 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 syntax-begin-function paragraph-separate paragraph-ignore-fill-prefix adaptive-fill-mode adaptive-fill-regexp c-setup-paragraph-variables js--syntax-begin-function syntax-propertize run-mode-hooks js-mode-hook] 6 (#$ . 95008) nil])
(byte-code "\300\301\302\"\210\303\304\305\"\210\306\307!\207" [defalias javascript-mode js-mode eval-after-load folding (when (fboundp 'folding-add-to-marks-list) (folding-add-to-marks-list 'js-mode "// {{{" "// }}}")) provide js] 3)