;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304\305\306#\210\300\307!\210\300\310!\207" [require cc-mode newcomment imenu moz nil t json prog-mode] 4)
#@73 Regexp matching the start of a JavaScript identifier, without grouping.
(defconst js--name-start-re "[[:alpha:]_$]" (#$ . 247))
(defconst js--stmt-delim-chars "^;{}?:")
#@60 Regexp matching a JavaScript identifier, without grouping.
(defconst js--name-re (concat js--name-start-re "\\(?:\\s_\\|\\sw\\)*") (#$ . 422))
#@57 Regexp matching the start of a JavaScript object field.
(defconst js--objfield-re (concat js--name-re ":") (#$ . 571))
#@63 Regexp matching a dot-separated sequence of JavaScript names.
(defconst js--dotted-name-re (concat js--name-re "\\(?:\\." js--name-re "\\)*") (#$ . 696))
#@40 Regexp matching a C preprocessor name.
(defconst js--cpp-name-re js--name-re (#$ . 856))
#@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:]]+\\)" (#$ . 952))
#@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\\)\\_>") (#$ . 1213))
#@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-*{") (#$ . 1556))
(defconst js--mp-class-decl-re (concat "^\\s-*var\\s-+\\(" js--name-re "\\)\\s-*=\\s-*\\(" 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 "\\)\\s-*,\\s-*\\(" js--dotted-name-re "\\)") (#$ . 2659))
#@55 Regexp matching an ExtJS class declaration (style 2).
(defconst js--extjs-class-decl-re-2 (concat "^\\s-*\\(?:var\\s-+\\)?\\(" js--name-re "\\)\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*\\(" js--dotted-name-re "\\)") (#$ . 2876))
#@47 Regexp matching a MochiKit class declaration.
(defconst js--mochikit-class-re (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*\\(" js--dotted-name-re "\\)") (#$ . 3103))
(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) (#$ . 3358))
#@50 List of available JavaScript frameworks symbols.
(defconst js--available-frameworks (byte-code "\301\211\211\211:\203*@\262\302\303\"\262>\204 
C\244\262A\262\301\262
\202
\207" [js--class-styles nil plist-get :framework] 8) (#$ . 5398))
#@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 "\\)") (#$ . 5659))
#@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\\_>") (#$ . 5883))
#@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\\_>") (#$ . 6114))
#@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-*(") (#$ . 6352))
#@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 (#$ . 6576)])
#@41 Regexp matching any JavaScript keyword.
(defconst js--keyword-re (js--regexp-opt-symbol '("abstract" "async" "await" "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" "of" "package" "private" "protected" "public" "return" "static" "super" "switch" "synchronized" "throw" "throws" "transient" "try" "typeof" "var" "void" "let" "yield" "volatile" "while" "with")) (#$ . 6771))
#@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")) (#$ . 7334))
#@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")) (#$ . 7540))
#@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) (#$ . 7751))
#@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) (#$ . 7992))
#@75 compiler-macro for inlining `js--pitem-children'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'js--pitem-children--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-children (progn (car cl-x))) nil] 9 (#$ . 8357)])
(put 'js--pitem-children 'compiler-macro 'js--pitem-children--cmacro)
#@63 Access slot "children" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-children #[257 "\211@\207" [] 2 (#$ . 8684)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--pitem-children side-effect-free t 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)"]] 5)
#@78 compiler-macro for inlining `js--pitem-paren-depth'.

(fn CL-WHOLE-ARG CL-X)
(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 (progn (nth 1 cl-x))) nil] 9 (#$ . 9047)])
(put 'js--pitem-paren-depth 'compiler-macro 'js--pitem-paren-depth--cmacro)
#@66 Access slot "paren-depth" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-paren-depth #[257 "\211A@\207" [] 2 (#$ . 9391)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--pitem-paren-depth side-effect-free t 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)"]] 5)
#@71 compiler-macro for inlining `js--pitem-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'js--pitem-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-type (progn (nth 2 cl-x))) nil] 9 (#$ . 9767)])
(put 'js--pitem-type 'compiler-macro 'js--pitem-type--cmacro)
#@59 Access slot "type" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-type #[257 "\300
8\207" [2] 3 (#$ . 10076)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--pitem-type side-effect-free t 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)"]] 5)
#@74 compiler-macro for inlining `js--pitem-h-begin'.

(fn CL-WHOLE-ARG CL-X)
(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 (progn (nth 3 cl-x))) nil] 9 (#$ . 10426)])
(put 'js--pitem-h-begin 'compiler-macro 'js--pitem-h-begin--cmacro)
#@62 Access slot "h-begin" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-h-begin #[257 "\300
8\207" [3] 3 (#$ . 10751)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--pitem-h-begin side-effect-free t 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)"]] 5)
#@71 compiler-macro for inlining `js--pitem-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'js--pitem-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block js--pitem-name (progn (nth 4 cl-x))) nil] 9 (#$ . 11113)])
(put 'js--pitem-name 'compiler-macro 'js--pitem-name--cmacro)
#@59 Access slot "name" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-name #[257 "\300
8\207" [4] 3 (#$ . 11423)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--pitem-name side-effect-free t 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)"]] 5)
#@72 compiler-macro for inlining `js--pitem-b-end'.

(fn CL-WHOLE-ARG CL-X)
(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 (progn (nth 5 cl-x))) nil] 9 (#$ . 11773)])
(put 'js--pitem-b-end 'compiler-macro 'js--pitem-b-end--cmacro)
#@60 Access slot "b-end" of `js--pitem' struct CL-X.

(fn CL-X)
(defalias 'js--pitem-b-end #[257 "\300
8\207" [5] 3 (#$ . 12088)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put js--pitem-b-end side-effect-free t defalias copy-js--pitem copy-sequence] 4)
#@122 compiler-macro for inlining `make-js--pitem'.

(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 (list children paren-depth type h-begin name b-end))] 20 (#$ . 12361)])
(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 (#$ . 13228)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\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] 11)
(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&\210\311\323\313\314\324DD\325\317\320\321\322&\210\311\326\313\314\327DD\330\317\320\321\322\331\332&	\210\311\333\313\314\334DD\335\317\320\321\322\331\332&	\210\311\336\313\314\337DD\340\317\320\321\322\331\332&	\210\311\341\313\314\342DD\343\317\320\321\322\331\344&	\210\311\345\313\314\346DD\347\317\350%\210\311\351\313\314\352DD\353\331\354\317\350\321\355&	\210\311\356\313\314\357DD\360\317\314%\210\311\361\313\314\362DD\363\317\364\365\366\"B%\210\311\367\313\314\370DD\371\317\350%\210\311\372\313\314\373DD\374\317\375\331\376&\210\311\377\313\314\201@DD\201A\317\320%\210\311\201B\313\314\201CDD\201D\331\201E\317\201F\321\201G&	\210\311\201H\313\314\201IDD\201J\331\354\317\350\321\355&	\210\311\201K\313\314\201LDD\201M\331\201N\317\350\321\355&	\210\311\201O\313\314\201PDD\201Q\331\201N\317\350\321\355&	\210\311\201R\313\314\201SDD\201T\331\201N\317\350\321\355&	\210\311\201U\313\314\201VDD\201W\331\201N\317\201X\321\201Y&	\210\311\201Z\313\314\201[DD\201\\\331\201N\317\320\321\322&	\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 #1=""] "Number of spaces for each indentation step in `js-mode'." :type integer :safe integerp js-expr-indent-offset #[0 "\300\207" [0] 1 #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 #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 #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 #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 #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 #1#] "Treat nested functions as top-level functions in `js-mode'.\nThis applies to function movement, marking, and so on." boolean js-indent-align-list-continuation #[0 "\300\207" [t] 1 #1#] "Align continuation of non-empty ([{ lines in `js-mode'." "26.1" booleanp js-comment-lineup-func #[0 "\300\207" [c-lineup-C-comments] 1 #1#] "Lineup function for `cc-mode-style', for C comments in `js-mode'." js-enabled-frameworks #[0 "\207" [js--available-frameworks] 1 #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 "\300
D\207" [const] 3 "\n\n(fn X)"] js-js-switch-tabs #[0 "\301=\205\302\207" [system-type darwin t] 2 #1#] "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\301!\207" [locate-user-emacs-file "js/js"] 2 #1#] "Temporary directory used by `js-mode' to communicate with Mozilla.\nThis directory must be readable and writable by both Mozilla and Emacs." directory "28.1" js-js-timeout #[0 "\300\207" [5] 1 #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 #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 js-chain-indent #[0 "\300\207" [nil] 1 #1#] "Use \"chained\" indentation.\nChained indentation applies when the current line starts with \".\".\nIf the previous expression also contains a \".\" at the same level,\nthen the \".\"s will be lined up:\n\n  let x = svg.mumble()\n             .chained;" js-jsx-detect-syntax #[0 "\300\207" [t] 1 #1#] "When non-nil, automatically detect whether JavaScript uses JSX.\n`js-jsx-syntax' (which see) may be made buffer-local and set to\nt.  The detection strategy can be customized by adding elements\nto `js-jsx-regexps', which see." "27.1" js-jsx-syntax #[0 "\300\207" [nil] 1 #1#] "When non-nil, parse JavaScript with consideration for JSX syntax.\n\nThis enables proper font-locking and indentation of code using\nFacebook’s “JSX” syntax extension for JavaScript, for use with\nFacebook’s “React” library.  Font-locking is like `sgml-mode'.\nIndentation is also like `sgml-mode', although some indentation\nbehavior may differ slightly to align more closely with the\nconventions of the React developer community.\n\nWhen `js-mode' is already enabled, you should call\n`js-jsx-enable' to set this variable.\n\nIt is set to be buffer-local (and t) when in `js-jsx-mode'." js-jsx-align->-with-< #[0 "\300\207" [t] 1 #1#] "When non-nil, “>” will be indented to the opening “<” in JSX.\n\nWhen this is enabled, JSX indentation looks like this:\n\n  <element\n    attr=\"\"\n  >\n  </element>\n  <input\n  />\n\nWhen this is disabled, JSX indentation looks like this:\n\n  <element\n    attr=\"\"\n    >\n  </element>\n  <input\n    />" js-jsx-indent-level #[0 "\300\207" [nil] 1 #1#] "When non-nil, indent JSX by this value, instead of like JS.\n\nLet `js-indent-level' be 4.  When this variable is also set to\nnil, JSX indentation looks like this (consistent):\n\n  return (\n      <element>\n          <element>\n              Hello World!\n          </element>\n      </element>\n  )\n\nAlternatively, when this variable is also set to 2, JSX\nindentation looks like this (different):\n\n  return (\n      <element>\n        <element>\n          Hello World!\n        </element>\n      </element>\n  )" (choice integer (const :tag "Not Set" nil)) #[257 "\211?\206\211\250\207" [] 2 "\n\n(fn X)"] js-jsx-attribute-offset #[0 "\300\207" [0] 1 #1#] "Specifies a delta for JSXAttribute indentation.\n\nLet `js-indent-level' be 2.  When this variable is also set to 0,\nJSXAttribute indentation looks like this:\n\n  <element\n    attribute=\"value\">\n  </element>\n\nAlternatively, when this variable is also set to 2, JSXAttribute\nindentation looks like this:\n\n  <element\n      attribute=\"value\">\n  </element>\n\nThis variable is like `sgml-attribute-offset'."] 10)
#@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\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) (#$ . 21620))
#@29 Syntax table for `js-mode'.
(defvar js-mode-syntax-table (byte-code "\300 \301
!\210\302\303\304#\210\302\305\306#\210\207" [make-syntax-table c-populate-syntax-table modify-syntax-entry 36 "_" 96 "\""] 5) (#$ . 22292))
#@68 Autogenerated regexp used by `js-mode' to match buffer constructs.
(defvar js--quick-match-re nil (#$ . 22520))
(make-variable-buffer-local 'js--quick-match-re)
#@75 Autogenerated regexp used by `js-mode' to match constructs and functions.
(defvar js--quick-match-re-func nil (#$ . 22687))
(make-variable-buffer-local 'js--quick-match-re-func)
#@62 Last valid buffer position for the `js-mode' function cache.
(defvar js--cache-end 1 (#$ . 22871))
(make-variable-buffer-local 'js--cache-end)
#@54 Latest parse position reached by `js--ensure-cache'.
(defvar js--last-parse-pos nil (#$ . 23020))
(make-variable-buffer-local 'js--last-parse-pos)
#@38 Parse state at `js--last-parse-pos'.
(defvar js--state-at-last-parse-pos nil (#$ . 23173))
(make-variable-buffer-local 'js--state-at-last-parse-pos)
#@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" [flatten-tree mapconcat identity] 9 (#$ . 23329)])
#@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 (#$ . 23817)])
#@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\f\301u\210\207\302`\301d$b\210m\204!\300`\"\262
\301u\210\207" [get-text-property nil next-single-property-change] 7 (#$ . 24745)])
#@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 (#$ . 25145)])
(defalias 'js--forward-pstate #[0 "\300\301!\207" [js--forward-text-property js--pstate] 2])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put js--forward-pstate speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defalias 'js--backward-pstate #[0 "\300\301!\207" [js--backward-text-property js--pstate] 2])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put js--backward-pstate speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn PITEM)
(defalias 'js--pitem-goto-h-end #[257 "\300
8b\210\301\302!\207" [3 js--forward-text-property js--pstate] 3 (#$ . 26059)])
#@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 (#$ . 26201)])
#@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\3051.\211#0\207b\210?\205<\306
@A\"\207" [1 0 js--re-search-backward-inner js--re-search-forward-inner ignore (search-failed) signal] 10 (#$ . 26796)])
#@85 Auxiliary function for `js--re-search-backward'.

(fn REGEXP &optional BOUND COUNT)
(defalias 'js--re-search-backward-inner #[769 "\300\212\301 \205`)\302V\203l\303\"\210`eV\203(\212\304u\210\305\306!)\203(\300u\210\307 \262\3108\203:\3108b\210\202	\3118\204O`Sf\312=\203V\300f\313=\203V\303\314!\210\202	\211\203``
Y\204e\301 \204	S\262\202	\266`\207" [nil js--beginning-of-macro 0 re-search-backward -1 looking-at "/[/*]" syntax-ppss 8 4 47 42 "/\\*"] 8 (#$ . 27394)])
#@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 (#$ . 27897)])
#@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 (#$ . 28336)])
#@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=\205X\3161F\317 \210\3060\202I\210\311\207\205X\310!\210\311f\320=\205X\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 (#$ . 28719)])
#@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#\205_\313 \314\315\"\216\303\224b\210\316 )\262
\205_
`X\205_\211\206_\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-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] js--forward-function-decl] 6 (#$ . 29484)])
#@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=\203o?\205\211\207" [js--ensure-cache nil js--backward-text-property js--pstate 2 function] 3 (#$ . 30319)])
#@168 Helper function for `js--beginning-of-defun-nested'.
If PSTATE represents a non-empty top-level defun, return the
top-most pitem.  Otherwise, return nil.

(fn PSTATE)
(defalias 'js--pstate-is-toplevel-defun #[257 "\211\300\301\300:\203#@\262\3028\303=\203
T\262\262
A\262\202
\304=\205*\211\207" [nil 0 2 function 1] 7 (#$ . 30709)])
#@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\211\211:\2036@\262\3028\303=\203+\304!\203+\3058b\210\262
\301\211\262\202,\306\2036A\262\202\266\203\206l\301\211\211\211\307\310!\262\203j\311!\211\203^\305
8b\210\211\262\301\211\262\202_\306\262
\203j\301\262\202?\266\203\207" [js--parse-state-at-point nil 2 function js--inside-pitem-p 3 t js--backward-text-property js--pstate js--pstate-is-toplevel-defun] 7 (#$ . 31064)])
#@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 (#$ . 31643)])
#@75 Value of `beginning-of-defun-function' for `js-mode'.

(fn &optional ARG)
(defalias 'js-beginning-of-defun #[256 "\211\206\301\262
m\204=\211\302W\203=\211T\262
\204(\303 \304=\204%\305 \203(\306 \210\307\310\311\312#\2037\305 b\210\202db\210\202\211\302V\205w\211S\262
`Sf\313=\203R\314u\210\305 \211\203e\211`W\203e\211b\266\202=\203p\315 \266\202=\316 \266\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 (#$ . 31815)])
#@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 (#$ . 32448) nil])
#@24 

(fn &rest ARGUMENTS)
(defalias 'js--debug '(macro . #[128 "\300\207" [nil] 2 (#$ . 32708)]))
#@31 

(fn OPEN-ITEMS PAREN-DEPTH)
(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 (#$ . 32809)])
#@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 (#$ . 33172)]))
(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)\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\"\216\303\304\305#)\262
\211G\306U\205\211@\307\232?\205%\310\307\"\211\262\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] split-string "\\." t 1 "prototype" remove] 6 (#$ . 34418)])
(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 (#$ . 34924)])
(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`\262

W\205\360\306 \307\211\307\310\311\"\216\312\211\211\211\211\312\211
\312\211:\203D@\262\313\314\"3>\203=

B\262
A\262\202%\211\237\266\203\262\212\214~\210b\210o\204{\315`S\316\"\262\204{\317`\316\312e$b\210o\204{\315`S\316\"\262\204{\320\321!\210\204\2044C\262\322 \262`\262\323 \210e}\210\312\211\211\211\3245\312\307#\203\233\325\224b\262\325\225\262`\262b\210\326\n\n@\"\262\n@\n@A@V\204\311\320\327!\210\330\f@A@\312
%\262	`\262`W\204\260\326\n\n@\"\262\n@\262\331	8\203\373\312\2027\332\333!\203U
\334 \211\262\203U
\307=\203)
\335!\262\203&
6\203)
6\262\202)
\307\262\312f\336=\2044
\320\337!\210\312u\210\340\341\342\343\344\345\307=\203L
\202P
\346!&\2027\3327!\203\262
\347 \210`\262b\210\326\n\n@\"\262\n@\n@A@V\204
\320\327!\210\330\f@A@\312
%\262	`\262`W\204f
\326\n\n@\"\262\n\312	@\350\351\352!C\312\257\2027\3328!\203\347
\353\224b\210\354 \310\355\"\216\334 )\262
\2057\312u\210\340\341\342\343\344\345\346\351\352!!\351\356!C\244&\2027\357\n!\312\211\211:\2035@\262\313\360\">\203*\332\313\361\"!\203*\325\225b\210\340\341\342\f\343\345\346\351\352!!&\262
\312\211\262\202+\307\2035A\262\202\360
\266\204\211\203\221`\262b\210\326@\"\262	@@A@V\204[\320\327!\210\330	
@A@\312%\262\n`\262	`W\204B\326@\"\262\211B\262\362`S`\316$\266\202\225b\266\312\262
\202\227\266b\210`\262
b\210\326@\"\262@@A@V\204\277\320\327!\210\330@A@\312	%\262`\262`
W\204\247\326@\"\2629\211:+\266\206,\262
\207" [js--cache-end buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search js--class-styles buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil 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 0 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 #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] 2 js--syntactic-context-from-pstate :contexts :class-decl put-text-property js-enabled-frameworks js--initial-pitem js--quick-match-re-func js--guess-function-name-start js--macro-decl-re js--plain-method-re js--last-parse-pos js--state-at-last-parse-pos] 29 (#$ . 35914)])
#@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,\307
8\310=\203(\300\262\301\211\262\202-\300\202-\300\262
\204
\203;db\210\301\207\207" [t nil js--re-search-forward "}" js--ensure-cache get-text-property js--pend 2 function] 6 (#$ . 38773)])
#@40 Helper function for `js-end-of-defun'.
(defalias 'js--end-of-defun-nested #[0 "\300\212\301 \211\262\205\302
!\205\303u\210\304 \210`)\300
\203&`W\203&
b\207\305\306\300\307#\203:\310\224b\210\311 \211\262\203&\211\203A\304 \207db\207" [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 (#$ . 39121)])
#@69 Value of `end-of-defun-function' for `js-mode'.

(fn &optional ARG)
(defalias 'js-end-of-defun #[256 "\211\206\301\262
o\204%\211\302W\203%\211T\262
\303 \210\303 \210o\204\304 \210\202\211\302V\205a\211S\262
\2039\305 \210\202%\306 \211\203Z\211`X\203Z\211b\210\307\310!\210\302\224b\210\311 \210\312 \266\202%\313 \266\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 (#$ . 39536)])
#@22 

(fn &optional LIM)
(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 (#$ . 40120)])
#@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 (#$ . 40412)])
#@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 (#$ . 40725)])
(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 (#$ . 41119)])
#@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\225
T=\262
)0\207\210\306\207" [js--dojo-class-decl-re (error) js--up-nearby-list 0 looking-at "\"\\s-*,\\s-*\\[" nil] 3 (#$ . 41422)])
#@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\"\302\303#\207" [apply concat make-closure #[257 "\300\n>\205\303\301\304#\207" [V0 V1 js-enabled-frameworks re-search-forward t] 5 "\n\n(fn LIMIT)"]] 7 (#$ . 41758)])
(defvar js--tmp-location nil 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\267\202\242\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\243\303u\210\313\207\303u\210\305!\210\311\n!\203\226\312\225b\210\305!\210\303f\315>\203l\307!\202~\311	!\203\226
\203y
 \210\312\225b\210\313\203\226\305!\210\303f\310=\203\226\303u\210\305!\210\202Q\303f\316=\205\243\303u\210\313\207\303\207" [most-positive-fixnum js--name-re js--objfield-re nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (91 8 123 74)) forward-comment (91 123) js--forward-destructuring-spec 44 looking-at 0 t 93 (91 123) 125] 4 (#$ . 42285)])
#@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 "\3021j\3031e\214e
}\210\304\305!\210\211\204$\306f\307=\205\\\306u\210\305!\210\310	!\2034\311\312!\210\313\225b\202>\212\314 )\205\\\314\315!\205\\\305!\210\306f\316=\203V\306u\210\317 \210\305!\210\306\262
\202\262
)00\210\202k0\210\202k\210\306\207" [most-positive-fixnum js--name-re (end-of-buffer) (scan-error) t forward-comment nil 44 looking-at #1=#[257 "\211@\211\224
\225\3008\204\3018\206\213\302\303#\207\304A@!\211\242\305=\2033\306AA#\210\211A@\262
\211\204A
\307=\204A\310\202\211
\311\267\202}\312\305\310$\206\211\313\305$\202\211\313\305$\202\211\314\305$\202\211\315\305$\202\211\316\305$\202\211\211\206\204
\307=?\205\211\310\262
\207" [2 3 error "No match %d in highlight %S" eval face add-text-properties t nil #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 71 t 89 prepend 98 append 107 keep 116)) text-property-not-all put-text-property font-lock-prepend-text-property font-lock-append-text-property font-lock-fillin-text-property] 11 2328620] (0 font-lock-variable-name-face) 0 js--forward-destructuring-spec #[0 "\300\301!\207" [#1# (0 font-lock-variable-name-face)] 2] 61 js--forward-expression] 4 (#$ . 43268)])
#@52 JSX font lock faces and multiline text properties.
(defconst js-jsx--font-lock-keywords '((js-jsx--match-tag-name 0 font-lock-function-name-face t) (js-jsx--match-attribute-name 0 font-lock-variable-name-face t) (js-jsx--match-text 0 'default t) (js-jsx--match-tag-beg) (js-jsx--match-tag-end) (js-jsx--match-expr)) (#$ . 44795))
#@58 Match JSXBoundaryElement names, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-tag-name #[257 "\205.\301`\302\303$\303
\205,
`V\205,
b\210\304\302\"\211\262\203)\305
!\266\306\207\307!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-tag-name nil get-text-property set-match-data t js-jsx--match-tag-name] 6 (#$ . 45131)])
#@52 Match JSXAttribute names, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-attribute-name #[257 "\205.\301`\302\303$\303
\205,
`V\205,
b\210\304\302\"\211\262\203)\305
!\266\306\207\307!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-attribute-name nil get-text-property set-match-data t js-jsx--match-attribute-name] 6 (#$ . 45492)])
#@41 Match JSXText, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-text #[257 "\2058\301`\302\303$\303
\2056
`V\2056
b\210\304\302\"\211\262\2033\305
!\210\306
@A@\307\310$\266\310\207\311!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-text nil get-text-property set-match-data put-text-property font-lock-multiline t js-jsx--match-text] 8 (#$ . 45865)])
#@64 Match JSXBoundaryElements from start, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-tag-beg #[257 "\2052\301`\302\303$\303
\2050
`V\2050
b\210\304\302\"\211\262\203-\305A\306\307$\266\307\207\310!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-tag-beg nil get-text-property put-text-property font-lock-multiline t js-jsx--match-tag-beg] 8 (#$ . 46257)])
#@62 Match JSXBoundaryElements from end, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-tag-end #[257 "\2051\301`\302\303$\303
\205/
`V\205/
b\210\304\302\"\211\262\203,\305
\306\307$\266\307\207\310!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-tag-end nil get-text-property put-text-property font-lock-multiline t js-jsx--match-tag-end] 8 (#$ . 46654)])
#@57 Match JSXExpressionContainers, until LIMIT.

(fn LIMIT)
(defalias 'js-jsx--match-expr #[257 "\2051\301`\302\303$\303
\205/
`V\205/
b\210\304\302\"\211\262\203,\305\306\307$\266\307\207\310!\266\202\207" [js-jsx-syntax next-single-char-property-change js-jsx-expr nil get-text-property put-text-property font-lock-multiline t js-jsx--match-expr] 8 (#$ . 47048)])
#@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\327Q\330BB\316\317\331\332$\311\327Q\333BB\334\fP\335\336\211\211FD\337\321Q\340\341DD\342\321Q\340\341DD\343\n\344
R\311\n\345Q\346\347\350FD\331\n\351Q\n\352\353\354FD\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-*[],]" ((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) js-jsx--font-lock-keywords] 19) (#$ . 47428))
#@78 Return whether point is inside the given pitem's header or body.

(fn PITEM)
(defalias 'js--inside-pitem-p #[257 "\300 \210\301
8\204
\302\303!\210\211A@\204\302\304!\210`\3018V\205+\305
8?\206+\305
8`V\207" [js--ensure-cache 3 cl--assertion-failed (js--pitem-h-begin pitem) (js--pitem-paren-depth pitem) 5] 4 (#$ . 49402)])
#@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!)\206C\304\211@\262\3058\306=\204/\307!\204/A\262\304\262
\202\266\211\262
*\207" [js--initial-pitem js--ensure-cache js--backward-text-property js--pstate nil 2 toplevel js--inside-pitem-p] 5 (#$ . 49740)])
#@79 Return the JavaScript syntactic context corresponding to PSTATE.

(fn PSTATE)
(defalias 'js--syntactic-context-from-pstate #[257 "\300
@8\211\301>\203\207\211:\203\302\207\303\207" [2 #'macro class toplevel] 4 (#$ . 50238)])
#@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\207" [js--syntactic-context-from-pstate js--parse-state-at-point called-interactively-p interactive message "Syntactic context: %s"] 4 (#$ . 50474) 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\211\211\211\304!\210\305\306#\203\204\307\225\262\307\224b\210	\303\211\211\211\211:\203h@\262\310\311\"\262\310\312\"\n>\203Z\313 \310\314\">\203Z\203Z\315!\203Z\307\225b\210\306\262
\303\211\262\202[\306\203hA\262\303\262\202\266\205\203w\306\262
\303\211\262\202{b\210\306\203\204\303\262\202\207" [js--quick-match-re js--class-styles js-enabled-frameworks nil js--ensure-cache re-search-forward t 0 plist-get :class-decl :framework js-syntactic-context :contexts looking-at] 15 (#$ . 50832)])
#@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) (#$ . 51529))
#@48 Return syntactic face given STATE.

(fn STATE)
(defalias 'js-font-lock-syntactic-face-function #[257 "\303
8\203\207\212\304
8b\210\305\306!)\203	\207\n\207" [font-lock-string-face font-lock-doc-face font-lock-comment-face 3 8 looking-at "/\\*\\*"] 3 (#$ . 51746)])
#@58 Regular expression matching a JavaScript regexp literal.
(defconst js--syntax-propertize-regexp-regexp "/\\(?:[^/[\\]\\|\\\\.\\|\\[\\(?:[^]\\]\\|\\\\.\\)*]\\)*\\(/?\\)" (#$ . 52023))
#@12 

(fn END)
(defalias 'js-syntax-propertize-regexp #[257 "\301 \302
8\303=\205*\304
8b\210\305!\205*
\306\225V\203 \306\225\262\307\306\224\310\311$\210
b\207" [js--syntax-propertize-regexp-regexp syntax-ppss 3 47 8 looking-at 1 put-text-property syntax-table (7 . 47)] 7 (#$ . 52212)])
#@42 Regexp matching unary operator keywords.
(defconst js--unary-keyword-re (js--regexp-opt-symbol '("await" "delete" "typeof" "void" "yield")) (#$ . 52510))
#@73 Check if STRING is a unary operator keyword in JavaScript.

(fn STRING)
(defalias 'js--unary-keyword-p #[257 "
\302\303\304#)\207" [js--unary-keyword-re inhibit-changing-match-data nil t string-match] 8 (#$ . 52670)])
#@135 Extend the START-END region for propertization, if necessary.
For use by `syntax-propertize-extend-region-functions'.

(fn START END)
(defalias 'js--syntax-propertize-extend-region #[514 "\205\301\"\207" [js-jsx-syntax js-jsx--syntax-propertize-extend-region] 5 (#$ . 52900)])
#@325 Extend the START-END region for propertization, if necessary.
If any “>” in the region appears to be the end of a tag starting
before the start of the region, extend region backwards to the
start of that tag so parsing may proceed from that point.
For use by `syntax-propertize-extend-region-functions'.

(fn START END)
(defalias 'js-jsx--syntax-propertize-extend-region #[514 "\303\211\211\3042\252b\210\305\306\307#\205\251\3102\245`S\206`Sf\311=\206)\303f\311=?\205\244\212\312u\210`eU\203<\313\310\303\"\210`Sf\314U\204\225\315\303x\210`eU\203S\313\310\303\"\210`Sf\316>\203o\3171f\320 0\210\2021\210\313\310\303\"\210\2021`Sf\321>\203}\312u\210\2021\322\n\323 \307#\203\215\324\224b\210\2021\313\310\303\"\210\2021`W\205\243`S\262
\313\304\303\")0\210\202\f0\210\211\205\262\211B*\207" [parse-sexp-lookup-properties forward-sexp-function js--dotted-name-re nil stop re-search-forward ">" t continue 62 -1 throw 60 " 	\n" (34 39 96 125) (scan-error) backward-sexp (47 61) looking-back line-beginning-position 0] 7 (#$ . 53189)])
#@52 Regexp unambiguously matching a JSXOpeningElement.
(defconst js-jsx--tag-start-re (concat "\\(" js--dotted-name-re "\\)\\(?:\\(?:\\s-\\|\n\\)*[{/>]\\|\\(?:\\s-\\|\n\\)+" js--name-start-re "\\)") (#$ . 54260))
#@220 Determine if the last “<” was a JSXBoundaryElement and its type.
Return `close' for a JSXClosingElement/JSXClosingFragment match,
return `self-closing' for some self-closing JSXOpeningElements,
else return `other'.
(defalias 'js-jsx--matched-tag-type #[0 "\301f\302U\203\f\301u\210\303\207\301f\304U\203\301u\210\305\207\306!\2056\307\310\311!!?\2056\312\225b\210`Sf\302U\2035\313\207\305\207" [js-jsx--tag-start-re nil 47 close 62 other looking-at js--unary-keyword-p match-string 1 0 self-closing] 3 (#$ . 54476)])
#@62 Regexp matching the end of a self-closing JSXOpeningElement.
(defconst js-jsx--self-closing-re "/\\s-*>" (#$ . 55010))
#@295 Return position of the closer of the opener before point.
Assuming a JSXOpeningElement or a JSXOpeningFragment is
immediately before point, find a matching JSXClosingElement or
JSXClosingFragment, skipping over any nested JSXElements to find
the match.  Return nil if a match can’t be found.
(defalias 'js-jsx--matching-close-tag-pos #[0 "\301\302\211\211\211\3032o\304\305\302\306#\205nm?\205n\307\212\310\311\224!)8\204	\311\224\262\312 \211\262\203	
\203F`\262

b\210\304\313#\203FS\262\2027\314=\203^S\262\311U\203h\315\303\"\210\202h\316=\204hT\262`\262\202	0\207" [js-jsx--self-closing-re 1 nil stop re-search-forward "<\\s-*" t 8 syntax-ppss 0 js-jsx--matched-tag-type move close throw self-closing] 9 (#$ . 55136)])
#@239 Return beginning and end of a JSXElement about point.
Look backward for a JSXElement that both starts before point and
also ends at/after point.  That may be either a self-closing
JSXElement or a JSXOpeningElement/JSXClosingElement pair.
(defalias 'js-jsx--enclosing-tag-pos #[0 "`\300\211\211\211\301\302!\211\262\203a`\262A\262@\303=\203\"W\204a@\304=\203XW\204a\305`\306\"\211\262\204N\212
b\210\307 \262
)\211\203N\310``T\306$\210\211\203a
X\204a\300\262\300\262
\202\205iE\207" [nil js--backward-text-property js-jsx-tag-beg self-closing open get-text-property js-jsx-close-tag-pos js-jsx--matching-close-tag-pos put-text-property] 10 (#$ . 55897)])
#@53 Return t if point is at an enclosing tag’s child.
(defalias 'js-jsx--at-enclosing-tag-child-p #[0 "\212\300 )\211\205
`
A@Y\207" [js-jsx--enclosing-tag-pos] 3 (#$ . 56588)])
#@61 Identify JSXText within a “>/{/}/<” pair.

(fn BEG END)
(defalias 'js-jsx--text-range #[514 "\211Z\300V\205I\212
b\210\301
w\2037`
W\2037\302f\303U\204)\304\305`!!\306U\2031\307``T\310\311$\210\302u\210\202\f)\307\211T\312pE$\210\307\313\314$\207" [0 " 	\n" nil 47 syntax-class syntax-after 7 put-text-property syntax-table (1) js-jsx-text syntax-multiline t] 9 (#$ . 56771)])
#@395 Determine if JSXText is before END and propertize it.
Text within an open/close tag pair may be JSXText.  Temporarily
interrupt JSXText by JSXExpressionContainers, and terminate
JSXText when another JSXBoundaryElement is encountered.  Despite
terminations, all JSXText will be identified once all the
JSXBoundaryElements within an outermost JSXElement’s tree have
been propertized.

(fn END)
(defalias 'js-jsx--syntax-propertize-tag-text #[257 "`\301\3022\221\303\304\305#\205\220\306
`S\"\210`Sf\307U\203z\301\211\31017\212\311u\210`\262\312 \210`\211\262)0\210\2028\210\313T\203GS^\202H\"\210\314\211T\315\206U$\210\314\203d^\202e\316\305$\210\211\203s\211^\202tb\266\202\212`Sf\317U\203\212\311u\210\320\302\301\"\210`\262
\2020)\207" [forward-sexp-function nil stop re-search-forward "[{<]" t js-jsx--text-range 123 (scan-error) -1 forward-sexp js-syntax-propertize put-text-property js-jsx-expr syntax-multiline 60 throw] 9 (#$ . 57171)])
#@50 Like `js--name-re', but matches “-” as well.
(defconst js-jsx--attribute-name-re (concat js--name-start-re "\\(?:\\s_\\|\\sw\\|-\\)*") (#$ . 58162))
#@182 Determine if a JSXBoundaryElement is before END and propertize it.
Disambiguate JSX from inequality operators and arrow functions by
testing for syntax only valid as JSX.

(fn END)
(defalias 'js-jsx--syntax-propertize-tag #[257 "`S\303\304\303\211\211\211\211\3052\240
`W\205\237
\306w\210`W\205\237
\303f\307U\203>\310``T\311\312$\210\303u\210\313\262
\314\305\303\"\210\202\203I\303f\315U\204P\303\211\262\203\311\313\262

\203b\310``T\316$\210\303\262\303\3171u\212\320 \210`\211\262)0\210\202v\210\303u\210`	Y\203\205\314\305\303\"\210\306	w\210`	Y\203\226\314\305\303\"\210\303f\321U\203\244\303u\266\202\322`\203\262S^\202\264\n\"\210\211\203\301\211	^\202\303b\266\202\303f\323U\203\347\304=\203\341\203\336\324\202\337\325\262\303u\210\202\204

\326	!\203

\327\330\331!!\203\376\314\305\303\"\210\331\224\262\332 \262\331\225b\210\202\203\227
\326\n!\203\227
\313\262
\310\331\224\331\224T\333\332 $\210\331\225b\210`Y\2035
\314\305\303\"\210\306w\210`Y\203F
\314\305\303\"\210\303f\334U\203\303u\210`Y\203\\
\314\305\303\"\210\306w\210`Y\203m
\314\305\303\"\210\303f\335>\203\220
\310``T\336\313$\210\3371\207
\320 0\210\202\210\314\305\303\"\210\202\331\224\262\202\314\305\303\"\210\2020\210\211\203\350
\203\262
\310\211T\340$\210\310\211T\311\341$\210m\203\304
`S\202\305
`\262\310\211T\342\nB$\210\310\211T\343\n$\210\310T\344\313$\210\345 \205\361
\346!)\207" [forward-sexp-function js--dotted-name-re js-jsx--attribute-name-re nil open stop " 	\n" 62 put-text-property syntax-table (5 . 60) t throw 123 js-jsx-expr-attribute (scan-error) forward-sexp 125 js-syntax-propertize 47 self-closing close looking-at js--unary-keyword-p match-string 0 match-data js-jsx-attribute-name 61 (34 39 96) js-jsx-string (scan-error) js-jsx-tag-name (4 . 62) js-jsx-tag-beg js-jsx-tag-end syntax-multiline js-jsx--at-enclosing-tag-child-p js-jsx--syntax-propertize-tag-text] 14 (#$ . 58322)])
#@59 Plist of text properties added by `js-syntax-propertize'.
(defconst js-jsx--text-properties (list 'js-jsx-tag-beg nil 'js-jsx-tag-end nil 'js-jsx-close-tag-pos nil 'js-jsx-tag-name nil 'js-jsx-attribute-name nil 'js-jsx-string nil 'js-jsx-text nil 'js-jsx-expr nil 'js-jsx-expr-attribute nil) (#$ . 60327))
#@18 

(fn START END)
(defalias 'js-syntax-propertize #[514 "
b\210\203
\302	#\210\303
!\210`\211b\210`W\205\221\304\305\306#\205\221\307\224\203V\310u\210\311\224f\312>\203F\212\311\224b\210\313`[!\210`Sf\314>)\203\315\307\224\307\225\316\317$\210\303!\210\202\320\224\203g\315\320\224\320\225\316\321$\210\202\322\224\203\323\324!\211A\325\233\241\210\326
!\266\203\325\212\327\311\224!)8\204\330!\210\202\207" [js-jsx-syntax js-jsx--text-properties remove-text-properties 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) 2 (2097163) 3 match-data ints 8 set-match-data syntax-ppss js-jsx--syntax-propertize-tag] 8 (#$ . 60640)])
#@49 Alist of symbol prettifications for JavaScript.
(defconst js--prettify-symbols-alist '(("=>" . 8658) (">=" . 8805) ("<=" . 8804)) (#$ . 61492))
#@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")) (#$ . 61642))
#@60 Regular expression matching variable declaration keywords.
(defconst js--declaration-keyword-re "\\<\\(const\\|let\\|var\\)\\>" (#$ . 61868))
#@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) (#$ . 62016))
#@59 Non-nil if a JSXOpeningElement immediately follows point.
(defalias 'js-jsx--looking-at-start-tag-p #[0 "\300`\301\"\211\205\f\211@\302>\207" [get-text-property js-jsx-tag-beg (open self-closing)] 3 (#$ . 62269)])
#@74 Return non-nil if point is on a JavaScript operator, other than a comma.
(defalias 'js--looking-at-operator-p #[0 "\303 \304\305\"\216\306!\205k\307f\310=\2033\212\311 \210`Sf\312U\203#\313 \210\314\315\307\316#\205/\307f\317=)\205k\307f\320=\205B\212\321\322 8)\320=?\205k\307f\323=\205`\306\324	\325Q!\205`\212\311 \210`Sf\326>)?\205k\n\205j\327 ?)\207" [js--indent-operator-re js--name-re js-jsx-syntax match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] looking-at nil 58 js--backward-syntactic-ws 41 backward-list js--re-search-backward "[?:{]\\|\\_<case\\_>" t 63 47 3 syntax-ppss 42 "\\* *\\(?:\\[\\|" " *(\\)" (44 125 123) js-jsx--looking-at-start-tag-p] 5 (#$ . 62490)])
#@70 Move backward to the nearest newline that is not in a block comment.
(defalias 'js--find-newline-backward #[0 "\300\211
\2031\301\262\302\303\301\300#\203+\304 \305
8\203'\306
8b\210\307
8\204'\300\262\210\202\301\262
\202\207" [t nil search-backward "\n" syntax-ppss 4 8 7] 6 (#$ . 63219)])
#@60 Non-nil if a JSXClosingElement immediately precedes point.
(defalias 'js-jsx--looking-back-at-end-tag-p #[0 "\300`\301\"\207" [get-text-property js-jsx-tag-end] 3 (#$ . 63527)])
#@61 Return non-nil if the current line continues an expression.
(defalias 'js--continued-expression-p #[0 "\212\301 \210\302 \2033\303f\304=\203\305\306`T!8?\307u\210\202k\303f\310>?\206k\311`[!\210`Sf\312>?\202k\313 \205k\314\303x\210\205B\315 ?\205ko\204M\307u\210`eV\205k\212\307u\210\316\317!)?\205k\302 \205k\307u\210\316\320!?)\207" [js-jsx-syntax back-to-indentation js--looking-at-operator-p nil 47 3 syntax-ppss -1 (45 43) forward-comment (44 91 40) js--find-newline-backward " 	" js-jsx--looking-back-at-end-tag-p looking-at "[/*]/\\|=>" "\\+\\+\\|--\\|/[/*]"] 3 (#$ . 63711)])
#@59 Skip a term before point; return t if a term was skipped.
(defalias 'js--skip-term-backward #[0 "\301\302\211\203!\301\262
\303\304!\210`Sf\305>\203\302\262
\302\262\306 \210\202\210`\303\307!\310W\203<\311!\203<\302\262\303\304!\266\202@\211b\266\211\205Q`eV\205Q\312u\210\301f\313=\207" [js--name-re nil t skip-syntax-backward " " (93 41 125) backward-list "w_" 0 looking-at -1 46] 4 (#$ . 64315)])
#@149 Skip any number of terms backward.
Move point to the earliest "." without changing paren levels.
Returns t if successful, nil if no term was found.
(defalias 'js--skip-terms-backward #[0 "\300 \205`\300 \203`\262
\202\211b\210\301\262
\207" [js--skip-term-backward t] 2 (#$ . 64738)])
#@410 A helper for js--proper-indentation that handles chained expressions.
A chained expression is when the current line starts with '.' and the
previous line also has a '.' expression.
This function returns the indentation for the current line if it is
a chained expression line; otherwise nil.
This should only be called while point is at the start of the line's content,
as determined by `back-to-indentation'.
(defalias 'js--chained-expression-p #[0 "\205\212\301f\302=\205\303 \205\304 \205\305 \205i)\207" [js-chain-indent nil 46 js--continued-expression-p js--find-newline-backward js--skip-terms-backward] 2 (#$ . 65036)])
#@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\"\216\303\304!\205]\212\305\306x\210\303\307!)\203)\212\310 \210\311\312!\210\303\313!)\202]\314\313\315 \316#\210\303\313!\206]\317 \314\320\306\316#\203G\317 
U\2038\303\321!\205[\322\323\324 \316#?\205[\317 
U\262
)\262
)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] looking-at "\\s-*\\_<while\\_>" " 	\n}" nil "[ 	\n]*}" 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] 6 (#$ . 65680) 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#\205Gm\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 (#$ . 66565)])
#@22 

(fn SYMBOL ANCHOR)
(defalias 'js--get-c-offset #[514 "\302BC\303BC!)\207" [js-comment-lineup-func c-offsets-alist c c-get-syntactic-indentation] 5 (#$ . 67277)])
#@12 

(fn POS)
(defalias 'js--same-line #[257 "\211\300 Y\205\211\301 X\207" [point-at-bol point-at-eol] 3 (#$ . 67451)])
#@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	!?\205`\305\n!\203\306\225b\210\307\310 8\203$\211b\210\210\211\204so\204s`\212\311 \210`Sf\312=\206[`Sf\313=\204X\314\315!\210\305\n!\311 \210\203X`Sf\313=?\206[\316
!)\262
\203s\3171l\320 0\210\202%\210\321\262
\202%\305	!\205\306\225b\210iT*\207" [forward-sexp-function js--declaration-keyword-re js--indent-operator-re nil back-to-indentation looking-at 0 3 syntax-ppss js--backward-syntactic-ws 44 59 skip-syntax-backward "." js--same-line (scan-error) backward-sexp t] 5 (#$ . 67578)])
#@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 "`\212
b\210\301\302!\205a\303u\210\304 \210\301\305!\203=\306\30717\310 \210\304 \210\306f\311U?\2053\301\312!\2053\313\2240\2029\210\306)\202a\211`V\205a\314\315\316#\205a\317`\"\211@\303U\205Z\320
8?\262
\205a\303\224)\207" [forward-sexp-function looking-at "\\[" 1 js--forward-syntactic-ws "[[{]" nil (scan-error) forward-sexp 44 "for" 0 re-search-forward "[^,]]* \\(for\\_>\\)" t parse-partial-sexp 8] 6 (#$ . 68362)])
#@24 

(fn BRACKET FOR-KWD)
(defalias 'js--array-comp-indentation #[514 "\300
!\203\212
b\210\301u\210\302\303w\210i)\207\212\211b\210i)\207" [js--same-line 1 " 	" nil] 4 (#$ . 68988)])
#@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\267\202W\305	!\205X\306\225Tb\207\211A@\307\211\211\211
\305	!\205U\306\225\262\212b\210\31014\311 \210\3120\2026\210\307\262\203M\313\314!\204<\315\312\305
!)\262
\262
)\211\205UTb)\207\307\207" [js-indent-first-init js--declaration-keyword-re forward-sexp-function inhibit-changing-match-data #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 6 dynamic 17)) looking-at 0 nil (error) forward-sexp t forward-comment 1 ","] 9 (#$ . 69178)])
#@110 Regexp matching the last "=>" (arrow) token on a line.
Whitespace and comments around the arrow are ignored.
(defconst js--line-terminating-arrow-re "=>\\s-*\\(/[/*]\\|$\\)" (#$ . 69959))
#@170 Helper function for `js--proper-indentation'.
Return non-nil if the last non-comment, non-whitespace token of the
current line is the "=>" token (of an arrow function).
(defalias 'js--broken-arrow-terminates-line-p #[0 "`\301\210\302\303#\207" [js--line-terminating-arrow-re nil re-search-backward t] 5 (#$ . 70154)])
#@50 Determine JSX context and move to enclosing JSX.
(defalias 'js-jsx--context #[0 "`\300 \301 \211\205,
A@W\203%\3028\203\303\3048D\207\305
@A@E\207\306
@\3078E\207" [syntax-ppss js-jsx--enclosing-tag-pos 3 string 8 tag text 2] 7 (#$ . 70481)])
#@136 Calculate indentation column for LINE from CONTEXT.
The column calculation is based off of `sgml-calculate-indent'.

(fn LINE CONTEXT)
(defalias 'js-jsx--contextual-indentation #[514 "\211@\211\304\267\202\226`A@V\203\305y\306U\203\307\310!\204`A@V\203(\311 \207
A@b\210iT\207\203O\3128b\210\313 U\203O\314\315\316 \"\203O
A@b\210i\207
A@b\210\317\320w\210\321\320w\210\317\320w\210l\204fi\207
A@	\\b\210i\n\206s\\\207
A@b\210i\3128\203\213\313\3128!W\203\223\n\206\224\202\224\306\\\207\320\207" [js-jsx-align->-with-< js-jsx-attribute-offset js-jsx-indent-level js-indent-level #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 8 tag 48 text 117)) -1 0 looking-at "[ 	]*$" current-indentation 2 line-number-at-pos looking-back "^\\s-*/?>" line-beginning-position " 	" nil "^ 	\n"] 8 (#$ . 70740)])
#@71 Return position of enclosing “{” in a “{/}” pair about point.
(defalias 'js-jsx--enclosing-curly-pos #[0 "\300\301\302 8!\303\211@\211\262\203&
f\304U\203
\211\262\204&A\211\262\204\207" [reverse 9 syntax-ppss nil 123] 5 (#$ . 71616)])
#@71 Set point to enclosing “{” at or closest after LIMIT.

(fn LIMIT)
(defalias 'js-jsx--goto-outermost-enclosing-curly #[257 "\300\301 \211\262\205\211Y\205\211b\205\211V\205\202
\207" [nil js-jsx--enclosing-curly-pos] 4 (#$ . 71877)])
#@69 Look back from START to LIMIT for a JSXAttribute.

(fn START LIMIT)
(defalias 'js-jsx--expr-attribute-pos #[514 "\212
b\210\300
!\210\301`\302\")\207" [js-jsx--goto-outermost-enclosing-curly get-text-property js-jsx-expr-attribute] 5 (#$ . 72132)])
#@48 Baseline column for JS indentation within JSX.
(defvar js-jsx--indent-col nil (#$ . 72387))
#@60 Line relative to which indentation uses JSX as a baseline.
(defvar js-jsx--indent-attribute-line nil (#$ . 72485))
#@311 Indent using PARSE-STATUS; relative to POS, use base COL.
To indent a JSXExpressionContainer’s expression, calculate the JS
indentation, using JSX indentation as the base column when
indenting relative to the beginning line of the
JSXExpressionContainer’s JSXAttribute (if any).

(fn PARSE-STATUS POS COL)
(defalias 'js-jsx--expr-indentation #[771 "\211
\205	\302!\303!*\207" [js-jsx--indent-col js-jsx--indent-attribute-line line-number-at-pos js--proper-indentation] 5 (#$ . 72607)])
#@205 Helper function for `js--proper-indentation'.
Return the proper indentation of the current line if it is part
of a JSXElement expression spanning multiple lines; otherwise,
return nil.

(fn PARSE-STATUS)
(defalias 'js-jsx--indentation #[257 "\301 \302 \303\211\211\211\211\211\212\304 \211\262\203;\204%\262\205#`W\262\301 \262
U\203;\203\f`V\204\f)\205eV\205e\212\305\"\262
)\203d\306\307A@\"#\202e\211)\207" [forward-sexp-function line-number-at-pos js-jsx--enclosing-curly-pos nil js-jsx--context js-jsx--contextual-indentation js-jsx--expr-indentation js-jsx--expr-attribute-pos] 13 (#$ . 73109)])
#@72 Return the proper indentation for the current line.

(fn PARSE-STATUS)
(defalias 'js--proper-indentation #[257 "\212\306 \210\307
8\203\310\311\3128\"\202R
\313
8\203\314\202R
\203-	\204-\212\315
!)\206R
\316f\317=\203I\212\320u\210\n\321\322
!)\262
)\203I\314\202R
\212\323 )\203T\307\202R
\211A@\316
\205v\324!?\205v\325!\211\262\205v`
Y\205v\326\"\266\202\206R
\327 \206R
\330 \206R
\331 \206R
\211A@\203C
\322\332!\322\333!\334 A@b\210\f\203\261\322\335!\204\261\212\316u\210\336 )\2032
\337\340!\210`Sf\341=\203\300\342 \210\306 \210\343!\210?\205\317\322\344!\206\330\205\330\211
\203\347
\345 =\203\347	\202\350i
\203\360\314\202
\203\376\346*_+\\\202
*A@f\211\347\267\202
,\202
-\202
.\202
\316\262
\\\\\203,
\211/\\\266\206\202R
\211\266\206\202R
\204=
\316u\210\350\316w\210i\266\203\202R
\334 \203P
*+\\\202R
\351 )\207" [js-jsx-syntax js-jsx--indent-col cpp-font-lock-keywords-source-directives inhibit-changing-match-data js-indent-align-list-continuation js-jsx--indent-attribute-line back-to-indentation 4 js--get-c-offset c 8 3 0 js-jsx--indentation nil 35 1 t looking-at js--beginning-of-macro js--same-line js--indent-in-array-comp js--array-comp-indentation js--chained-expression-p js--ctrl-statement-indentation js--multi-line-declaration-indentation "[]})]" "default\\_>\\|case\\_>[^:]" js--continued-expression-p "[({[]\\s-*\\(/[/*]\\|$\\)" js--broken-arrow-terminates-line-p skip-syntax-backward " " 41 backward-list js--maybe-goto-declaration-keyword-end "\\_<switch\\_>" line-number-at-pos 2 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (40 267 91 272 123 277)) " 	" prog-first-column js-indent-level js-expr-indent-offset js-paren-indent-offset js-square-indent-offset js-curly-indent-offset js-switch-indent-offset] 11 (#$ . 73757)])
#@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 (#$ . 75622) nil])
#@44 Indent the current line as JavaScript+JSX.
(defalias 'js-jsx-indent-line #[0 "\301\302 )\207" [js-jsx-syntax t js-indent-line] 1 (#$ . 75894) nil])
(defvar js--filling-paragraph nil)
#@15 

(fn JS-FUN)
(defalias 'js--fill-c-advice #[257 "\300\301\"\207" [make-closure #[385 "	\203	\300
@!\207\302\"\207" [V0 js--filling-paragraph apply] 5 "\n\n(fn ORIG-FUN &rest ARGS)"]] 4 (#$ . 76084)])
(byte-code "\300\301\302\303\304!#\210\300\305\302\303\306!#\210\300\307\302\303\310!#\210\311\312\313\314#\210\315\312\313\316#\207" [advice-add c-forward-sws :around js--fill-c-advice js--forward-syntactic-ws c-backward-sws js--backward-syntactic-ws c-beginning-of-macro js--beginning-of-macro defalias js-c-fill-paragraph js-fill-paragraph nil make-obsolete "27.1"] 5)
#@65 Fill the paragraph for Javascript code.

(fn &optional JUSTIFY)
(defalias 'js-fill-paragraph #[256 "\302\303\303
!*\207" [fill-paragraph-function js--filling-paragraph t c-fill-paragraph] 3 (#$ . 76667) "*P"])
(defalias 'js-do-auto-fill #[0 "\301\302 )\207" [js--filling-paragraph t c-do-auto-fill] 1])
#@14 

(fn PITEM)
(defalias 'js--pitem-format #[257 "\300
8\3018\302\303:\204\202\304\305\"#\207" [4 2 format "name:%S type:%S" plist-get :name] 9 (#$ . 76979)])
#@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 (#$ . 77152)])
#@68 Last part of the name of PITEM, as a string or symbol.

(fn PITEM)
(defalias 'js--pitem-strname #[257 "\300
8\211:\203
\301
!@\207\207" [4 last] 4 (#$ . 77687)])
#@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\203c\306@!\232\203E\307@#AB\262

\203?

\241\210\202c\211\262\202c@C\262

\203U

\241\210\202X\211\262\211\262A\211\262\204\203i\207A\203\202\310\311\312\301\n\nA#\313\314\n&\202\204B\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 (#$ . 77857)])
#@85 Copy `js--pitem' PITEM, and push CHILD onto its list of children.

(fn PITEM CHILD)
(defalias 'js--pitem-add-child #[514 "\300
8\250\204\301\302!\210\303
8:\2039\303
8\304\305:\203/@\262
;\211\262\203/A\262\202\211\2054\305\266\203\202:\305\204A\301\306!\210\303
8\3078
\243\203W\310@#\266\202\202}\211:\203w\311
\312\"\203w
:\204l\301\313!\210\310@#\266\202\202}@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 (#$ . 78657)])
#@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 (#$ . 79326)])
#@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\226\3018\262\302!\262
\303=\203-\304\305\211@T\240\"\262\306>\203M\3078\250\204>\310\311!\210
\312\3078!BB\262\202:\203\216\313@\"\262
\211\203h

BB\262\202\3078\203\3078\250\204y\310\314!\210\315\312\3078!BC\262


BB\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"] 11 (#$ . 79536)])
#@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\205I	\305C
A\2036\306A@@\"AAB\262\202!
G\307U\204A\303\310!\210\311@@\"\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 js--pitem-add-child 1 (= (length state) 1) js--pitems-to-imenu] 5 (#$ . 80270)])
#@14 

(fn PARTS)
(defalias 'js--which-func-joiner #[257 "\300\301\302#\207" [mapconcat identity "."] 5 (#$ . 80753)])
#@29 

(fn ITEMS PREFIX SYMBOLS)
(defalias 'js--imenu-to-flat #[771 "\300
:\203K
@\262
\301
!\203\302
A@\303Q#\210\202D
@P\211\304\305\"\203;\306\307T\211\262#\262\202%\310A#\266
A\262\202\300\207" [nil imenu--subalist-p js--imenu-to-flat "." 0 gethash format "%s<%d>" puthash] 13 (#$ . 80874)])
#@239 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\211:\2034@\262rq\210\307\310!\205 \311 )\262\312\313#\210A\262\306\262
\202)\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 ""] 9 (#$ . 81198)])
#@40 History of entered JavaScript symbols.
(defvar js--symbol-history nil (#$ . 81764))
#@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\"\"\210\211\242\237\262
\304\310\311&\211\312\"B\207" [ido-mode 1 -1 ido-completing-read nil maphash make-closure #[514 "\300\300\242B\240\207" [V0] 5 "\n\n(fn KEY --CL-VAR--)"] t js--symbol-history gethash] 10 (#$ . 81855)])
(defalias 'js--guess-symbol-at-point #[0 "\300\301!\211\205!\212\211@b\210`Sf\302=\203\303u\210\211`\240\210)\211@
A{\207" [bounds-of-thing-at-point symbol 46 -1] 3])
#@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 (#$ . 82703) "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\"\304\305\304\211\306\307\304\"!\262db\210\310	\"\2036\305\262
\304\211\262\2027\305\203T\311V\203T\312\n\304\305$\210\302\n!b\210\304\262\202\203g\313\314\315\316\f\"C\"\266\304\202j\211\266\206)\207" [process-buffer marker-position process-mark time-add nil t float-time time-subtract looking-back 0 accept-process-output signal js-moz-bad-rpc format "Timed out waiting for output matching %S"] 15 (#$ . 83502)])
#@72 compiler-macro for inlining `js--js-handle-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (and (memq (type-of cl-x) cl-struct-js--js-handle-tags) t)) nil] 9 (#$ . 84323)])
(put 'js--js-handle-p 'compiler-macro 'js--js-handle-p--cmacro)
#@13 

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

(fn CL-WHOLE-ARG CL-X)
(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 (progn (or (js--js-handle-p cl-x) (signal 'wrong-type-argument (list 'js--js-handle cl-x))) (aref cl-x 1))) nil] 9 (#$ . 84963)])
(put 'js--js-handle-id 'compiler-macro 'js--js-handle-id--cmacro)
#@61 Access slot "id" of `js--js-handle' struct CL-X.

(fn CL-X)
(defalias 'js--js-handle-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-js--js-handle-tags type-of signal wrong-type-argument js--js-handle 1] 5 (#$ . 85369)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put js--js-handle-id side-effect-free t 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)"]] 5)
#@78 compiler-macro for inlining `js--js-handle-process'.

(fn CL-WHOLE-ARG CL-X)
(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 (progn (or (js--js-handle-p cl-x) (signal 'wrong-type-argument (list 'js--js-handle cl-x))) (aref cl-x 2))) nil] 9 (#$ . 85842)])
(put 'js--js-handle-process 'compiler-macro 'js--js-handle-process--cmacro)
#@66 Access slot "process" of `js--js-handle' struct CL-X.

(fn CL-X)
(defalias 'js--js-handle-process #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-js--js-handle-tags type-of signal wrong-type-argument js--js-handle 2] 5 (#$ . 86273)])
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\"\207" [function-put js--js-handle-process side-effect-free t 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] 5)
#@92 compiler-macro for inlining `make-js--js-handle'.

(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 (record 'js--js-handle id process))] 12 (#$ . 86818)])
(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)" record js--js-handle] 7 (#$ . 87442)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-js--js-handle side-effect-free t cl-struct-define js--js-handle nil cl-structure-object record ((cl-tag-slot) (id nil :read-only t) (process nil :read-only t)) cl-struct-js--js-handle-tags] 11)
#@10 

(fn X)
(defalias 'js--js-handle-expired-p #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306 =?\207" [cl-struct-js--js-handle-tags type-of signal wrong-type-argument js--js-handle 2 inferior-moz-process] 5 (#$ . 88163)])
#@62 Maps Elisp JavaScript proxy objects to their JavaScript IDs.
(defvar js--js-references nil (#$ . 88396))
#@41 The most recent MozRepl process object.
(defvar js--js-process nil (#$ . 88507))
#@50 Idle timer for cleaning up JS object references.
(defvar js--js-gc-idle-timer nil (#$ . 88594))
(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") (#$ . 88730))
#@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;\204\n\211\247\203\301
!\207\2119\203\302\303\304!\"\207\305
!>\203B\306
!\203,\307\310!\210\302\311\305!>\204=\312\313\314D\"\210\315H\"\207\316
!\203b\211\242\317=\203Y\302\320\321\322A\323#\"\207\324\321\322\323#\325Q\207\307\326\"\207" [cl-struct-js--js-handle-tags json-encode format "{objid:%S}" symbol-name type-of 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 (#$ . 97103)])
(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 #\210T\211)\207" [inferior-moz-buffer js--js-process js--js-references js--js-repl-depth js--moz-interactor moz-repl-name inferior-moz-process make-hash-table :test eq :weakness t 0 comint-send-string "(" ")\n" js--wait-for-matching-output looking-back js--js-wait-for-eval-prompt match-string-no-properties 1 ".pushInteractor('js')" comint-send-input nil js--js-prompt-regexp js-js-timeout js--js-repl-prompt-regexp] 5])
(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])
#@14 

(fn VALUE)
(defalias 'js--js-not #[257 "\211\300>\207" [(nil null false undefined)] 3 (#$ . 99296)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put js--js-not speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn VALUE)
(defalias 'js--js-true #[257 "\211\211\300>\262
?\207" [(nil null false undefined)] 4 (#$ . 99541)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put js--js-true speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@74 Convert immediate js< and js! references to deferred ones.

(fn ARGLIST)
(defalias 'js--optimize-arglist #[257 "\211\300\211:\203\223@\262
\242\301=\203$\302\303\304\305E\306A!\"
B\262
\202\214
\242\307=\203X\302\303\310\311EA@:\204>A@C\202K\302\303\312\313E\306A@!\"C\306AA!#
B\262
\202\214
\242\314=\203\207
\243\211\242
\243\302\303\315:\203v\303\306!B\202wE\306!\"\266\202\262

B\262
\202\214

B\262
A\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] 13 (#$ . 99798)])
#@34 

(fn CLASS-NAME INTERFACE-NAME)
(defalias 'js--js-get-service '(macro . #[514 "\300\301\302\303BBB\304\301\305FE\207" [js! "Components" "classes" ("getService") js< "interfaces"] 8 (#$ . 100471)]))
#@34 

(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 (#$ . 100678)]))
#@30 

(fn OBJECT INTERFACE-NAME)
(defalias 'js--js-qi '(macro . #[514 "\300\301B\302\303\304FE\207" [js! ("QueryInterface") js< "Components" "interfaces"] 8 (#$ . 100893)]))
#@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 (#$ . 101072)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-js lisp-indent-function 0 put edebug-form-spec t] 5)
#@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 (#$ . 102596))
#@15 

(fn RESULT)
(defalias 'js--js-decode-retval #[257 "\301
@!\211\302\267\202<
A@\207\301A@!\207\303\304A@\"\207\305A@\"\206@\306A@\307\310A@\311\312 $#\207\313\314A@C\"\207\315\316\"\207" [js--js-references intern #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (atom 10 special 14 array 20 objid 27 error 52)) mapcar js--js-decode-retval gethash puthash make-js--js-handle :id :process inferior-moz-process signal js-js-error error "Unmatched case in js--js-decode-retval: %S"] 9 (#$ . 102762)])
#@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#\210b\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 (#$ . 103314)])
#@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 (#$ . 104345)])
#@19 

(fn THISOBJ JS)
(defalias 'js--js-eval #[514 "\300\301#\207" [js--js-funcall (interactor "_callEval")] 6 (#$ . 104626)])
#@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 (#$ . 104757)])
#@20 

(fn &rest PROPS)
(defalias 'js--js-get #[128 "\300\301\302#\207" [apply js--js-funcall (interactor "_getProp")] 5 (#$ . 104994)])
#@20 

(fn PROPS VALUE)
(defalias 'js--js-put #[514 "\300\301#\207" [js--js-funcall (interactor "_putProp")] 6 (#$ . 105133)])
#@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\205^\306\303!\205^\307!\205^=?\205^rq\210\212db\210\310\f\212\311y\210`)\"*\205^\305C\312\313\314\"\n\"\210\211\242\237\262
\262\315\316\206M\317\"\262
\320\321!\203]\322\323\"\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-closure #[514 "\300\300\242B\240\207" [V0] 5 "\n\n(fn X --CL-VAR--)"] js--js-funcall (repl "_jsGC") [] called-interactively-p interactive message "Cleaned %s entries"] 9 (#$ . 105264) 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 (#$ . 106037) "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\211\304\317D!\211\211\320>\262
?\262
\203\205\304\321D!\262\322\311\312\313D\323\324\257\311\325\326ED\311\312\313D\327F\311\312\313D	\330F%\262
AAA@\211\211\320>\262
?\262
\204
\331
8\262
\332=\204
B\262\303\262
\202\266\211\303\211\211\211\211\211\211:\203$
@\262\211A\262\242\262\211A\262\242\262@\262EB\262\333\334\"\262\335!>\203
\336\333\337\340#\303W\203
\322\311\312\313D\337\341\324\257\311\337\342\325\326\257D\311\312\313D	\337	\257\311	\343\344\345FE	%
B\262
T\262\202\315\211\237\266\203\237\244\262A\262\303\262
\202\217\237\266\210\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" type-of 0 "browsers" "length" "contentDocument" "contentWindow" "tabContainer" "childNodes" "item"] 21 (#$ . 106458)])
(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\211:\203f@\262\313\314A@@#\262\315\316\n\303#T	#\262\317V\203U\313\320#\262BB\262A\262\307\262
\202$
\237\266\207\240\210\321\322\"\323\321\324$\321\325#\321\326#\216\211	B\327	\330\331\242\"\307\332\307\333&)\262)\334\333\"\210\242\307\211\211:\203\315@\262@\232\203\302A\262
\307\211\262\202\303\332\203\315A\262\202\246\266\203\262AAA@\203\335\335\202\336\336AA@B\266\210)\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-closure #[257 "\300\242\301\211\211:\203+@\262@\232\203 A\262
\301\211\262\202!\302\203+A\262\202\207" [V0 nil t] 7 "\n\n(fn CNAME)"] #[514 "\301AAA@\203\302C\262
\303
B\262
\203*\304
B\262
\202*AA@\203*\305
B\262

AAA@\203?\306
B\262
\307
B\262
\202K
AA@\203K\310
B\262
\311\312\313\237BD\314\"\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 t] 7 "\n\n(fn HITAB UNHITAB)"] #[0 "\301@!\302
\300\242\"\210\300
\240\207" [V0 V1 V2 ido-matches] 4] #[0 "\300\n@!\211\203g\211AAA@\204g\304
AA@\305\306\307F\310\"\311\232\203g\312
AA@\313\314#\n\315\211\211\211\211:\203e@\262\300!\262AAA@=\203W\316\"\317\262
\315\211\262\202X\317\203eA\262\315\262\202.\266\210\320\321\301\317\211$\207" [V0 V1 ido-matches ido-cur-list js--js-funcall "document" "documentElement" "getAttribute" "windowtype" "navigator:browser" js--js-get "gBrowser" "selectedTab" nil ido-chop t add-hook post-command-hook] 11] #[0 "\300\242\205\301\302\300\242\"\210\300\302\240\207" [V0 V1 nil] 3] ido-completing-read mapcar car t js-read-tab-history add-to-history browser window] 19 (#$ . 108112)])
#@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\301
A@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 (#$ . 110761)])
#@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 (#$ . 111294))
(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 (#$ . 112226) (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\203D\303A!\204D@\211\304\267\202;\305A\306\"\211\211\307>\262
?\262
\202?\305A\310\"\211\211\307>\262
?\262
?\202?\311\312\"\262
\203H\313\314!)\207" [js--js-context js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] js--js-handle-expired-p #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (window 24 browser 41)) js--js-get "closed" (nil null false undefined) "contentDocument" error "Unmatched case in js--get-js-context: %S" js--read-tab "JavaScript Context: "] 5 (#$ . 112488)])
#@16 

(fn CONTEXT)
(defalias 'js--js-content-window #[257 "\300 \210\301\216\211@\211\302\267\202
A\202\303A\304\305#\202\306\307\"\262
)\207" [js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (window 13 browser 18)) js--js-get "contentWindow" "wrappedJSObject" error "Unmatched case in js--js-content-window: %S"] 6 (#$ . 113185)])
#@13 

(fn PATH)
(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 (#$ . 113621)])
#@19 

(fn ALIAS 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 (#$ . 114019)])
#@59 Update a Mozilla tab using the JavaScript defun at point.
(defalias 'js-eval-defun #[0 "\3032D
\212\304\211\211\211\211C\304\305 \210`\262\306 \210\307 \210\310\311!\210\312\224\262\313\314!\262\203/`V\2033\315\316!\210\317!\262\320\"\321
\322\323#\210\324\325\"\216\326\327\330\331\332\333#\"!\204`\334\335!\210\336\303\304\"\210)\210\337\"\262
\340\341\"\210\342\343\"\210
\344\345P\304\346#\240\210\324\347\"\216\350 \210\351\216\352\353\341\"r\211q\210\324\354\"\216	c\210\355c\210p\356!\210)\357c\210
c\210\360c\210\361ed\242\304\362%\210*\210\363\364 !\365
\366\"\365
\367\"\211\211\370>\262
?\262
\203\332\365\371\372D\373E\312\"\202\336\365
\374\"\375\376D\377\201@#\375
\201AD\201B\201C#\210\375
\201AD\201D\327\201E\201F\242!\"#\210\375\201GD\"\210\375\201HD\201I\371\201J\201K\201L\201M#C\201N\242!E\201O$\210\304\240\266\204*\266\206)0\207" [js-js-tmpdir js--js-inserter standard-output --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-closure #[0 "\301\300!\207" [V0 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" #[0 "\300\242\205	\301\300\242!\207" [V0 delete-file] 2] js--js-enter-repl #[0 "\300 \207" [js--js-leave-repl] 1] generate-new-buffer " *temp*" #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] "(" json--print-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 (#$ . 114616) nil])
#@54 If non-nil, print enabled syntaxes in the mode name.
(defvar js-syntactic-mode-name t (#$ . 116838))
#@67 Return a string like “[JSX]” when `js-jsx-syntax' is enabled.
(defalias 'js--syntactic-mode-name-part #[0 "\203\302	\203
\303C\262
\211\203\304\305\306\307#\310Q\207\311\207\311\207" [js-syntactic-mode-name js-jsx-syntax nil "JSX" "[" mapconcat identity "," "]" ""] 6 (#$ . 116945)])
#@181 Print enabled syntaxes if `js-syntactic-mode-name' is t.
Modes deriving from `js-mode' should call this to ensure that
their `mode-name' updates to show enabled syntax extensions.
(defalias 'js-use-syntactic-mode-name #[0 ";\205\n\301B\211\207" [mode-name ((:eval (js--syntactic-mode-name-part)))] 2 (#$ . 117247)])
#@35 Enable JSX in the current buffer.
(defalias 'js-jsx-enable #[0 "\301\300!\210\302\211\207" [js-jsx-syntax make-local-variable t] 2 (#$ . 117573) nil])
#@251 Case-sensitive regexps for detecting JSX in JavaScript buffers.
When `js-jsx-detect-syntax' is non-nil and any of these regexps
match text near the beginning of a JavaScript buffer,
`js-jsx-syntax' (which see) will be made buffer-local and set to
t.
(defvar js-jsx-regexps (list "\\_<\\(?:var\\|let\\|const\\|import\\)\\_>.*?React") (#$ . 117732))
#@271 Detect if JSX is likely to be used, and enable it if so.
Might make `js-jsx-syntax' buffer-local and set it to t.  Matches
from the beginning of the buffer, unless optional arg ARBITRARILY
is non-nil.  Return t after enabling, nil otherwise.

(fn &optional ARBITRARILY)
(defalias 'js-jsx--detect-and-enable #[256 "\303 \203\304\303 \305\306\307#)\266\203\2041	\2055\212\211\204\"eb\210\3102-\311\312\n\"\210\3050)\2055\313 \210\306\207" [inhibit-changing-match-data js-jsx-detect-syntax js-jsx-regexps buffer-file-name "\\.jsx\\'" nil t string-match match mapc #[257 "\301\302
\303\304#)\205\305\306\304\"\207" [case-fold-search nil re-search-forward 4000 t throw match] 5 "\n\n(fn REGEXP)"] js-jsx-enable] 8 (#$ . 118087)])
#@133 Detect if JSX is likely to be used after a change.
This function is intended for use in `after-change-functions'.

(fn BEG END LEN)
(defalias 'js-jsx--detect-after-change #[771 "
\300X\205\212b\210\301 \210\214`}\210\302\303!\205\304\305\306\307#*\207" [4000 beginning-of-line js-jsx--detect-and-enable arbitrarily remove-hook after-change-functions js-jsx--detect-after-change t] 7 (#$ . 118833)])
(byte-code "\300\301\302\"\210\303\304\305\306BC\307#\207" [c-add-language js-mode java-mode c-define-lang-constant c-paragraph-start (js-mode-mode) #[0 "\300\207" [#1="\\(@[[:alpha:]]+\\>\\|$\\)"] 1 #1#] (cc-langs)] 4)
(defvar js-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [js-mode-hook variable-documentation put "Hook run after entering JavaScript mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp js-mode-map definition-name js-mode] 4)
(defvar js-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\210\303\311\323\324#\207" [js-mode-abbrev-table js-mode-map variable-documentation put purecopy "Keymap for `js-mode'." boundp js-mode-syntax-table definition-name js-mode (lambda (#1=#:def-tmp-var) (defvar js-mode-syntax-table #1#)) make-syntax-table "Syntax table for `js-mode'." (lambda (#1#) (defvar js-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `js-mode'." derived-mode-parent prog-mode custom-mode-group js] 5)
#@218 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 or penultimate
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
@\311\331\211A\306\332!\210\306\333!\210\306\334!\210\306\335!\210\306\336!\210\306\337!\210\306\340!\210\3411\357B\342=\203\305\332\262\343\333\262\344\334\262\345\335\262\346\336\262\331\337\262\347\340\262\350 \351\262\352\353! )\354\262\355,\356\262\357\360\211A\204\322\361\362!\210A\363N\211\204\340\361\364A\"\210\365
P!\266\202J\262
!,\331
\203

@\262

A\262\366
@A#\210\202\356\266\203.\367\262\370\211<\203
\211\202
\211C\262
7\371\262\372\211<\203*
\211\202,
\211C\262
9\373\262\374C;\375\262\331=\376\262\331>\377\262\331?\201C\262\331C\201D\262\201
D\201E\262\201

E\201F\262\331F\201G\262\331G\201H\262\331H\201I\262\331I\201J\262\331J\201K\262\331K\201L\262\331L\201M\262\331M\201N\262\201
N\201O\262\201
O\201P\262\331P\201Q\262\331Q\201R\262\331R\201S\262\201
S\201T\262\201
T\201U\262\201
U\201V\262\201
V\201W\262\201
W\201X\262\201	
X\201Y\262\201\n
Y\201Z\262\201
Z\201[\262\201
[\201\\\262\331\\\201]\262\331]\201^\262\201\f
^\201_\262\331_\201`\262\331`\201a\262\331a\201b\262\331b\201c\262\201

c\201d\262\331d\201e\262\331e\201f\262\331f\201g\262\331g\201h\262\201
h\201i\262\201
i\201j\262\201
j\201k\262\331k\201l\262\331l\201m\262\201
m\201n\262\201
n\201o\262\201
o\201p\262\201
p\201q\262\201

q\201r\262\201
r\201s\262\201
s\201t\262\201

t\201u\262\201
u\201v\262\201
v\201w\262\201
w\201x\262\201
x\201y\262\201

y\201z\262\201
z\201{\262\201
{\201|\262\201
|\201}\262\201
}\201~\262\201
~\201\262\201
\201\200\262\201
\200\201\201\262\201

\201\201\202\262\201

\202\201\203\262\201
\203\201\204\262\201
\204\201\205\262\201 
\205\201\206\262\201!
\206\201\207\262\201\"
\207\201\210\262\201#
\210\201\211\262\201$
\211\201\212\262\201%
\212\201\213\262\201&
\213\201\214\262\201 
\214\201\215\262\201'
\215\201\216\262\201(
\216\201\217\262\201)
\217\201\220\262\331\220\201\221\262\201*
\221\201\222\262\201+
\222\201\223\262\201,
\223\201\224\262\201-
\224\201\225\262\201.
\225\201\226\262\201/
\226\201\227\262\2010
\227\201\230\262\201
\230\201\231\262\201
\231\201\232\262\201
\232\201\233\262\201
\233\201\234\262\331\234\201\235\262\331\235\201\236\262\331\236\201\237\262\201
\237\201\240\262\201
\240\201\241\262\2011
\241\201\242\262\2012
\242\201\243\262\201
\243\201\244\262\331\244\201\245\262\201
\245\201\246\262\2013
\2014
\331\"\246\201\247\262\2015
\247\201\250\262\2015
\250\201\251\262\201
\251\201\252\262\201
\252\201\253\262\201
\253\201\254\262\201
\254\201\255\262\2016
\255\201\256\262\2016
\256\201\257\262\2017
\257\201\260\262\2018
\260\201\261\262\201
\261\201\262\262\331\262\201\263\262\331\263\201\264\262\2019
\264\201\265\262\201
\265\201\266\262\331\266\201\267\262\201
\267\201\270\262\201
\270\201\271\262\201:
\271\201\272\262\201;
\272\201\273\262\201<
\273\201\274\262\201=
\274\201\275\262\201
\275\201\276\262\201>
\276\201\277\262\201?
\277\201\300\262\201@
\300\201\301\262\331\301\201\302\262\201A
\302\201\303\262\201B
\303\201\304\262\201C
\304\201\305\262\201D
\305\201\306\262\201E
\306\201\307\262\201F
\307\201\310\262\331\310\201\311\262\201G
\311\201\312\262\201H
\312\201\313\262\201I
\313\201\315\262\201J
\331\211\201K
G\201
_\201
\"\314\203\254@@\262@A\262
A\262\201L
\365\314\"\201M
\201N
\2013
\201O
\"\"\"\210\202}\314)\266\203\315\201\316\262\201P
\316\201\317\262\201Q
\317\201\320\262\201

\320\201\321\262\201R
\321\201\322\262\201
\322\201\323\262\201R
\323\201\324\262\331\324\201\325\262\201S
\325\201\326\262\201T
\326\201\327\262\201U
\327\201\330\262\201

\330\201\331\262\201V
\331\201\332\262\201W
\332\201\333\262\201X
\333\201\334\262\331\334\201\335\262\201Y
\335\201\336\262\201Z
\201[
A\204c\361\362!\210A\363N\211\204q\361\364A\"\210\365
P!\266\202!\205\241\201[
\211A\204\211\361\362!\210A\363N\211\204\227\361\364A\"\210\365
P!\266\202J\262
\201\\
\331\2013
\201]
\"\"\201\\
\331\2013
\201^
\"\"\201_
\201`
\201a
\201b
\331\201a
\201c
\"\"C\"\201d
\"\201e
Q\266\203\336\201\337\262\331\337\201\340\262\331\340\201\341\262\201
\341\201\342\262\201

\342\201\343\262\307\343\201\344\262\307\344\201\345\262\201f
\345\201\346\262\201g
\346\201\347\262\307\347\201\350\262\331\350\201\351\262\331\351\201\352\262\331\352\201\353\262\201h
\353\201\354\262\201i
\354\201\355\262\2019
\355\201\356\262\307\356\201\357\262\201j
\357\201\360\262\201k
\360\201\361\262\201k
\361\201\362\262\201

\362\201\363\262\331\363\201\364\262\331\364\201\365\262\331\365\201\366\262\307\366\201\367\262\201l
\211\367\202\352\307\262
\201m
\211\211\205\346\211@\211@\262\211@\352A@!L\210
A\266\202\202\314\262
\262
0\210\202 	\203	\201n
\201o
\203	\201p
\201q
\311\201r
\370$\202	\345$\266\202 	\201s

@A\"\266)\266\306\201\371!\210\201t
\371\306\337!\210\201u
\306\340!\210\201v
 \306\201\372!\210\331\372\306\201\374!\210\373\331\211\211\211\201w
\257\374\306\201\375!\210\201x
\375\201y
\201z
\201{
\201a
\201|
$\210\201y
\201z
\201}
\201a
\201|
$\210\306\201\377!\210\376\377\306\201~
!\210\307~
\306\201
!\210\201\200

\306\333!\210\344\306\335!\210\346\306\334!\210\345\306\201\201
!\210\201\202
\201
\306\201\203
!\210\201\204
\203
\201y
\201\205
\201\206
\307\211$\210\201\207
 \210\201\210
 \204\374	\201y
\201\211
\201\212
\331\307$\210\201\213
 \210\331\243
\201\214
\244
\201\215
 \210\201y
\201\205
\201\216
\331\307$\210\306\201\217
!\210\201\220
\217
\306\201\221
!\210\307\221
\306\201\222
!\210\201a
\201\223
\222
\"\222
\306\201\224
!\210\201\225
\224
\307A\306\201\226
!\210\306\201\227
!\210\306\201\230
!\210\306\201\231
!\210\306\201\232
!\210\201\233
 \210\201\234
\311\245
\"\201\235

!\266\201\236
\246
\201\237
\247
\201\240
 \210*\201\241
\201\242
!\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 nil font-lock-comment-end-skip comment-start comment-end comment-start-skip comment-end-can-be-escaped beginning-of-defun-function end-of-defun-function (error) 5\.35\.1 "[ 	]*\\*/" "// " "" "\\(?://+\\|/\\*+\\)\\s *" c-beginning-of-defun c-end-of-defun c-no-parens-syntax-table eval (lambda nil (let ((table (funcall (lambda nil (let ((table (make-syntax-table))) (c-populate-syntax-table table) (modify-syntax-entry 64 "'" table) table))))) (modify-syntax-entry 40 "." table) (modify-syntax-entry 41 "." table) (modify-syntax-entry 91 "." table) (modify-syntax-entry 93 "." table) (modify-syntax-entry 123 "." table) (modify-syntax-entry 125 "." table) table)) c-identifier-syntax-modifications ((64 . "w") (95 . "w") (36 . "w")) c-identifier-syntax-table copy-syntax-table #10="mode-syntax-table" error "Not inside a CC Mode based mode" c-mode-prefix "%S has no mode prefix known to `c-mode-symbol'" intern modify-syntax-entry c-get-state-before-change-functions (c-parse-quotes-before-change c-before-change-check-unbalanced-strings c-before-change-check-<>-operators) c-before-font-lock-functions (c-depropertize-new-text c-after-change-escape-NL-in-string c-parse-quotes-after-change c-after-change-mark-abnormal-strings c-restore-<>-properties c-change-expand-fl-region) c-before-context-fontification-functions c-context-expand-fl-region c-at-vsemi-p-fn c-vsemi-status-unknown-p-fn c-has-bitfields local-abbrev-table c-buffer-is-cc-mode c-version-sym c-single-quotes-quote-strings c-string-delims c-ml-string-non-punc-skip-chars c-ml-string-opener-re c-ml-string-max-opener-len c-ml-string-any-closer-re c-ml-string-max-closer-len c-ml-string-max-closer-len-no-leader c-ml-string-back-closer-re c-make-ml-string-closer-re-function c-make-ml-string-opener-re-function c-ml-string-cpp-or-opener-re c-cpp-or-ml-match-offset c-has-quoted-numbers c-has-compound-literals c-modified-constant c-symbol-start c-symbol-chars c-symbol-char-key c-symbol-key c-nonsymbol-chars c-nonsymbol-key c-opt-identifier-concat-key c-identifier-start c-identifier-key c-string-escaped-newlines c-multiline-string-start-char c-string-innards-re-alist c-opt-cpp-symbol c-opt-cpp-prefix c-anchored-cpp-prefix c-opt-cpp-start c-cpp-include-key c-opt-cpp-macro-define c-opt-cpp-macro-define-start c-opt-cpp-macro-define-id c-cpp-expr-intro-re c-cpp-expr-functions-key c-operator-re c-non-after-{}-ops-re c-overloadable-operators-regexp c-opt-op-identifier-prefix c-ambiguous-overloadable-or-identifier-prefix-re c-nonsymbol-token-regexp c-assignment-op-regexp c-arithmetic-op-regexp c-:$-multichar-token-regexp c-<>-multichar-token-regexp c-<-op-cont-regexp c-<-pseudo-digraph-cont-regexp c-<-pseudo-digraph-cont-len c->-op-cont-regexp c->-op-without->-cont-regexp c-multichar->-op-not->>->>>-regexp c-:-op-cont-regexp c-stmt-delim-chars c-stmt-boundary-skip-chars c-stmt-boundary-skip-list c-stmt-delim-chars-with-comma c-stmt-boundary-skip-chars-with-comma c-stmt-boundary-skip-list-with-comma c-pack-key c-auto-ops-re c-haskell-op-re c-pre-start-tokens c-pre-lambda-tokens-re c-line-comment-starter c-block-comment-starter c-block-comment-ender c-block-comment-ender-regexp c-block-comment-awkward-chars c-comment-start-regexp c-block-comment-start-regexp c-line-comment-start-regexp c-last-c-comment-end-on-line-re c-literal-start-regexp c-doc-comment-start-regexp c-block-comment-is-default c-syntactic-ws-start c-syntactic-ws-end c-syntactic-eol c-paragraph-start c-paragraph-separate c-return-key c-primitive-type-key c-typedef-key c-typeof-key c-template-typename-key c-type-prefix-key c-opt-type-modifier-prefix-key c-opt-type-modifier-key c-opt-type-component-key c-type-decl-suffix-ws-ids-key c-class-id-suffix-ws-ids-key c-class-key c-brace-list-key c-after-brace-list-key c-recognize-post-brace-list-type-p c-other-decl-block-key c-other-decl-block-key-in-symbols-alist c-defun-type-name-decl-key c-typedef-decl-key c-using-key c-no-type-key c-equals-type-clause-key c-decl-hangon-key c-prefix-spec-kwds-re c-specifier-key c-not-decl-init-keywords c-not-primitive-type-keywords-regexp c-protection-key c-post-protection-token c-opt-block-decls-with-vars-key c-postfix-decl-spec-key c-make-top-level-key c-colon-type-list-re c-paren-nontype-key c-opt-<>-sexp-key c-inside-<>-type-key c-block-stmt-1-key c-block-stmt-1-2-key c-block-stmt-2-key c-block-stmt-hangon-key c-opt-block-stmt-key c-simple-stmt-key c-paren-stmt-key c-opt-asm-stmt-key c-case-kwds-regexp c-label-kwds-regexp c-opt-inexpr-brace-list-key c-brace-stack-thing-key c-brace-stack-no-semi-key c-decl-block-key c-opt-bitfield-key c-std-abbrev-keywords c-keywords-regexp c-stmt-block-only-keywords-regexp obarray c-keywords-obarray c-regular-keywords-regexp c-primary-expr-regexp c-decl-start-colon-kwd-re c-decl-prefix-re c-decl-start-re c-decl-prefix-or-start-re c-dposr-cpp-macro-depth c-cast-parens c-block-prefix-charset c-type-decl-prefix-key c-type-decl-operator-prefix-key c-type-decl-suffix-key c-after-suffixed-type-decl-key c-after-suffixed-type-maybe-decl-key c-opt-type-concat-key c-opt-type-suffix-key c-known-type-key c-special-brace-lists c-recognize-knr-p c-pre-id-bracelist-key c-pre-brace-non-bracelist-key c-recognize-typeless-decls c-recognize-<>-arglists c-<>-notable-chars-re c-enum-clause-introduction-re c-enums-contain-decls c-recognize-paren-inits c-recognize-bare-brace-inits c-recognize-paren-inexpr-blocks c-opt-<>-arglist-start c-opt-<>-arglist-start-in-paren c-opt-postfix-decl-spec-key c-recognize-colon-labels c-label-prefix-re c-nonlabel-token-key c-nonlabel-nonparen-token-key c-nonlabel-token-2-key c-opt-extra-label-key c-opt-friend-key c-opt-method-key c-type-decl-end-used c-maybe-decl-faces c-version indent-line-function open-paren-in-column-0-is-defun-start js--font-lock-keywords font-lock-defaults syntax-propertize-function js--prettify-symbols-alist prettify-symbols-alist (34) "^\"\\" "\\(\\`a\\`\\)\\|\\(\\`a\\`\\)" 2 "[[:alpha:]_@]" "[:alnum:]_$" "[[:alnum:]_$]+" "[[:alpha:]_@][[:alnum:]_$]*" "^[:alnum:]_$" "[^[:alnum:]_$]" "\\(\\.\\)" "\\([[:alpha:]_@][[:alnum:]_$]*\\)\\(\\(\\s \\|[\n
]\\)*\\(\\.\\)\\(\\s \\|[\n
]\\)*\\(\\(\\*\\)\\(\\(\\s \\|[\n
]\\)*\\([[:alpha:]_@][[:alnum:]_$]*\\)\\)?\\|\\([[:alpha:]_@][[:alnum:]_$]*\\)\\)\\)*" ((34 . "\\(\\\\\\(.\\|\n\\)\\|[^\\\n
\"]\\)*")) "\\`a\\`" "\\(\\`a\\`\\)" "\\(?:!=\\|%=\\|&[&=]\\|\\*=\\|\\+[+=]\\|-[=-]\\|/=\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\|\\^=\\|instanceof\\|new\\||[=|]\\|[]!%&(-,./:<-?[|~^-]\\)" "\\(?:!=\\|%=\\|&[&=]\\|\\*=\\|\\+=\\|-=\\|/=\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\|\\^=\\|instanceof\\||[=|]\\|[%&*,./:=?|^]\\)" "\\(?:!=\\|%=\\|&[&=]\\|\\*[/=]\\|\\+[+=]\\|-[=-]\\|/[*/=]\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\|\\^=\\||[=|]\\|[!%&*+,./:-?|~^-]\\)" "=\\([^=]\\|$\\)\\|\\(?:\\(?:<<\\|>>>?\\|[%&*+/|^-]\\)=\\)" "\\(?:!=\\|%=\\|&[&=]\\|\\*=\\|\\+=\\|-=\\|/=\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>?=\\)\\|[=>]\\)\\|\\^=\\||[=|]\\|[%&*+/<=>|^-]\\)" "\\(?:<\\(?:<=\\|[<=]\\)\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\)" "\\(?:<=\\|[<=]\\)" 0 "\\(?:>?=\\)" "=" "\\(?:>\\(?:\\(?:>>?\\)?=\\)\\)" "^;{}?:" (59 123 125 63 58) "^;,{}?:" (59 44 123 125 63 58) (";" "{" "}") "\\(\\(?:!=\\|%=\\|&[&=]\\|\\*[/=]\\|\\+[+=]\\|-[=-]\\|/[*/=]\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\|\\^=\\|instanceof\\||[=|]\\|[!%&(*+,/:-?[{-~^-]\\)\\)\\([^[:alnum:]_$]\\|$\\)" "//" "/*" "*/" "\\*/" (42) "\\(?:/[*/]\\)\\|\\s!" "/\\*" "\\(\\*/\\)\\([^*]\\|\\*+\\([^*/]\\|$\\)\\)*$" "\\(?:/[*/]\\)\\|\\s!\\|\"\\|\\s|" "/\\*\\*" "\\s \\|\\(?:/[*/]\\|[\n
]\\)\\|\\\\[\n
]\\|\\s!" "\\s \\|[\n
/]\\|\\s!" "\\s *\\(/\\*[^*\n
]*\\(\\*+[^*\n
/][^*\n
]*\\)*\\*+/\\s *\\)*\\(//\\|/\\*[^*\n
]*\\(\\*+[^*\n
/][^*\n
]*\\)*$\\|\\\\$\\|$\\)" "\\(@[a-zA-Z]+\\>\\|$\\)" "$" "\\(\\(?:return\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:b\\(?:oolean\\|yte\\)\\|char\\|double\\|float\\|int\\|long\\|short\\|void\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:@interface\\|class\\|interface\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:enum\\)\\)\\([^[:alnum:]_$]\\|$\\)" mapcar #[257 "\211
\300\230\203\301\202\302\303P!B\207" [#11="extern" inextern-lang intern #12="in"] 5 "\n\n(fn ELT)"] "\\(\\(?:@interface\\|class\\|enum\\|interface\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:@interface\\|abstract\\|c\\(?:lass\\|onst\\)\\|default\\|enum\\|final\\|i\\(?:mport\\|nterface\\)\\|native\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|s\\(?:t\\(?:atic\\|rictfp\\)\\|ynchronized\\)\\|transient\\|volatile\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:break\\|c\\(?:a\\(?:se\\|tch\\)\\|ontinue\\)\\|do\\|e\\(?:lse\\|xtends\\)\\|f\\(?:alse\\|inally\\|or\\)\\|goto\\|i\\(?:f\\|mplements\\|nstanceof\\)\\|n\\(?:ew\\|ull\\)\\|return\\|s\\(?:uper\\|witch\\)\\|t\\(?:h\\(?:is\\|rows?\\)\\|r\\(?:ue\\|y\\)\\)\\|while\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:@interface\\|abstract\\|break\\|c\\(?:a\\(?:se\\|tch\\)\\|lass\\|on\\(?:st\\|tinue\\)\\)\\|d\\(?:efault\\|o\\)\\|e\\(?:lse\\|num\\|xtends\\)\\|f\\(?:alse\\|inal\\(?:ly\\)?\\|or\\)\\|goto\\|i\\(?:f\\|mp\\(?:lements\\|ort\\)\\|n\\(?:stanceof\\|terface\\)\\)\\|n\\(?:ative\\|ew\\|ull\\)\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|return\\|s\\(?:t\\(?:atic\\|rictfp\\)\\|uper\\|witch\\|ynchronized\\)\\|t\\(?:h\\(?:is\\|rows?\\)\\|r\\(?:ansient\\|ue\\|y\\)\\)\\|\\(?:volat\\|wh\\)ile\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:\\(?:extend\\|implement\\|throw\\)s\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:extends\\|super\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:do\\|else\\|\\(?:finall\\|tr\\)y\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:try\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:catch\\|for\\|if\\|s\\(?:witch\\|ynchronized\\)\\|while\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:catch\\|do\\|else\\|f\\(?:inally\\|or\\)\\|if\\|s\\(?:witch\\|ynchronized\\)\\|try\\|while\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:break\\|continue\\|goto\\|return\\|throw\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:for\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:case\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:case\\|default\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:new\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(?:@interface\\|class\\|interface\\|new\\|[)*,:;<{}]\\)\\)" "\\(\\(?:@interface\\|class\\|interface\\|new\\|[<{}]\\)\\)" "\\(\\(?:@interface\\|class\\|interface\\|new\\)\\)\\([^[:alnum:]_$]\\|$\\)" ("else" "while" "catch" "finally") "\\(\\(?:@interface\\|abstract\\|b\\(?:oolean\\|reak\\|yte\\)\\|c\\(?:a\\(?:se\\|tch\\)\\|har\\|lass\\|on\\(?:st\\|tinue\\)\\)\\|d\\(?:efault\\|o\\(?:uble\\)?\\)\\|e\\(?:lse\\|num\\|xtends\\)\\|f\\(?:alse\\|inal\\(?:ly\\)?\\|loat\\|or\\)\\|goto\\|i\\(?:f\\|mp\\(?:lements\\|ort\\)\\|n\\(?:stanceof\\|t\\(?:erface\\)?\\)\\)\\|long\\|n\\(?:ative\\|ew\\|ull\\)\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|return\\|s\\(?:hort\\|t\\(?:atic\\|rictfp\\)\\|uper\\|witch\\|ynchronized\\)\\|t\\(?:h\\(?:is\\|rows?\\)\\|r\\(?:ansient\\|ue\\|y\\)\\)\\|vo\\(?:id\\|latile\\)\\|while\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(^\\|\\=\\|[^[:alnum:]_$]\\)\\(\\(?:@interface\\|abstract\\|break\\|c\\(?:a\\(?:se\\|tch\\)\\|lass\\|on\\(?:st\\|tinue\\)\\)\\|d\\(?:efault\\|o\\)\\|e\\(?:lse\\|num\\|xtends\\)\\|f\\(?:inal\\(?:ly\\)?\\|or\\)\\|goto\\|i\\(?:f\\|mp\\(?:lements\\|ort\\)\\|nterface\\)\\|n\\(?:ative\\|ew\\)\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|return\\|s\\(?:t\\(?:atic\\|rictfp\\)\\|uper\\|witch\\|ynchronized\\)\\|t\\(?:hrows?\\|r\\(?:ansient\\|y\\)\\)\\|\\(?:volat\\|wh\\)ile\\)\\)\\([^[:alnum:]_$]\\|$\\)" (("instanceof" c-expr-kwds) ("this" c-primary-expr-kwds c-expr-kwds) ("case" c-case-kwds c-label-kwds) ("catch" c-block-stmt-2-kwds c-block-stmt-kwds) ("while" c-block-stmt-2-kwds c-block-stmt-kwds) ("switch" c-block-stmt-2-kwds c-block-stmt-kwds) ("if" c-block-stmt-2-kwds c-block-stmt-kwds) ("for" c-block-stmt-2-kwds c-paren-stmt-kwds c-block-stmt-kwds) ("try" c-block-stmt-1-2-kwds c-block-stmt-1-kwds c-block-stmt-kwds) ("finally" c-block-stmt-1-kwds c-block-stmt-kwds) ("else" c-block-stmt-1-kwds c-block-stmt-kwds) ("do" c-block-stmt-1-kwds c-block-stmt-kwds) ("null" c-constant-kwds) ("false" c-constant-kwds) ("true" c-constant-kwds) ("throw" c-simple-stmt-kwds) ("return" c-return-kwds c-simple-stmt-kwds) (#9="void" c-type-start-kwds c-primitive-type-kwds) (#8="short" c-type-start-kwds c-primitive-type-kwds) (#7="long" c-type-start-kwds c-primitive-type-kwds) (#6="int" c-type-start-kwds c-primitive-type-kwds) (#5="float" c-type-start-kwds c-primitive-type-kwds) (#4="double" c-type-start-kwds c-primitive-type-kwds) (#3="char" c-type-start-kwds c-primitive-type-kwds) (#2="byte" c-type-start-kwds c-primitive-type-kwds) (#1="boolean" c-type-start-kwds c-primitive-type-kwds) ("throws" c-postfix-spec-kwds c-postfix-decl-spec-kwds c-type-list-kwds) ("implements" c-postfix-spec-kwds c-postfix-decl-spec-kwds c-type-list-kwds) ("super" c-inside-<>-type-kwds c-type-list-kwds) ("extends" c-inside-<>-type-kwds c-postfix-spec-kwds c-postfix-decl-spec-kwds c-type-list-kwds) ("new" c-inexpr-class-kwds c-expr-kwds c-inexpr-brace-list-kwds c-flat-decl-block-kwds c-type-list-kwds) ("goto" c-simple-stmt-kwds c-before-label-kwds) ("continue" c-simple-stmt-kwds c-before-label-kwds) ("break" c-simple-stmt-kwds c-before-label-kwds) ("volatile" c-modifier-kwds c-prefix-spec-kwds) ("transient" c-modifier-kwds c-prefix-spec-kwds) ("synchronized" c-block-stmt-2-kwds c-modifier-kwds c-block-stmt-kwds c-prefix-spec-kwds) ("strictfp" c-modifier-kwds c-prefix-spec-kwds) ("static" c-modifier-kwds c-prefix-spec-kwds) ("public" c-modifier-kwds c-prefix-spec-kwds) ("protected" c-modifier-kwds c-prefix-spec-kwds) ("private" c-modifier-kwds c-prefix-spec-kwds) ("native" c-modifier-kwds c-prefix-spec-kwds) ("final" c-modifier-kwds c-prefix-spec-kwds) ("default" c-label-kwds c-modifier-kwds c-prefix-spec-kwds) ("const" c-modifier-kwds c-prefix-spec-kwds) ("abstract" c-modifier-kwds c-prefix-spec-kwds) ("enum" c-brace-id-list-kwds c-typeless-decl-kwds c-brace-list-decl-kwds c-defun-type-name-decl-kwds c-typedef-decl-kwds c-prefix-spec-kwds) ("interface" c-class-decl-kwds c-typeless-decl-kwds c-defun-type-name-decl-kwds c-typedef-decl-kwds c-flat-decl-block-kwds c-prefix-spec-kwds) ("@interface" c-class-decl-kwds c-typeless-decl-kwds c-defun-type-name-decl-kwds c-typedef-decl-kwds c-flat-decl-block-kwds c-prefix-spec-kwds) ("class" c-class-decl-kwds c-typeless-decl-kwds c-defun-type-name-decl-kwds c-typedef-decl-kwds c-flat-decl-block-kwds c-prefix-spec-kwds) ("import" c-type-list-kwds c-prefix-spec-kwds c-other-decl-kwds) ("package" c-prefix-spec-kwds c-other-decl-kwds c-ref-list-kwds)) make-vector setplist apply nconc #[257 "\211\300D\207" [t] 3 "\n\n(fn LANG-CONST)"] "\\(\\(?:@interface\\|abstract\\|break\\|c\\(?:a\\(?:se\\|tch\\)\\|lass\\|on\\(?:st\\|tinue\\)\\)\\|d\\(?:efault\\|o\\)\\|e\\(?:lse\\|num\\|xtends\\)\\|f\\(?:inal\\(?:ly\\)?\\|or\\)\\|goto\\|i\\(?:f\\|mp\\(?:lements\\|ort\\)\\|n\\(?:stanceof\\|terface\\)\\)\\|n\\(?:ative\\|ew\\)\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|return\\|s\\(?:t\\(?:atic\\|rictfp\\)\\|uper\\|witch\\|ynchronized\\)\\|t\\(?:h\\(?:is\\|rows?\\)\\|r\\(?:ansient\\|y\\)\\)\\|\\(?:volat\\|wh\\)ile\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\(\\(\\(?:new\\|this\\)\\)\\([^[:alnum:]_$]\\|$\\)\\|\\(?:\\+\\+\\|--\\|[(+-]\\)\\)\\|[[:alpha:]_@]\\|\\.?[0-9]\\|[!~]\\|\\s\"\\|\\s|" "\\([{}(;,<]+\\)" (40) "^!-#%-'+\\-/:-@[-^`{-~" "\\(\\`a\\`\\)\\|\\(abstract\\|const\\|default\\|final\\|native\\|p\\(?:r\\(?:ivate\\|otected\\)\\|ublic\\)\\|s\\(?:t\\(?:atic\\|rictfp\\)\\|ynchronized\\)\\|transient\\|volatile\\)\\>\\([^_]\\|$\\)" "\\([[()]\\)" "{\\|\\(\\(?:\\(?:extend\\|implement\\|throw\\)s\\)\\)\\([^[:alnum:]_$]\\|$\\)" "\\({\\|\\(\\(?:\\(?:extend\\|implement\\|throw\\)s\\)\\)\\([^[:alnum:]_$]\\|$\\)\\)\\|[;,]" "\\(\\[\\(\\s \\|[\n
]\\)*\\]\\|\\.\\.\\.\\)" boundp #13="font-lock-extra-types" delq #[257 "\300\301\"\205\211\207" [string-match #14="[][.*+?^$\\]"] 4 "\n\n(fn RE)"] #[257 "\300\301\"?\205	\211\207" [string-match #15="[][.*+?^$\\]"] 4 "\n\n(fn RE)"] #16="\\<\\(" c-concat-separated append c-make-keywords-re (#1# #2# #3# #4# #5# #6# #7# #8# #9#) #17="\\|" #18="\\)\\>" "[<;{},|+&>)-]" "\\<\\(\\(?:enum\\)\\)\\>[^][{};/#=]*{" "\\([[:alpha:]_@][[:alnum:]_$]*\\)\\(\\s \\|[\n
]\\)*\\(\\(//[^\n
]*[\n
]\\|/\\*[^*\n
]*\\(\\*+[^*\n
/][^*\n
]*\\)*\\*+/\\|\\\\[\n
]\\|\\s!\\S!*\\s!\\)\\(\\s \\|[\n
]\\)*\\)*<" "\\(\\([[:alpha:]_@][[:alnum:]_$]*\\)\\(\\s \\|[\n
]\\)*\\(\\(//[^\n
]*[\n
]\\|/\\*[^*\n
]*\\(\\*+[^*\n
/][^*\n
]*\\)*\\*+/\\|\\\\[\n
]\\|\\s!\\S!*\\s!\\)\\(\\s \\|[\n
]\\)*\\)*<\\)\\|\\s)" "\\([{};]+\\)" "\\(\\(?:@interface\\|abstract\\|b\\(?:oolean\\|reak\\|yte\\)\\|c\\(?:atch\\|har\\|lass\\|on\\(?:st\\|tinue\\)\\)\\|do\\(?:uble\\)?\\|e\\(?:lse\\|num\\|xtends\\)\\|f\\(?:alse\\|inal\\(?:ly\\)?\\|loat\\|or\\)\\|goto\\|i\\(?:f\\|mp\\(?:lements\\|ort\\)\\|n\\(?:stanceof\\|t\\(?:erface\\)?\\)\\)\\|long\\|n\\(?:ative\\|ew\\|ull\\)\\|p\\(?:ackage\\|r\\(?:ivate\\|otected\\)\\|ublic\\)\\|return\\|s\\(?:hort\\|t\\(?:atic\\|rictfp\\)\\|uper\\|witch\\|ynchronized\\)\\|t\\(?:h\\(?:is\\|rows?\\)\\|r\\(?:ansient\\|ue\\|y\\)\\)\\|vo\\(?:id\\|latile\\)\\|while\\)\\)\\([^[:alnum:]_$]\\|$\\)" (list nil font-lock-type-face c-reference-face-name font-lock-keyword-face font-lock-preprocessor-face) ((font-lock-comment-end-skip (c-lang-const c-font-lock-comment-end-skip)) (comment-start (c-lang-const comment-start)) (comment-end (c-lang-const comment-end)) (comment-start-skip (c-lang-const comment-start-skip)) (comment-end-can-be-escaped (c-lang-const comment-end-can-be-escaped)) (beginning-of-defun-function (c-lang-const beginning-of-defun-function)) (end-of-defun-function (c-lang-const end-of-defun-function)) (c-no-parens-syntax-table (and (c-lang-const c-make-no-parens-syntax-table) (funcall (eval (c-lang-const c-make-no-parens-syntax-table)))) nil) (c-identifier-syntax-modifications (c-lang-const c-identifier-syntax-modifications) "A list that describes the modifications that should be done to the\nmode syntax table to get a syntax table that matches all identifiers\nand keywords as words.\n\nThe list is just like the one used in `font-lock-defaults': Each\nelement is a cons where the car is the character to modify and the cdr\nthe new syntax, as accepted by `modify-syntax-entry'.") (c-identifier-syntax-table (let ((table (copy-syntax-table (c-mode-var #10#))) (mods c-identifier-syntax-modifications) mod) (while mods (setq mod (car mods) mods (cdr mods)) (modify-syntax-entry (car mod) (cdr mod) table)) table) "Syntax table built on the mode syntax table but additionally\nclassifies symbol constituents like `_' and `$' as word constituents,\nso that all identifiers are recognized as words.") (c-get-state-before-change-functions (let ((fs (c-lang-const c-get-state-before-change-functions))) (if (listp fs) fs (list fs))) "If non-nil, a list of functions called from c-before-change-hook.\nTypically these will record enough state to allow\n`c-before-font-lock-functions' to extend the region to fontify,\nand may do such things as removing text-properties which must be\nrecalculated.\n\nThese functions will be run in the order given.  Each of them\ntakes 2 parameters, the BEG and END supplied to every\nbefore-change function; on entry, the buffer will have been\nwidened and match-data will have been saved; point is undefined\non both entry and exit; the return value is ignored.\n\nThe functions are called even when font locking isn't enabled.\n\nWhen the mode is initialized, the functions are called with\nparameters (point-min) and (point-max).") (c-before-font-lock-functions (let ((fs (c-lang-const c-before-font-lock-functions))) (if (listp fs) fs (list fs))) "If non-nil, a list of functions called just before font locking.\nTypically they will extend the region about to be fontified (see\nbelow) and will set `syntax-table' text properties on the region.\n\nThese functions will be run in the order given.  Each of them\ntakes 3 parameters, the BEG, END, and OLD-LEN supplied to every\nafter-change function; point is undefined on both entry and exit;\non entry, the buffer will have been widened and match-data will\nhave been saved; the return value is ignored.\n\nThe functions may extend the region to be fontified by setting the\nbuffer local variables c-new-BEG and c-new-END.\n\nThe functions are called even when font locking is disabled.\n\nWhen the mode is initialized, these functions are called with\nparameters (point-min), (point-max) and <buffer size>.") (c-before-context-fontification-functions (let ((fs (c-lang-const c-before-context-fontification-functions))) (if (listp fs) fs (list fs))) "If non-nil, a list of functions called just before context (or\nother non-change) fontification is done.  Typically they will\nextend the region.\n\nThese functions will be run in the order given.  Each of them\ntakes 2 parameters, the BEG and END of the region to be\nfontified.  Point is undefined on both entry and exit.  On entry,\nthe buffer will have been widened and match-data will have been\nsaved; the return value is a cons of the adjusted\nregion, (NEW-BEG . NEW-END).") (c-at-vsemi-p-fn (c-lang-const c-at-vsemi-p-fn) "Contains a function \"Is there a virtual semicolon at POS or point?\".\nSuch a function takes one optional parameter, a buffer position (defaults to\npoint), and returns nil or t.  This variable contains nil for languages which\ndon't have EOL terminated statements. ") (c-vsemi-status-unknown-p-fn (c-lang-const c-vsemi-status-unknown-p-fn) "A function \"are we unsure whether there is a virtual semicolon on this line?\".\nThe (admittedly kludgy) purpose of such a function is to prevent an infinite\nrecursion in c-beginning-of-statement-1 when point starts at a `while' token.\nThe function MUST NOT UNDER ANY CIRCUMSTANCES call `c-beginning-of-statement-1',\neven indirectly.  This variable contains nil for languages which don't have\nEOL terminated statements.") (c-has-bitfields (c-lang-const c-has-bitfields) "Whether the language has bitfield declarations.") (c-single-quotes-quote-strings (c-lang-const c-single-quotes-quote-strings) "Whether the language uses single quotes for multi-char strings.\n\nNote that to set up a language to use this, additionally:\n(i) the syntax of \"'\" must be \"string quote\" (7);\n(ii) the language's value of `c-has-quoted-numbers' must be nil;\n(iii) the language's value of `c-get-state-before-change-functions' may not\n  contain `c-parse-quotes-before-change';\n(iv) the language's value of `c-before-font-lock-functions' may not contain\n  `c-parse-quotes-after-change'.") (c-string-delims (c-lang-const c-string-delims) nil) (c-ml-string-non-punc-skip-chars (c-lang-const c-ml-string-non-punc-skip-chars) nil) (c-ml-string-opener-re (c-lang-const c-ml-string-opener-re) "If non-nil, a regexp that matches a multi-line string opener.\nIt may also match context.\n\nSuch an opener must be at least 2 characters long, and must\ncontain a \" character.  (match-string 1) matches the actual\ndelimiter and (match-string 2) matches the actual \".  If a\ndelimiter contains several \"s, it is recommended to configure\nthe first of them as \"the\" \".") (c-ml-string-max-opener-len (c-lang-const c-ml-string-max-opener-len) "If non-nil, the maximum length of a multi-line string opener.") (c-ml-string-any-closer-re (c-lang-const c-ml-string-any-closer-re) "If non-nil, a regexp that matches any multi-line string closer.\nIt may also match context.\n\nA search for this regexp starting at the end of the corresponding\nopener must find the first closer as the first match.\n\nSuch a closer must include a \" character.  (match-string 1)\nmatches the actual delimiter and (match-string 2) matches the\nactual \".  If a delimiter contains several \"s, it is\nrecommended to regard the last of them as \"the\" \".") (c-ml-string-max-closer-len (c-lang-const c-ml-string-max-closer-len) "If non-nil, the maximum length of a multi-line string closer.\nThis must include the length of any \"context trailer\" following\nthe actual closer and any \"context leader\" preceding it.  This\nvariable is ignored when `c-ml-string-back-closer-re' is non-nil.") (c-ml-string-max-closer-len-no-leader (c-lang-const c-ml-string-max-closer-len-no-leader) "If non-nil, the maximum length of a ml string closer without its leader.\nBy \"leader\" is meant the context bytes preceding the actual\nmulti-line string closer, that part of\n`c-ml-string-any-closer-re''s match preceding (match-beginning 1).") (c-ml-string-back-closer-re (c-lang-const c-ml-string-back-closer-re) "A regexp to move back out of a putative ml closer point is in.\n\nThis variable need only be non-nil for languages with multi-line\nstring closers that can contain an indefinite length \"leader\"\npreceding the actual closer.  It was designed for formats where\nan unbounded number of \\s or \"s might precede the closer\nproper, for example in Pike Mode or csharp-mode.\n\nIf point is in a putative multi-line string closer, a backward\nregexp search with `c-ml-string-back-closer-re' will leave point\nin a \"safe place\", from where a forward regexp search with\n`c-ml-string-any-closer-re' can test whether the original\nposition was inside an actual closer.\n\nWhen non-nil, this variable should end in \"\\\\\\==\".  Note that\nsuch a backward search will match a minimal string, so a\n\"context character\" is probably needed at the start of the\nregexp.  The value for csharp-mode would be something like\n\"\\\\(:?\\\\`\\\\|[^\\\"]\\\\)\\\"*\\\\\\==\".") (c-make-ml-string-closer-re-function (c-lang-const c-make-ml-string-closer-re-function) "If non-nil, a function which creates a closer regexp matching an opener.\n\nSuch a function is given one argument, a multi-line opener (a\nstring), and returns a regexp which will match the corresponding\ncloser.  When this regexp matches, (match-string 1) should be the\nactual closing delimiter, and (match-string 2) the \"active\" \"\nit contains.\n\nA forward regexp search for this regexp starting at the end of\nthe opener must find the closer as its first match.") (c-make-ml-string-opener-re-function (c-lang-const c-make-ml-string-opener-re-function) "If non-nil, a function which creates an opener regexp matching a closer.\n\nSuch a function is given one argument, a multi-line closer (a\nstring), and returns a regexp which will match the corresponding\nopener.  When this regexp matches, (match-string 1) should be the\nactual opening delimiter, and (match-string 2) the \"active\" \"\nit contains.\n\nA backward regexp search for this regexp starting at the start of\nthe closer might not find the opener as its first match, should\nthere be copies of the opener contained in the multi-line string.") (c-ml-string-cpp-or-opener-re (c-lang-const c-ml-string-cpp-or-opener-re) nil) (c-cpp-or-ml-match-offset (c-lang-const c-cpp-or-ml-match-offset) nil) (c-has-quoted-numbers (c-lang-const c-has-quoted-numbers) "Whether the language has numbers quoted like 4'294'967'295.") (c-has-compound-literals (c-lang-const c-has-compound-literals) "Whether literal initializers {...} are used other than in initializations.") (c-modified-constant (c-lang-const c-modified-constant) "Regexp that matches a “modified” constant literal such as \"L\\='a\\='\",\na “long character”.  In particular, this recognizes forms of constant\nwhich `c-backward-sexp' needs to be called twice to move backwards over.") (c-symbol-start (c-lang-const c-symbol-start) "Regexp that matches the start of a symbol, i.e. any identifier or\nkeyword.  It's unspecified how far it matches.  Does not contain a \\|\noperator at the top level.") (c-symbol-chars (c-lang-const c-symbol-chars) "Set of characters that can be part of a symbol.\nThis is of the form that fits inside [ ] in a regexp.") (c-symbol-char-key (c-lang-const c-symbol-char-key) "Regexp matching a sequence of at least one identifier character.") (c-symbol-key (c-lang-const c-symbol-key) "Regexp matching identifiers and keywords (with submatch 0).  Assumed\nto match if `c-symbol-start' matches on the same position.") (c-nonsymbol-chars (c-lang-const c-nonsymbol-chars) "This is the set of chars that can't be part of a symbol, i.e. the\nnegation of `c-symbol-chars'.") (c-nonsymbol-key (c-lang-const c-nonsymbol-key) "Regexp that matches any character that can't be part of a symbol.\nIt's usually appended to other regexps to avoid matching a prefix.\nIt's assumed to not contain any submatchers.") (c-opt-identifier-concat-key (c-lang-const c-opt-identifier-concat-key) nil) (c-identifier-start (c-lang-const c-identifier-start) "Regexp that matches the start of an (optionally qualified) identifier.\nIt should also match all keywords.  It's unspecified how far it\nmatches.") (c-identifier-key (c-lang-const c-identifier-key) "Regexp matching a fully qualified identifier, like \"A::B::c\" in\nC++.  It does not recognize the full range of syntactic whitespace\nbetween the tokens; `c-forward-name' has to be used for that.  It\nshould also not match identifiers containing parenthesis groupings,\ne.g. identifiers with template arguments such as \"A<X,Y>\" in C++.") (c-string-escaped-newlines (c-lang-const c-string-escaped-newlines) "Set if the language support backslash escaped newlines inside string\nliterals.") (c-multiline-string-start-char (c-lang-const c-multiline-string-start-char) "Set if the language supports multiline string literals without escaped\nnewlines.  If t, all string literals are multiline.  If a character,\nonly literals where the open quote is immediately preceded by that\nliteral are multiline.\n\nNote that from CC Mode 5.36, this character use is obsolete,\nhaving been superseded by the \"multi-line string\" mechanism.\nIf both mechanisms are set for a language, the newer one prevails\nover the old `c-multiline-string-start-char'.  See the variables\nin the page containing `c-ml-string-opener-re' in cc-langs.el for\nfurther directions.") (c-string-innards-re-alist (c-lang-const c-string-innards-re-alist) nil) (c-opt-cpp-symbol (c-lang-const c-opt-cpp-symbol) "The symbol which starts preprocessor constructs when in the margin.") (c-opt-cpp-prefix (c-lang-const c-opt-cpp-prefix) "Regexp matching the prefix of a cpp directive in the languages that\nnormally use that macro preprocessor.  Tested at bol or at boi.\nAssumed to not contain any submatches or \\| operators.") (c-anchored-cpp-prefix (c-lang-const c-anchored-cpp-prefix) "Regexp matching the prefix of a cpp directive anchored to BOL,\nin the languages that have a macro preprocessor.") (c-opt-cpp-start (c-lang-const c-opt-cpp-start) "Regexp matching the prefix of a cpp directive including the directive\nname, or nil in languages without preprocessor support.  The first\nsubmatch surrounds the directive name.") (c-cpp-include-key (c-lang-const c-cpp-include-key) nil) (c-opt-cpp-macro-define (c-lang-const c-opt-cpp-macro-define) "Cpp directive (without the prefix) that is followed by a macro\ndefinition, or nil if the language doesn't have any.") (c-opt-cpp-macro-define-start (c-lang-const c-opt-cpp-macro-define-start) nil) (c-opt-cpp-macro-define-id (c-lang-const c-opt-cpp-macro-define-id) nil) (c-cpp-expr-intro-re (c-lang-const c-cpp-expr-intro-re) "Regexp which matches the start of a CPP directive which contains an\nexpression, or nil if there aren't any in the language.") (c-cpp-expr-functions-key (c-lang-const c-cpp-expr-functions-key) nil) (c-operator-re (c-lang-const c-operator-re) nil) (c-non-after-{}-ops-re (c-lang-const c-non-after-{}-ops-re) nil) (c-overloadable-operators-regexp (c-lang-const c-overloadable-operators-regexp) nil) (c-opt-op-identifier-prefix (c-lang-const c-opt-op-identifier-prefix) "Regexp matching the token before the ones in\n`c-overloadable-operators' when operators are specified in their\n\"identifier form\".  This typically matches \"operator\" in C++ where\noperator functions are specified as e.g. \"operator +\".  It's nil in\nlanguages without operator functions or where the complete operator\nidentifier is listed in `c-overloadable-operators'.\n\nThis regexp is assumed to not match any non-operator identifier.") (c-ambiguous-overloadable-or-identifier-prefix-re (c-lang-const c-ambiguous-overloadable-or-identifier-prefix-re) nil) (c-nonsymbol-token-regexp (c-lang-const c-nonsymbol-token-regexp) nil) (c-assignment-op-regexp (c-lang-const c-assignment-op-regexp) nil) (c-arithmetic-op-regexp (c-lang-const c-arithmetic-op-regexp) nil) (c-:$-multichar-token-regexp (c-lang-const c-:$-multichar-token-regexp) nil) (c-<>-multichar-token-regexp (c-lang-const c-<>-multichar-token-regexp) nil) (c-<-op-cont-regexp (c-lang-const c-<-op-cont-regexp) nil) (c-<-pseudo-digraph-cont-regexp (c-lang-const c-<-pseudo-digraph-cont-regexp) "Regexp matching the continuation of a pseudo digraph starting \"<\".\nThis is used only in C++ Mode, where \"<::\" is handled as a\ntemplate opener followed by the \"::\" operator - usually.") (c-<-pseudo-digraph-cont-len (c-lang-const c-<-pseudo-digraph-cont-len) "The maximum length of the main bit of a `c-<-pseudo-digraph-cont-regexp' match.\nThis doesn't count the merely contextual bits of the regexp match.") (c->-op-cont-regexp (c-lang-const c->-op-cont-regexp) nil) (c->-op-without->-cont-regexp (c-lang-const c->-op-without->-cont-regexp) nil) (c-multichar->-op-not->>->>>-regexp (c-lang-const c-multichar->-op-not->>->>>-regexp) nil) (c-:-op-cont-regexp (c-lang-const c-:-op-cont-regexp) nil) (c-stmt-delim-chars (c-lang-const c-stmt-delim-chars) nil) (c-stmt-boundary-skip-chars (c-lang-const c-stmt-boundary-skip-chars) nil) (c-stmt-boundary-skip-list (c-lang-const c-stmt-boundary-skip-list) nil) (c-stmt-delim-chars-with-comma (c-lang-const c-stmt-delim-chars-with-comma) nil) (c-stmt-boundary-skip-chars-with-comma (c-lang-const c-stmt-boundary-skip-chars-with-comma) nil) (c-stmt-boundary-skip-list-with-comma (c-lang-const c-stmt-boundary-skip-list-with-comma) nil) (c-pack-key (c-lang-const c-pack-key) nil) (c-auto-ops-re (c-lang-const c-auto-ops-re) nil) (c-haskell-op-re (c-lang-const c-haskell-op-re) nil) (c-pre-start-tokens (c-lang-const c-pre-start-tokens) "List of operators following which an apparent declaration (e.g.\n\"t1 *fn (t2 *b);\") is most likely to be an actual declaration\n(as opposed to an arithmetic expression).") (c-pre-lambda-tokens-re (c-lang-const c-pre-lambda-tokens-re) nil) (c-line-comment-starter (c-lang-const c-line-comment-starter) "String that starts line comments, or nil if such don't exist.\nLine comments are always terminated by newlines.  At least one of\n`c-block-comment-starter' and this one is assumed to be set.\n\nNote that it's currently not enough to set this to support a new\ncomment style.  Other stuff like the syntax table must also be set up\nproperly.") (c-block-comment-starter (c-lang-const c-block-comment-starter) "String that starts block comments, or nil if such don't exist.\nBlock comments are ended by `c-block-comment-ender', which is assumed\nto be set if this is.  At least one of `c-line-comment-starter' and\nthis one is assumed to be set.\n\nNote that it's currently not enough to set this to support a new\ncomment style.  Other stuff like the syntax table must also be set up\nproperly.") (c-block-comment-ender (c-lang-const c-block-comment-ender) "String that ends block comments, or nil if such don't exist.\n\nNote that it's currently not enough to set this to support a new\ncomment style.  Other stuff like the syntax table must also be set up\nproperly.") (c-block-comment-ender-regexp (c-lang-const c-block-comment-ender-regexp) nil) (c-block-comment-awkward-chars (c-lang-const c-block-comment-awkward-chars) "List of characters which, inside a block comment, could be the first\ncharacter of a double character construct.  This doesn't include\nbackslash.") (c-comment-start-regexp (c-lang-const c-comment-start-regexp) nil) (c-block-comment-start-regexp (c-lang-const c-block-comment-start-regexp) nil) (c-line-comment-start-regexp (c-lang-const c-line-comment-start-regexp) nil) (c-last-c-comment-end-on-line-re (c-lang-const c-last-c-comment-end-on-line-re) "Regexp which matches the last block comment ender on the\ncurrent line, if any, or nil in those languages without block\ncomments.  When a match is found, submatch 1 contains the comment\nender.") (c-literal-start-regexp (c-lang-const c-literal-start-regexp) nil) (c-doc-comment-start-regexp (c-lang-const c-doc-comment-start-regexp) "Regexp to match the start of documentation comments.") (c-block-comment-is-default (c-lang-const c-block-comment-is-default) "Non-nil when the default comment style is block comment.") (c-syntactic-ws-start (c-lang-const c-syntactic-ws-start) nil) (c-syntactic-ws-end (c-lang-const c-syntactic-ws-end) nil) (c-syntactic-eol (c-lang-const c-syntactic-eol) nil) (c-paragraph-start (c-lang-const c-paragraph-start) "Regexp to append to `paragraph-start'.") (c-paragraph-separate (c-lang-const c-paragraph-separate) "Regexp to append to `paragraph-separate'.") (c-return-key (c-lang-const c-return-key) nil) (c-primitive-type-key (c-lang-const c-primitive-type-key) nil) (c-typedef-key (c-lang-const c-typedef-key) nil) (c-typeof-key (c-lang-const c-typeof-key) nil) (c-template-typename-key (c-lang-const c-template-typename-key) nil) (c-type-prefix-key (c-lang-const c-type-prefix-key) nil) (c-opt-type-modifier-prefix-key (c-lang-const c-opt-type-modifier-prefix-key) nil) (c-opt-type-modifier-key (c-lang-const c-opt-type-modifier-key) nil) (c-opt-type-component-key (c-lang-const c-opt-type-component-key) nil) (c-type-decl-suffix-ws-ids-key (c-lang-const c-type-decl-suffix-ws-ids-key) nil) (c-class-id-suffix-ws-ids-key (c-lang-const c-class-id-suffix-ws-ids-key) nil) (c-class-key (c-lang-const c-class-key) nil) (c-brace-list-key (c-lang-const c-brace-list-key) nil) (c-after-brace-list-key (c-lang-const c-after-brace-list-key) nil) (c-recognize-post-brace-list-type-p (c-lang-const c-recognize-post-brace-list-type-p) "Set to t when we recognize a colon and then a type after an enum,\ne.g., enum foo : int { A, B, C };") (c-other-decl-block-key (c-lang-const c-other-decl-block-key) nil) (c-other-decl-block-key-in-symbols-alist (mapcar (lambda (elt) (cons elt (if (string= elt #11#) 'inextern-lang (intern (concat #12# elt))))) (c-lang-const c-other-block-decl-kwds)) "Alist associating keywords in c-other-decl-block-decl-kwds with\ntheir matching \"in\" syntactic symbols.") (c-defun-type-name-decl-key (c-lang-const c-defun-type-name-decl-key) nil) (c-typedef-decl-key (c-lang-const c-typedef-decl-key) nil) (c-using-key (c-lang-const c-using-key) nil) (c-no-type-key (c-lang-const c-no-type-key) nil) (c-equals-type-clause-key (c-lang-const c-equals-type-clause-key) nil) (c-decl-hangon-key (c-lang-const c-decl-hangon-key) nil) (c-prefix-spec-kwds-re (c-lang-const c-prefix-spec-kwds-re) nil) (c-specifier-key (c-lang-const c-specifier-key) nil) (c-not-decl-init-keywords (c-lang-const c-not-decl-init-keywords) nil) (c-not-primitive-type-keywords-regexp (c-lang-const c-not-primitive-type-keywords-regexp) nil) (c-protection-key (c-lang-const c-protection-key) nil) (c-post-protection-token (c-lang-const c-post-protection-token) "The token which (may) follow a protection keyword,\ne.g. the \":\" in C++ Mode's \"public:\".  nil if there is no such token.") (c-opt-block-decls-with-vars-key (c-lang-const c-opt-block-decls-with-vars-key) nil) (c-postfix-decl-spec-key (c-lang-const c-postfix-decl-spec-key) nil) (c-make-top-level-key (c-lang-const c-make-top-level-key) nil) (c-colon-type-list-re (c-lang-const c-colon-type-list-re) "Regexp matched after the keywords in `c-colon-type-list-kwds' to skip\nforward to the colon.  The end of the match is assumed to be directly\nafter the colon, so the regexp should end with \":\".  Must be a\nregexp if `c-colon-type-list-kwds' isn't nil.") (c-paren-nontype-key (c-lang-const c-paren-nontype-key) nil) (c-opt-<>-sexp-key (c-lang-const c-opt-<>-sexp-key) nil) (c-inside-<>-type-key (c-lang-const c-inside-<>-type-key) nil) (c-block-stmt-1-key (c-lang-const c-block-stmt-1-key) nil) (c-block-stmt-1-2-key (c-lang-const c-block-stmt-1-2-key) nil) (c-block-stmt-2-key (c-lang-const c-block-stmt-2-key) nil) (c-block-stmt-hangon-key (c-lang-const c-block-stmt-hangon-key) nil) (c-opt-block-stmt-key (c-lang-const c-opt-block-stmt-key) nil) (c-simple-stmt-key (c-lang-const c-simple-stmt-key) nil) (c-paren-stmt-key (c-lang-const c-paren-stmt-key) nil) (c-opt-asm-stmt-key (c-lang-const c-opt-asm-stmt-key) nil) (c-case-kwds-regexp (c-lang-const c-case-kwds-regexp) nil) (c-label-kwds-regexp (c-lang-const c-label-kwds-regexp) nil) (c-opt-inexpr-brace-list-key (c-lang-const c-opt-inexpr-brace-list-key) nil) (c-brace-stack-thing-key (c-lang-const c-brace-stack-thing-key) nil) (c-brace-stack-no-semi-key (c-lang-const c-brace-stack-no-semi-key) nil) (c-decl-block-key (c-lang-const c-decl-block-key) nil) (c-opt-bitfield-key (c-lang-const c-opt-bitfield-key) nil) (c-std-abbrev-keywords (c-lang-const c-std-abbrev-keywords) "List of keywords which may need to cause electric indentation.") (c-keywords-regexp (c-lang-const c-keywords-regexp) nil) (c-stmt-block-only-keywords-regexp (c-lang-const c-stmt-block-only-keywords-regexp) nil) (c-keywords-obarray (let* ((alist (c-lang-const c-keyword-member-alist)) kwd lang-const-list (obarray (make-vector (* (length alist) 2) 0))) (while alist (setq kwd (caar alist) lang-const-list (cdar alist) alist (cdr alist)) (setplist (intern kwd obarray) (apply 'nconc (mapcar (lambda (lang-const) (list lang-const t)) lang-const-list)))) obarray) nil) (c-regular-keywords-regexp (c-lang-const c-regular-keywords-regexp) nil) (c-primary-expr-regexp (c-lang-const c-primary-expr-regexp) nil) (c-decl-start-colon-kwd-re (c-lang-const c-decl-start-colon-kwd-re) "Regexp matching a keyword that is followed by a colon, where\n  the whole construct can precede a declaration.\n  E.g. \"public:\" in C++.") (c-decl-prefix-re (c-lang-const c-decl-prefix-re) nil) (c-decl-start-re (c-lang-const c-decl-start-re) "Regexp matching the start of any declaration, cast or label.\nIt's used on the token after the one `c-decl-prefix-re' matched.  This\nregexp should not try to match those constructs accurately as it's\nonly used as a sieve to avoid spending more time checking other\nconstructs.") (c-decl-prefix-or-start-re (c-lang-const c-decl-prefix-or-start-re) nil) (c-dposr-cpp-macro-depth (c-lang-const c-dposr-cpp-macro-depth) nil) (c-cast-parens (c-lang-const c-cast-parens) nil) (c-block-prefix-charset (c-lang-const c-block-prefix-charset) nil) (c-type-decl-prefix-key (c-lang-const c-type-decl-prefix-key) nil) (c-type-decl-operator-prefix-key (c-lang-const c-type-decl-operator-prefix-key) "Regexp matching any declarator operator which isn't a keyword,\nthat might precede the identifier in a declaration, e.g. the\n\"*\" in \"char *argv\".  The end of the first submatch is taken\nas the end of the operator.  Identifier syntax is in effect when\nthis is matched (see `c-identifier-syntax-table').") (c-type-decl-suffix-key (c-lang-const c-type-decl-suffix-key) nil) (c-after-suffixed-type-decl-key (c-lang-const c-after-suffixed-type-decl-key) nil) (c-after-suffixed-type-maybe-decl-key (c-lang-const c-after-suffixed-type-maybe-decl-key) nil) (c-opt-type-concat-key (c-lang-const c-opt-type-concat-key) nil) (c-opt-type-suffix-key (c-lang-const c-opt-type-suffix-key) "Regexp matching operators that might follow after a type, or nil in\nlanguages that don't have such operators.  The end of the first\nsubmatch is taken as the end of the operator.  This should not match\nthings like C++ template arglists if `c-recognize-<>-arglists' is set.\nIt's undefined whether identifier syntax (see `c-identifier-syntax-table')\nis in effect or not.") (c-known-type-key (let* ((extra-types (when (boundp (c-mode-symbol #13#)) (c-mode-var "font-lock-extra-types"))) (regexp-strings (delq nil (mapcar (lambda (re) (when (string-match #14# re) re)) extra-types))) (plain-strings (delq nil (mapcar (lambda (re) (unless (string-match #15# re) re)) extra-types)))) (concat #16# (c-concat-separated (append (list (c-make-keywords-re nil (append (c-lang-const c-primitive-type-kwds) plain-strings))) regexp-strings) #17#) #18#)) nil) (c-special-brace-lists (c-lang-const c-special-brace-lists) "List of open- and close-chars that makes up a pike-style brace list,\ni.e., for a ([ ]) list there should be a cons (?\\[ . ?\\]) in this\nlist.") (c-recognize-knr-p (c-lang-const c-recognize-knr-p) "Non-nil means K&R style argument declarations are valid.") (c-pre-id-bracelist-key (c-lang-const c-pre-id-bracelist-key) nil) (c-pre-brace-non-bracelist-key (c-lang-const c-pre-brace-non-bracelist-key) "A regexp matching tokens which, preceding a brace, make it a non-bracelist.") (c-recognize-typeless-decls (c-lang-const c-recognize-typeless-decls) "Non-nil means function declarations without return type should be\nrecognized.  That can introduce an ambiguity with parenthesized macro\ncalls before a brace block.  This setting does not affect declarations\nthat are preceded by a declaration starting keyword, so\ne.g. `c-typeless-decl-kwds' may still be used when it's set to nil.") (c-recognize-<>-arglists (c-lang-const c-recognize-<>-arglists) "Non-nil means C++ style template arglists should be handled.  More\nspecifically, this means a comma separated list of types or\nexpressions surrounded by \"<\" and \">\".  It's always preceded by an\nidentifier or one of the keywords on `c-<>-type-kwds' or\n`c-<>-arglist-kwds'.  If there's an identifier before then the whole\nexpression is considered to be a type.") (c-<>-notable-chars-re (c-lang-const c-<>-notable-chars-re) "A regexp matching any single character notable inside a <...> construct.\nThis must include \"<\" and \">\", and should include \",\", and\nany character which cannot be valid inside such a construct.\nThis is used in `c-forward-<>-arglist-recur' to try to detect\nsequences of tokens which cannot be a template/generic construct.\nWhen \"(\" is present, that defun will attempt to parse a\nparenthesized expression inside the template.  When \")\" is\npresent it will treat an unbalanced closing paren as a sign of\nthe invalidity of the putative template construct.") (c-enum-clause-introduction-re (c-lang-const c-enum-clause-introduction-re) nil) (c-enums-contain-decls (c-lang-const c-enums-contain-decls) "Non-nil means that an enum structure can contain declarations.") (c-recognize-paren-inits (c-lang-const c-recognize-paren-inits) "Non-nil means that parenthesis style initializers exist,\ni.e. constructs like\n\nFoo bar (gnu);\n\nin addition to the more classic\n\nFoo bar = gnu;") (c-recognize-bare-brace-inits (c-lang-const c-recognize-bare-brace-inits) "Non-nil means that brace initializers without \"=\" exist,\ni.e. constructs like\n\nint foo[] {1, 2, 3};\n\nin addition to the more classic\n\nint foo[] = {1, 2, 3};") (c-recognize-paren-inexpr-blocks (c-lang-const c-recognize-paren-inexpr-blocks) "Non-nil to recognize gcc style in-expression blocks,\ni.e. compound statements surrounded by parentheses inside expressions.") (c-opt-<>-arglist-start (c-lang-const c-opt-<>-arglist-start) nil) (c-opt-<>-arglist-start-in-paren (c-lang-const c-opt-<>-arglist-start-in-paren) nil) (c-opt-postfix-decl-spec-key (c-lang-const c-opt-postfix-decl-spec-key) nil) (c-recognize-colon-labels (c-lang-const c-recognize-colon-labels) "Non-nil if generic labels ending with \":\" should be recognized.\nThat includes labels in code and access keys in classes.  This does\nnot apply to labels recognized by `c-label-kwds' and\n`c-opt-extra-label-key'.") (c-label-prefix-re (c-lang-const c-label-prefix-re) "Regexp like `c-decl-prefix-re' that matches any token that can precede\na generic colon label.  Not used if `c-recognize-colon-labels' is\nnil.") (c-nonlabel-token-key (c-lang-const c-nonlabel-token-key) "Regexp matching things that can't occur in generic colon labels,\nneither in a statement nor in a declaration context.  The regexp is\ntested at the beginning of every sexp in a suspected label,\ni.e. before \":\".  Only used if `c-recognize-colon-labels' is set.") (c-nonlabel-nonparen-token-key (c-lang-const c-nonlabel-nonparen-token-key) "Regexp matching things that can't occur in generic colon labels,\nneither in a statement nor in a declaration context, with the\nexception of an open parenthesis.  The regexp is tested at the\nbeginning of every sexp in a suspected label, i.e. before \":\".\nOnly used if `c-recognize-colon-labels' is set.") (c-nonlabel-token-2-key (c-lang-const c-nonlabel-token-2-key) "Regexp matching things that can't occur two symbols before a colon in\na label construct.  This catches C++'s inheritance construct \"class foo\n: bar\".  Only used if `c-recognize-colon-labels' is set.") (c-opt-extra-label-key (c-lang-const c-opt-extra-label-key) "Optional regexp matching labels.\nNormally, labels are detected according to `c-nonlabel-token-key',\n`c-decl-prefix-re' and `c-nonlabel-decl-prefix-re'.  This regexp can\nbe used if there are additional labels that aren't recognized that\nway.") (c-opt-friend-key (c-lang-const c-opt-friend-key) nil) (c-opt-method-key (c-lang-const c-opt-method-key) nil) (c-type-decl-end-used (c-lang-const c-type-decl-end-used) nil) (c-maybe-decl-faces (c-lang-const c-maybe-decl-faces) "List of faces that might be put at the start of a type when\n`c-font-lock-declarations' runs.  This must be evaluated (with `eval') at\nruntime to get the actual list of faces.  This ensures that face name\naliases in Emacs are resolved.")) message "Eval error in the `c-lang-defvar' or `c-lang-setvar' for `%s'%s: %S" format " (fallback source eval - %s compiled with CC Mode %s but loaded with %s)" "5.35.1" signal js-indent-line js-beginning-of-defun js-end-of-defun (font-lock-syntactic-face-function . js-font-lock-syntactic-face-function) js-syntax-propertize add-hook syntax-propertize-extend-region-functions syntax-propertize-multiline local js--syntax-propertize-extend-region parse-sexp-ignore-comments which-func-imenu-joiner-function js--which-func-joiner fill-paragraph-function js-fill-paragraph normal-auto-fill-function js-do-auto-fill before-change-functions js--flush-caches js--update-quick-match-re js-jsx--detect-and-enable after-change-functions js-jsx--detect-after-change js-use-syntactic-mode-name js--imenu-create-index c-foreign-init-lit-pos-cache c-foreign-truncate-lit-pos-cache comment-line-break-function c-indent-new-comment-line comment-multi-line electric-indent-chars "{}():;," electric-layout-rules ((59 . after) (123 . after) (125 . before)) paragraph-start paragraph-separate paragraph-ignore-fill-prefix adaptive-fill-mode adaptive-fill-regexp c-initialize-builtin-style cc-choose-style-for-mode c-set-style "* " "//+\\|\\**" c-setup-paragraph-variables run-mode-hooks js-mode-hook imenu-case-fold-search imenu-create-index-function c-default-style c-block-comment-prefix c-comment-prefix-regexp] 14 (#$ . 120593) nil])
(defvar js-jsx-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [js-jsx-mode-hook variable-documentation put "Hook run after entering JavaScript mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp js-jsx-mode-map definition-name js-jsx-mode] 4)
(defvar js-jsx-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\210\303\311\323\324#\207" [js-jsx-mode-abbrev-table js-jsx-mode-map variable-documentation put purecopy "Keymap for `js-jsx-mode'." boundp js-jsx-mode-syntax-table definition-name js-jsx-mode (lambda (#1=#:def-tmp-var) (defvar js-jsx-mode-syntax-table #1#)) make-syntax-table "Syntax table for `js-jsx-mode'." (lambda (#1#) (defvar js-jsx-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `js-jsx-mode'." derived-mode-parent js-mode custom-mode-group js] 5)
#@716 Major mode for editing JavaScript+JSX.

Simply makes `js-jsx-syntax' buffer-local and sets it to t.

`js-mode' may detect and enable support for JSX automatically if
it appears to be used in a JavaScript file.  You could also
customize `js-jsx-regexps' to improve that detection; or, you
could set `js-jsx-syntax' to t in your init file, or in a
.dir-locals.el file, or using file variables; or, you could call
`js-jsx-enable' in `js-mode-hook'.  You may be better served by
one of the aforementioned options instead of using this mode.

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

\{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
\325C#\210\327!\210\330\f!\210
\331 \210\306\332!\210\333\334 \210)\335\336!\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 "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 js-jsx-enable comment-region-function js-jsx--comment-region js-use-syntactic-mode-name run-mode-hooks js-jsx-mode-hook local-abbrev-table] 5 (#$ . 180010) nil])
#@30 

(fn BEG END &optional ARG)
(defalias 'js-jsx--comment-region #[770 "\302 \204\212\303\304w\210\305 )\203\306\307\310#*\207\310#\207" [comment-end comment-start js-jsx--context " 	" nil js-jsx--looking-at-start-tag-p "{/* " " */}" comment-region-default] 7 (#$ . 181576)])
(byte-code "\300\301\302\"\210\303\304\305\306F\211\203 \211@\307\310\311!\312B\"\210
A\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)