| blob | e6ffe4d75a60879553101ed5e335a8e51ba8fc6a |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2017 Free Software Foundation, Inc.
5 ;; Author: Karl Landstrom <karl.landstrom@brgeight.se>
6 ;; Daniel Colascione <dan.colascione@gmail.com>
7 ;; Maintainer: Daniel Colascione <dan.colascione@gmail.com>
8 ;; Version: 9
9 ;; Date: 2009-07-25
10 ;; Keywords: languages, javascript
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;;; Commentary
29 ;; This is based on Karl Landstrom's barebones javascript-mode. This
30 ;; is much more robust and works with cc-mode's comment filling
31 ;; (mostly).
32 ;;
33 ;; The main features of this JavaScript mode are syntactic
34 ;; highlighting (enabled with `font-lock-mode' or
35 ;; `global-font-lock-mode'), automatic indentation and filling of
36 ;; comments, C preprocessor fontification, and MozRepl integration.
37 ;;
38 ;; General Remarks:
39 ;;
40 ;; XXX: This mode assumes that block comments are not nested inside block
41 ;; XXX: comments
42 ;;
43 ;; Exported names start with "js-"; private names start with
44 ;; "js--".
46 ;;; Code:
69 ;;; Constants
91 "Regexp matching the prefix of a cpp directive.
92 This includes the directive name, or nil in languages without
93 preprocessor support. The first submatch surrounds the directive
100 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
109 ;; var NewClass = BaseClass.extend(
117 ;; var NewClass = Class.create()
133 ;; var NewClass = Class.create({
140 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
141 ;; matched with dedicated font-lock matchers
169 :prototype t
175 :prototype t
191 :prototype t
197 :prototype t
208 :prototype t
222 "List of JavaScript class definition styles.
224 A class definition style is a plist with the following keys:
226 :name is a human-readable name of the class type
228 :class-decl is a regular expression giving the start of the
229 class. Its first group must match the name of its class. If there
230 is a parent class, the second group should match, and it should be
231 the name of the class.
233 If :prototype is present and non-nil, the parser will merge
234 declarations for this constructs with others at the same lexical
235 level that have the same name. Otherwise, multiple definitions
236 will create multiple top-level entries. Don't use :prototype
237 unnecessarily: it has an associated cost in performance.
239 If :strip-prototype is present and non-nil, then if the class
240 name as matched contains
247 collect framework into available-frameworks
248 finally return available-frameworks)
254 "Regexp matching the start of a JavaScript function header.
260 "Regexp matching the start of a function entry in an associative array.
272 "Regexp matching a CPP macro definition, up to the opening parenthesis.
322 ;; js--pitem is the basic building block of the lexical
323 ;; database. When one refers to a real part of the buffer, the region
324 ;; of text to which it refers is split into a conceptual header and
325 ;; body. Consider the (very short) block described by a hypothetical
326 ;; js--pitem:
327 ;;
328 ;; function foo(a,b,c) { return 42; }
329 ;; ^ ^ ^
330 ;; | | |
331 ;; +- h-begin +- h-end +- b-end
332 ;;
333 ;; (Remember that these are buffer positions, and therefore point
334 ;; between characters, not at them. An arrow drawn to a character
335 ;; indicates the corresponding position is between that character and
336 ;; the one immediately preceding it.)
337 ;;
338 ;; The header is the region of text [h-begin, h-end], and is
339 ;; the text needed to unambiguously recognize the start of the
340 ;; construct. If the entire header is not present, the construct is
341 ;; not recognized at all. No other pitems may be nested inside the
342 ;; header.
343 ;;
344 ;; The body is the region [h-end, b-end]. It may contain nested
345 ;; js--pitem instances. The body of a pitem may be empty: in
346 ;; that case, b-end is equal to header-end.
347 ;;
348 ;; The three points obey the following relationship:
349 ;;
350 ;; h-begin < h-end <= b-end
351 ;;
352 ;; We put a text property in the buffer on the character *before*
353 ;; h-end, and if we see it, on the character *before* b-end.
354 ;;
355 ;; The text property for h-end, js--pstate, is actually a list
356 ;; of all js--pitem instances open after the marked character.
357 ;;
358 ;; The text property for b-end, js--pend, is simply the
359 ;; js--pitem that ends after the marked character. (Because
360 ;; pitems always end when the paren-depth drops below a critical
361 ;; value, and because we can only drop one level per character, only
362 ;; one pitem may end at a given character.)
363 ;;
364 ;; In the structure below, we only store h-begin and (sometimes)
365 ;; b-end. We can trivially and quickly find h-end by going to h-begin
366 ;; and searching for an js--pstate text property. Since no other
367 ;; js--pitem instances can be nested inside the header of a
368 ;; pitem, the location after the character with this text property
369 ;; must be h-end.
370 ;;
371 ;; js--pitem instances are never modified (with the exception
372 ;; of the b-end field). Instead, modified copies are added at
373 ;; subsequence parse points.
374 ;; (The exception for b-end and its caveats is described below.)
375 ;;
378 ;; IMPORTANT: Do not alter the position of fields within the list.
379 ;; Various bits of code depend on their positions, particularly
380 ;; anything that manipulates the list of children.
382 ;; List of children inside this pitem's body
385 ;; When we reach this paren depth after h-end, the pitem ends
388 ;; Symbol or class-style plist if this is a class
391 ;; See above
394 ;; List of strings giving the parts of the name of this pitem (e.g.,
395 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
398 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
399 ;; this pitem: when we copy-and-modify pitem instances, we share
400 ;; their tail structures, so all the copies actually have the same
401 ;; terminating cons cell. We modify that shared cons cell directly.
402 ;;
403 ;; The field value is either a number (buffer location) or nil if
404 ;; unknown.
405 ;;
406 ;; If the field's value is greater than `js--cache-end', the
407 ;; value is stale and must be treated as if it were nil. Conversely,
408 ;; if this field is nil, it is guaranteed that this pitem is open up
409 ;; to at least `js--cache-end'. (This property is handy when
410 ;; computing whether we're inside a given pitem.)
411 ;;
414 ;; The pitem we start parsing with.
417 :paren-depth most-negative-fixnum
420 ;;; User Customization
423 "Customization variables for JavaScript mode."
428 "Number of spaces for each indentation step in `js-mode'."
434 "Number of additional spaces for indenting continued expressions.
435 The value must be no less than minus `js-indent-level'."
441 "Number of additional spaces for indenting expressions in parentheses.
442 The value must be no less than minus `js-indent-level'."
449 "Number of additional spaces for indenting expressions in square braces.
450 The value must be no less than minus `js-indent-level'."
457 "Number of additional spaces for indenting expressions in curly braces.
458 The value must be no less than minus `js-indent-level'."
465 "Number of additional spaces for indenting the contents of a switch block.
466 The value must not be negative."
473 "Treat nested functions as top-level functions in `js-mode'.
474 This applies to function movement, marking, and so on."
479 "Align continuation of non-empty ([{ lines in `js-mode'."
484 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
489 "Frameworks recognized by `js-mode'.
490 To improve performance, you may turn off some frameworks you
491 seldom use, either globally or on a per-buffer basis."
494 js--available-frameworks))
499 "Whether `js-mode' should display tabs while selecting them.
500 This is useful only if the windowing system has a good mechanism
501 for preventing Firefox from stealing the keyboard focus."
506 "~/.emacs.d/js/js"
507 "Temporary directory used by `js-mode' to communicate with Mozilla.
508 This directory must be readable and writable by both Mozilla and Emacs."
513 "Reply timeout for executing commands in Mozilla via `js-mode'.
514 The value is given in seconds. Increase this value if you are
515 getting timeout messages."
520 "Non-nil means specially indent the first variable declaration's initializer.
521 Normally, the first declaration's initializer is unindented, and
522 subsequent declarations have their identifiers aligned with it:
524 var o = {
525 foo: 3
526 };
528 var o = {
529 foo: 3
530 },
531 bar = 2;
533 If this option has the value t, indent the first declaration's
534 initializer by an additional level:
536 var o = {
537 foo: 3
538 };
540 var o = {
541 foo: 3
542 },
543 bar = 2;
545 If this option has the value `dynamic', if there is only one declaration,
546 don't indent the first one's initializer; otherwise, indent it.
548 var o = {
549 foo: 3
550 };
552 var o = {
553 foo: 3
554 },
555 bar = 2;"
567 let x = svg.mumble()
568 .chained;
569 "
575 ;;; KeyMap
591 keymap)
594 ;;; Syntax table and parsing
601 table)
632 "Helper function for `js--update-quick-match-re'.
633 If LIST contains any element that is not nil, return its non-nil
634 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
635 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
636 nil. If any element in LIST is itself a list, flatten that
637 element."
643 "Internal function used by `js-mode' for caching buffer constructs.
644 This updates `js--quick-match-re', based on the current set of
645 enabled frameworks."
650 ;; #define mumble
659 ;; var mumble = THING (
680 ;; mumble.prototypeTHING
688 ;; mumble.prototype = {
695 "Move over the next value of PROPNAME in the buffer.
696 If found, return that value and leave point after the character
697 having that value; otherwise, return nil and leave point at EOB."
708 next-value))
711 "Move over the previous value of PROPNAME in the buffer.
712 If found, return that value and leave point just before the
713 character that has that value, otherwise return nil and leave
714 point at BOB."
727 prev-value)))
740 "Helper function for `js--re-search-forward'."
742 str-terminator
771 "Search forward, ignoring strings, cpp macros, and comments.
772 This function invokes `re-search-forward', but treats the buffer
773 as if strings, cpp macros, and comments have been removed.
775 If invoked while inside a macro, it treats the contents of the
776 macro as normal text."
793 "Auxiliary function for `js--re-search-backward'."
795 str-terminator
826 "Search backward, ignoring strings, preprocessor macros, and comments.
828 This function invokes `re-search-backward' but treats the buffer
829 as if strings, preprocessor macros, and comments have been
830 removed.
832 If invoked while inside a macro, treat the macro as normal text."
836 "Move forward over a whole JavaScript expression.
837 This function doesn't move over expressions continued across
838 lines."
840 ;; non-continued case; simplistic, but good enough?
853 "Move forward over a JavaScript function declaration.
854 This puts point at the `function' keyword.
856 If this is a syntactically-correct non-expression function,
857 return the name of the function, or t if the name could not be
858 determined. Otherwise, return nil."
874 name)))))
877 "Return the start of the JavaScript function prologue containing POS.
878 A function prologue is everything from start of the definition up
879 to and including the opening brace. POS defaults to point.
880 If POS is not in a function prologue, return nil."
907 "Helper function for `js-beginning-of-defun'.
908 Go to previous defun-beginning and return the parse state for it,
909 or nil if we went all the way back to bob and don't find
910 anything."
918 "Helper function for `js--beginning-of-defun-nested'.
919 If PSTATE represents a non-empty top-level defun, return the
920 top-most pitem. Otherwise, return nil."
923 with func-pitem
930 "Helper function for `js--beginning-of-defun'.
931 Return the pitem of the function we went to the beginning of."
933 ;; Look for the smallest function that encloses point...
938 and return pitem)
940 ;; ...and if that isn't found, look for the previous top-level
941 ;; defun
943 while pstate
946 and return it)))
949 "Helper function for `js-beginning-of-defun'."
955 "Value of `beginning-of-defun-function' for `js-mode'."
971 ;; If we're just past the end of a function, the user probably wants
972 ;; to go to the beginning of *that* function
986 "Flush the `js-mode' syntax cache after position BEG.
987 BEG defaults to `point-min', meaning to flush the entire cache."
993 ;; `(message ,@arguments)
994 )
1003 ;; open-items must contain at least two items for this to
1004 ;; work, but because we push a dummy item to start with,
1005 ;; that assumption holds.
1008 open-items)
1011 "Helper function for `js--ensure-cache'.
1012 Update parsing information up to point, referring to parse,
1013 prev-parse-point, goal-point, and open-items bound lexically in
1014 the body of `js--ensure-cache'."
1021 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
1022 ;; the given depth -- i.e., make sure we're deeper than the target
1023 ;; depth.
1027 prev-parse-point goal-point
1029 nil parse))
1031 ;; (let ((overlay (make-overlay prev-parse-point (point))))
1032 ;; (overlay-put overlay 'face '(:background "red"))
1033 ;; (unwind-protect
1034 ;; (progn
1035 ;; (js--debug "parsed: %S" parse)
1036 ;; (sit-for 1))
1037 ;; (delete-overlay overlay)))
1053 "Split a JavaScript name into its dot-separated parts.
1054 This also removes any prototype parts from the split name
1066 "Guess the name of the JavaScript function at POSITION.
1068 Return the name of the function, or nil if the name could not be
1069 guessed.
1071 This function clobbers match data. If we find the preamble
1072 begins earlier than expected while guessing the function name,
1073 set `js--guess-function-name-start' to that position; otherwise,
1074 set that variable to nil."
1091 ;; Clear any endings that occur after point
1098 ;; Remove any cache properties after this point
1103 "Ensures brace cache is valid up to the character before LIMIT.
1104 LIMIT defaults to point."
1110 parse
1111 prev-parse-point
1112 name
1113 case-fold-search
1114 filtered-class-styles
1115 goal-point)
1117 ;; Figure out which class styles we need to look for
1121 js-enabled-frameworks)
1122 collect style))
1128 ;; Find last known good position
1144 ;; Make a placeholder for the top-level definition
1160 ;; Each of these conditions should return non-nil if
1161 ;; we should add a new item and leave point at the end
1162 ;; of the new item's header (h-end in the
1163 ;; js--pitem diagram). This point is the one
1164 ;; after the last character we need to unambiguously
1165 ;; detect this construct. If one of these evaluates to
1166 ;; nil, the location of the point is ignored.
1168 ;; In comment or string
1171 ;; Regular function declaration
1180 js--guess-function-name-start))
1187 :paren-depth orig-depth
1188 :h-begin orig-match-start
1191 name
1194 ;; Macro
1197 ;; Macros often contain unbalanced parentheses.
1198 ;; Make sure that h-end is at the textual end of
1199 ;; the macro no matter what the parenthesis say.
1205 :h-begin orig-match-start
1209 ;; "Prototype function" declaration
1216 :paren-depth orig-depth
1217 :h-begin orig-match-start
1223 ;; Class definition
1225 with syntactic-context =
1227 for class-style in filtered-class-styles
1233 and return
1235 :paren-depth orig-depth
1236 :h-begin orig-match-start
1237 :type class-style
1252 )))))
1255 "Helper function for `js-end-of-defun'."
1260 return t
1264 "Helper function for `js-end-of-defun'."
1273 found)
1276 ;; We're already inside a function; just go to its end.
1279 ;; Otherwise, go to the end of the next function...
1286 ;; ... or eob.
1290 "Value of `end-of-defun-function' for `js-mode'."
1301 ;; look for function backward. if we're inside it, go to that
1302 ;; function's end. otherwise, search for the next function's end and
1303 ;; go there
1307 ;; if we're doing nested functions, see whether we're in the
1308 ;; prologue. If we are, go to the end of the function; otherwise,
1309 ;; call js--end-of-defun-nested to do the real work
1330 t
1332 nil))))
1335 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1346 pos
1350 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1360 pos
1363 ;; Like (up-list -1), but only considers lists that end nearby"
1366 ;; Look at a very small region so our computation time doesn't
1367 ;; explode in pathological cases.
1372 "Return non-nil if point is in a function parameter list."
1383 "Return non-nil if point is in a Dojo multiple-inheritance class block."
1394 ;;; Font Lock
1396 "Helper function for building `js--font-lock-keywords'.
1397 Create a byte-compiled function for matching a concatenation of
1398 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1409 "Move forward over a JavaScript destructuring spec.
1410 If FUNC is supplied, call it with no arguments before every
1411 variable name in the spec. Return true if this was actually a
1412 spec. FUNC must preserve the match data."
1424 t)
1429 t))))
1432 t))
1446 t))
1451 t)))))
1454 t))))
1457 "Font-lock matcher for variable names in a variable declaration.
1458 This is a cc-mode-style matcher that *always* fails, from the
1459 point of view of font-lock. It applies highlighting directly with
1460 `font-lock-apply-highlight'."
1472 t))
1494 ;; Conditions to handle
1498 ;; Matcher always "fails"
1499 nil)
1502 `(
1503 ;; This goes before keywords-2 so it gets used preferentially
1504 ;; instead of the keywords in keywords-2. Don't use override
1505 ;; because that will override syntactic fontification too, which
1506 ;; will fontify commented-out directives as if they weren't
1507 ;; commented out.
1510 ,@js--font-lock-keywords-2
1515 ;; Highlights class being declared, in parts
1519 nil
1522 ;; Highlights parent class, in parts, if available
1539 ;; Highlights parent class
1543 ;; Dojo needs its own matcher to override the string highlighting
1545 'dojo
1552 ;; Match Dojo base classes. Of course Mojo has to be different
1553 ;; from everything else under the sun...
1555 'dojo
1564 ;; continued Dojo base-class list
1566 'dojo
1577 ;; variable declarations
1582 ;; class instantiation
1587 ;; instanceof
1592 ;; formal parameters
1596 js--name-start-re)
1602 ;; continued formal parameter list
1616 "Return whether point is inside the given pitem's header or body."
1626 "Parse the JavaScript program state at point.
1627 Return a list of `js--pitem' instances that apply to point, most
1628 specific first. In the worst case, the current toplevel instance
1629 will be returned."
1638 ;; Loop until we either hit a pitem at BOB or pitem ends after
1639 ;; point (or at point if we're at eob)
1646 pstate))))
1649 "Return the JavaScript syntactic context corresponding to PSTATE."
1652 type)
1658 "Return the JavaScript syntactic context at point.
1659 When called interactively, also display a message with that
1660 context."
1668 syntactic-context))
1671 "Font lock function used by `js-mode'.
1672 This performs fontification according to `js--class-styles'."
1680 js-enabled-frameworks)
1683 decl-re
1686 and return t)
1687 return t
1692 js--font-lock-keywords-2
1693 js--font-lock-keywords-3)
1697 "Return syntactic face given STATE."
1699 font-lock-string-face
1703 font-lock-doc-face
1704 font-lock-comment-face)))
1708 ;; Start of regexp.
1709 "/"
1711 ;; Match characters outside of a character class.
1713 ;; Match backslash quoted characters.
1715 ;; Match character class.
1717 "["
1728 ;; A /.../ regexp.
1731 ;; Don't touch text after END.
1739 ;; JavaScript allows immediate regular expression objects, written /.../.
1744 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1745 ;; FIXME: Allow regexps after infix ops like + ...
1746 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1747 ;; We can probably just add +, -, <, >, %, ^, ~, ?, : at which
1748 ;; point I think only * and / would be missing which could also be added,
1749 ;; but need care to avoid affecting the // and */ comment markers.
1754 ;; If the / is at the beginning of line, we have to check
1755 ;; the end of the previous text.
1773 ;;; Indentation
1791 "Return non-nil if point is on a JavaScript operator, other than a comma."
1806 ;; Generator method (possibly using computed property).
1810 ;; We might misindent some expressions that would
1811 ;; return NaN anyway. Shouldn't be a problem.
1815 "Move backward to the nearest newline that is not in a block comment."
1822 ;; We match the end of a // comment but not a newline in a
1823 ;; block comment.
1826 ;; If we saw a block comment, keep trying.
1830 result))
1833 "Return non-nil if the current line continues an expression."
1852 "Skip a term before point; return t if a term was skipped."
1854 ;; Skip backward over balanced parens.
1858 ;; First skip whitespace.
1860 ;; Now if we're looking at closing paren, skip to the opener.
1861 ;; This doesn't strictly follow JS syntax, in that we might
1862 ;; skip something nonsensical like "()[]{}", but it is enough
1863 ;; if it works ok for valid input.
1867 ;; Maybe skip over a symbol.
1871 ;; Skipped.
1875 ;; Did not skip, so restore point.
1882 "Skip any number of terms backward.
1884 Returns t if successful, nil if no term was found."
1886 ;; Found at least one.
1891 t)))
1894 "A helper for js--proper-indentation that handles chained expressions.
1895 A chained expression is when the current line starts with '.' and the
1896 previous line also has a '.' expression.
1897 This function returns the indentation for the current line if it is
1898 a chained expression line; otherwise nil.
1899 This should only be called while point is at the start of the line's content,
1900 as determined by `back-to-indentation'."
1911 Otherwise, return nil. A braceless do-while statement spanning
1912 several lines requires that the start of the loop is indented to
1913 the same column as the current line."
1935 "Helper function for `js--proper-indentation'.
1936 Return the proper indentation of the current line if it starts
1937 the body of a control statement without braces; otherwise, return
1938 nil."
1967 "Helper function for `js--proper-indentation'.
1968 Return the proper indentation of the current line if it belongs to a declaration
1969 statement spanning multiple lines; otherwise, return nil."
1971 at-opening-bracket)
1998 "Return non-nil if we think we're in an array comprehension.
1999 In particular, return the buffer position of the first `for' kwd."
2016 ;; Nothing to do here.
2017 nil)))
2018 ;; To skip arbitrary expressions we need the parser,
2019 ;; so we'll just guess at it.
2022 ;; Not inside comment or string literal.
2030 ;; First continuation line.
2041 "Helper function for `js--proper-indentation'.
2042 Depending on the value of `js-indent-first-init', move
2043 point to the end of a variable declaration keyword so that
2044 indentation is aligned to that column."
2051 declaration-keyword-end
2052 at-closing-bracket-p
2053 forward-sexp-function ; Use Lisp version.
2054 comma-p)
2063 t)
2072 "Return the proper indentation for the current line."
2080 ;; Indent array comprehension continuation lines specially.
2082 beg)
2086 ;; At or after the first loop?
2093 ;; A single closing paren/bracket should be indented at the
2094 ;; same level as the opening statement. Same goes for
2095 ;; "case" and "default".
2111 in-switch-p)))
2117 js-expr-indent-offset))
2126 indent)))
2127 ;; If there is something following the opening
2128 ;; paren/bracket, everything else should be indented at
2129 ;; the same level.
2139 ;;; JSX Indentation
2142 "Find where JSX starts.
2144 Assume JSX appears in the following instances:
2145 - Inside parentheses, when returned or as the first argument
2146 to a function, and after a newline
2147 - When assigned to variables or object properties, but only
2148 on a single line
2149 - As the N+1th argument to a function
2152 nil t), except set point to the end of the match. This logic
2153 executes up to the number of lines in the file, so it should be
2154 really fast to reduce that impact."
2162 pos))
2169 "Find where JSX ends.
2170 This complements the assumption of where JSX appears from
2174 "Determine if/how the current line should be indented as JSX.
2176 Return `first' for the first JSXElement on its own line.
2177 Return `nth' for subsequent lines of the first JSXElement.
2178 Return `expression' for an embedded JS expression.
2179 Return `after' for anything after the last JSXElement.
2180 Return nil for non-JSX lines.
2182 Currently, JSX indentation supports the following styles:
2184 - Single-line elements (indented like normal JS):
2186 var element = <div></div>;
2188 - Multi-line elements (enclosed in parentheses):
2190 function () {
2191 return (
2192 <div>
2193 <div></div>
2194 </div>
2195 );
2196 }
2198 - Function arguments:
2200 React.render(
2201 <div></div>,
2202 document.querySelector('.root')
2203 );"
2206 last-pos
2207 before-tag-pos before-tag-line
2208 tag-start-pos tag-start-line
2209 tag-end-pos tag-end-line
2210 after-tag-line
2211 parens paren type)
2214 ;; Determine if we're inside a jsx element
2224 tag-start-pos)
2229 ;; A "before" line which also starts an element begins with js, so
2230 ;; indent it like js
2232 ;; Only indent the jsx lines like jsx
2235 ;; Analyze bounds if there are any
2242 tag-end-pos)
2246 ;; Ensure we're actually within the bounds of the jsx
2248 ;; An "after" line which does not end an element begins with
2249 ;; js, so indent it like js
2252 ;; Handle another case where there could be e.g. comments after
2253 ;; the element
2257 ;; They may not be any bounds (yet)
2259 ;; Check if we're inside an embedded multi-line js expression
2269 ;; Curly bracket indicates the start of an embedded expression
2271 ;; The first line of the expression is indented like sgml
2273 ;; Check if within a closing curly bracket (if any)
2274 ;; (exclusive, as the closing bracket is indented like sgml)
2282 ;; Indicate this guy will be indented specially
2285 t)
2289 ;; Indent the first jsx thing like js so we can indent future jsx things
2290 ;; like sgml relative to the first thing
2295 "Execute BODY as if in sgml-mode."
2298 parse-sexp-lookup-properties)
2302 "Indent the current line as JavaScript or SGML (whichever is farther)."
2305 ;; Don't whine about errors/warnings when we're indenting.
2306 ;; This has to be set before calling parse-partial-sexp below.
2310 ;; Don't touch multiline strings.
2317 'noindent
2318 ;; Use whichever indentation column is greater, such that the sgml
2319 ;; column is effectively a minimum
2327 "Indent the current line as JavaScript."
2337 "Indent the current line as JSX (with SGML offsets).
2338 i.e., customize JSX element indentation with `sgml-basic-offset',
2339 `sgml-attribute-offset' et al."
2347 ;; Don't treat this first thing as a continued expression (often a "<" or
2348 ;; ">" causes this misinterpretation)
2355 ;;; Filling
2359 ;; FIXME: Such redefinitions are bad style. We should try and use some other
2360 ;; way to get the same result.
2364 ad-do-it))
2369 ad-do-it))
2374 ad-do-it))
2377 "Fill the paragraph with `c-fill-paragraph'."
2383 ;;; Type database and Imenu
2385 ;; We maintain a cache of semantic information, i.e., the classes and
2386 ;; functions we've encountered so far. In order to avoid having to
2387 ;; re-parse the buffer on every change, we cache the parse state at
2388 ;; each interesting point in the buffer. Each parse state is a
2389 ;; modified copy of the previous one, or in the case of the first
2390 ;; parse state, the empty state.
2391 ;;
2392 ;; The parse state itself is just a stack of js--pitem
2393 ;; instances. It starts off containing one element that is never
2394 ;; closed, that is initially js--initial-pitem.
2395 ;;
2403 name
2405 type
2409 "Helper function for `js--splice-into-items'.
2410 Return a new item that is the result of merging CHILD into
2411 ITEM. NAME-PARTS is a list of parts of the name of CHILD
2412 that we haven't consumed yet."
2417 ;; If the item we're merging into isn't a class, make it into one
2423 ;; Use the child's class-style if it's available
2425 js--dummy-class-style
2430 ;; Now we can merge either a function or a class into a class
2434 ;; if we have more name-parts to go before we get to the
2435 ;; bottom of the class hierarchy, call the merger
2436 ;; recursively
2442 ;; Not merging a class, but something else, so just prepend
2443 ;; it
2447 ;; Otherwise, merge the new child's items into those
2448 ;; of the new class
2454 "Last part of the name of PITEM, as a string or symbol."
2458 name)))
2461 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
2462 If a class doesn't exist in the tree, create it. Return
2463 the new items list. NAME-PARTS is a list of strings given
2464 the broken-down class name of the item to insert."
2468 new-items last-new-item new-cons)
2471 name-parts
2477 ;; If top-name isn't found in items, then we build a copy of items
2478 ;; and throw it away. But that's okay, since most of the time, we
2479 ;; *will* find an instance.
2483 ;; Okay, we found an entry with the right name. Splice
2484 ;; the merged item into the list...
2487 name-parts)
2494 ;; ...and terminate the loop
2495 nil)
2498 ;; Otherwise, copy the current cons and move onto the
2499 ;; text. This is tricky; we keep track of the tail of
2500 ;; the list that begins with new-items in
2501 ;; last-new-item.
2508 ;; Go to the next cell in items
2512 ;; Yay! We stopped because we found something, not because
2513 ;; we ran out of items to search. Just return the new
2514 ;; list.
2517 new-items)
2519 ;; We didn't find anything. If the child is a class and we don't
2520 ;; have any classes to drill down into, just push that class;
2521 ;; otherwise, make a fake class and carry on.
2524 ;; We have name-parts left to process. Make a fake
2525 ;; class for this particular part...
2527 ;; ...and recursively digest the rest of the name
2530 :type js--dummy-class-style
2533 ;; Otherwise, this is the only name we have, so stick
2534 ;; the item on the front of the list
2535 child)
2536 items))))
2539 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2544 t))
2546 ;; This trick works because we know (based on our defstructs) that
2547 ;; the child list is always the first element, and so the second
2548 ;; element and beyond can be shared when we make our "copy".
2555 ;; Use slow path because we need class lookup
2561 ;; Use slow path because we need class merging. We know
2562 ;; name is a list here because down in
2563 ;; `js--ensure-cache', we made sure to only add
2564 ;; class entries with lists for :name
2569 ;; Fast path
2575 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2578 location))
2581 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2598 imenu-items))
2603 unknown-ctr))
2606 imenu-items))
2615 imenu-items))))
2619 imenu-items))
2622 "Return an imenu index for the current buffer."
2634 ;; Make sure everything is closed
2642 ;; Convert the new-finalized state into what imenu expects
2645 unknown-ctr))))))
2647 ;; Silence the compiler.
2658 symbols)
2659 else
2670 "Return a hash table of all JavaScript symbols.
2671 This searches all existing `js-mode' buffers. Each key is the
2672 name of a symbol (possibly disambiguated with <N>, where N > 1),
2673 and each value is a marker giving the location of that symbol."
2675 with imenu-use-markers = t
2676 for buffer being the buffers
2681 finally return symbols))
2687 "Helper function for `js-find-symbol'.
2688 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2689 one from `js--get-all-known-symbols', using prompt PROMPT and
2690 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2691 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2692 marker."
2698 prompt
2700 collect key)
2716 ;; etags loads ring.
2720 "Read a JavaScript symbol and jump to it.
2721 With a prefix argument, restrict symbols to those from the
2722 current buffer. Pushes a mark onto the tag ring just like
2723 `find-tag'."
2734 symbols "Jump to: "
2742 ;;; MozRepl integration
2749 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2750 On timeout, return nil. On success, return t with match data
2751 set. If START is non-nil, look for output starting from START.
2752 Otherwise, use the current value of `process-mark'."
2764 'js-moz-bad-rpc
2768 ;; Integer, mirrors the value we see in JS
2771 ;; Process to which this thing belongs
2792 ; */" Make Emacs happy
2793 "(function(repl) {
2794 repl.defineInteractor('js', {
2795 onStart: function onStart(repl) {
2796 if(!repl._jsObjects) {
2797 repl._jsObjects = {};
2798 repl._jsLastID = 0;
2799 repl._jsGC = this._jsGC;
2800 }
2801 this._input = '';
2802 },
2804 _jsGC: function _jsGC(ids_in_use) {
2805 var objects = this._jsObjects;
2806 var keys = [];
2807 var num_freed = 0;
2809 for(var pn in objects) {
2810 keys.push(Number(pn));
2811 }
2813 keys.sort(function(x, y) x - y);
2814 ids_in_use.sort(function(x, y) x - y);
2815 var i = 0;
2816 var j = 0;
2818 while(i < ids_in_use.length && j < keys.length) {
2819 var id = ids_in_use[i++];
2820 while(j < keys.length && keys[j] !== id) {
2821 var k_id = keys[j++];
2822 delete objects[k_id];
2823 ++num_freed;
2824 }
2825 ++j;
2826 }
2828 while(j < keys.length) {
2829 var k_id = keys[j++];
2830 delete objects[k_id];
2831 ++num_freed;
2832 }
2834 return num_freed;
2835 },
2837 _mkArray: function _mkArray() {
2838 var result = [];
2839 for(var i = 0; i < arguments.length; ++i) {
2840 result.push(arguments[i]);
2841 }
2842 return result;
2843 },
2845 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2846 if(typeof parts === 'string') {
2847 parts = [ parts ];
2848 }
2850 var obj = parts[0];
2851 var start = 1;
2853 if(typeof obj === 'string') {
2854 obj = window;
2855 start = 0;
2856 } else if(parts.length < 2) {
2857 throw new Error('expected at least 2 arguments');
2858 }
2860 for(var i = start; i < parts.length - 1; ++i) {
2861 obj = obj[parts[i]];
2862 }
2864 return [obj, parts[parts.length - 1]];
2865 },
2867 _getProp: function _getProp(/*...*/) {
2868 if(arguments.length === 0) {
2869 throw new Error('no arguments supplied to getprop');
2870 }
2872 if(arguments.length === 1 &&
2873 (typeof arguments[0]) !== 'string')
2874 {
2875 return arguments[0];
2876 }
2878 var [obj, propname] = this._parsePropDescriptor(arguments);
2879 return obj[propname];
2880 },
2882 _putProp: function _putProp(properties, value) {
2883 var [obj, propname] = this._parsePropDescriptor(properties);
2884 obj[propname] = value;
2885 },
2887 _delProp: function _delProp(propname) {
2888 var [obj, propname] = this._parsePropDescriptor(arguments);
2889 delete obj[propname];
2890 },
2892 _typeOf: function _typeOf(thing) {
2893 return typeof thing;
2894 },
2896 _callNew: function(constructor) {
2897 if(typeof constructor === 'string')
2898 {
2899 constructor = window[constructor];
2900 } else if(constructor.length === 1 &&
2901 typeof constructor[0] !== 'string')
2902 {
2903 constructor = constructor[0];
2904 } else {
2905 var [obj,propname] = this._parsePropDescriptor(constructor);
2906 constructor = obj[propname];
2907 }
2909 /* Hacky, but should be robust */
2910 var s = 'new constructor(';
2911 for(var i = 1; i < arguments.length; ++i) {
2912 if(i != 1) {
2913 s += ',';
2914 }
2916 s += 'arguments[' + i + ']';
2917 }
2919 s += ')';
2920 return eval(s);
2921 },
2923 _callEval: function(thisobj, js) {
2924 return eval.call(thisobj, js);
2925 },
2927 getPrompt: function getPrompt(repl) {
2928 return 'EVAL>'
2929 },
2931 _lookupObject: function _lookupObject(repl, id) {
2932 if(typeof id === 'string') {
2933 switch(id) {
2934 case 'global':
2935 return window;
2936 case 'nil':
2937 return null;
2938 case 't':
2939 return true;
2940 case 'false':
2941 return false;
2942 case 'undefined':
2943 return undefined;
2944 case 'repl':
2945 return repl;
2946 case 'interactor':
2947 return this;
2948 case 'NaN':
2949 return NaN;
2950 case 'Infinity':
2951 return Infinity;
2952 case '-Infinity':
2953 return -Infinity;
2954 default:
2955 throw new Error('No object with special id:' + id);
2956 }
2957 }
2959 var ret = repl._jsObjects[id];
2960 if(ret === undefined) {
2961 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2962 }
2963 return ret;
2964 },
2966 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2967 if(typeof value !== 'object' && typeof value !== 'function') {
2968 throw new Error('_findOrAllocateObject called on non-object('
2969 + typeof(value) + '): '
2970 + value)
2971 }
2973 for(var id in repl._jsObjects) {
2974 id = Number(id);
2975 var obj = repl._jsObjects[id];
2976 if(obj === value) {
2977 return id;
2978 }
2979 }
2981 var id = ++repl._jsLastID;
2982 repl._jsObjects[id] = value;
2983 return id;
2984 },
2986 _fixupList: function _fixupList(repl, list) {
2987 for(var i = 0; i < list.length; ++i) {
2988 if(list[i] instanceof Array) {
2989 this._fixupList(repl, list[i]);
2990 } else if(typeof list[i] === 'object') {
2991 var obj = list[i];
2992 if(obj.funcall) {
2993 var parts = obj.funcall;
2994 this._fixupList(repl, parts);
2995 var [thisobj, func] = this._parseFunc(parts[0]);
2996 list[i] = func.apply(thisobj, parts.slice(1));
2997 } else if(obj.objid) {
2998 list[i] = this._lookupObject(repl, obj.objid);
2999 } else {
3000 throw new Error('Unknown object type: ' + obj.toSource());
3001 }
3002 }
3003 }
3004 },
3006 _parseFunc: function(func) {
3007 var thisobj = null;
3009 if(typeof func === 'string') {
3010 func = window[func];
3011 } else if(func instanceof Array) {
3012 if(func.length === 1 && typeof func[0] !== 'string') {
3013 func = func[0];
3014 } else {
3015 [thisobj, func] = this._parsePropDescriptor(func);
3016 func = thisobj[func];
3017 }
3018 }
3020 return [thisobj,func];
3021 },
3023 _encodeReturn: function(value, array_as_mv) {
3024 var ret;
3026 if(value === null) {
3027 ret = ['special', 'null'];
3028 } else if(value === true) {
3029 ret = ['special', 'true'];
3030 } else if(value === false) {
3031 ret = ['special', 'false'];
3032 } else if(value === undefined) {
3033 ret = ['special', 'undefined'];
3034 } else if(typeof value === 'number') {
3035 if(isNaN(value)) {
3036 ret = ['special', 'NaN'];
3037 } else if(value === Infinity) {
3038 ret = ['special', 'Infinity'];
3039 } else if(value === -Infinity) {
3040 ret = ['special', '-Infinity'];
3041 } else {
3042 ret = ['atom', value];
3043 }
3044 } else if(typeof value === 'string') {
3045 ret = ['atom', value];
3046 } else if(array_as_mv && value instanceof Array) {
3047 ret = ['array', value.map(this._encodeReturn, this)];
3048 } else {
3049 ret = ['objid', this._findOrAllocateObject(repl, value)];
3050 }
3052 return ret;
3053 },
3055 _handleInputLine: function _handleInputLine(repl, line) {
3056 var ret;
3057 var array_as_mv = false;
3059 try {
3060 if(line[0] === '*') {
3061 array_as_mv = true;
3062 line = line.substring(1);
3063 }
3064 var parts = eval(line);
3065 this._fixupList(repl, parts);
3066 var [thisobj, func] = this._parseFunc(parts[0]);
3067 ret = this._encodeReturn(
3068 func.apply(thisobj, parts.slice(1)),
3069 array_as_mv);
3070 } catch(x) {
3071 ret = ['error', x.toString() ];
3072 }
3074 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
3075 repl.print(JSON.encode(ret));
3076 repl._prompt();
3077 },
3079 handleInput: function handleInput(repl, chunk) {
3080 this._input += chunk;
3081 var match, line;
3083 line = match[0];
3086 repl.popInteractor();
3087 repl._prompt();
3088 return;
3089 }
3091 this._input = this._input.substring(line.length);
3092 this._handleInputLine(repl, line);
3093 }
3094 }
3095 });
3096 })
3102 "Marshall the given value for JS.
3103 Strings and numbers are JSON-encoded. Lists (including nil) are
3104 made into JavaScript array literals and their contents encoded
3105 with `js--js-encode-value'."
3132 js--js-repl-prompt-regexp js-js-timeout
3134 ;; start matching against the beginning of the line in
3135 ;; order to catch a prompt that's only partially arrived
3138 ;; Presumably "inferior-moz-process" loads comint.
3148 ;; Do some initialization the first time we see a process
3154 ;; Send interactor definition
3160 js-js-timeout))
3162 ;; Sanity check
3168 ;; If js--js-repl-depth > 0, we *should* be seeing an
3169 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
3170 ;; up with us.
3173 ;; Otherwise, tell Mozilla to enter the interactor mode
3179 js-js-timeout))
3193 js-js-timeout))))
3203 "Convert immediate js< and js! references to deferred ones."
3227 function))
3229 else
3230 collect item)))
3245 "Run FORMS with the Mozilla repl set up for js commands.
3246 Inside the lexical scope of `with-js', `js?', `js!',
3247 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
3248 `js-create-instance', and `js-qi' are defined."
3259 function)
3267 function)
3299 props)
3301 ))
3307 "Whether to listify any Array returned by a Mozilla function.
3314 (`array
3316 (`objid
3318 js--js-references)
3323 js--js-references)))
3331 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
3332 If function is a string, look it up as a property on the global
3333 object and use the global object for `this'.
3334 If FUNCTION is a list with one element, use that element as the
3335 function with the global object for `this', except that if that
3336 single element is a string, look it up on the global object.
3337 If FUNCTION is a list with more than one argument, use the list
3338 up to the last value as a property descriptor and the last
3339 argument as a function."
3346 ;; Actual funcall
3353 js-js-timeout)
3356 ;; Read the result
3363 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
3364 CONSTRUCTOR is a JS handle, a string, or a list of these things."
3367 constructor arguments))
3373 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
3376 arguments)))
3385 "Tell the repl about any objects we don't reference anymore.
3386 With argument, run even if no intervening GC has happened."
3397 ;; Don't bother running unless we've had an intervening
3398 ;; garbage collection; without a gc, nothing is deleted
3399 ;; from the weak hash table, so it's pointless telling
3400 ;; MozRepl about that references we still hold
3403 ;; Are we looking at a normal prompt? Make sure not to
3404 ;; interrupt the user if he's doing something
3412 of js--js-references
3413 collect x))
3420 num)))
3425 "Evaluate the JavaScript in JS and return JSON-decoded result."
3433 result)))
3436 "Enumerate all JavaScript contexts available.
3437 Each context is a list:
3438 (TITLE URL BROWSER TAB TABBROWSER) for content documents
3439 (TITLE URL WINDOW) for windows
3441 All tabs of a given window are grouped together. The most recent
3442 window is first. Within each window, the tabs are returned
3443 left-to-right."
3448 "@mozilla.org/appshell/window-mediator;1"
3474 "browsers"
3475 x
3476 "contentDocument"
3480 "browsers"
3481 x
3482 "contentWindow"
3483 "location"
3486 "browsers"
3487 x)
3490 "tabContainer"
3491 "childNodes"
3493 x)
3495 gbrowser))))))
3502 "Read a Mozilla tab with prompt PROMPT.
3503 Return a cons of (TYPE . OBJECT). TYPE is either `window' or
3504 `tab', and OBJECT is a JavaScript handle to a ChromeWindow or a
3505 browser, respectively."
3507 ;; Prime IDO
3514 selected-tab prev-hitab)
3516 ;; Disambiguate names
3519 for tab in tabs
3537 ;; Hack to reduce the number of
3538 ;; round-trips to mozilla
3541 ;; Highlighting tab
3544 "style"
3546 cmds)
3548 ;; Highlight window proper
3551 "style"
3553 cmds)
3555 ;; Select tab, when appropriate
3559 cmds)))
3561 ;; Highlighting whole window
3565 "style"
3568 cmds)))
3571 ;; Unhighlighting tab
3574 cmds)
3576 cmds))
3578 ;; Unhighlighting window
3583 cmds)))
3589 ()
3595 ()
3596 ;; Fiddle with the match list a bit: if our first match
3597 ;; is a tabbrowser window, rotate the match list until
3598 ;; the active tab comes up
3604 "document"
3605 "documentElement"
3610 "gBrowser"
3613 for match in ido-matches
3618 and return t)))
3624 ;; FIXME: Don't impose IDO on the user.
3629 prompt
3631 nil t nil
3648 "Helper function for `js-eval-defun'.
3649 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3650 strings making up the class name and NAME is the name of the
3651 function part."
3670 "The current JavaScript context.
3671 This is a cons like the one returned from `js--read-tab'.
3675 "(function(func_info,func) {
3676 func_info.unshift('window');
3677 var obj = window;
3678 for(var i = 1; i < func_info.length - 1; ++i) {
3679 var next = obj[func_info[i]];
3680 if(typeof next !== 'object' && typeof next !== 'function') {
3681 next = obj.prototype && obj.prototype[func_info[i]];
3682 if(typeof next !== 'object' && typeof next !== 'function') {
3683 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3684 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3685 return;
3686 }
3688 func_info.splice(i+1, 0, 'prototype');
3689 ++i;
3690 }
3691 }
3693 obj[func_info[i]] = func;
3694 alert('Successfully updated '+func_info.join('.'));
3698 "Set the JavaScript context to CONTEXT.
3699 When called interactively, prompt for CONTEXT."
3704 "Return a valid JavaScript context.
3705 If one hasn't been set, or if it's stale, prompt for a new one."
3715 js--js-context))
3730 file)))
3743 "Update a Mozilla tab using the JavaScript defun at point."
3746 ;; This function works by generating a temporary file that contains
3747 ;; the function we'd like to insert. We then use the elisp-js bridge
3748 ;; to command mozilla to load this file by inserting a script tag
3749 ;; into the document we set. This way, debuggers and such will have
3750 ;; a way to find the source of the just-inserted function.
3751 ;;
3752 ;; We delete the temporary file if there's an error, but otherwise
3753 ;; we add an unload event listener on the Mozilla side to delete the
3754 ;; file.
3785 ;; (Re)register a Mozilla resource URL to point to the
3786 ;; temporary directory
3804 ;; Give Mozilla responsibility for deleting this file
3809 ;; Regular content
3813 ;; Chrome
3835 ))
3837 ;; temp-name is set to nil on success
3841 ;;; Main Function
3843 ;;;###autoload
3845 "Major mode for editing JavaScript."
3854 . js-font-lock-syntactic-face-function)))
3862 ;; Comments
3867 ;; Parse cache
3870 ;; Frameworks
3873 ;; Imenu
3877 ;; for filling, pretend we're cc-mode
3880 c-paragraph-separate "$"
3881 c-block-comment-prefix "* "
3882 c-line-comment-starter "//"
3895 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3896 ;; we call it instead? (Bug#6071)
3904 ;; Important to fontify the whole buffer syntactically! If we don't,
3905 ;; then we might have regular expression literals that aren't marked
3906 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3907 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3908 ;; When we attempt to find the error and scroll to the portion of
3909 ;; the buffer containing the problem, JIT-lock will apply the
3910 ;; correct syntax to the regular expression literal and the problem
3911 ;; will mysteriously disappear.
3912 ;; FIXME: We should instead do this fontification lazily by adding
3913 ;; calls to syntax-propertize wherever it's really needed.
3914 ;;(syntax-propertize (point-max))
3915 )
3917 ;;;###autoload
3919 "Major mode for editing JSX.
3921 To customize the indentation for this mode, set the SGML offset
3922 variables (`sgml-basic-offset', `sgml-attribute-offset' et al.)
3923 locally, like so:
3925 (defun set-jsx-indentation ()
3926 (setq-local sgml-basic-offset js-indent-level))
3931 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3937 ;;;###autoload
3943 ;; js.el ends here