ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/progmodes/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/progmodes/js.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.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#\210\300\311!\207" [require cc-mode newcomment thingatpt imenu moz nil t json sgml-mode] 4)
#@73 Regexp matching the start of a JavaScript identifier, without grouping.
(defconst js--name-start-re "[a-zA-Z_$]" (#$ . 604))
(defconst js--stmt-delim-chars "^;{}?:")
#@60 Regexp matching a JavaScript identifier, without grouping.
(defconst js--name-re (concat js--name-start-re "\\(?:\\s_\\|\\sw\\)*") (#$ . 776))
#@57 Regexp matching the start of a JavaScript object field.
(defconst js--objfield-re (concat js--name-re ":") (#$ . 925))
#@63 Regexp matching a dot-separated sequence of JavaScript names.
(defconst js--dotted-name-re (concat js--name-re "\\(?:\\." js--name-re "\\)*") (#$ . 1050))
#@40 Regexp matching a C preprocessor name.
(defconst js--cpp-name-re js--name-re (#$ . 1211))
#@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:]]+\\)" (#$ . 1308))
#@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\\)\\_>") (#$ . 1570))
#@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-*{") (#$ . 1916))
(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#) (#$ . 3059))
#@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#) (#$ . 3283))
#@47 Regexp matching a MochiKit class declaration.
(defconst js--mochikit-class-re (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*" "\\(" js--dotted-name-re "\\)") (#$ . 3521))
(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) (#$ . 3779))
#@50 List of available JavaScript frameworks symbols.
(defconst js--available-frameworks (byte-code "\301\211\211:\203& @\262\302\303\"\262>\204 \211C\244\262A\262\202 \207" [js--class-styles nil plist-get :framework] 7) (#$ . 5819))
#@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 "\\)") (#$ . 6069))
#@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\\_>") (#$ . 6293))
#@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\\_>") (#$ . 6524))
#@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-*(") (#$ . 6765))
#@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 (#$ . 6989)])
#@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")) (#$ . 7184))
#@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")) (#$ . 7726))
#@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")) (#$ . 7932))
#@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) (#$ . 8143))
#@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) (#$ . 8384))
(defalias 'js--pitem-children--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-children (declare (side-effect-free t)) (car cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-children 'compiler-macro 'js--pitem-children--cmacro)
(defalias 'js--pitem-children #[257 "\211@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--pitem-children side-effect-free t put 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)"]] 4)
(defalias 'js--pitem-paren-depth--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-paren-depth (declare (side-effect-free t)) (nth 1 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-paren-depth 'compiler-macro 'js--pitem-paren-depth--cmacro)
(defalias 'js--pitem-paren-depth #[257 "\211A@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--pitem-paren-depth side-effect-free t put 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)"]] 4)
(defalias 'js--pitem-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-type (declare (side-effect-free t)) (nth 2 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-type 'compiler-macro 'js--pitem-type--cmacro)
(defalias 'js--pitem-type #[257 "\3008\207" [2] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--pitem-type side-effect-free t put 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)"]] 4)
(defalias 'js--pitem-h-begin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-h-begin (declare (side-effect-free t)) (nth 3 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-h-begin 'compiler-macro 'js--pitem-h-begin--cmacro)
(defalias 'js--pitem-h-begin #[257 "\3008\207" [3] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--pitem-h-begin side-effect-free t put 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)"]] 4)
(defalias 'js--pitem-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-name (declare (side-effect-free t)) (nth 4 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-name 'compiler-macro 'js--pitem-name--cmacro)
(defalias 'js--pitem-name #[257 "\3008\207" [4] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--pitem-name side-effect-free t put 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)"]] 4)
(defalias 'js--pitem-b-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-b-end (declare (side-effect-free t)) (nth 5 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--pitem-b-end 'compiler-macro 'js--pitem-b-end--cmacro)
(defalias 'js--pitem-b-end #[257 "\3008\207" [5] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [function-put js--pitem-b-end side-effect-free t defalias copy-js--pitem copy-sequence] 4)
#@77
(fn CL-WHOLE &cl-quote &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-js--pitem--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R \211@\307>\203: \211AA\262\202' \310>A@\203I \311\262\202' \312\313@\"\210\202' \210\314\315\316\311 \311 & \207" [plist-member :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 "Constructor for objects of type `js--pitem'." (declare (side-effect-free t)) (list children paren-depth type h-begin name b-end))] 20 (#$ . 12163)])
(put 'make-js--pitem 'compiler-macro 'make-js--pitem--cmacro)
#@102 Constructor for objects of type `js--pitem'.
(fn &key CHILDREN PAREN-DEPTH TYPE H-BEGIN NAME B-END)
(defalias 'make-js--pitem #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R \211@\307>\203: \211AA\262\202' \310>A@\203I \311\262\202' \312\313@\"\210\202' \210\257\207" [plist-member :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 (#$ . 13063)])
(byte-code "\300\301\302\303#\210\304\305\306\211\307\306\310\311\312\306& \207" [function-put make-js--pitem side-effect-free t cl-struct-define js--pitem nil list ((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-js--pitem-tags cl-struct-js--pitem] 10)
(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\320\321\322\307\302\331\344& \210\311\345\313\314\346DD\347\317\350\307\302&\210\311\351\313\314\352DD\353\317\314\307\302&\210\311\354\313\314\355DD\356\317\357\360\361\"B\307\302&\210\311\362\313\314\363DD\364\317\350\307\302&\210\311\365\313\314\366DD\367\317\370\307\302&\210\311\371\313\314\372DD\373\317\320\307\302&\210\311\374\313\314\375DD\376\331\377\317\201@ \321\201A \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] "Number of spaces for each indentation step in `js-mode'." :type integer :safe integerp js-expr-indent-offset #[0 "\300\207" [0] 1] "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] "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] "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] "Number of additional spaces for indenting expressions in curly braces.\nThe value must be no less than minus `js-indent-level'." js-switch-indent-offset #[0 "\300\207" [0] 1] "Number of additional spaces for indenting the contents of a switch block.\nThe value must not be negative." "24.4" js-flat-functions #[0 "\300\207" [nil] 1] "Treat nested functions as top-level functions in `js-mode'.\nThis applies to function movement, marking, and so on." boolean js-comment-lineup-func #[0 "\300\207" [c-lineup-C-comments] 1] "Lineup function for `cc-mode-style', for C comments in `js-mode'." js-enabled-frameworks #[0 "\207" [js--available-frameworks] 1] "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 "\300D\207" [const] 3 "\n\n(fn X)"] js-js-switch-tabs #[0 "\301>\205 \302\207" [system-type (darwin) t] 2] "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" [#1="~/.emacs.d/js/js"] 1 #1#] "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] "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." js-indent-first-init #[0 "\300\207" [nil] 1] "Non-nil means specially indent the first variable declaration's initializer.\nNormally, the first declaration's initializer is unindented, and\nsubsequent declarations have their identifiers aligned with it:\n\n var o = {\n foo: 3\n };\n\n var o = {\n foo: 3\n },\n bar = 2;\n\nIf this option has the value t, indent the first declaration's\ninitializer by an additional level:\n\n var o = {\n foo: 3\n };\n\n var o = {\n foo: 3\n },\n bar = 2;\n\nIf this option has the value `dynamic', if there is only one declaration,\ndon't indent the first one's initializer; otherwise, indent it.\n\n var o = {\n foo: 3\n };\n\n var o = {\n foo: 3\n },\n bar = 2;" "25.1" (choice (const nil) (const t) (const dynamic)) symbolp] 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) (#$ . 18190))
#@29 Syntax table for `js-mode'.
(defvar js-mode-syntax-table (byte-code "\300 \301!\210\302\303\304#\210\302\305\306#\210\211\207" [make-syntax-table c-populate-syntax-table modify-syntax-entry 36 "_" 96 "\""] 5) (#$ . 18866))
#@68 Autogenerated regexp used by `js-mode' to match buffer constructs.
(defvar js--quick-match-re nil (#$ . 19098))
#@75 Autogenerated regexp used by `js-mode' to match constructs and functions.
(defvar js--quick-match-re-func nil (#$ . 19216))
(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 (#$ . 19461))
(make-variable-buffer-local 'js--cache-end)
#@54 Latest parse position reached by `js--ensure-cache'.
(defvar js--last-parse-pos nil (#$ . 19610))
(make-variable-buffer-local 'js--last-parse-pos)
#@38 Parse state at `js--last-parse-pos'.
(defvar js--state-at-last-parse-pos nil (#$ . 19763))
(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\262A\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 (#$ . 20094)])
#@151 Internal function used by `js-mode' for caching buffer constructs.
This updates `js--quick-match-re', based on the current set of
enabled frameworks.
(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 (#$ . 20586)])
#@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 (#$ . 21514)])
#@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 (#$ . 21919)])
(defalias 'js--forward-pstate #[0 "\300\301!\207" [js--forward-text-property js--pstate] 2])
(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])
(put 'js--backward-pstate 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'js--pitem-goto-h-end #[257 "\3008b\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 (#$ . 22812)])
#@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 "\211\204 \300\262`\301W\203 [\262\302\202! \301V\203 \303\202! \304\30510 \211#0\202@ b\210?\205> \306@A\"\262\207" [1 0 js--re-search-backward-inner js--re-search-forward-inner ignore (search-failed) signal] 10 (#$ . 23407)])
#@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\n S\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 (#$ . 24012)])
#@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 (#$ . 24657)])
#@118 Move forward over a whole JavaScript expression.
This function doesn't move over expressions continued across
lines.
(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 (#$ . 25096)])
#@257 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.
(defalias 'js--forward-function-decl #[0 "\302\303!\204\n \304\305!\210\306\307 \210\310!\210\311f\312=\203 \311u\210\310!\210\302 !\203/ \313\314!\262\314\225b\210\310!\210\311f\315=\205Z \3161F \317 \210\3060\202K \210\311\202Z \205Z \310!\210\311f\320=\205Z \211\207" [most-positive-fixnum js--name-re looking-at #1="\\_<function\\_>" cl--assertion-failed (looking-at #1#) t forward-word-strictly forward-comment nil 42 match-string-no-properties 0 40 (error) forward-list 123] 3 (#$ . 25479)])
#@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#\205f \313 \314\303\315\316\317!\320\"\321$\216\303\224b\210\322 )\262\205f `X\205f \211\206f \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 make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 js--forward-function-decl] 9 (#$ . 26246)])
#@179 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.
(defalias 'js--beginning-of-defun-raw #[0 "\300 \210\301\302\303!\211\262\203 \304@8\305=\203 o?\205 \211\207" [js--ensure-cache nil js--backward-text-property js--pstate 2 function] 3 (#$ . 27112)])
#@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\262A\262\202 \304=\205* \211\207" [nil 0 2 function 1] 7 (#$ . 27502)])
#@109 Helper function for `js--beginning-of-defun'.
Return the pitem of the function we went to the beginning of.
(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\2036 A\262\202 \266\203\206e \301\302\301\307\310!\262\203c \311!\211\203] \3068b\210\211\262\301\211\262\202^ \302\262\204> \266\202\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 (#$ . 27857)])
#@46 Helper function for `js-beginning-of-defun'.
(defalias 'js--beginning-of-defun-flat #[0 "\300 \211\205 \301@8b\207" [js--beginning-of-defun-raw 3] 3 (#$ . 28417)])
#@75 Value of `beginning-of-defun-function' for `js-mode'.
(fn &optional ARG)
(defalias 'js-beginning-of-defun #[256 "\211\206 \301\262m\204= \211\302W\203= \211T\262\204( \303 \304=\204% \305 \203( \306 \210\307\310\311\312#\2037 \305 b\210\202 db\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 (#$ . 28589)])
#@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 (#$ . 29223) 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\2032 \300`S\301\"\203 \302\303!\210\304`S`\305$\210\306\233\211`\240\266\307A@\"AAB\262\210\207" [get-text-property js-pend cl--assertion-failed (not (get-text-property (1- (point)) 'js-pend)) put-text-property js--pend 5 js--pitem-add-child] 8 "\n\n(fn OPEN-ITEMS PAREN-DEPTH)"])
#@197 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'.
(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 (#$ . 29917)]))
(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 nil 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$\216\310\311\312#)\262\211G\313U\205! \211@\314\232?\205, \315\314\"\211\262\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 split-string "\\." t 1 "prototype" remove] 8 (#$ . 31171)])
(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 (#$ . 31710)])
(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])
#@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 `\262W\205\306 \307\211\307\310\211 \310\211 7 8\310\211 9\310\211\211\211 :\310\211\311\312\313\314\315 !\316\"\317$\216;\310\211:\203[ @\262\320\321\"<>\203T B\262A\262\202< \211\237\266\203\262\212\214~\210b\210o\204\222 \322`S\323\"\262\204\222 \324`\323\310e$b\210o\204\222 \322`S\323\"\262\204\222 \325\326!\210\204\233 =C\262\327 \262`\262\330 \210e}\210\310\211\211\331>\310\307#\203\261\312\224b\262\312\225\262`\262b\210\332 @\"\262 @ @A@V\204\337 \325\333!\210\334 @A@\310\f%\262`\262`W\204\306 \332 @\"\262 @\262\3358\203\310\202R\336\337!\203h\340 \211\262\203h\307=\203<\341!\262\2039?\203<?\262\202<\307\262\310f\342=\204G\325\343!\210\310u\210\344\345\346\347\350\351
\307=\203_
\202c\352!&\202R\336@!\203\307\353 \210`\262b\210\332 @\"\262 @ @A@V\204\222\325\333!\210\334 @A@\310\f%\262`\262`W\204y\332 @\"\262 \344\345 @\346\347\354\351\355\356!C&\202R\336A!\203\357\224b\210\360 \311\312\361\314\315!\362\"\357$\216\340 )\262\205R\310u\210\344\345\346\347\350\351\352\355\356!!\355\317!C\244&\202R\363 !\310\307\310:\203P@\262\320\364\">\203E\336\320\365\"!\203E\312\225b\210\344\345\346 \347\351\352\355\356!!&\262\310\211\262\202F\307\203PA\262\202 \266\204\211\203\252`\262b\210\332\n\n@\"\262\n@\n@A@V\204v\325\333!\210\334\f@A@\310
%\262 `\262`W\204]\332\n\n@\"\262\n\211\nB\262\n\366`S`\323
$\210\202\255b\210\210\202\255 \266b\210`\262b\210\332@\"\262@@A@V\204\325\325\333!\210\334@A@\310 %\262`\262`W\204\275\332@\"\262B\211C.\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 make-byte-code 0 "\300?\205
\301 \205
\302\303!\207" vconcat vector [buffer-modified-p set-buffer-modified-p nil] 2 plist-get :framework get-text-property js--pstate previous-single-property-change 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] 28 (#$ . 32700)])
#@40 Helper function for `js-end-of-defun'.
(defalias 'js--end-of-defun-flat #[0 "\300\301\302\303\301\300#\2032 \304 \210\305`S\306\"\211\203, \3078\310=\203( \300\262\301\211\262\202- \300\202- \300\262\204 \203= db\210\301\202> \211\207" [t nil js--re-search-forward "}" js--ensure-cache get-text-property js--pend 2 function] 6 (#$ . 35741)])
#@40 Helper function for `js-end-of-defun'.
(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 \202K db\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 (#$ . 36095)])
#@69 Value of `end-of-defun-function' for `js-mode'.
(fn &optional ARG)
(defalias 'js-end-of-defun #[256 "\211\206 \301\262o\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 (#$ . 36542)])
(defalias 'js--beginning-of-macro #[256 "`\214\203\n d}\210\301 \210`S\206 `Sf\302=\203 \303y\210\202
\304 \210`X\2033 \305!\2033 \306\2027 \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 (#$ . 37406)])
#@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 (#$ . 37719)])
(defalias 'js--up-nearby-list #[0 "\214e`\300Z]`}\210\301\302!)\207" [500 up-list -1] 3])
#@58 Return non-nil if point is in a function parameter list.
(defalias 'js--inside-param-list-p #[0 "\3001\" \212\301 \210\302\303!\205 \304\305!\210\302\306!\206 \304\305!\210\302\306!)0\207\210\307\207" [(error) js--up-nearby-list looking-at "(" forward-symbol -1 "function" nil] 2 (#$ . 38113)])
#@72 Return non-nil if point is in a Dojo multiple-inheritance class block.
(defalias 'js--inside-dojo-class-list-p #[0 "\3011( \212\302 \210`\303y\210\304!\205# \303\225b\205# \304\305!\205# \303\225T=\262)0\207\210\306\207" [js--dojo-class-decl-re (error) js--up-nearby-list 0 looking-at "\"\\s-*,\\s-*\\[" nil] 3 (#$ . 38416)])
#@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 (#$ . 38752)])
(defvar js--tmp-location nil)
(make-variable-buffer-local 'js--tmp-location)
#@238 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 if 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 (#$ . 39291)])
#@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 "\3061\3071 \214e}\210\310\311!\210\211\204$ \312f\313=\205\312u\210\311!\210\314 !\203\333 \315\211@\211\224 \225 \316\n8 \"\f\204L \317\n8\206\323 \320\321 \n#\202\323 \322\nA@!\211 #\242\323=\203i \324\f
#AA#\210#A@##\204y \"\310=\204y \312\202\322 \"\204\221 \325\f
\323\312$\206\322 \326\f
\323#$\202\322 \"\310=\203\242 \326\f
\323#$\202\322 \"\327=\203\263 \330\f
\323#$\202\322 \"\331=\203\304 \332\f
\323#$\202\322 \"\333=\205\322 \334\f
\323#$)-\210\335\225b\202\345 \212\336 )\205\336\337!\205\311!\210\312f\340=\203\375 \312u\210\341 \210\311!\210\312\262\202 \262)00\2020\210\202\210\202\210\312\207" [most-positive-fixnum js--name-re highlight match start end (end-of-buffer) (scan-error) t forward-comment nil 44 looking-at (0 font-lock-variable-name-face) 2 3 error #1="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\230 \311\312 #\202\230 \313A@!\211 \242\314=\203: \315\n
AA#\210
A@
\204H \f\316=\204H \317\202\227 \f\204^ \320\n \314\317$\206\227 \321\n \314
$\202\227 \f\316=\203m \321\n \314
$\202\227 \f\322=\203| \323\n \314
$\202\227 \f\324=\203\213 \325\n \314
$\202\227 \f\326=\205\227 \327\n \314
$)-\207" [highlight match start end override val (0 font-lock-variable-name-face) 2 3 error #1# 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] 6] 61 js--forward-expression override val] 8 (#$ . 40209)])
#@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) (#$ . 42264))
#@78 Return whether point is inside the given pitem's header or body.
(fn PITEM)
(defalias 'js--inside-pitem-p #[257 "\300 \210\3018\204
\302\303!\210\211A@\204 \302\304!\210`\3018V\205+ \3058?\206+ \3058`V\207" [js--ensure-cache 3 cl--assertion-failed (js--pitem-h-begin pitem) (js--pitem-paren-depth pitem) 5] 4 (#$ . 44243)])
#@195 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.
(defalias 'js--parse-state-at-point #[0 "\212\214~\210\301 \210\212\302\303!)\206 C\304@\262\3058\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 (#$ . 44581)])
#@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 (#$ . 45073)])
#@120 Return the JavaScript syntactic context at point.
When called interactively, also display a message with that
context.
(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 (#$ . 45317) 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\203a A\262\202 \266\204\203p \304\262\303\211\262\202t b\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 (#$ . 45679)])
#@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) (#$ . 46336))
(defconst js--syntax-propertize-regexp-syntax-table (byte-code "\300\301\302\"\303\304\305#\210\303\306\307#\210\303\310\311#\210\211\207" [make-char-table syntax-table (1) modify-syntax-entry 91 "(]" 93 ")[" 92 "\\"] 5))
(defalias 'js-syntax-propertize-regexp #[257 "\302 \3038\304=\205A \305\306\307#\205A \310 p\311\312\313\314\315\"\316\"\317$\216\320!\210\321\322\3238`\"*\266\202A@\204\n \324`S`\310\325$\210\321\207" [js--syntax-propertize-regexp-syntax-table parse-sexp-lookup-properties syntax-ppss 3 47 re-search-forward "\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*/" move syntax-table make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table nil parse-partial-sexp 8 put-text-property (7 . 47)] 11 "\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 "\\(?:^\\|[=([{,:;]\\|\\_<return\\_>\\)\\(?:[ ]\\)*\\(/\\)[^/*]" 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)"])
#@49 Alist of symbol prettifications for JavaScript.
(defconst js--prettify-symbols-alist '(("=>" . 8658) (">=" . 8805) ("<=" . 8804)) (#$ . 47799))
#@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")) (#$ . 47949))
#@60 Regular expression matching variable declaration keywords.
(defconst js--declaration-keyword-re "\\<\\(const\\|let\\|var\\)\\>" (#$ . 48175))
#@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) (#$ . 48323))
#@74 Return non-nil if point is on a JavaScript operator, other than a comma.
(defalias 'js--looking-at-operator-p #[0 "\302 \303\304\305\306\307!\310\"\311$\216\312!\205Z \313f\314=\203, \212\315\316\313\317#\205( \313f\320=)\205Z \313f\321=\205; \212\311\322 8)\321=?\205Z \313f\323=\205Y \312\324 \325Q!\205Y \212\326 \210`Sf\327>)?)\207" [js--indent-operator-re js--name-re match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 looking-at nil 58 js--re-search-backward "[?:{]\\|\\_<case\\_>" t 63 47 syntax-ppss 42 "\\* *\\(?:\\[\\|" " *(\\)" js--backward-syntactic-ws (44 125 123)] 7 (#$ . 48576)])
#@61 Return non-nil if the current line continues an expression.
(defalias 'js--continued-expression-p #[0 "\212\300 \210\301 \203 \302f\303>?\206P \304`[!\210`Sf\305>?\202P \306\307\302\310#\205P \311\302x\210o\2042 \312u\210`eV\205P \212\312u\210\313\314!)?\205P \301 \205P \312u\210\313\315!?)\207" [back-to-indentation js--looking-at-operator-p nil (45 43) forward-comment (44 91 40) js--re-search-backward "\n" t " " -1 looking-at "[/*]/" "+\\+\\|--\\|/[/*]"] 4 (#$ . 49222)])
#@234 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.
(defalias 'js--end-of-do-while-loop-p #[0 "\212\300 \301\302\303\304\305!\306\"\307$\216\310\311!\205d \212\312\313x\210\310\312!)\2030 \212\314 \210\315\316!\210\310\317!)\202d \320\317\321 \322#\210\310\317!\206d \323 \320\324\313\322#\203N \323 U\203? \310\325!\205b \326\327\330 \322#?\205b \323 U\262)\262)\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 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] 7 (#$ . 49708) nil])
#@181 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.
(defalias 'js--ctrl-statement-indentation #[0 "\212\302 \210\212\303 e=?\205G \304\305!?\205G \306\307\310\311#\205G m\204# \310u\210`Sf\312U\203. \313 \210\314\315!\210\314\316!\210\304!\205G `Sf\317>\205G \320 ?)\205U \212\321\224b\210\322 \\))\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_" (32 9 10 125) js--end-of-do-while-loop-p 0 current-indentation] 4 (#$ . 50618)])
(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)"])
(defalias 'js--same-line #[257 "\211\300 Y\205 \211\301 X\207" [point-at-bol point-at-eol] 3 "\n\n(fn POS)"])
#@186 Helper function for `js--proper-indentation'.
Return the proper indentation of the current line if it belongs to a declaration
statement spanning multiple lines; otherwise, return nil.
(defalias 'js--multi-line-declaration-indentation #[0 "\303\211\212\304 \210\305 !?\205t \305\n!\203 \306\225b\210\211\204h o\204h `\212\307 \210`Sf\310=\206O `Sf\311=\204L \312\313!\210\305\n!\307 \210\203L `Sf\311=?\206O \314!)\262\203h \3151_ \316 0\202d \210\317\211\262\210\202 \305 !\205t \306\225b\210iT*\207" [forward-sexp-function js--declaration-keyword-re js--indent-operator-re nil back-to-indentation looking-at 0 js--backward-syntactic-ws 44 59 skip-syntax-backward "." js--same-line (scan-error) backward-sexp t] 5 (#$ . 51601)])
#@141 Return non-nil if we think we're in an array comprehension.
In particular, return the buffer position of the first `for' kwd.
(fn BRACKET)
(defalias 'js--indent-in-array-comp #[257 "`\212b\210\301\302!\205W \303u\210\304 \210\301\305!\2033 \306\307 \210\304 \210\306f\310U?\205/ \301\311!\205/ \312\224)\202W \211`V\205W \313\314\315#\205W \316`\"\211@\303U\205P \3178?\262\205W \303\224)\207" [forward-sexp-function looking-at "\\[" 1 js--forward-syntactic-ws "[[{]" nil forward-sexp 44 "for" 0 re-search-forward "[^,]]* \\(for\\_>\\)" t parse-partial-sexp 8] 6 (#$ . 52345)])
(defalias 'js--array-comp-indentation #[514 "\300!\203 \212b\210\301u\210\302\303w\210i)\207\212\211b\210i)\207" [js--same-line 1 " " nil] 4 "\n\n(fn BRACKET FOR-KWD)"])
#@219 Helper function for `js--proper-indentation'.
Depending on the value of `js-indent-first-init', move
point to the end of a variable declaration keyword so that
indentation is aligned to that column.
(fn PARSE-STATUS)
(defalias 'js--maybe-goto-declaration-keyword-end #[257 "\304=\203 \305 !\205^ \306\225Tb\207\307=\205^ \211A@\310\211\211\211\305 !\205[ \306\225\262\212b\210\3111: \312 \210\3040\202< \210\310\262\203S \313\314!\204B \315\304\305!)\262\262)\211\205[ Tb)\266\205\207" [js-indent-first-init js--declaration-keyword-re forward-sexp-function inhibit-changing-match-data t looking-at 0 dynamic nil (error) forward-sexp forward-comment 1 ","] 9 (#$ . 53111)])
#@72 Return the proper indentation for the current line.
(fn PARSE-STATUS)
(defalias 'js--proper-indentation #[257 "\212\306 \210\3078\203 \310\311\3128\"\202\3138\203 \314\202\315f\316=\203( \314\202\212\317 )\2033 \307\202\211A@\315\205U \320!?\205U \321!\211\262\205U `Y\205U \322\"\266\202\206\323 \206\324 \206\211A@\203\325\326!\325\327!\330 A@b\210\325\331!\203\364 \332\333!\210`Sf\334=\203\214 \335 \210\306 \210\336!\210?\205\233 \325\337!\206\244 \205\244 \211\211\203\254 i\202\344 \203\272 \340i\341_ #\202\344 \340iA@f\211\342=\203\314 \n\202\341 \211\343=\203\326 \202\341 \211\344=\203\340 \f\202\341 \315\262#\203\356 \211
\\\202\357 \211\266\203\202 \204\377 \315u\210\345\315w\210i\266\203\202\330 \203 \\\202\314)\207" [js-indent-level js-expr-indent-offset js-paren-indent-offset js-square-indent-offset js-curly-indent-offset js-switch-indent-offset back-to-indentation 4 js--get-c-offset c 8 3 0 nil 35 js--beginning-of-macro js--same-line js--indent-in-array-comp js--array-comp-indentation js--ctrl-statement-indentation js--multi-line-declaration-indentation looking-at "[]})]" "default\\_>\\|case\\_>[^:]" js--continued-expression-p "[({[]\\s-*\\(/[/*]\\|$\\)" skip-syntax-backward " " 41 backward-list js--maybe-goto-declaration-keyword-end "\\_<switch\\_>" + 2 40 91 123 " "] 12 (#$ . 53805)])
#@509 Find where JSX starts.
Assume JSX appears in the following instances:
- Inside parentheses, when returned or as the first argument
to a function, and after a newline
- When assigned to variables or object properties, but only
on a single line
- As the N+1th argument to a function
This is an optimized version of (re-search-backward "[(,]
"
nil t), except set point to the end of the match. This logic
executes up to the number of lines in the file, so it should be
really fast to reduce that impact.
(defalias 'js--jsx-find-before-tag #[0 "\300`eV\203\" \301\210`Sf\302=\204 `Sf\303=\203 `S\211\262\203 \211\207" [nil 0 40 44] 3 (#$ . 55182)])
(put 'js--jsx-find-before-tag 'byte-optimizer 'byte-compile-inline-expand)
#@32 Find the end of a JSX element.
(defconst js--jsx-end-tag-re (concat "</" sgml-name-re ">\\|/>") (#$ . 55920))
#@116 Find where JSX ends.
This complements the assumption of where JSX appears from
`js--jsx-before-tag-re', which see.
(defconst js--jsx-after-tag-re "[),]" (#$ . 56037))
#@688 Determine if/how the current line should be indented as JSX.
Return `first' for the first JSXElement on its own line.
Return `nth' for subsequent lines of the first JSXElement.
Return `expression' for an embedded JS expression.
Return `after' for anything after the last JSXElement.
Return nil for non-JSX lines.
Currently, JSX indentation supports the following styles:
- Single-line elements (indented like normal JS):
var element = <div></div>;
- Multi-line elements (enclosed in parentheses):
function () {
return (
<div>
<div></div>
</div>
);
}
- Function arguments:
React.render(
<div></div>,
document.querySelector('.root')
);
(defalias 'js--jsx-indented-element-p #[0 "`\303 \304\211\211\211\211\211\211\211\211\211\211\212\304\210\204] \304`eV\2039 \305\210`Sf\306=\2041 `Sf\307=\203 `S\211\262\203 \211\262\211\262\f\203] \310\311!\204B \304f\312U\203V \n\262\n`\262\nb\210\202 \205K\303\n!\262 \303!\262 V\205K Y\205K\204\240 \313\304\314#\211\262\f\203\240 \310\311!\204\215 \315 !\203~ \n\262\202~ \203\322 \303!\262\303!\262 X\203\275 X\204\326 V\205K W\205K\316\211\262\202\323 \314\205K\211\204:\fb\210\304\210\317\320 8\262\203:\211\204:@\262Y\2033f\321U\2033 \303!V\2033b\210\3221\304\323 )0\202 \210\202)\203) \303 W\202*\314\2033\324\262\202\347 A\262\202\347 \211\206K U\203J\325\202K\326)\207" [js--jsx-end-tag-re js--jsx-after-tag-re forward-sexp-function line-number-at-pos nil 0 40 44 forward-comment 1 60 re-search-forward t looking-at after 9 syntax-ppss 123 (error) forward-sexp expression first nth] 17 (#$ . 56211)])
#@51 Execute BODY as if in sgml-mode.
(fn &rest BODY)
(defalias 'js--as-sgml '(macro . #[128 "\300\301\302\303BBE\207" [with-syntax-table sgml-mode-syntax-table let (forward-sexp-function parse-sexp-lookup-properties)] 6 (#$ . 57905)]))
#@71 Indent the current line as JavaScript or SGML (whichever is farther).
(defalias 'js--expression-in-sgml-indent-line #[0 "\305`\306\212\307\310 !)\3118?\205` \212\312 \210`Y\203 \305\262\313 p\314\315\316\317\320\"\321\"\322$\216\323 !\210\305\211\324 +\266\202)\262\204H \325\202` \326!\f\\]\262\203] \212\327!)\202` \327!)\207" [inhibit-point-motion-hooks sgml-mode-syntax-table parse-sexp-lookup-properties forward-sexp-function js-indent-level nil t syntax-ppss point-at-bol 3 back-to-indentation syntax-table make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table sgml-calculate-indent noindent js--proper-indentation indent-line-to] 12 (#$ . 58145)])
#@40 Indent the current line as JavaScript.
(defalias 'js-indent-line #[0 "\212\300\301 !)`\212\302 \210`)Z\3038?\205# \304\305!!\210\211\306V\205# \211u\207" [syntax-ppss point-at-bol back-to-indentation 3 indent-line-to js--proper-indentation 0] 5 (#$ . 58868) nil])
#@150 Indent the current line as JSX (with SGML offsets).
i.e., customize JSX element indentation with `sgml-basic-offset',
`sgml-attribute-offset' et al.
(defalias 'js-jsx-indent-line #[0 "\303 \211\304=\203
\305 \202] \211\306=\204 \211\307=\2033 \310K\311\312\313\314\315!\316\"\317$\216\310\320M\210\321 )\262\202] \211\322=\203[ \323 p\311\312\324\314\315\"\325\"\317$\216\326!\210\327\211\330 +\266\202\202] \321 \207" [sgml-mode-syntax-table parse-sexp-lookup-properties forward-sexp-function js--jsx-indented-element-p expression js--expression-in-sgml-indent-line first after js--continued-expression-p make-byte-code 0 "\301\300M\207" vconcat vector [js--continued-expression-p] 2 ignore js-indent-line nth syntax-table "r\301q\210\302\300!)\207" [set-syntax-table] set-syntax-table nil sgml-indent-line] 10 (#$ . 59141) nil])
(defvar js--filling-paragraph nil)
(byte-code "\300\301\302\303\304$\210\305\301\304\"\210\300\306\307\303\304$\210\305\306\304\"\210\300\310\311\303\304$\210\305\310\304\"\207" [ad-add-advice c-forward-sws (js-fill-paragraph nil t (advice lambda nil (if js--filling-paragraph (setq ad-return-value (js--forward-syntactic-ws (ad-get-arg 0))) ad-do-it))) around nil ad-activate c-backward-sws (js-fill-paragraph nil t (advice lambda nil (if js--filling-paragraph (setq ad-return-value (js--backward-syntactic-ws (ad-get-arg 0))) ad-do-it))) c-beginning-of-macro (js-fill-paragraph nil t (advice lambda nil (if js--filling-paragraph (setq ad-return-value (js--beginning-of-macro (ad-get-arg 0))) ad-do-it)))] 5)
#@69 Fill the paragraph with `c-fill-paragraph'.
(fn &optional JUSTIFY)
(defalias 'js-c-fill-paragraph #[256 "\302\303\303!*\207" [fill-paragraph-function js--filling-paragraph t c-fill-paragraph] 3 (#$ . 60699) "*P"])
(defalias 'js--pitem-format #[257 "\3008\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 (#$ . 61081)])
#@68 Last part of the name of PITEM, as a string or symbol.
(fn PITEM)
(defalias 'js--pitem-strname #[257 "\3008\211:\203 \301!@\202 \211\207" [4 last] 4 (#$ . 61616)])
#@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!\210G\304V\204 \302\305!\210\203d \306@!\232\203E \307@#AB\262\203? \241\210\202d \211\262\202d @\301B\262\203V \241\210\202Y \211\262\211\262A\211\262\204 \203l \202\212 A\203\205 \310\311\312\301\n\nA#\313\314\n&\202\207 B\207" [js--dummy-class-style nil 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 (#$ . 61792)])
#@85 Copy `js--pitem' PITEM, and push CHILD onto its list of children.
(fn PITEM CHILD)
(defalias 'js--pitem-add-child #[514 "\3008\250\204 \301\302!\210\3038:\2039 \3038\304\305:\203/ @\262;\211\262\203/ A\262\202 \211\2054 \305\266\203\202: \305\204A \301\306!\210\3038\3078\243\203U \310@#\202w \211:\203s \311\312\"\203s :\204j \301\313!\210\310@#\202w @B\266\202AB\207" [3 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 (#$ . 62601)])
#@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 (#$ . 63254)])
#@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\242\211\262\203\231 \3018\262\302!\262\303=\2030 \304\305\211@T\240\262\"\262\306>\203P \3078\250\204A \310\311!\210\312\3078!BB\262\202 :\203\221 \313@\"\262\211\203k BB\262\202 \3078\203 \3078\250\204| \310\314!\210\315\312\3078!BC\262BB\262\202 \316\317\"\210\202 \207" [nil 2 js--pitem-strname t format "[unknown %s]" #'macro 3 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 (#$ . 63464)])
#@47 Return an imenu index for the current buffer.
(defalias 'js--imenu-create-index #[0 "\212\214~\210db\210\302 \210edU\204 `=\204 \303\304!\210\205J \305\306BA\2037 \307A@@\"AAB\262\202\" G\310U\204B \303\311!\210\312@@\"\266\202*\207" [js--last-parse-pos js--state-at-last-parse-pos js--ensure-cache 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] 5 (#$ . 64204)])
(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 \302A@\303Q#\210\202D @P\211\304\305\"\203; \306\307T\211\262#\262\202% \310A#\266A\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)"])
#@238 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.
(defalias 'js--get-all-known-symbols #[0 "\301\302\303\"\304\305 \306\211:\2030 @\262rq\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 (#$ . 65111)])
#@40 History of entered JavaScript symbols.
(defvar js--symbol-history nil (#$ . 65664))
#@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\242\237\262\304\316\317&\211\320\"B\207" [ido-mode 1 -1 ido-completing-read nil maphash make-byte-code 514 "\300\300\242B\240\207" vconcat vector [] 5 "\n\n(fn KEY --CL-VAR--)" t js--symbol-history gethash] 13 (#$ . 65755)])
(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])
#@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 (#$ . 66647) "P"])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [define-error js-moz-bad-rpc "Mozilla RPC Error" js-js-error "Javascript Error"] 3)
#@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 (#$ . 67446)])
(defalias 'js--js-handle-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-p (declare (side-effect-free error-free)) (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)"])
(put 'js--js-handle-p 'compiler-macro 'js--js-handle-p--cmacro)
(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)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put js--js-handle-p side-effect-free error-free put js--js-handle cl-deftype-satisfies] 4)
(defalias 'js--js-handle-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-id (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-js--js-handle-tags)) (signal 'wrong-type-argument (list 'js--js-handle cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--js-handle-id 'compiler-macro 'js--js-handle-id--cmacro)
(defalias 'js--js-handle-id #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-js--js-handle-tags 0 signal wrong-type-argument js--js-handle 1] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put js--js-handle-id side-effect-free t put 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)"]] 4)
(defalias 'js--js-handle-process--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--js-handle-process (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-js--js-handle-tags)) (signal 'wrong-type-argument (list 'js--js-handle cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'js--js-handle-process 'compiler-macro 'js--js-handle-process--cmacro)
(defalias 'js--js-handle-process #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-js--js-handle-tags 0 signal wrong-type-argument js--js-handle 2] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\307\310\311\"\207" [function-put js--js-handle-process side-effect-free t put 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)"] defalias copy-js--js-handle copy-sequence] 4)
#@43
(fn CL-WHOLE &cl-quote &key ID PROCESS)
(defalias 'make-js--js-handle--cmacro #[385 "\300\301\"A@\300\302\"A@\211\2037 \211@\303>\203 \211AA\262\202
\304>A@\203. \305\262\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :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 "Constructor for objects of type `js--js-handle'." (declare (side-effect-free t)) (vector 'cl-struct-js--js-handle id process))] 12 (#$ . 70609)])
(put 'make-js--js-handle 'compiler-macro 'make-js--js-handle--cmacro)
#@72 Constructor for objects of type `js--js-handle'.
(fn &key ID PROCESS)
(defalias 'make-js--js-handle #[128 "\300\301\"A@\300\302\"A@\211\2037 \211@\303>\203 \211AA\262\202
\304>A@\203. \305\262\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :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 (#$ . 71276)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put make-js--js-handle side-effect-free t cl-struct-define js--js-handle nil cl-structure-object ((cl-tag-slot) (id nil :read-only t) (process nil :read-only t)) cl-struct-js--js-handle-tags cl-struct-js--js-handle] 10)
(defalias 'js--js-handle-expired-p #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\306 =?\207" [cl-struct-js--js-handle-tags 0 signal wrong-type-argument 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 (#$ . 72243))
#@41 The most recent MozRepl process object.
(defvar js--js-process nil (#$ . 72354))
#@50 Idle timer for cleaning up JS object references.
(defvar js--js-gc-idle-timer nil (#$ . 72441))
(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") (#$ . 72577))
#@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!\203S \211G\307Y\203S \211\310H>\203S \311!\203= \312\313!\210\303\314\310H>\204N \315\316\317D\"\210\320H\"\207\321!\203s \211\242\322=\203j \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}" signal wrong-type-argument js--js-handle 1 sequencep js--funcall "{funcall:[%s]}" mapconcat js--js-encode-value "," "[" "]" "Unrecognized item: %S"] 7 (#$ . 80950)])
(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])
(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 #\210 T\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])
(defalias 'js--js-leave-repl #[0 "\304V\204\n \305\306!\210S\211\304U\205, r q\210db\210\307 \210\310c\210\311\312\313\"\210\314\315 \n #)\207" [js--js-repl-depth inferior-moz-buffer js--js-prompt-regexp js-js-timeout 0 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])
(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\300\211:\203\224 @\262\242\301=\203$ \302\303\304\305E\306A!\"B\262\202\215 \242\307=\203X \302\303\310\311EA@:\204> A@C\202K \302\303\312\313E\306A@!\"C\306AA!#B\262\202\215 \242\314=\203\210 A\211@A\211\302\303\315:\203w \303\306!B\202x E\306!\"\266\202\266\203B\262\202\215 B\262A\262\202 \211\237\207" [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] 15 (#$ . 83537)])
(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 (#$ . 84761)]))
#@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 (#$ . 86160))
(defalias 'js--js-decode-retval #[257 "\301@!\211\302=\203 A@\202e \211\303=\203 \301A@!\202e \211\304=\203- \305\306A@\"\202e \211\307=\203N \310A@\"\206e \311A@\312\313A@\314\315 $#\202e \211\316=\203^ \317\320A@C\"\202e \211\316\321\"\262\207" [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"] 9 "\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\216\307B!rq\210 \203 \310c\210\211c\210\311\312\313\"\210\314\315 \316\n#\210 b\210\317 \320 db\210\321!)\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 #[0 "\300 \207" [js--js-leave-repl] 1] 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 (#$ . 86828)])
#@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 (#$ . 87858)])
(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 (#$ . 88253)])
(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 =?\205g r q\210\212db\210\310\f\212\311y\210`)\"*\205g \305C\312\313\314\315\316\317!\320\"\321\322%\n\"\210\211\242\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\242B\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 (#$ . 88727) 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\216\302\303 !\304\"\305\306!\203 \307\310\311\312\"\"\210\262)\207" [js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] js--js-content-window js--get-js-context js--js-eval called-interactively-p interactive message "%s" js--js-funcall "String"] 8 (#$ . 89536) "MJavascript to evaluate: "])
#@306 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.
(defalias 'js--get-tabs #[0 "\301 \210\302\216\303\304\305\306\307\310F\311\312\313D\305\314\315\257\"\304\316D\303\"\303\211\304\317D!\211\211\320>\262?\262\203~ \304\321D!\262\322\311\312\313D\323\324\257\311\325\326ED\311\312\313D\327F\311\312\313D\330F%\262\211AAA@\211\211\320>\262?\262\204 \211\3318\262\332=\204 \211B\262\202 \266\211\303\211\211\211:\203@\262@\262A@AA@EB\262\333\334\"\262\335!\203
\211G\336Y\203
\211\337H>\203
\337\333\340\341#\303W\203\322\311\312\313D\340\342\324\257\311\340\343\325\326\257D\311\312\313D\340 \257\311\344\345\346FE%B\262T\262\202\301 \211\237\266\203\237\244\262A\262\202\205 \237\266\205\262)\207" [cl-struct-js--js-handle-tags js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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"] 18 (#$ . 89956)])
(defvar js-read-tab-history nil)
#@202 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\302!\210\300\303!\210\304 \210\305\216\306 C\307\211\211C\310\311\312\"\242\307\211\211\211:\203c @\262\313\314A@@#\262\315\316\303#T#\266\202\262\317V\203U \313\320#\262BB\262A\262\202# \211\237\266\206\240\210\307C\307C\307C\307\321\322\323\324\325
!\326\"\327\330%\240\210\331\240\210\321\317\332\324\325\n\n\n#\333\"\334$\240\210\321\317\335\324\325\"\336\"\337$\262\321\317\340\324\325 \"\341\"\342$\216\211 B\343 \344\345 \242\"\307\346\307\347&)\262)\350\347\"\210\242\307\346\307:\203 @\262@ \232\203\365 A\262\307\211\262\202\366 \346\203 A\262\202\331 \266\203\262AAA@\203\351\202\352AA@B\266\204\266\204)\207" [ido-mode ido-minibuffer-setup-hook 1 -1 js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] js--get-tabs nil make-hash-table :test equal format "%s (%s)" puthash gethash 0 "%s <%d>" make-byte-code 257 "\300\242\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 \302B\262\303B\262\203+ \304B\262\202+ AA@\203+ \305B\262AAA@\203@ \306B\262\307B\262\202L AA@\203L \310B\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\242 @!\302\242\300\242\"\210\300\240\207" [ido-matches] 4 "\300\242\n@!\211\203d \211AAA@\204d \304AA@\305\306\307F\310\"\311\232\203d \312AA@\313\314#\n\315\211\316\315:\203b @\262\300\242!\262AAA@=\203W \317 \"\316\262\315\211\262\202X \316\203b A\262\202. \266\210\320\321\301\242\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\242\205 \301\242\302\300\242\"\210\300\302\240\207" [nil] 3 ido-completing-read mapcar car t js-read-tab-history add-to-history browser window] 20 (#$ . 91571)])
#@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\300U\2031 \301@8\302=\2031 \303@8G\304U\2031 \301A@8:\2031 \305\303A@8\303@8@C\"\207\211G\301U\203R \301@8\302=\203R \305\306\303@8!\307\303@8!@C\"\207\310\311!\207" [3 2 function 4 1 append butlast last error "Function not a toplevel defun or class member"] 6 (#$ . 94348)])
#@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 (#$ . 94880))
(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 (#$ . 95811) (byte-code "\300\301!C\207" [js--read-tab "Javascript Context: "] 2)])
#@100 Return a valid JavaScript context.
If one hasn't been set, or if it's stale, prompt for a new one.
(defalias 'js--get-js-context #[0 "\301 \210\302\216\203M \303A!\204M @\211\304=\203) \305A\306\"\211\211\307>\262?\262\202H \211\310=\203A \305A\311\"\211\211\307>\262?\262?\202H \211\312\313\"\262\262\203Q \314\315!)\207" [js--js-context js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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 (#$ . 96072)])
(defalias 'js--js-content-window #[257 "\300 \210\301\216\211@\211\302=\203 A\202( \211\303=\203! \304A\305\306#\202( \211\307\310\"\262\262)\207" [js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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\216\302\303\304\305\306F\307\310\311D\303\312\313\257\"\302\314D\"\210\211\262)\207" [js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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\216\302\303\304\305\306F\307\310\311D\303\312\313\257\"\302\314D\315\"\302\316D\307\310\311D\303\312\317\257\"\320!\302\321D\"\302\322D#\266\205)\207" [js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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)"])
#@59 Update a Mozilla tab using the JavaScript defun at point.
(defalias 'js-eval-defun #[0 "\3022i\212\303\211\211\211\211C\303\304 \210`\262\305 \210\306 \210\307\310!\210\311\224\262\312\313!\262\203/ `V\2033 \314\315!\210\316!\262\317\"\320\321\322#\210\323\311\324\325\326!\327\"\330$\216\331\332\333\334\335\336#\"!\204g \337\340!\210\341\302\303\"\210)\210\342\"\262\343\344\"\210\345\346\"\210\347\350P\303\351#\240\210\323\311\352\325\326!\353\"\330$\216\354 \210\355\216\356\357!r\211q\210\323\311\360\325\326!\361\"\330$\216 c\210\362c\210\363!c\210\364c\210c\210\365c\210\366ed\242\303\367%\210*\210\370\371 !\372\373\"\372\374\"\211\211\375>\262?\262\203\357 \372\376\377D\201@ E\311\"\202\365 \372\201A \"\201B \201C D\201D \201E #\201B \201F D\201G \201H #\210\201B \201F D\201I \332\201J \201K \242!\"#\210\201B \201L D\"\210\201B \201M D\201N \376\201O \201P \201Q \201R #C\201S \242!E\201T $\210\303\240\266\204*\266\206)0\207" [js-js-tmpdir js--js-inserter --cl-block-js-eval-defun-- 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 make-byte-code "\301\300!\207" vconcat vector [delete-overlay] 2 y-or-n-p format "Send %s to Mozilla? " mapconcat identity "." message "" throw buffer-substring-no-properties make-directory t js--js-add-resource-alias "js" make-temp-file "/js-" ".js" "\300\242\205 \301\300\242!\207" [delete-file] js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] 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 (#$ . 98005) nil])
#@167 Hook run after entering JavaScript mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar js-mode-hook nil (#$ . 100278))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp js-mode-map put definition-name js-mode] 4)
(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)
#@203 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}
(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!\210B$\306\345!\210\307%\306\346!\210\307&\306\347!\210\350'\306\351!\210\352)\306\353!\210\354+\306\355!\210\356-\357\360\361\307\211$\210\362 \210\340C\363D\364E\365F\366G\367H\370I\371J\372K\306\373!\210\374\375;\";\306\376!\210\377>\307 L\306\201M !\210\306\201N !\210\306\201O !\210\306\201P !\210\306\201Q !\210\201R \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 prettify-symbols-alist 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 js--imenu-create-index "//+\\|\\**" "\\(@[[:alpha:]]+\\>\\|$\\)" "$" "* " "//" "/[*/]\\|\\s!" "\\(//+\\|/\\*+\\)\\s *" electric-indent-chars append "{}():;," electric-layout-rules ((59 . after) (123 . after) (125 . before)) local-abbrev-table js--font-lock-keywords js--prettify-symbols-alist imenu-case-fold-search imenu-create-index-function 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 paragraph-start paragraph-separate paragraph-ignore-fill-prefix adaptive-fill-mode adaptive-fill-regexp c-setup-paragraph-variables run-mode-hooks js-mode-hook] 5 (#$ . 101490) nil])
#@160 Hook run after entering JSX mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar js-jsx-mode-hook nil (#$ . 104022))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp js-jsx-mode-map put definition-name js-jsx-mode] 4)
(defvar js-jsx-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-jsx-mode-map variable-documentation put purecopy "Keymap for `js-jsx-mode'." boundp js-jsx-mode-syntax-table definition-name js-jsx-mode] 5)
(defvar js-jsx-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [js-jsx-mode-syntax-table variable-documentation put purecopy "Syntax table for `js-jsx-mode'." js-jsx-mode-abbrev-table definition-name js-jsx-mode] 5)
(defvar js-jsx-mode-abbrev-table (progn (define-abbrev-table 'js-jsx-mode-abbrev-table nil) js-jsx-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-jsx-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `js-jsx-mode'." js-jsx-mode derived-mode-parent js-mode custom-mode-group js] 5)
#@338 Major mode for editing JSX.
To customize the indentation for this mode, set the SGML offset
variables (`sgml-basic-offset', `sgml-attribute-offset' et al.)
locally, like so:
(defun set-jsx-indentation ()
(setq-local sgml-basic-offset js-indent-level))
(add-hook \='js-jsx-mode-hook #\='set-jsx-indentation)
\{js-jsx-mode-map}
(defalias 'js-jsx-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)\333\334!\207" [delay-mode-hooks major-mode mode-name js-jsx-mode-map js-jsx-mode-syntax-table js-jsx-mode-abbrev-table make-local-variable t js-mode js-jsx-mode "JSX" 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-jsx-indent-line run-mode-hooks js-jsx-mode-hook local-abbrev-table] 5 (#$ . 105301) nil])
(byte-code "\300\301\302\"\210\303\304\305\306F\211\203 \211@\307\310\311!\312B\"\210A\266\202\202\n \210\313\314!\207" [eval-after-load folding #[0 "\300\301!\205 \301\302\303\304#\207" [fboundp folding-add-to-marks-list js-mode "// {{{" "// }}}"] 4] "node" "nodejs" "gjs" "rhino" add-to-list interpreter-mode-alist purecopy js-mode provide js] 6)
Kontol Shell Bypass