Use `JsShrink` if `jsxmin` is not available

Summary: If `jsxmin` is not available, use a pure PHP implementation instead (JsShrink).

Test Plan:
- Ran `arc lint --lintall` on all JS and fixed every relevant warning.
- Forced minification on and browsed around the site using JS behaviors. Didn't hit anything problematic.

Reviewers: vrana, btrahan

Reviewed By: vrana

CC: aran, Korvin

Differential Revision: https://secure.phabricator.com/D5670

.arcconfig

···
   "phutil_libraries" : {
     "phabricator" : "src/"
   },
-  "lint.xhpast.naminghook" : "PhabricatorSymbolNameLinter"
+  "lint.xhpast.naminghook" : "PhabricatorSymbolNameLinter",
+  "lint.jshint.config" : "support/jshint/jshintconfig"
 }

externals/JsShrink/jsShrink.php

···
+<?php
+/** Remove spaces and comments from JavaScript code
+* @param string code with commands terminated by semicolon
+* @return string shrinked code
+* @link http://vrana.github.com/JsShrink/
+* @author Jakub Vrana, http://www.vrana.cz/
+* @copyright 2007 Jakub Vrana
+* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
+* @license http://www.gnu.org/licenses/gpl-2.0.html GNU General Public License, version 2 (one or other)
+*/
+function jsShrink($input) {
+	return preg_replace_callback('(
+		(?:
+			(^|[-+\([{}=,:;!%^&*|?~]|/(?![/*])|return|throw) # context before regexp
+			(?:\s|//[^\n]*+\n|/\*(?:[^*]|\*(?!/))*+\*/)* # optional space
+			(/(?![/*])(?:\\\\[^\n]|[^[\n/\\\\]|\[(?:\\\\[^\n]|[^]])++)+/) # regexp
+			|(^
+				|\'(?:\\\\.|[^\n\'\\\\])*\'
+				|"(?:\\\\.|[^\n"\\\\])*"
+				|([0-9A-Za-z_$]+)
+				|([-+]+)
+				|.
+			)
+		)(?:\s|//[^\n]*+\n|/\*(?:[^*]|\*(?!/))*+\*/)* # optional space
+	)sx', 'jsShrinkCallback', "$input\n");
+}
+
+function jsShrinkCallback($match) {
+	static $last = '';
+	$match += array_fill(1, 5, null); // avoid E_NOTICE
+	list(, $context, $regexp, $result, $word, $operator) = $match;
+	if ($word != '') {
+		$result = ($last == 'word' ? "\n" : ($last == 'return' ? " " : "")) . $result;
+		$last = ($word == 'return' || $word == 'throw' || $word == 'break' ? 'return' : 'word');
+	} elseif ($operator) {
+		$result = ($last == $operator[0] ? "\n" : "") . $result;
+		$last = $operator[0];
+	} else {
+		if ($regexp) {
+			$result = $context . ($context == '/' ? "\n" : "") . $regexp;
+		}
+		$last = '';
+	}
+	return $result;
+}

externals/JsShrink/readme.txt

···
+JsShrink - Remove spaces and comments from JavaScript code
+Available in PHP and JavaScript
+Requires statements ending by semicolon, use JSHint or JSLint to verify.
+
+http://vrana.github.com/JsShrink/
+
+Usage PHP:
+<?php
+include "jsShrink.php";
+echo jsShrink($code);
+?>
+
+Usage JavaScript:
+<script type="text/javascript" src="jsShrink.js"></script>
+<script type="text/javascript">
+textarea.value = jsShrink(code);
+</script>
+
+Note:
+Google Closure Compiler is much more powerful and efficient tool.
+JsShrink was created for those looking for PHP or JavaScript only solution.
+Most other JS minifiers are not able to process valid JavaScript code:
+http://php.vrana.cz/minifikace-javascriptu.php#srovnani

src/__celerity_resource_map__.php

···
   ),
   'differential-inline-comment-editor' =>
   array(
-    'uri' => '/res/e0ad34ac/rsrc/js/application/differential/DifferentialInlineCommentEditor.js',
+    'uri' => '/res/37e0564f/rsrc/js/application/differential/DifferentialInlineCommentEditor.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior' =>
   array(
-    'uri' => '/res/adf7368b/rsrc/externals/javelin/lib/behavior.js',
+    'uri' => '/res/15482715/rsrc/externals/javelin/lib/behavior.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-magical-init',
+      1 => 'javelin-util',
     ),
     'disk' => '/rsrc/externals/javelin/lib/behavior.js',
   ),
   'javelin-behavior-aphlict-dropdown' =>
   array(
-    'uri' => '/res/2418f448/rsrc/js/application/aphlict/behavior-aphlict-dropdown.js',
+    'uri' => '/res/b3be58e8/rsrc/js/application/aphlict/behavior-aphlict-dropdown.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-aphlict-listen' =>
   array(
-    'uri' => '/res/6dde3f43/rsrc/js/application/aphlict/behavior-aphlict-listen.js',
+    'uri' => '/res/7487f207/rsrc/js/application/aphlict/behavior-aphlict-listen.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-audit-preview' =>
   array(
-    'uri' => '/res/3048b073/rsrc/js/application/diffusion/behavior-audit-preview.js',
+    'uri' => '/res/d8f31e46/rsrc/js/application/diffusion/behavior-audit-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-conpherence-widget-pane' =>
   array(
-    'uri' => '/res/a9bcb950/rsrc/js/application/conpherence/behavior-widget-pane.js',
+    'uri' => '/res/d2063fd4/rsrc/js/application/conpherence/behavior-widget-pane.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-countdown-timer' =>
   array(
-    'uri' => '/res/7468acb7/rsrc/js/application/countdown/timer.js',
+    'uri' => '/res/3c52aac2/rsrc/js/application/countdown/timer.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
       1 => 'javelin-dom',
-      2 => 'javelin-util',
     ),
     'disk' => '/rsrc/js/application/countdown/timer.js',
   ),
···
   ),
   'javelin-behavior-differential-comment-jump' =>
   array(
-    'uri' => '/res/b580229b/rsrc/js/application/differential/behavior-comment-jump.js',
+    'uri' => '/res/8ffb4222/rsrc/js/application/differential/behavior-comment-jump.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
-      1 => 'javelin-util',
+      1 => 'javelin-stratcom',
       2 => 'javelin-dom',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-comment-jump.js',
···
   ),
   'javelin-behavior-differential-dropdown-menus' =>
   array(
-    'uri' => '/res/4e3f1e2f/rsrc/js/application/differential/behavior-dropdown-menus.js',
+    'uri' => '/res/f04cf682/rsrc/js/application/differential/behavior-dropdown-menus.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-differential-edit-inline-comments' =>
   array(
-    'uri' => '/res/70c1f3a3/rsrc/js/application/differential/behavior-edit-inline-comments.js',
+    'uri' => '/res/86f459a4/rsrc/js/application/differential/behavior-edit-inline-comments.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-differential-feedback-preview' =>
   array(
-    'uri' => '/res/5fbce8db/rsrc/js/application/differential/behavior-comment-preview.js',
+    'uri' => '/res/4421fac6/rsrc/js/application/differential/behavior-comment-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-differential-keyboard-navigation' =>
   array(
-    'uri' => '/res/89e93cc9/rsrc/js/application/differential/behavior-keyboard-nav.js',
+    'uri' => '/res/22ed93ba/rsrc/js/application/differential/behavior-keyboard-nav.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-differential-populate' =>
   array(
-    'uri' => '/res/526c2615/rsrc/js/application/differential/behavior-populate.js',
+    'uri' => '/res/bb9a29f4/rsrc/js/application/differential/behavior-populate.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-differential-show-all-comments' =>
   array(
-    'uri' => '/res/5a26be1a/rsrc/js/application/differential/behavior-show-all-comments.js',
+    'uri' => '/res/8801848d/rsrc/js/application/differential/behavior-show-all-comments.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-diffusion-commit-graph' =>
   array(
-    'uri' => '/res/62bd2035/rsrc/js/application/diffusion/behavior-commit-graph.js',
+    'uri' => '/res/536b8483/rsrc/js/application/diffusion/behavior-commit-graph.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-diffusion-jump-to' =>
   array(
-    'uri' => '/res/7c42e1ba/rsrc/js/application/diffusion/behavior-jump-to.js',
+    'uri' => '/res/bade44bd/rsrc/js/application/diffusion/behavior-jump-to.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
-      1 => 'javelin-util',
-      2 => 'javelin-vector',
-      3 => 'javelin-dom',
+      1 => 'javelin-vector',
+      2 => 'javelin-dom',
     ),
     'disk' => '/rsrc/js/application/diffusion/behavior-jump-to.js',
   ),
···
   ),
   'javelin-behavior-fancy-datepicker' =>
   array(
-    'uri' => '/res/9b67a0f4/rsrc/js/core/behavior-fancy-datepicker.js',
+    'uri' => '/res/f5c13e07/rsrc/js/core/behavior-fancy-datepicker.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-global-drag-and-drop' =>
   array(
-    'uri' => '/res/528e18ed/rsrc/js/core/behavior-global-drag-and-drop.js',
+    'uri' => '/res/ee8e9c39/rsrc/js/core/behavior-global-drag-and-drop.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-lightbox-attachments' =>
   array(
-    'uri' => '/res/f2b17609/rsrc/js/core/behavior-lightbox-attachments.js',
+    'uri' => '/res/72b4d3a8/rsrc/js/core/behavior-lightbox-attachments.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-maniphest-batch-editor' =>
   array(
-    'uri' => '/res/00accaec/rsrc/js/application/maniphest/behavior-batch-editor.js',
+    'uri' => '/res/81b2b86f/rsrc/js/application/maniphest/behavior-batch-editor.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-maniphest-batch-selector' =>
   array(
-    'uri' => '/res/f8cf3b84/rsrc/js/application/maniphest/behavior-batch-selector.js',
+    'uri' => '/res/c33cb5e3/rsrc/js/application/maniphest/behavior-batch-selector.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-maniphest-description-preview' =>
   array(
-    'uri' => '/res/8acd6f07/rsrc/js/application/maniphest/behavior-task-preview.js',
+    'uri' => '/res/58ba0ec2/rsrc/js/application/maniphest/behavior-task-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-maniphest-transaction-controls' =>
   array(
-    'uri' => '/res/62465554/rsrc/js/application/maniphest/behavior-transaction-controls.js',
+    'uri' => '/res/e8498688/rsrc/js/application/maniphest/behavior-transaction-controls.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-maniphest-transaction-preview' =>
   array(
-    'uri' => '/res/855c9f0c/rsrc/js/application/maniphest/behavior-transaction-preview.js',
+    'uri' => '/res/9447a3f9/rsrc/js/application/maniphest/behavior-transaction-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-active-nav' =>
   array(
-    'uri' => '/res/326866c1/rsrc/js/core/behavior-active-nav.js',
+    'uri' => '/res/9c8d3df8/rsrc/js/core/behavior-active-nav.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-gesture-example' =>
   array(
-    'uri' => '/res/da636e19/rsrc/js/application/uiexample/gesture-example.js',
+    'uri' => '/res/91d1e7f2/rsrc/js/application/uiexample/gesture-example.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-hovercards' =>
   array(
-    'uri' => '/res/ed56d3c4/rsrc/js/core/behavior-hovercard.js',
+    'uri' => '/res/4fe6b436/rsrc/js/core/behavior-hovercard.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-nav' =>
   array(
-    'uri' => '/res/ede26aac/rsrc/js/core/behavior-phabricator-nav.js',
+    'uri' => '/res/afabcf16/rsrc/js/core/behavior-phabricator-nav.js',
     'type' => 'js',
     'requires' =>
     array(
···
       3 => 'javelin-dom',
       4 => 'javelin-magical-init',
       5 => 'javelin-vector',
+      6 => 'javelin-request',
+      7 => 'javelin-util',
     ),
     'disk' => '/rsrc/js/core/behavior-phabricator-nav.js',
   ),
   'javelin-behavior-phabricator-notification-example' =>
   array(
-    'uri' => '/res/a6d51998/rsrc/js/application/uiexample/notification-example.js',
+    'uri' => '/res/7c50cefd/rsrc/js/application/uiexample/notification-example.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'phabricator-notification',
       1 => 'javelin-stratcom',
       2 => 'javelin-behavior',
-      3 => 'javelin-uri',
     ),
     'disk' => '/rsrc/js/application/uiexample/notification-example.js',
   ),
   'javelin-behavior-phabricator-object-selector' =>
   array(
-    'uri' => '/res/31145104/rsrc/js/core/behavior-object-selector.js',
+    'uri' => '/res/461f95f7/rsrc/js/core/behavior-object-selector.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-oncopy' =>
   array(
-    'uri' => '/res/c5839892/rsrc/js/core/behavior-oncopy.js',
+    'uri' => '/res/cd3a9345/rsrc/js/core/behavior-oncopy.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-remarkup-assist' =>
   array(
-    'uri' => '/res/ddfb4eba/rsrc/js/core/behavior-phabricator-remarkup-assist.js',
+    'uri' => '/res/6d9c05d9/rsrc/js/core/behavior-phabricator-remarkup-assist.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-reveal-content' =>
   array(
-    'uri' => '/res/5f9da91f/rsrc/js/core/behavior-reveal-content.js',
+    'uri' => '/res/fef525ef/rsrc/js/core/behavior-reveal-content.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-search-typeahead' =>
   array(
-    'uri' => '/res/2662f34f/rsrc/js/core/behavior-search-typeahead.js',
+    'uri' => '/res/b39896d5/rsrc/js/core/behavior-search-typeahead.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phabricator-transaction-comment-form' =>
   array(
-    'uri' => '/res/acc3ada1/rsrc/js/application/transactions/behavior-transaction-comment-form.js',
+    'uri' => '/res/7591a57f/rsrc/js/application/transactions/behavior-transaction-comment-form.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phame-post-preview' =>
   array(
-    'uri' => '/res/ac4c503a/rsrc/js/application/phame/phame-post-preview.js',
+    'uri' => '/res/181d1cbe/rsrc/js/application/phame/phame-post-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-pholio-mock-view' =>
   array(
-    'uri' => '/res/ecf5f969/rsrc/js/application/pholio/behavior-pholio-mock-view.js',
+    'uri' => '/res/0632e7d9/rsrc/js/application/pholio/behavior-pholio-mock-view.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-phriction-document-preview' =>
   array(
-    'uri' => '/res/f1665ecd/rsrc/js/application/phriction/phriction-document-preview.js',
+    'uri' => '/res/e2fe02de/rsrc/js/application/phriction/phriction-document-preview.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-ponder-votebox' =>
   array(
-    'uri' => '/res/9d091af3/rsrc/js/application/ponder/behavior-votebox.js',
+    'uri' => '/res/d8c973a2/rsrc/js/application/ponder/behavior-votebox.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-refresh-csrf' =>
   array(
-    'uri' => '/res/424ccc57/rsrc/js/core/behavior-refresh-csrf.js',
+    'uri' => '/res/6c54100f/rsrc/js/core/behavior-refresh-csrf.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-behavior-releeph-preview-branch' =>
   array(
-    'uri' => '/res/a77ebc86/rsrc/js/application/releeph/releeph-preview-branch.js',
+    'uri' => '/res/f694854d/rsrc/js/application/releeph/releeph-preview-branch.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
       1 => 'javelin-dom',
-      2 => 'javelin-stratcom',
-      3 => 'javelin-uri',
-      4 => 'javelin-util',
+      2 => 'javelin-uri',
+      3 => 'javelin-request',
     ),
     'disk' => '/rsrc/js/application/releeph/releeph-preview-branch.js',
   ),
   'javelin-behavior-releeph-request-state-change' =>
   array(
-    'uri' => '/res/38f96ba8/rsrc/js/application/releeph/releeph-request-state-change.js',
+    'uri' => '/res/07ecde0c/rsrc/js/application/releeph/releeph-request-state-change.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
       1 => 'javelin-dom',
       2 => 'javelin-stratcom',
-      3 => 'javelin-util',
+      3 => 'javelin-request',
       4 => 'phabricator-keyboard-shortcut',
       5 => 'phabricator-notification',
     ),
···
   ),
   'javelin-behavior-releeph-request-typeahead' =>
   array(
-    'uri' => '/res/b52096e2/rsrc/js/application/releeph/releeph-request-typeahead.js',
+    'uri' => '/res/2c2350a0/rsrc/js/application/releeph/releeph-request-typeahead.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
-      1 => 'javelin-util',
-      2 => 'javelin-dom',
-      3 => 'javelin-typeahead',
-      4 => 'javelin-tokenizer',
-      5 => 'javelin-typeahead-preloaded-source',
-      6 => 'javelin-typeahead-ondemand-source',
-      7 => 'javelin-dom',
-      8 => 'javelin-stratcom',
-      9 => 'javelin-util',
+      1 => 'javelin-dom',
+      2 => 'javelin-typeahead',
+      3 => 'javelin-typeahead-ondemand-source',
+      4 => 'javelin-dom',
     ),
     'disk' => '/rsrc/js/application/releeph/releeph-request-typeahead.js',
   ),
···
   ),
   'javelin-behavior-slowvote-embed' =>
   array(
-    'uri' => '/res/eef0818f/rsrc/js/application/slowvote/behavior-slowvote-embed.js',
+    'uri' => '/res/8e85e20d/rsrc/js/application/slowvote/behavior-slowvote-embed.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
-      1 => 'javelin-util',
+      1 => 'javelin-request',
       2 => 'javelin-stratcom',
       3 => 'javelin-dom',
     ),
···
   ),
   'javelin-behavior-view-placeholder' =>
   array(
-    'uri' => '/res/faaf0af7/rsrc/externals/javelin/ext/view/ViewPlaceholder.js',
+    'uri' => '/res/6abdb85b/rsrc/externals/javelin/ext/view/ViewPlaceholder.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-behavior',
       1 => 'javelin-dom',
       2 => 'javelin-view-renderer',
+      3 => 'javelin-install',
     ),
     'disk' => '/rsrc/externals/javelin/ext/view/ViewPlaceholder.js',
   ),
···
   ),
   'javelin-dom' =>
   array(
-    'uri' => '/res/64689b54/rsrc/externals/javelin/lib/DOM.js',
+    'uri' => '/res/175211d6/rsrc/externals/javelin/lib/DOM.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-event' =>
   array(
-    'uri' => '/res/0a4efce8/rsrc/externals/javelin/core/Event.js',
+    'uri' => '/res/5f70f4d0/rsrc/externals/javelin/core/Event.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-magical-init' =>
   array(
-    'uri' => '/res/7af6987f/rsrc/externals/javelin/core/init.js',
+    'uri' => '/res/7c6c8d5a/rsrc/externals/javelin/core/init.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-mask' =>
   array(
-    'uri' => '/res/5c40c29f/rsrc/externals/javelin/lib/Mask.js',
+    'uri' => '/res/465cf513/rsrc/externals/javelin/lib/Mask.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-reactor-dom' =>
   array(
-    'uri' => '/res/477f5d3b/rsrc/externals/javelin/ext/reactor/dom/RDOM.js',
+    'uri' => '/res/5e03117e/rsrc/externals/javelin/ext/reactor/dom/RDOM.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-dom',
       1 => 'javelin-dynval',
-      2 => 'javelin-reactornode',
-      3 => 'javelin-install',
-      4 => 'javelin-util',
+      2 => 'javelin-reactor',
+      3 => 'javelin-reactornode',
+      4 => 'javelin-install',
+      5 => 'javelin-util',
     ),
     'disk' => '/rsrc/externals/javelin/ext/reactor/dom/RDOM.js',
   ),
···
   ),
   'javelin-request' =>
   array(
-    'uri' => '/res/a9fbc4ae/rsrc/externals/javelin/lib/Request.js',
+    'uri' => '/res/687bdcfc/rsrc/externals/javelin/lib/Request.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-resource' =>
   array(
-    'uri' => '/res/1020e732/rsrc/externals/javelin/lib/Resource.js',
+    'uri' => '/res/33a3bb57/rsrc/externals/javelin/lib/Resource.js',
     'type' => 'js',
     'requires' =>
     array(
-      0 => 'javelin-magical-init',
-      1 => 'javelin-stratcom',
-      2 => 'javelin-util',
-      3 => 'javelin-uri',
+      0 => 'javelin-util',
+      1 => 'javelin-uri',
+      2 => 'javelin-install',
     ),
     'disk' => '/rsrc/externals/javelin/lib/Resource.js',
   ),
···
   ),
   'javelin-tokenizer' =>
   array(
-    'uri' => '/res/2c55cb68/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js',
+    'uri' => '/res/7c117141/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-typeahead-ondemand-source' =>
   array(
-    'uri' => '/res/9ab98c3d/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js',
+    'uri' => '/res/4e5add88/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
       1 => 'javelin-util',
-      2 => 'javelin-stratcom',
-      3 => 'javelin-request',
-      4 => 'javelin-typeahead-source',
+      2 => 'javelin-request',
+      3 => 'javelin-typeahead-source',
     ),
     'disk' => '/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js',
   ),
   'javelin-typeahead-preloaded-source' =>
   array(
-    'uri' => '/res/ffc234d1/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js',
+    'uri' => '/res/147900c7/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
       1 => 'javelin-util',
-      2 => 'javelin-stratcom',
-      3 => 'javelin-request',
-      4 => 'javelin-typeahead-source',
+      2 => 'javelin-request',
+      3 => 'javelin-typeahead-source',
     ),
     'disk' => '/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js',
   ),
   'javelin-typeahead-source' =>
   array(
-    'uri' => '/res/df206a51/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadSource.js',
+    'uri' => '/res/13289259/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadSource.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-uri' =>
   array(
-    'uri' => '/res/a1e5cbb3/rsrc/externals/javelin/lib/URI.js',
+    'uri' => '/res/75aa4597/rsrc/externals/javelin/lib/URI.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-util' =>
   array(
-    'uri' => '/res/322fc289/rsrc/externals/javelin/core/util.js',
+    'uri' => '/res/90222113/rsrc/externals/javelin/core/util.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-vector' =>
   array(
-    'uri' => '/res/c8c64ab7/rsrc/externals/javelin/lib/Vector.js',
+    'uri' => '/res/58ea3dd7/rsrc/externals/javelin/lib/Vector.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-view' =>
   array(
-    'uri' => '/res/3022e596/rsrc/externals/javelin/ext/view/View.js',
+    'uri' => '/res/38daaec0/rsrc/externals/javelin/ext/view/View.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'javelin-view-html' =>
   array(
-    'uri' => '/res/1b6e621c/rsrc/externals/javelin/ext/view/HTMLView.js',
+    'uri' => '/res/0d225e8c/rsrc/externals/javelin/ext/view/HTMLView.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
+      1 => 'javelin-dom',
+      2 => 'javelin-view-visitor',
+      3 => 'javelin-util',
     ),
     'disk' => '/rsrc/externals/javelin/ext/view/HTMLView.js',
   ),
   'javelin-view-interpreter' =>
   array(
-    'uri' => '/res/39fe3ad3/rsrc/externals/javelin/ext/view/ViewInterpreter.js',
+    'uri' => '/res/b0c07f96/rsrc/externals/javelin/ext/view/ViewInterpreter.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-view',
       1 => 'javelin-install',
+      2 => 'javelin-dom',
     ),
     'disk' => '/rsrc/externals/javelin/ext/view/ViewInterpreter.js',
   ),
   'javelin-view-renderer' =>
   array(
-    'uri' => '/res/d2119b79/rsrc/externals/javelin/ext/view/ViewRenderer.js',
+    'uri' => '/res/fe0d2f60/rsrc/externals/javelin/ext/view/ViewRenderer.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
+      1 => 'javelin-util',
     ),
     'disk' => '/rsrc/externals/javelin/ext/view/ViewRenderer.js',
   ),
···
   ),
   'javelin-workflow' =>
   array(
-    'uri' => '/res/73e8d0e2/rsrc/externals/javelin/lib/Workflow.js',
+    'uri' => '/res/8274d65f/rsrc/externals/javelin/lib/Workflow.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-drag-and-drop-file-upload' =>
   array(
-    'uri' => '/res/3991c1b6/rsrc/js/core/DragAndDropFileUpload.js',
+    'uri' => '/res/396d3b3b/rsrc/js/core/DragAndDropFileUpload.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-file-upload' =>
   array(
-    'uri' => '/res/ee9664fd/rsrc/js/core/FileUpload.js',
+    'uri' => '/res/c9605008/rsrc/js/core/FileUpload.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-hovercard' =>
   array(
-    'uri' => '/res/2cf2c195/rsrc/js/core/Hovercard.js',
+    'uri' => '/res/7fb94260/rsrc/js/core/Hovercard.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-phtize' =>
   array(
-    'uri' => '/res/50a80ff1/rsrc/js/core/phtize.js',
+    'uri' => '/res/dc655a81/rsrc/js/core/phtize.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-prefab' =>
   array(
-    'uri' => '/res/513c4313/rsrc/js/core/Prefab.js',
+    'uri' => '/res/511859ca/rsrc/js/core/Prefab.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-tooltip' =>
   array(
-    'uri' => '/res/1dc73d91/rsrc/js/core/ToolTip.js',
+    'uri' => '/res/a23bc887/rsrc/js/core/ToolTip.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'phabricator-uiexample-javelin-view' =>
   array(
-    'uri' => '/res/a2ce2cfc/rsrc/js/application/uiexample/JavelinViewExample.js',
+    'uri' => '/res/2da87384/rsrc/js/application/uiexample/JavelinViewExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
+      1 => 'javelin-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/JavelinViewExample.js',
   ),
   'phabricator-uiexample-reactor-button' =>
   array(
-    'uri' => '/res/142127f6/rsrc/js/application/uiexample/ReactorButtonExample.js',
+    'uri' => '/res/6bfe4f05/rsrc/js/application/uiexample/ReactorButtonExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
+      1 => 'javelin-dom',
       2 => 'javelin-util',
-      3 => 'javelin-dom',
+      3 => 'javelin-dynval',
       4 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorButtonExample.js',
   ),
   'phabricator-uiexample-reactor-checkbox' =>
   array(
-    'uri' => '/res/c75cb9e9/rsrc/js/application/uiexample/ReactorCheckboxExample.js',
+    'uri' => '/res/3e8b30ac/rsrc/js/application/uiexample/ReactorCheckboxExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorCheckboxExample.js',
   ),
   'phabricator-uiexample-reactor-focus' =>
   array(
-    'uri' => '/res/3cc992eb/rsrc/js/application/uiexample/ReactorFocusExample.js',
+    'uri' => '/res/d8f3b56e/rsrc/js/application/uiexample/ReactorFocusExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorFocusExample.js',
   ),
   'phabricator-uiexample-reactor-input' =>
   array(
-    'uri' => '/res/4953da16/rsrc/js/application/uiexample/ReactorInputExample.js',
+    'uri' => '/res/936352d9/rsrc/js/application/uiexample/ReactorInputExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
-      5 => 'javelin-view-html',
-      6 => 'javelin-view-interpreter',
-      7 => 'javelin-view-renderer',
+      1 => 'javelin-reactor-dom',
+      2 => 'javelin-view-html',
+      3 => 'javelin-view-interpreter',
+      4 => 'javelin-view-renderer',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorInputExample.js',
   ),
   'phabricator-uiexample-reactor-mouseover' =>
   array(
-    'uri' => '/res/52a355b6/rsrc/js/application/uiexample/ReactorMouseoverExample.js',
+    'uri' => '/res/031a9f4f/rsrc/js/application/uiexample/ReactorMouseoverExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorMouseoverExample.js',
   ),
   'phabricator-uiexample-reactor-radio' =>
   array(
-    'uri' => '/res/ae87f3af/rsrc/js/application/uiexample/ReactorRadioExample.js',
+    'uri' => '/res/208c58e3/rsrc/js/application/uiexample/ReactorRadioExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorRadioExample.js',
   ),
   'phabricator-uiexample-reactor-select' =>
   array(
-    'uri' => '/res/23cb448a/rsrc/js/application/uiexample/ReactorSelectExample.js',
+    'uri' => '/res/1b68a6db/rsrc/js/application/uiexample/ReactorSelectExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorSelectExample.js',
   ),
   'phabricator-uiexample-reactor-sendclass' =>
   array(
-    'uri' => '/res/8cd34264/rsrc/js/application/uiexample/ReactorSendClassExample.js',
+    'uri' => '/res/00cb3131/rsrc/js/application/uiexample/ReactorSendClassExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorSendClassExample.js',
   ),
   'phabricator-uiexample-reactor-sendproperties' =>
   array(
-    'uri' => '/res/18af54aa/rsrc/js/application/uiexample/ReactorSendPropertiesExample.js',
+    'uri' => '/res/392f1e02/rsrc/js/application/uiexample/ReactorSendPropertiesExample.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-install',
-      1 => 'javelin-view',
-      2 => 'javelin-util',
-      3 => 'javelin-dom',
-      4 => 'javelin-reactor-dom',
+      1 => 'javelin-dom',
+      2 => 'javelin-reactor-dom',
     ),
     'disk' => '/rsrc/js/application/uiexample/ReactorSendPropertiesExample.js',
   ),
···
   ),
   'raphael-core' =>
   array(
-    'uri' => '/res/0939b925/rsrc/externals/raphael/raphael.js',
+    'uri' => '/res/5dc5e17c/rsrc/externals/raphael/raphael.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'raphael-g' =>
   array(
-    'uri' => '/res/e14432ce/rsrc/externals/raphael/g.raphael.js',
+    'uri' => '/res/229b89a1/rsrc/externals/raphael/g.raphael.js',
     'type' => 'js',
     'requires' =>
     array(
···
   ),
   'raphael-g-line' =>
   array(
-    'uri' => '/res/2c9e6746/rsrc/externals/raphael/g.raphael.line.js',
+    'uri' => '/res/96da30f7/rsrc/externals/raphael/g.raphael.line.js',
     'type' => 'js',
     'requires' =>
     array(
···
       'uri' => '/res/pkg/bdba44f0/core.pkg.css',
       'type' => 'css',
     ),
-    '26980a1c' =>
+    '25aa6fec' =>
     array(
       'name' => 'core.pkg.js',
       'symbols' =>
···
         33 => 'javelin-behavior-global-drag-and-drop',
         34 => 'javelin-behavior-phabricator-reveal-content',
       ),
-      'uri' => '/res/pkg/26980a1c/core.pkg.js',
+      'uri' => '/res/pkg/25aa6fec/core.pkg.js',
       'type' => 'js',
     ),
     '4ccfeb47' =>
···
       'uri' => '/res/pkg/dd27a69b/differential.pkg.css',
       'type' => 'css',
     ),
-    '77e07ff4' =>
+    '9488bb69' =>
     array(
       'name' => 'differential.pkg.js',
       'symbols' =>
···
         18 => 'javelin-behavior-differential-toggle-files',
         19 => 'javelin-behavior-differential-user-select',
       ),
-      'uri' => '/res/pkg/77e07ff4/differential.pkg.js',
+      'uri' => '/res/pkg/9488bb69/differential.pkg.js',
       'type' => 'js',
     ),
     'c8ce2d88' =>
···
       'uri' => '/res/pkg/c8ce2d88/diffusion.pkg.css',
       'type' => 'css',
     ),
-    'f96657b8' =>
+    96909266 =>
     array(
       'name' => 'diffusion.pkg.js',
       'symbols' =>
···
         1 => 'javelin-behavior-diffusion-commit-graph',
         2 => 'javelin-behavior-audit-preview',
       ),
-      'uri' => '/res/pkg/f96657b8/diffusion.pkg.js',
+      'uri' => '/res/pkg/96909266/diffusion.pkg.js',
       'type' => 'js',
     ),
-    '202a3dd0' =>
+    '565e00f7' =>
     array(
       'name' => 'javelin.pkg.js',
       'symbols' =>
···
         17 => 'javelin-typeahead-ondemand-source',
         18 => 'javelin-tokenizer',
       ),
-      'uri' => '/res/pkg/202a3dd0/javelin.pkg.js',
+      'uri' => '/res/pkg/565e00f7/javelin.pkg.js',
       'type' => 'js',
     ),
     '6b1fccc6' =>
···
       'uri' => '/res/pkg/6b1fccc6/maniphest.pkg.css',
       'type' => 'css',
     ),
-    'f85eb6d8' =>
+    '1621e522' =>
     array(
       'name' => 'maniphest.pkg.js',
       'symbols' =>
···
         3 => 'javelin-behavior-maniphest-transaction-expand',
         4 => 'javelin-behavior-maniphest-subpriority-editor',
       ),
-      'uri' => '/res/pkg/f85eb6d8/maniphest.pkg.js',
+      'uri' => '/res/pkg/1621e522/maniphest.pkg.js',
       'type' => 'js',
     ),
   ),
···
     'aphront-typeahead-control-css' => 'bdba44f0',
     'differential-changeset-view-css' => 'dd27a69b',
     'differential-core-view-css' => 'dd27a69b',
-    'differential-inline-comment-editor' => '77e07ff4',
+    'differential-inline-comment-editor' => '9488bb69',
     'differential-local-commits-view-css' => 'dd27a69b',
     'differential-results-table-css' => 'dd27a69b',
     'differential-revision-add-comment-css' => 'dd27a69b',
···
     'diffusion-icons-css' => 'c8ce2d88',
     'global-drag-and-drop-css' => 'bdba44f0',
     'inline-comment-summary-css' => 'dd27a69b',
-    'javelin-aphlict' => '26980a1c',
-    'javelin-behavior' => '202a3dd0',
-    'javelin-behavior-aphlict-dropdown' => '26980a1c',
-    'javelin-behavior-aphlict-listen' => '26980a1c',
-    'javelin-behavior-aphront-basic-tokenizer' => '26980a1c',
-    'javelin-behavior-aphront-drag-and-drop' => '77e07ff4',
-    'javelin-behavior-aphront-drag-and-drop-textarea' => '77e07ff4',
-    'javelin-behavior-aphront-form-disable-on-submit' => '26980a1c',
-    'javelin-behavior-audit-preview' => 'f96657b8',
+    'javelin-aphlict' => '25aa6fec',
+    'javelin-behavior' => '565e00f7',
+    'javelin-behavior-aphlict-dropdown' => '25aa6fec',
+    'javelin-behavior-aphlict-listen' => '25aa6fec',
+    'javelin-behavior-aphront-basic-tokenizer' => '25aa6fec',
+    'javelin-behavior-aphront-drag-and-drop' => '9488bb69',
+    'javelin-behavior-aphront-drag-and-drop-textarea' => '9488bb69',
+    'javelin-behavior-aphront-form-disable-on-submit' => '25aa6fec',
+    'javelin-behavior-audit-preview' => '96909266',
     'javelin-behavior-dark-console' => '4ccfeb47',
-    'javelin-behavior-device' => '26980a1c',
-    'javelin-behavior-differential-accept-with-errors' => '77e07ff4',
-    'javelin-behavior-differential-add-reviewers-and-ccs' => '77e07ff4',
-    'javelin-behavior-differential-comment-jump' => '77e07ff4',
-    'javelin-behavior-differential-diff-radios' => '77e07ff4',
-    'javelin-behavior-differential-dropdown-menus' => '77e07ff4',
-    'javelin-behavior-differential-edit-inline-comments' => '77e07ff4',
-    'javelin-behavior-differential-feedback-preview' => '77e07ff4',
-    'javelin-behavior-differential-keyboard-navigation' => '77e07ff4',
-    'javelin-behavior-differential-populate' => '77e07ff4',
-    'javelin-behavior-differential-show-more' => '77e07ff4',
-    'javelin-behavior-differential-toggle-files' => '77e07ff4',
-    'javelin-behavior-differential-user-select' => '77e07ff4',
-    'javelin-behavior-diffusion-commit-graph' => 'f96657b8',
-    'javelin-behavior-diffusion-pull-lastmodified' => 'f96657b8',
+    'javelin-behavior-device' => '25aa6fec',
+    'javelin-behavior-differential-accept-with-errors' => '9488bb69',
+    'javelin-behavior-differential-add-reviewers-and-ccs' => '9488bb69',
+    'javelin-behavior-differential-comment-jump' => '9488bb69',
+    'javelin-behavior-differential-diff-radios' => '9488bb69',
+    'javelin-behavior-differential-dropdown-menus' => '9488bb69',
+    'javelin-behavior-differential-edit-inline-comments' => '9488bb69',
+    'javelin-behavior-differential-feedback-preview' => '9488bb69',
+    'javelin-behavior-differential-keyboard-navigation' => '9488bb69',
+    'javelin-behavior-differential-populate' => '9488bb69',
+    'javelin-behavior-differential-show-more' => '9488bb69',
+    'javelin-behavior-differential-toggle-files' => '9488bb69',
+    'javelin-behavior-differential-user-select' => '9488bb69',
+    'javelin-behavior-diffusion-commit-graph' => '96909266',
+    'javelin-behavior-diffusion-pull-lastmodified' => '96909266',
     'javelin-behavior-error-log' => '4ccfeb47',
-    'javelin-behavior-global-drag-and-drop' => '26980a1c',
-    'javelin-behavior-history-install' => '26980a1c',
-    'javelin-behavior-konami' => '26980a1c',
-    'javelin-behavior-lightbox-attachments' => '26980a1c',
-    'javelin-behavior-load-blame' => '77e07ff4',
-    'javelin-behavior-maniphest-batch-selector' => 'f85eb6d8',
-    'javelin-behavior-maniphest-subpriority-editor' => 'f85eb6d8',
-    'javelin-behavior-maniphest-transaction-controls' => 'f85eb6d8',
-    'javelin-behavior-maniphest-transaction-expand' => 'f85eb6d8',
-    'javelin-behavior-maniphest-transaction-preview' => 'f85eb6d8',
-    'javelin-behavior-phabricator-active-nav' => '26980a1c',
-    'javelin-behavior-phabricator-autofocus' => '26980a1c',
-    'javelin-behavior-phabricator-gesture' => '26980a1c',
-    'javelin-behavior-phabricator-keyboard-shortcuts' => '26980a1c',
-    'javelin-behavior-phabricator-nav' => '26980a1c',
-    'javelin-behavior-phabricator-object-selector' => '77e07ff4',
-    'javelin-behavior-phabricator-oncopy' => '26980a1c',
-    'javelin-behavior-phabricator-remarkup-assist' => '26980a1c',
-    'javelin-behavior-phabricator-reveal-content' => '26980a1c',
-    'javelin-behavior-phabricator-search-typeahead' => '26980a1c',
-    'javelin-behavior-phabricator-tooltips' => '26980a1c',
-    'javelin-behavior-phabricator-watch-anchor' => '26980a1c',
-    'javelin-behavior-refresh-csrf' => '26980a1c',
-    'javelin-behavior-repository-crossreference' => '77e07ff4',
-    'javelin-behavior-toggle-class' => '26980a1c',
-    'javelin-behavior-workflow' => '26980a1c',
-    'javelin-dom' => '202a3dd0',
-    'javelin-event' => '202a3dd0',
-    'javelin-install' => '202a3dd0',
-    'javelin-json' => '202a3dd0',
-    'javelin-mask' => '202a3dd0',
-    'javelin-request' => '202a3dd0',
-    'javelin-resource' => '202a3dd0',
-    'javelin-stratcom' => '202a3dd0',
-    'javelin-tokenizer' => '202a3dd0',
-    'javelin-typeahead' => '202a3dd0',
-    'javelin-typeahead-normalizer' => '202a3dd0',
-    'javelin-typeahead-ondemand-source' => '202a3dd0',
-    'javelin-typeahead-preloaded-source' => '202a3dd0',
-    'javelin-typeahead-source' => '202a3dd0',
-    'javelin-uri' => '202a3dd0',
-    'javelin-util' => '202a3dd0',
-    'javelin-vector' => '202a3dd0',
-    'javelin-workflow' => '202a3dd0',
+    'javelin-behavior-global-drag-and-drop' => '25aa6fec',
+    'javelin-behavior-history-install' => '25aa6fec',
+    'javelin-behavior-konami' => '25aa6fec',
+    'javelin-behavior-lightbox-attachments' => '25aa6fec',
+    'javelin-behavior-load-blame' => '9488bb69',
+    'javelin-behavior-maniphest-batch-selector' => '1621e522',
+    'javelin-behavior-maniphest-subpriority-editor' => '1621e522',
+    'javelin-behavior-maniphest-transaction-controls' => '1621e522',
+    'javelin-behavior-maniphest-transaction-expand' => '1621e522',
+    'javelin-behavior-maniphest-transaction-preview' => '1621e522',
+    'javelin-behavior-phabricator-active-nav' => '25aa6fec',
+    'javelin-behavior-phabricator-autofocus' => '25aa6fec',
+    'javelin-behavior-phabricator-gesture' => '25aa6fec',
+    'javelin-behavior-phabricator-keyboard-shortcuts' => '25aa6fec',
+    'javelin-behavior-phabricator-nav' => '25aa6fec',
+    'javelin-behavior-phabricator-object-selector' => '9488bb69',
+    'javelin-behavior-phabricator-oncopy' => '25aa6fec',
+    'javelin-behavior-phabricator-remarkup-assist' => '25aa6fec',
+    'javelin-behavior-phabricator-reveal-content' => '25aa6fec',
+    'javelin-behavior-phabricator-search-typeahead' => '25aa6fec',
+    'javelin-behavior-phabricator-tooltips' => '25aa6fec',
+    'javelin-behavior-phabricator-watch-anchor' => '25aa6fec',
+    'javelin-behavior-refresh-csrf' => '25aa6fec',
+    'javelin-behavior-repository-crossreference' => '9488bb69',
+    'javelin-behavior-toggle-class' => '25aa6fec',
+    'javelin-behavior-workflow' => '25aa6fec',
+    'javelin-dom' => '565e00f7',
+    'javelin-event' => '565e00f7',
+    'javelin-install' => '565e00f7',
+    'javelin-json' => '565e00f7',
+    'javelin-mask' => '565e00f7',
+    'javelin-request' => '565e00f7',
+    'javelin-resource' => '565e00f7',
+    'javelin-stratcom' => '565e00f7',
+    'javelin-tokenizer' => '565e00f7',
+    'javelin-typeahead' => '565e00f7',
+    'javelin-typeahead-normalizer' => '565e00f7',
+    'javelin-typeahead-ondemand-source' => '565e00f7',
+    'javelin-typeahead-preloaded-source' => '565e00f7',
+    'javelin-typeahead-source' => '565e00f7',
+    'javelin-uri' => '565e00f7',
+    'javelin-util' => '565e00f7',
+    'javelin-vector' => '565e00f7',
+    'javelin-workflow' => '565e00f7',
     'lightbox-attachment-css' => 'bdba44f0',
     'maniphest-task-summary-css' => '6b1fccc6',
     'maniphest-transaction-detail-css' => '6b1fccc6',
-    'phabricator-busy' => '26980a1c',
+    'phabricator-busy' => '25aa6fec',
     'phabricator-content-source-view-css' => 'dd27a69b',
     'phabricator-core-buttons-css' => 'bdba44f0',
     'phabricator-core-css' => 'bdba44f0',
     'phabricator-crumbs-view-css' => 'bdba44f0',
     'phabricator-directory-css' => 'bdba44f0',
-    'phabricator-drag-and-drop-file-upload' => '77e07ff4',
-    'phabricator-dropdown-menu' => '26980a1c',
-    'phabricator-file-upload' => '26980a1c',
+    'phabricator-drag-and-drop-file-upload' => '9488bb69',
+    'phabricator-dropdown-menu' => '25aa6fec',
+    'phabricator-file-upload' => '25aa6fec',
     'phabricator-filetree-view-css' => 'bdba44f0',
     'phabricator-flag-css' => 'bdba44f0',
     'phabricator-form-view-css' => 'bdba44f0',
     'phabricator-header-view-css' => 'bdba44f0',
     'phabricator-jump-nav' => 'bdba44f0',
-    'phabricator-keyboard-shortcut' => '26980a1c',
-    'phabricator-keyboard-shortcut-manager' => '26980a1c',
+    'phabricator-keyboard-shortcut' => '25aa6fec',
+    'phabricator-keyboard-shortcut-manager' => '25aa6fec',
     'phabricator-main-menu-view' => 'bdba44f0',
-    'phabricator-menu-item' => '26980a1c',
+    'phabricator-menu-item' => '25aa6fec',
     'phabricator-nav-view-css' => 'bdba44f0',
-    'phabricator-notification' => '26980a1c',
+    'phabricator-notification' => '25aa6fec',
     'phabricator-notification-css' => 'bdba44f0',
     'phabricator-notification-menu-css' => 'bdba44f0',
     'phabricator-object-item-list-view-css' => 'bdba44f0',
     'phabricator-object-selector-css' => 'dd27a69b',
-    'phabricator-phtize' => '26980a1c',
-    'phabricator-prefab' => '26980a1c',
+    'phabricator-phtize' => '25aa6fec',
+    'phabricator-prefab' => '25aa6fec',
     'phabricator-project-tag-css' => '6b1fccc6',
     'phabricator-remarkup-css' => 'bdba44f0',
-    'phabricator-shaped-request' => '77e07ff4',
+    'phabricator-shaped-request' => '9488bb69',
     'phabricator-side-menu-view-css' => 'bdba44f0',
     'phabricator-standard-page-view' => 'bdba44f0',
-    'phabricator-textareautils' => '26980a1c',
-    'phabricator-tooltip' => '26980a1c',
+    'phabricator-textareautils' => '25aa6fec',
+    'phabricator-tooltip' => '25aa6fec',
     'phabricator-transaction-view-css' => 'bdba44f0',
     'phabricator-zindex-css' => 'bdba44f0',
     'sprite-apps-large-css' => 'bdba44f0',

src/infrastructure/celerity/CelerityResourceTransformer.php

···
     return $this;
   }
 
+  /**
+   * @phutil-external-symbol function jsShrink
+   */
   public function transformResource($path, $data) {
     $type = self::getResourceType($path);
 
···
         $data = trim($data);
         break;
       case 'js':
-        $root = dirname(phutil_get_library_root('phabricator'));
-        $bin = $root.'/externals/javelin/support/jsxmin/jsxmin';
 
-        if (@file_exists($bin)) {
-          $future = new ExecFuture('%s __DEV__:0', $bin);
+        // If `jsxmin` is available, use it. jsxmin is the Javelin minifier and
+        // produces the smallest output, but is complicated to build.
+        if (Filesystem::binaryExists('jsxmin')) {
+          $future = new ExecFuture('jsxmin __DEV__:0');
           $future->write($data);
           list($err, $result) = $future->resolve();
           if (!$err) {
             $data = $result;
+            break;
           }
         }
+
+        // If `jsxmin` is not available, use `JsShrink`, which doesn't compress
+        // quite as well but is always available.
+        $root = dirname(phutil_get_library_root('phabricator'));
+        require_once $root.'/externals/JsShrink/jsShrink.php';
+        $data = jsShrink($data);
+
         break;
     }
 

src/infrastructure/lint/PhabricatorLintEngine.php

···
     $javelin_linter = new PhabricatorJavelinLinter();
     $linters[] = $javelin_linter;
 
+    $jshint_linter = new ArcanistJSHintLinter();
+    $linters[] = $jshint_linter;
+
     foreach ($paths as $path) {
+      if (!preg_match('/\.js$/', $path)) {
+        continue;
+      }
+
+      if (strpos($path, 'externals/JsShrink') !== false) {
+        // Ignore warnings in JsShrink tests.
+        continue;
+      }
+
+      if (strpos($path, 'externals/raphael') !== false) {
+        // Ignore Raphael.
+        continue;
+      }
+
+      $jshint_linter->addPath($path);
+      $jshint_linter->addData($path, $this->loadData($path));
+
       if (strpos($path, 'support/aphlict/') !== false) {
         // This stuff is Node.js, not Javelin, so don't apply the Javelin
         // linter.
         continue;
       }
-      if (preg_match('/\.js$/', $path)) {
-        $javelin_linter->addPath($path);
-        $javelin_linter->addData($path, $this->loadData($path));
-      }
+
+      $javelin_linter->addPath($path);
+      $javelin_linter->addData($path, $this->loadData($path));
     }
 
     return $linters;

src/infrastructure/lint/linter/PhabricatorJavelinLinter.php

···
   }
 
   private function shouldIgnorePath($path) {
-    return preg_match('@/__tests__/|externals/javelinjs/src/docs/@', $path);
+    return preg_match('@/__tests__/|externals/javelin/docs/@', $path);
   }
 
   public function lintPath($path) {
···
         continue;
       }
 
-      $symbol_path = 'webroot'.$symbol_info['disk'];
-      list($ignored, $req_install) = $this->getUsedAndInstalledSymbolsForPath(
-        $symbol_path);
-      if (array_intersect_key($req_install, $external_classes)) {
-        $need = array_diff_key($need, $req_install);
+      if (preg_match('/\\.css$/', $symbol_info['disk'])) {
+        // If JS requires CSS, just assume everything is fine.
         unset($requires[$key]);
+      } else {
+        $symbol_path = 'webroot'.$symbol_info['disk'];
+        list($ignored, $req_install) = $this->getUsedAndInstalledSymbolsForPath(
+          $symbol_path);
+        if (array_intersect_key($req_install, $external_classes)) {
+          $need = array_diff_key($need, $req_install);
+          unset($requires[$key]);
+        }
       }
     }
 

support/aphlict/server/aphlict_server.js

···
   return config;
 }
 
-if (process.getuid() != 0) {
+if (process.getuid() !== 0) {
   console.log(
     "ERROR: "+
     "This server must be run as root because it needs to bind to privileged "+
···
 // you want to write something pretty be my guest
 
 function generate_id() {
-  if (typeof generate_id.current_id == 'undefined'
-      || generate_id.current_id > MAX_ID) {
+  if (typeof generate_id.current_id == 'undefined' ||
+      generate_id.current_id > MAX_ID) {
     generate_id.current_id = 0;
   }
   return generate_id.current_id++;
···
   socket.on('connect', function() {
     clients[client_id] = socket;
     current_connections++;
-    log(client_name + 'connected\t\t('
-        + current_connections + ' current connections)');
+    log(client_name + 'connected\t\t(' +
+      current_connections + ' current connections)');
   });
 
   socket.on('close', function() {
     delete clients[client_id];
     current_connections--;
-    log(client_name + 'closed\t\t('
-        + current_connections + ' current connections)');
+    log(client_name + 'closed\t\t(' +
+      current_connections + ' current connections)');
   });
 
   socket.on('timeout', function() {

support/jshint/jshintconfig

···
+{
+  "expr" : true,
+  "loopfunc" : true,
+  "sub" : true
+}

webroot/rsrc/externals/javelin/core/Event.js

···
       JX.Event.prototype.toString = function() {
         var path = '['+this.getPath().join(', ')+']';
         return 'Event<'+this.getType()+', '+path+', '+this.getTarget()+'>';
-      }
+      };
     }
   }
 });

webroot/rsrc/externals/javelin/core/init.js

···
       return;
     }
     holding_queues[name] = [];
-    JX[name] = function() { holding_queues[name].push(arguments); }
+    JX[name] = function() { holding_queues[name].push(arguments); };
   }
 
   JX.flushHoldingQueue = function(name, fn) {
···
       fn.apply(null, holding_queues[name][ii]);
     }
     holding_queues[name] = {};
-  }
+  };
 
   makeHoldingQueue('install');
   makeHoldingQueue('behavior');
···
         return false;
       }
     }
-  }
+  };
 
   JX.enableDispatch = function(target, type) {
     if (__DEV__) {
···
     }
   }
 
-  for (var ii = 0; ii < document_events.length; ++ii) {
+  var ii;
+  for (ii = 0; ii < document_events.length; ++ii) {
     JX.enableDispatch(root, document_events[ii]);
   }
 
···
   ];
 
 
-  for (var ii = 0; ii < window_events.length; ++ii) {
+  for (ii = 0; ii < window_events.length; ++ii) {
     JX.enableDispatch(window, window_events[ii]);
   }
 
···
       '<script' +
       ' defer="defer"' +
       ' onreadystatechange="' + ready + '"' +
-      '><\/sc' + 'ript\>');
+      '><\/sc' + 'ript' + '>');
   }
 
   JX.onload = function(func) {
···
     } else {
       onload.push(func);
     }
-  }
+  };
+
 })();

webroot/rsrc/externals/javelin/core/util.js

···
 
   return function() {
     return func.apply(context || window, bound.concat(JX.$A(arguments)));
-  }
+  };
 };
 
 
···
    */
   JX.log = function(message) {
     window.console.log(message);
-  }
+  };
 
   window.alert = (function(native_alert) {
     var recent_alerts = [];
···
         native_alert(msg);
       }
       in_alert = false;
-    }
+    };
   })(window.alert);
 }
 

webroot/rsrc/externals/javelin/ext/reactor/dom/RDOM.js

···
  * @provides javelin-reactor-dom
  * @requires javelin-dom
  *           javelin-dynval
+ *           javelin-reactor
  *           javelin-reactornode
  *           javelin-install
  *           javelin-util

webroot/rsrc/externals/javelin/ext/view/HTMLView.js

···
  *
  * @provides javelin-view-html
  * @requires javelin-install
- *           javelin-view
+ *           javelin-dom
+ *           javelin-view-visitor
+ *           javelin-util
  */
 
 JX.install('HTMLView', {
···
 
     validate: function(view, children) {
       var spec = this._getHTMLSpec();
-      if (!view.getName() in spec) {
+      if (!(view.getName() in spec)) {
         throw new Error("invalid tag");
       }
 

webroot/rsrc/externals/javelin/ext/view/View.js

···
       var result = [];
       var should_repack = false;
 
-      for(var ii = 0; ii < this._childKeys.length; ii++) {
-        var key = this._childKeys[ii];
+      var ii;
+      var key;
+
+      for (ii = 0; ii < this._childKeys.length; ii++) {
+        key = this._childKeys[ii];
         if (this._rawChildren[key] === undefined) {
           should_repack = true;
         } else {
···
 
       if (should_repack) {
         var new_child_keys = [];
-        for(var ii = 0; ii < this._childKeys.length; ii++) {
-          var key = this._childKeys[ii];
+        for (ii = 0; ii < this._childKeys.length; ii++) {
+          key = this._childKeys[ii];
           if (this._rawChildren[key] !== undefined) {
             new_child_keys.push(key);
           }

webroot/rsrc/externals/javelin/ext/view/ViewInterpreter.js

···
  * @provides javelin-view-interpreter
  * @requires javelin-view
  *           javelin-install
- *
+ *           javelin-dom
  */
 
 JX.install('ViewInterpreter', {
···
         result.addChildren(children);
 
         return result;
-      }
+      };
     }
   }
 });

webroot/rsrc/externals/javelin/ext/view/ViewPlaceholder.js

···
  * @requires javelin-behavior
  *           javelin-dom
  *           javelin-view-renderer
+ *           javelin-install
  */
 
 
···
   statics: {
     register: function(wait_on_token, token, cb) {
       var ready_q = [];
+      var waiting;
 
       if (!wait_on_token || wait_on_token in JX.ViewPlaceholder.ready) {
         ready_q.push({token: token, cb: cb});
       } else {
-        var waiting = JX.ViewPlaceholder.waiting;
+        waiting = JX.ViewPlaceholder.waiting;
         waiting[wait_on_token] = waiting[wait_on_token] || [];
         waiting[wait_on_token].push({token: token, cb: cb});
       }
···
       while(ready_q.length) {
         var ready = ready_q.shift();
 
-        var waiting = JX.ViewPlaceholder.waiting[ready.token];
+        waiting = JX.ViewPlaceholder.waiting[ready.token];
         if (waiting) {
           for (var ii = 0; ii < waiting.length; ii++) {
             ready_q.push(waiting[ii]);

webroot/rsrc/externals/javelin/ext/view/ViewRenderer.js

···
 /**
  * @provides javelin-view-renderer
  * @requires javelin-install
+ *           javelin-util
  */
 
 JX.install('ViewRenderer', {

webroot/rsrc/externals/javelin/ext/view/__tests__/ViewRenderer.js

···
     parent.addChild(child);
     child.render = function(_) {
       child_rendered = true;
-    }
+    };
 
     parent.render = function(rendered_children) {
       child_rendered_first = child_rendered;
-    }
+    };
 
     JX.ViewRenderer.render(parent);
     expect(child_rendered_first).toBe(true);

webroot/rsrc/externals/javelin/lib/DOM.js

···
       var tags = ['legend', 'thead', 'tbody', 'tfoot', 'column', 'colgroup',
                   'caption', 'tr', 'th', 'td', 'option'];
       var evil_stuff = new RegExp('^\\s*<(' + tags.join('|') + ')\\b', 'i');
-      var match = null;
-      if (match = str.match(evil_stuff)) {
+      var match = str.match(evil_stuff);
+      if (match) {
         JX.$E(
           'new JX.HTML("<' + match[1] + '>..."): ' +
           'call initializes an HTML object with an invalid partial fragment ' +
···
      * @return void
      */
     show : function() {
+      var ii;
+
       if (__DEV__) {
-        for (var ii = 0; ii < arguments.length; ++ii) {
+        for (ii = 0; ii < arguments.length; ++ii) {
           if (!arguments[ii]) {
             JX.$E(
               'JX.DOM.show(...): ' +
···
         }
       }
 
-      for (var ii = 0; ii < arguments.length; ++ii) {
+      for (ii = 0; ii < arguments.length; ++ii) {
         arguments[ii].style.display = '';
       }
     },
···
      * @return void
      */
     hide : function() {
+      var ii;
+
       if (__DEV__) {
-        for (var ii = 0; ii < arguments.length; ++ii) {
+        for (ii = 0; ii < arguments.length; ++ii) {
           if (!arguments[ii]) {
             JX.$E(
               'JX.DOM.hide(...): ' +
···
         }
       }
 
-      for (var ii = 0; ii < arguments.length; ++ii) {
+      for (ii = 0; ii < arguments.length; ++ii) {
         arguments[ii].style.display = 'none';
       }
     },

webroot/rsrc/externals/javelin/lib/Mask.js

···
         document.body.appendChild(self._mask);
       }
 
-      self._adjustType(mask_type)
+      self._adjustType(mask_type);
       JX.Mask._stack.push(mask_type);
     },
 

webroot/rsrc/externals/javelin/lib/Request.js

···
               'JX.Request("'+this.getURI()+'", ...): '+
               'server returned an empty response.');
           }
-          if (expect_guard && xport.responseText.indexOf('for (;;);') != 0) {
+          if (expect_guard && xport.responseText.indexOf('for (;;);') !== 0) {
             JX.$E(
               'JX.Request("'+this.getURI()+'", ...): '+
               'server returned an invalid response.');
···
           recurse(obj, ii);
         }
       } else if (obj && typeof obj == 'object') {
-        if (obj.__html != null) {
+        if (('__html' in obj) && (obj.__html !== null)) {
           parent[index] = JX.$H(obj.__html);
         } else {
           for (var key in obj) {

webroot/rsrc/externals/javelin/lib/Resource.js

···
 /**
  * @provides javelin-resource
- * @requires javelin-magical-init
- *           javelin-stratcom
- *           javelin-util
+ * @requires javelin-util
  *           javelin-uri
+ *           javelin-install
  *
  * @javelin
  */

webroot/rsrc/externals/javelin/lib/URI.js

···
     _defaultQuerySerializer : function(obj) {
       var kv_pairs = [];
       for (var key in obj) {
-        if (obj[key] != null) {
+        if (obj[key] !== null) {
           var value = encodeURIComponent(obj[key]);
           kv_pairs.push(encodeURIComponent(key) + (value ? '=' + value : ''));
         }

webroot/rsrc/externals/javelin/lib/Vector.js

···
      */
     setDim : function(node) {
       node.style.width =
-        (this.x === null)
-          ? ''
-          : (parseInt(this.x, 10) + 'px');
+        (this.x === null) ? '' : (parseInt(this.x, 10) + 'px');
       node.style.height =
-        (this.y === null)
-          ? ''
-          : (parseInt(this.y, 10) + 'px');
+        (this.y === null) ? '' : (parseInt(this.y, 10) + 'px');
       return this;
     },
 

webroot/rsrc/externals/javelin/lib/Workflow.js

···
 
       JX.Workflow._pop();
       e.prevent();
-    };
+    }
 
     JX.Stratcom.listen('keydown', null, close_dialog_when_user_presses_escape);
   }

webroot/rsrc/externals/javelin/lib/__tests__/URI.js

···
     expect(uri.toString()).toEqual('/?clown=town');
   });
 
-  it('can remove non existant query data', function() {
+  it('can remove non existent query data', function() {
     var uri = JX.$U('/?key=value');
     uri.addQueryParams({'magic' : null});
     expect(uri.getQueryParams()).toEqual({

webroot/rsrc/externals/javelin/lib/behavior.js

···
 /**
  * @provides javelin-behavior
  * @requires javelin-magical-init
+ *           javelin-util
  *
  * @javelin-installs JX.behavior
  * @javelin-installs JX.initBehaviors

webroot/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js

···
         case 'delete':
           if (!this._focus.value.length) {
             var tok;
-            while (tok = this._tokens.pop()) {
+            while ((tok = this._tokens.pop())) {
               if (this._remove(tok, true)) {
                 break;
               }

webroot/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js

···
 /**
  * @requires javelin-install
  *           javelin-util
- *           javelin-stratcom
  *           javelin-request
  *           javelin-typeahead-source
  * @provides javelin-typeahead-ondemand-source

webroot/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js

···
 /**
  * @requires javelin-install
  *           javelin-util
- *           javelin-stratcom
  *           javelin-request
  *           javelin-typeahead-source
  * @provides javelin-typeahead-preloaded-source

webroot/rsrc/externals/javelin/lib/control/typeahead/source/TypeaheadSource.js

···
 
     sortHits : function(value, hits) {
       var objs = [];
-      for (var ii = 0; ii < hits.length; ii++) {
+      var ii;
+      for (ii = 0; ii < hits.length; ii++) {
         objs.push(this._raw[hits[ii]]);
       }
 
···
       handler(value, objs, default_comparator);
 
       hits.splice(0, hits.length);
-      for (var ii = 0; ii < objs.length; ii++) {
+      for (ii = 0; ii < objs.length; ii++) {
         hits.push(objs[ii].id);
       }
     },

webroot/rsrc/externals/raphael/g.raphael.js

···
 /**
  * @provides raphael-g
  * @do-not-minify
+ * @nolint
  */
 /*!
  * g.Raphael 0.5 - Charting library, based on Raphaël

webroot/rsrc/externals/raphael/g.raphael.line.js

···
 /**
  * @provides raphael-g-line
  * @do-not-minify
+ * @nolint
  */
 /*!
  * g.Raphael 0.5 - Charting library, based on Raphaël

webroot/rsrc/externals/raphael/raphael.js

···
 /**
  * @provides raphael-core
  * @do-not-minify
+ * @nolint
  */
 // ┌─────────────────────────────────────────────────────────────────────┐ \\
 // │ Raphaël 2.0.1 - JavaScript Vector Library                           │ \\

webroot/rsrc/js/application/aphlict/behavior-aphlict-dropdown.js

···
       return;
     }
     request = new JX.Request('/notification/panel/', function(response) {
-      var display = (response.number > 999)
-        ? "\u221E"
-        : response.number;
+      var display = (response.number > 999) ? "\u221E" : response.number;
 
       JX.DOM.setContent(count, display);
-      if (response.number == 0) {
+      if (response.number === 0) {
         JX.DOM.alterClass(bubble, 'alert-unread', false);
       } else {
         JX.DOM.alterClass(bubble, 'alert-unread', true);
···
       visible = !visible;
       e.kill();
     }
-  )
+  );
 
   JX.Stratcom.listen('notification-panel-update', null, function() {
     dirty = true;

webroot/rsrc/js/application/aphlict/behavior-aphlict-listen.js

···
         .send();
     } else if (__DEV__) {
       if (config.debug) {
-        var details = message
-          ? JX.JSON.stringify(message)
-          : '';
+        var details = message ? JX.JSON.stringify(message) : '';
 
         new JX.Notification()
           .setContent('(Aphlict) [' + type + '] ' + details)
···
         .setContent('Page updated, click to reload.')
         .alterClassName('jx-notification-alert', true)
         .setDuration(0);
-      reload.listen('activate', function(e) { JX.$U().go(); })
+      reload.listen('activate', function(e) { JX.$U().go(); });
       reload.show();
 
       showing_reload = true;
···
 
   // Add Flash object to page
   JX.$(config.containerID).innerHTML =
-    '<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000">'
-    + '<param name="movie" value="/rsrc/swf/aphlict.swf" />'
-    + '<param name="allowScriptAccess" value="always" />'
-    + '<param name="wmode" value="opaque" />'
-    + '<embed src="/rsrc/swf/aphlict.swf" wmode="opaque"'
-      + 'width="0" height="0" id="' + config.id + '">'
-    + '</embed></object>'; //Evan sanctioned
+    '<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000">' +
+      '<param name="movie" value="/rsrc/swf/aphlict.swf" />' +
+      '<param name="allowScriptAccess" value="always" />' +
+      '<param name="wmode" value="opaque" />' +
+      '<embed src="/rsrc/swf/aphlict.swf" wmode="opaque"' +
+        'width="0" height="0" id="' + config.id + '">' +
+    '</embed></object>'; //Evan sanctioned
 });

webroot/rsrc/js/application/conpherence/behavior-widget-pane.js

···
 
     var root = JX.DOM.find(document, 'div', 'conpherence-layout');
     var widgetPane = JX.DOM.find(root, 'div', 'conpherence-widget-pane');
+    var i;
+    var tag_data;
+    var node;
+
     for (var widget in config.widgetRegistery) {
       // device-only widgets are *always shown* on the desktop
       if (config.widgetRegistery[widget] == config.devicesOnly) {
         if (is_desktop) {
           JX.$(widget).style.display = 'block';
           if (config.widgetExtraNodes[widget]) {
-            for (var i in config.widgetExtraNodes[widget]) {
-              var tag_data = config.widgetExtraNodes[widget][i];
-              var node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
+            for (i in config.widgetExtraNodes[widget]) {
+              tag_data = config.widgetExtraNodes[widget][i];
+              node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
               node.style.display = tag_data.desktopstyle;
             }
           }
···
           widgetPane.style.height = '100%';
         }
         if (config.widgetExtraNodes[widget]) {
-          for (var i in config.widgetExtraNodes[widget]) {
-            var tag_data = config.widgetExtraNodes[widget][i];
-            var node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
+          for (i in config.widgetExtraNodes[widget]) {
+            tag_data = config.widgetExtraNodes[widget][i];
+            node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
             node.style.display = tag_data.showstyle;
           }
         }
···
         );
         JX.$(widget).style.display = 'none';
         if (config.widgetExtraNodes[widget]) {
-          for (var i in config.widgetExtraNodes[widget]) {
-            var tag_data = config.widgetExtraNodes[widget][i];
-            var node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
+          for (i in config.widgetExtraNodes[widget]) {
+            tag_data = config.widgetExtraNodes[widget][i];
+            node = JX.DOM.find(root, tag_data.tagname, tag_data.sigil);
             node.style.display = tag_data.hidestyle;
           }
         }

webroot/rsrc/js/application/countdown/timer.js

···
  * @provides javelin-behavior-countdown-timer
  * @requires javelin-behavior
  *           javelin-dom
- *           javelin-util
  */
 
 JX.behavior('countdown-timer', function(config) {

webroot/rsrc/js/application/differential/DifferentialInlineCommentEditor.js

···
         return;
       }
 
+      var textarea;
       try {
-        var textarea = JX.DOM.find(
+        textarea = JX.DOM.find(
           document.body, // TODO: use getDialogRootNode() when available
           'textarea',
           'differential-inline-comment-edit-textarea');
···
 
       // If the user hasn't edited the text (i.e., no change from original for
       // 'edit' or no text at all), don't offer them an undo.
-      if (text == this.getOriginalText() || text == '') {
+      if (text == this.getOriginalText() || text === '') {
         return;
       }
 
       // Save the text so we can 'undo' back to it.
       this._undoText = text;
 
-      var template = this.getOnRight()
-        ? this.getTemplates().r
-        : this.getTemplates().l;
+      var templates = this.getTemplates();
+      var template = this.getOnRight() ? templates.r : templates.l;
       template = JX.$N('div', JX.$H(template));
 
       // NOTE: Operation order matters here; we can't remove anything until

webroot/rsrc/js/application/differential/behavior-comment-jump.js

···
 /**
  * @provides javelin-behavior-differential-comment-jump
  * @requires javelin-behavior
- *           javelin-util
+ *           javelin-stratcom
  *           javelin-dom
  */
 
···
         }
       }
       JX.Stratcom.invoke('differential-toggle-file-request', null, {
-        element: jumpto,
+        element: jumpto
       });
       JX.DOM.scrollTo(jumpto);
       e.kill();

webroot/rsrc/js/application/differential/behavior-comment-preview.js

···
   var action = JX.$(config.action);
   var content = JX.$(config.content);
   var previewTokenizers = {};
-  for (var field in config.previewTokenizers) {
+  var field;
+  for (field in config.previewTokenizers) {
     var tokenizer = JX.$(config.previewTokenizers[field]);
     previewTokenizers[field] = JX.Stratcom.getData(tokenizer).tokenizer;
   }
···
 
   JX.DOM.listen(content, 'keydown', null, trigger);
   JX.DOM.listen(action,  'change',  null, trigger);
-  for (var field in previewTokenizers) {
+  for (field in previewTokenizers) {
     previewTokenizers[field].listen('change', trigger);
   }
 

webroot/rsrc/js/application/differential/behavior-dropdown-menus.js

···
 
     var visible_item = new JX.PhabricatorMenuItem('', function () {
       JX.Stratcom.invoke('differential-toggle-file', null, {
-        diff: JX.DOM.scry(JX.$(data.containerID), 'table', 'differential-diff'),
+        diff: JX.DOM.scry(JX.$(data.containerID), 'table', 'differential-diff')
       });
     });
     menu.addItem(visible_item);

webroot/rsrc/js/application/differential/behavior-edit-inline-comments.js

···
 
     var node = e.getNode('differential-inline-comment');
     handle_inline_action(node, op);
-  }
+  };
 
   var handle_inline_action = function(node, op) {
     var data = JX.Stratcom.getData(node);
···
       .start();
 
     set_link_state(true);
-  }
+  };
 
   for (var op in {'edit' : 1, 'delete' : 1, 'reply' : 1}) {
     JX.Stratcom.listen(

webroot/rsrc/js/application/differential/behavior-keyboard-nav.js

···
           selection_end = blocks[focus][1];
 
           manager.scrollTo(selection_begin);
-          (refreshFocus = function() {
+
+          refreshFocus = function() {
             manager.focusOn(selection_begin, selection_end);
-          })();
+          };
+
+          refreshFocus();
 
           return;
         } else {

webroot/rsrc/js/application/differential/behavior-populate.js

···
       var diff;
       try {
         diff = JX.$(meta.id);
-      } catch (e) {
+      } catch (ex) {
         // Already loaded.
       }
       if (diff) {

webroot/rsrc/js/application/differential/behavior-show-all-comments.js

···
           try {
             var target = JX.$(window.location.hash.replace(/^#/, ''));
             window.scrollTo(0, target.offsetTop);
-          } catch (e) {
+          } catch (ex) {
           }
         }
       });

webroot/rsrc/js/application/diffusion/behavior-audit-preview.js

···
       action: action.value,
       content: content.value
     };
-  }
+  };
 
   var request = new JX.PhabricatorShapedRequest(config.uri, callback, getdata);
   var trigger = JX.bind(request, request.trigger);

webroot/rsrc/js/application/diffusion/behavior-commit-graph.js

···
       '#00cccc',
       '#00cc33',
       '#66cc00',
-      '#cc9900',
+      '#cc9900'
     ];
     return colors[c % colors.length];
   }
···
     var data = JX.Stratcom.getData(nodes[ii]);
 
     var cell = 12; // Width of each thread.
-    function xpos(col) {
+    var xpos = function(col) {
       return (col * cell) + (cell / 2);
-    }
+    };
 
     var h = 26;
     var w = cell * config.count;
···
     // a parent). We use this to figure out where to draw the join/split lines.
 
     var origin = null;
-    for (var jj = 0; jj < data.line.length; jj++) {
-      var c = data.line.charAt(jj);
+    var jj;
+    var x;
+    var c;
+    for (jj = 0; jj < data.line.length; jj++) {
+      c = data.line.charAt(jj);
       switch (c) {
         case 'o':
         case '^':
···
     // Draw all the join lines. These start at some column at the top of the
     // canvas and join the commit's column. They indicate branching.
 
-    for (var jj = 0; jj < data.join.length; jj++) {
+    for (jj = 0; jj < data.join.length; jj++) {
       var join = data.join[jj];
-      var x = xpos(join);
+      x = xpos(join);
       cxt.beginPath();
         cxt.moveTo(x, 0);
         cxt.bezierCurveTo(x, h/4, origin, h/4, origin, h/2);
···
     // Draw all the split lines. These start at the commit and end at some
     // column on the bottom of the canvas. They indicate merging.
 
-    for (var jj = 0; jj < data.split.length; jj++) {
+    for (jj = 0; jj < data.split.length; jj++) {
       var split = data.split[jj];
-      var x = xpos(split);
+      x = xpos(split);
       cxt.beginPath();
         cxt.moveTo(origin, h/2);
         cxt.bezierCurveTo(origin, 3*h/4, x, 3*h/4, x, h);
···
     // Draw the vertical lines (a branch with no activity at this commit) and
     // the commit circles.
 
-    for (var jj = 0; jj < data.line.length; jj++) {
-      var c = data.line.charAt(jj);
+    for (jj = 0; jj < data.line.length; jj++) {
+      c = data.line.charAt(jj);
       switch (c) {
         case 'o':
         case '^':
-          origin = xpos(jj);
         case '|':
+          if (c == 'o' || c == '^') {
+            origin = xpos(jj);
+          }
+
           cxt.beginPath();
           cxt.moveTo(xpos(jj), (c == '^' ? h/2 : 0));
           cxt.lineTo(xpos(jj), h);

webroot/rsrc/js/application/diffusion/behavior-jump-to.js

···
 /**
  * @provides javelin-behavior-diffusion-jump-to
  * @requires javelin-behavior
- *           javelin-util
  *           javelin-vector
  *           javelin-dom
  */

webroot/rsrc/js/application/maniphest/behavior-batch-editor.js

···
           vfunc = function() { return status_select.value; };
           break;
       }
-    };
+    }
 
     JX.DOM.listen(action_select, 'change', null, update);
     update();

webroot/rsrc/js/application/maniphest/behavior-batch-selector.js

···
 
   var get_id = function(task) {
     return JX.Stratcom.getData(task).taskID;
-  }
+  };
 
   var is_selected = function(task) {
     return (get_id(task) in selected);
-  }
+  };
 
   // Change the selected state of a task.
 
···
     for (var ii = 0; ii < inputs.length; ii++) {
       change(inputs[ii], to);
     }
-  }
+  };
 
   // Clear any document text selection after toggling a task via shift click,
   // since errant clicks tend to start selecting various ranges otherwise.
···
     } else if (document.selection) {
       document.selection.empty();
     }
-  }
+  };
 
   // Update the status text showing how many tasks are selected, and the button
   // state.
···
   var update = function() {
     var count = JX.keys(selected).length;
     var status;
-    if (count == 0) {
+    if (count === 0) {
       status = 'Shift-Click to Select Tasks';
     } else if (status == 1) {
       status = '1 Selected Task';
···
     JX.DOM.setContent(JX.$(config.status), status);
 
     var submit = JX.$(config.submit);
-    var disable = (count == 0);
+    var disable = (count === 0);
     submit.disabled = disable;
     JX.DOM.alterClass(submit, 'disabled', disable);
   };

webroot/rsrc/js/application/maniphest/behavior-task-preview.js

···
     return {
       description : textarea.value
     };
-  }
+  };
 
   var request = new JX.PhabricatorShapedRequest(config.uri, callback, getdata);
   var trigger = JX.bind(request, request.trigger);

webroot/rsrc/js/application/maniphest/behavior-transaction-controls.js

···
   for (var k in config.tokenizers) {
     var tconfig = config.tokenizers[k];
     tokenizers[k] = JX.Prefab.buildTokenizer(tconfig).tokenizer;
-    tokenizers[k].start()
+    tokenizers[k].start();
   }
 
   JX.DOM.listen(

webroot/rsrc/js/application/maniphest/behavior-transaction-preview.js

···
       action : selected,
       value : value || ''
     };
-  }
+  };
 
   var request = new JX.PhabricatorShapedRequest(config.uri, callback, getdata);
   var trigger = JX.bind(request, request.trigger);

webroot/rsrc/js/application/phame/phame-post-preview.js

···
     if (!sync_titles) {
       return;
     }
-    var title_string  = new String(title.value);
+    var title_string  = title.value;
     phame_title.value = normalizeSlug(title_string);
-  }
+  };
 
   var phameTitleKeyupCallback = function (e) {
     // stop sync'ing once user edits phame_title directly
···
       phame_title.focus();
       phame_title.setSelectionRange(position, position);
     }
-  }
+  };
 
   var phameTitleBlurCallback = function (e) {
     phame_title.value = normalizeSlug(phame_title.value);
-  }
+  };
 
   // This is a sort of implementation of PhabricatorSlug::normalize
   var normalizeSlug = function (slug, spare_trailing_underscore) {
···
       s = s.replace(/_$/g, '');
     }
     return s;
-  }
+  };
 
   var callback = function(r) {
     JX.DOM.setContent(JX.$(config.preview), JX.$H(r));
···
       title       : title.value,
       phame_title : phame_title.value
     };
-  }
+  };
 
   var request = new JX.PhabricatorShapedRequest(config.uri, callback, getdata);
   var trigger = JX.bind(request, request.trigger);

webroot/rsrc/js/application/pholio/behavior-pholio-mock-view.js

···
     }
 
     function clear_stage() {
-      for (var ii = 0; ii < reticles.length; ii++) {
+      var ii;
+      for (ii = 0; ii < reticles.length; ii++) {
         JX.DOM.remove(reticles[ii]);
       }
-      for (var ii = 0; ii < cards.length; ii++) {
+      for (ii = 0; ii < cards.length; ii++) {
         JX.DOM.remove(cards[ii]);
       }
       reticles = [];
···
     if (!active_image) {
       return;
     }
-    var idx = get_image_index(active_image.id)
+    var idx = get_image_index(active_image.id);
     idx = (idx + delta + config.images.length) % config.images.length;
     select_image(config.images[idx].id);
   }
···
         ).setPos(dialog);
 
         JX.DOM.focus(JX.DOM.find(dialog, 'textarea'));
-      }
+      };
 
       new JX.Workflow('/pholio/inline/save/', data)
         .setHandler(handler)
···
 
     var width = end.x - start.x;
     var height = end.y - start.y;
+    var addon;
 
     if (width < min_size) {
-      var addon = (min_size-width)/2;
+      addon = (min_size-width)/2;
 
       start.x = Math.max(0, start.x - addon);
       end.x = Math.min(active_image.tag.naturalWidth, end.x + addon);
 
-      if (start.x == 0) {
+      if (start.x === 0) {
         end.x = Math.min(min_size, active_image.tag.naturalWidth);
       } else if (end.x == active_image.tag.naturalWidth) {
         start.x = Math.max(0, active_image.tag.naturalWidth - min_size);
···
     }
 
     if (height < min_size) {
-      var addon = (min_size-height)/2;
+      addon = (min_size-height)/2;
 
       start.y = Math.max(0, start.y - addon);
       end.y = Math.min(active_image.tag.naturalHeight, end.y + addon);
 
-      if (start.y == 0) {
+      if (start.y === 0) {
         end.y = Math.min(min_size, active_image.tag.naturalHeight);
       } else if (end.y == active_image.tag.naturalHeight) {
         start.y = Math.max(0, active_image.tag.naturalHeight - min_size);

webroot/rsrc/js/application/phriction/phriction-document-preview.js

···
     return {
       document : textarea.value
     };
-  }
+  };
 
   var request = new JX.PhabricatorShapedRequest(config.uri, callback, getdata);
   var trigger = JX.bind(request, request.trigger);

webroot/rsrc/js/application/ponder/behavior-votebox.js

···
     JX.DOM.alterClass(upv, 'ponder-vote-active', (data.vote > 0));
 
     var downv = JX.DOM.find(root, 'a', 'downvote');
-    JX.DOM.alterClass(downv, 'ponder-vote-active', (data.vote < 0))
+    JX.DOM.alterClass(downv, 'ponder-vote-active', (data.vote < 0));
 
     JX.DOM.setContent(
       JX.DOM.find(root, 'div', 'ponder-vote-count'),
···
 
     new JX.Request(e.getTarget().href, JX.bag)
       .setData({vote: data.vote})
-      .send()
+      .send();
   }
 
   JX.Stratcom.listen(

webroot/rsrc/js/application/releeph/releeph-preview-branch.js

···
  * @provides javelin-behavior-releeph-preview-branch
  * @requires javelin-behavior
  *           javelin-dom
- *           javelin-stratcom
  *           javelin-uri
- *           javelin-util
+ *           javelin-request
  */
 
 JX.behavior('releeph-preview-branch', function(config) {
 
   var uri = JX.$U(config.uri);
-  for (param_name in config.params.static) {
+  for (var param_name in config.params.static) {
     var value = config.params.static[param_name];
     uri.setQueryParam(param_name, value);
   }
···
   var dynamics = config.params.dynamic;
 
   function renderPreview() {
-    for (param_name in dynamics) {
+    for (var param_name in dynamics) {
       var node_id = dynamics[param_name];
       var input = JX.$(node_id);
       uri.setQueryParam(param_name, input.value);
···
 
   renderPreview();
 
-  for (ii in dynamics) {
+  for (var ii in dynamics) {
     var node_id = dynamics[ii];
     var input = JX.$(node_id);
     JX.DOM.listen(

webroot/rsrc/js/application/releeph/releeph-request-state-change.js

···
  * @requires javelin-behavior
  *           javelin-dom
  *           javelin-stratcom
- *           javelin-util
+ *           javelin-request
  *           phabricator-keyboard-shortcut
  *           phabricator-notification
  */
···
 
   function keynavMarkup() {
     var headers = getRequestHeaderNodes();
-    for (ii in headers) {
-      JX.DOM.alterClass(headers[ii], 'focus', ii == keynav_cursor);
+    for (var k in headers) {
+      JX.DOM.alterClass(headers[k], 'focus', k == keynav_cursor);
     }
   }
 

webroot/rsrc/js/application/releeph/releeph-request-typeahead.js

···
 /**
  * @provides javelin-behavior-releeph-request-typeahead
  * @requires javelin-behavior
- *           javelin-util
  *           javelin-dom
  *           javelin-typeahead
- *           javelin-tokenizer
- *           javelin-typeahead-preloaded-source
  *           javelin-typeahead-ondemand-source
  *           javelin-dom
- *           javelin-stratcom
- *           javelin-util
  */
 
 JX.behavior('releeph-request-typeahead', function(config) {
···
               'div',
               { className: 'summary' },
               summary
-            ),
+            )
           ]
         );
 

webroot/rsrc/js/application/slowvote/behavior-slowvote-embed.js

···
 /**
  * @provides javelin-behavior-slowvote-embed
  * @requires javelin-behavior
- *           javelin-util
+ *           javelin-request
  *           javelin-stratcom
  *           javelin-dom
  */

webroot/rsrc/js/application/transactions/behavior-transaction-comment-form.js

···
         [
           JX.$H(response.spacer),
           JX.$H(response.xactions.join(response.spacer)),
-          JX.$H(response.spacer),
+          JX.$H(response.spacer)
         ]);
       JX.DOM.show(panel);
     }

webroot/rsrc/js/application/uiexample/JavelinViewExample.js

···
 /**
  * @provides phabricator-uiexample-javelin-view
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  */
 

webroot/rsrc/js/application/uiexample/ReactorButtonExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-button
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
+ *           javelin-util
+ *           javelin-dynval
  *           javelin-reactor-dom
  */
 

webroot/rsrc/js/application/uiexample/ReactorCheckboxExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-checkbox
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/ReactorFocusExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-focus
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/ReactorInputExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-input
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
- *           javelin-dom
  *           javelin-reactor-dom
  *           javelin-view-html
  *           javelin-view-interpreter

webroot/rsrc/js/application/uiexample/ReactorMouseoverExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-mouseover
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/ReactorRadioExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-radio
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/ReactorSelectExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-select
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */
···
       var select = JX.$N('select', {}, [
         JX.$N('option', { value: 'goat' }, 'Goat'),
         JX.$N('option', { value: 'bat' }, 'Bat'),
-        JX.$N('option', { value: 'duck' }, 'Duck'),
+        JX.$N('option', { value: 'duck' }, 'Duck')
       ]);
 
       return [select, JX.RDOM.$DT(JX.RDOM.select(select))];

webroot/rsrc/js/application/uiexample/ReactorSendClassExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-sendclass
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/ReactorSendPropertiesExample.js

···
 /**
  * @provides phabricator-uiexample-reactor-sendproperties
  * @requires javelin-install
- *           javelin-view
- *           javelin-util
  *           javelin-dom
  *           javelin-reactor-dom
  */

webroot/rsrc/js/application/uiexample/gesture-example.js

···
     cxt.fillStyle = '#dfdfdf';
     cxt.fillRect(0, 0, d.x, d.y);
 
-    for (var ii = 0; ii < strokes.length; ii++) {
-      var s = strokes[ii];
+    var s;
+    var ii;
+    for (ii = 0; ii < strokes.length; ii++) {
+      s = strokes[ii];
       cxt.strokeStyle = 'rgba(0, 0, 0, 0.50)';
       cxt.beginPath();
         cxt.moveTo(s[0], s[1]);
···
       cxt.stroke();
     }
 
-    for (var ii = 0; ii < current.length; ii++) {
-      var s = current[ii];
+    for (ii = 0; ii < current.length; ii++) {
+      s = current[ii];
       cxt.strokeStyle = 'rgba(255, 0, 0, 1)';
       cxt.beginPath();
         cxt.moveTo(s[0], s[1]);

webroot/rsrc/js/application/uiexample/notification-example.js

···
  * @requires phabricator-notification
  *           javelin-stratcom
  *           javelin-behavior
- *           javelin-uri
  * @provides javelin-behavior-phabricator-notification-example
  */
 

webroot/rsrc/js/core/DragAndDropFileUpload.js

···
     _node : null,
     _depth : 0,
     _updateDepth : function(delta) {
-      if (this._depth == 0 && delta > 0) {
+      if (this._depth === 0 && delta > 0) {
         this.invoke('didBeginDrag');
       }
 
       this._depth += delta;
 
-      if (this._depth == 0 && delta < 0) {
+      if (this._depth === 0 && delta < 0) {
         this.invoke('didEndDrag');
       }
     },

webroot/rsrc/js/core/FileUpload.js

···
         .setDuration(0)
         .show();
 
+      var content;
       switch (this.getStatus()) {
         case 'done':
           var link = JX.$N('a', {href: this.getURI()}, 'F' + this.getID());
 
-          var content = [
+          content = [
             JX.$N('strong', {}, ['Upload Complete (', link, ')']),
             JX.$N('br'),
             this.getName()
···
           this._notification = null;
           break;
         case 'error':
-          var content = [
+          content = [
             JX.$N('strong', {}, 'Upload Failure'),
             JX.$N('br'),
             this.getName(),
···
         return null;
       }
       var ratio = this.getUploadedBytes() / this.getTotalBytes();
-      return parseInt(100 * ratio) + '%';
+      return parseInt(100 * ratio, 10) + '%';
     },
     _renderFileSize : function() {
       if (!this.getTotalBytes()) {

webroot/rsrc/js/core/Hovercard.js

···
       // TODO: Fix southern graceful align
       var margin = 20;
       // We can't shift left by ~$margin or more here due to Pholio, Phriction
-      var x = parseInt(p.x) - margin / 2;
-      var y = parseInt(p.y - n.y) - margin;
+      var x = parseInt(p.x, 10) - margin / 2;
+      var y = parseInt(p.y - n.y, 10) - margin;
 
       // If more in the center, we can safely center
       if (x > (n.x / 2) + margin) {
-        x = parseInt(p.x - (n.x / 2) + d.x);
+        x = parseInt(p.x - (n.x / 2) + d.x, 10);
       }
 
       // Temporarily disabled, since it gives weird results (you can only see

webroot/rsrc/js/core/Prefab.js

···
      *
      */
     buildTokenizer : function(config) {
+      var root;
+
       try {
-        var root = config.root || JX.$(config.id);
+        root = config.root || JX.$(config.id);
       } catch (ex) {
         // If the root element does not exist, just return without building
         // anything. This happens in some cases -- like Conpherence -- where we

webroot/rsrc/js/core/ToolTip.js

···
 
       switch (align) {
         case 'N':
-          node.style.left = parseInt(p.x - ((n.x - d.x) / 2)) + 'px';
-          node.style.top  = parseInt(p.y - n.y) + 'px';
+          node.style.left = parseInt(p.x - ((n.x - d.x) / 2), 10) + 'px';
+          node.style.top  = parseInt(p.y - n.y, 10) + 'px';
           break;
         case 'E':
-          node.style.left = parseInt(p.x + d.x) + 'px';
-          node.style.top  = parseInt(p.y - ((n.y - d.y) / 2)) + 'px';
+          node.style.left = parseInt(p.x + d.x, 10) + 'px';
+          node.style.top  = parseInt(p.y - ((n.y - d.y) / 2), 10) + 'px';
           break;
         case 'S':
-          node.style.left = parseInt(p.x - ((n.x - d.x) / 2)) + 'px';
-          node.style.top  = parseInt(p.y + d.y + 5) + 'px';
+          node.style.left = parseInt(p.x - ((n.x - d.x) / 2), 10) + 'px';
+          node.style.top  = parseInt(p.y + d.y + 5, 10) + 'px';
           break;
         case 'W':
-          node.style.left = parseInt(p.x - n.x - 5) + 'px';
-          node.style.top  = parseInt(p.y - ((n.y - d.y) / 2)) + 'px';
+          node.style.left = parseInt(p.x - n.x - 5, 10) + 'px';
+          node.style.top  = parseInt(p.y - ((n.y - d.y) / 2), 10) + 'px';
           break;
       }
     },

webroot/rsrc/js/core/behavior-active-nav.js

···
         'phabricator-active-nav-focus',
         selected);
     }
-  }
+  };
 
 
   /**
···
 
     // Sort the markers by Y position, descending.
     var markinfo = [];
-    for (var ii = 0; ii < markers.length; ii++) {
+    var ii;
+    for (ii = 0; ii < markers.length; ii++) {
       markinfo.push({
         marker: markers[ii],
         position: JX.$V(markers[ii]).y - 15
···
     // Find the first marker above the current scroll position, or the first
     // marker in the document if we're above all the markers.
     var active = null;
-    for (var ii = 0; ii < markinfo.length; ii++) {
+    for (ii = 0; ii < markinfo.length; ii++) {
       active = markinfo[ii].marker;
       if (markinfo[ii].position <= scroll_position) {
         break;
···
 
     // If we get above the first marker, select it.
     selectnav(active && JX.Stratcom.getData(active).anchor);
-  }
+  };
 
   var pending = null;
   var onviewportchange = function(e) {
     pending && clearTimeout(pending);
     pending = setTimeout(updateposition, 100);
-  }
+  };
 
   JX.Stratcom.listen('scroll', null, onviewportchange);
   JX.Stratcom.listen('resize', null, onviewportchange);

webroot/rsrc/js/core/behavior-fancy-datepicker.js

···
       m: JX.DOM.find(root, 'select', 'month-input'),
       d: JX.DOM.find(root, 'select', 'day-input')
     };
-  }
+  };
 
   var read_date = function() {
     var i = get_inputs();
···
       picker.firstChild,
       [
         render_month(),
-        render_day(),
+        render_day()
       ]);
   };
 
···
     }
 
     return JX.$N('td', {meta: {value: value}, className: class_name}, label);
-  }
+  };
 
 
   // Render the top bar which allows you to pick a month and year.
···
     // First, render the weekday names.
     var weekdays = 'SMTWTFS';
     var weekday_names = [];
-    for (var ii = 0; ii < weekdays.length; ii++) {
+    var ii;
+    for (ii = 0; ii < weekdays.length; ii++) {
       weekday_names.push(cell(weekdays.charAt(ii), null, false, 'day-name'));
     }
     weeks.push(JX.$N('tr', {}, weekday_names));
···
 
     var today = new Date();
 
-    for (var ii = 1; ii <= 31; ii++) {
+    for (ii = 1; ii <= 31; ii++) {
       var date = new Date(value_y, value_m - 1, ii);
       if (date.getMonth() != (value_m - 1)) {
         // We've spilled over into the next month, so stop rendering.
···
       if (is_today) {
         classes.push('today');
       }
-      if (date.getDay() == 0 || date.getDay() == 6) {
+      if (date.getDay() === 0 || date.getDay() == 6) {
         classes.push('weekend');
       }
 
···
     }
 
     // Slice the days into weeks.
-    for (var ii = 0; ii < days.length; ii += 7) {
+    for (ii = 0; ii < days.length; ii += 7) {
       weeks.push(JX.$N('tr', {}, days.slice(ii, ii + 7)));
     }
 
···
       switch (p[0]) {
         case 'm':
           // User clicked left or right month selection buttons.
-          value_m = value_m + parseInt(p[1]);
+          value_m = value_m + parseInt(p[1], 10);
           if (value_m > 12) {
             value_m -= 12;
             value_y++;
···
           break;
         case 'd':
           // User clicked a day.
-          value_d = parseInt(p[1]);
+          value_d = parseInt(p[1], 10);
           write_date();
 
           // Wait a moment to close the selector so they can see the effect

webroot/rsrc/js/core/behavior-global-drag-and-drop.js

···
     files.push(f);
 
     pending--;
-    if (pending == 0 && !errors) {
+    if (pending === 0 && !errors) {
       // If whatever the user dropped in has finished uploading, send them to
       // their uploads.
       var uri;

webroot/rsrc/js/core/behavior-hovercard.js

···
   // We listen for mousemove instead of mouseover to handle the case when user
   // scrolls with keyboard. We don't want to display hovercard if node gets
   // under the mouse cursor randomly placed somewhere on the screen. This
-  // unfortunatelly doesn't work in Google Chrome which triggers both mousemove
+  // unfortunately doesn't work in Google Chrome which triggers both mousemove
   // and mouseover in this case but works in other browsers.
   JX.Stratcom.listen(
     'mousemove',

webroot/rsrc/js/core/behavior-lightbox-attachments.js

···
     img.onload = function() {
       JX.DOM.alterClass(img, 'loading', false);
       JX.Busy.done();
-    }
+    };
 
     img.src = img_uri;
   }

webroot/rsrc/js/core/behavior-object-selector.js

···
     var cells = [
       JX.$N('td', {}, view_object_link),
       JX.$N('th', {}, select_object_link),
-      JX.$N('td', {}, select_object_button),
+      JX.$N('td', {}, select_object_button)
     ];
 
     var table = JX.$N(
···
 
   function sendQuery() {
     query_timer = null;
-    JX.DOM.setContent(JX.$(config.results), renderNote('Loading...'))
+    JX.DOM.setContent(JX.$(config.results), renderNote('Loading...'));
     new JX.Request(config.uri, JX.bind(null, onreceive, ++n))
       .setData({
         filter: JX.$(config.filter).value,

webroot/rsrc/js/core/behavior-oncopy.js

···
     var pos;
     for (var ii = 0; ii < lines.length; ii++) {
       pos = lines[ii].indexOf(zws);
-      if (pos == -1 && ii != 0) {
+      if (pos == -1 && ii !== 0) {
         continue;
       }
       result.push(lines[ii].substring(pos + 1));
···
       // to work or give me any errors. So you lose your selection when you
       // copy. Oh well?
     }
-  }
+  };
 });

webroot/rsrc/js/core/behavior-phabricator-nav.js

···
  *           javelin-dom
  *           javelin-magical-init
  *           javelin-vector
+ *           javelin-request
+ *           javelin-util
  * @javelin
  */
 
···
         element: background,
         parameter: 'width',
         start: JX.Vector.getDim(background).x,
-        start: JX.Vector.getDim(background).x,
         minWidth: 1
       },
       {
···
 
     var dx = JX.$V(e).x - dragging.x;
     var panel;
+    var k;
 
-    for (var k = 0; k < track.length; k++) {
+    for (k = 0; k < track.length; k++) {
       panel = track[k];
       if (!panel.minWidth) {
         continue;
···
       }
     }
 
-    for (var k = 0; k < track.length; k++) {
+    for (k = 0; k < track.length; k++) {
       panel = track[k];
       var v = (panel.start + (dx * (panel.scale || 1)));
       panel.element.style[panel.parameter] = v + 'px';
···
     JX.DOM.alterClass(main, 'has-local-nav', !collapsed);
     JX.DOM.alterClass(main, 'has-drag-nav', !collapsed);
     resetdrag();
-    new JX.Request('/settings/adjust/', JX.Bag)
+    new JX.Request('/settings/adjust/', JX.bag)
       .setData({ key : 'nav-collapsed', value : (collapsed ? 1 : 0) })
       .send();
   });

webroot/rsrc/js/core/behavior-phabricator-remarkup-assist.js

···
     // Now, select just the middle part. For instance, if the user clicked
     // "B" to create bold text, we insert '**bold**' but just select the word
     // "bold" so if they type stuff they'll be editing the bold text.
-    var r = JX.TextAreaUtils.getSelectionRange(area);
+    var range = JX.TextAreaUtils.getSelectionRange(area);
     JX.TextAreaUtils.setSelectionRange(
       area,
-      r.start + l.length,
-      r.start + l.length + m.length);
+      range.start + l.length,
+      range.start + l.length + m.length);
   }
 
   function assist(area, action, root) {
···
           sel = ["List Item"];
         }
         sel = sel.join("\n" + ch);
-        update(area, ((r.start == 0) ? "" : "\n\n") + ch, sel, "\n\n");
+        update(area, ((r.start === 0) ? "" : "\n\n") + ch, sel, "\n\n");
         break;
       case 'code':
         sel = sel || "foreach ($list as $item) {\n  work_miracles($item);\n}";
         sel = sel.split("\n");
         sel = "  " + sel.join("\n  ");
-        update(area, ((r.start == 0) ? "" : "\n\n"), sel, "\n\n");
+        update(area, ((r.start === 0) ? "" : "\n\n"), sel, "\n\n");
         break;
       case 'table':
-        update(area, (r.start == 0 ? '' : '\n\n') + '| ', sel || 'data', ' |');
+        update(area, (r.start === 0 ? '' : '\n\n') + '| ', sel || 'data', ' |');
         break;
       case 'meme':
         new JX.Workflow('/macro/meme/create/')
···
               area,
               '',
               sel,
-              (r.start == 0 ? '' : '\n\n') + response.text + '\n\n');
+              (r.start === 0 ? '' : '\n\n') + response.text + '\n\n');
           })
           .start();
         break;

webroot/rsrc/js/core/behavior-refresh-csrf.js

···
 
   JX.Request.listen('finally', function(r) {
     JX.Busy.done();
-  })
+  });
+
 });

webroot/rsrc/js/core/behavior-reveal-content.js

···
     function(e) {
       e.kill();
       var nodes = e.getNodeData('reveal-content');
-      for (var ii = 0; ii < nodes.showIDs.length; ii++) {
+      var ii;
+      for (ii = 0; ii < nodes.showIDs.length; ii++) {
         JX.DOM.show(JX.$(nodes.showIDs[ii]));
       }
-      for (var ii = 0; ii < nodes.hideIDs.length; ii++) {
+      for (ii = 0; ii < nodes.hideIDs.length; ii++) {
         JX.DOM.hide(JX.$(nodes.hideIDs[ii]));
       }
     });

webroot/rsrc/js/core/behavior-search-typeahead.js

···
   function transform(object) {
     var attr = {
       className: 'phabricator-main-search-typeahead-result'
-    }
+    };
 
     if (object[6]) {
       attr.style = {backgroundImage: 'url('+object[6]+')'};
···
 
     var tokens = this.tokenize(value);
 
-    for (var ii = 0; ii < list.length; ii++) {
+    var ii;
+    for (ii = 0; ii < list.length; ii++) {
       var item = list[ii];
       if (!item.priority) {
         continue;
···
     // we show 3 applications, then 3 users, etc.
     var type_count = 0;
     var current_type = null;
-    for (var ii = 0; ii < list.length; ii++) {
+    for (ii = 0; ii < list.length; ii++) {
       if (list.length <= config.limit) {
         break;
       }

webroot/rsrc/js/core/phtize.js

···
 /**
  * @provides phabricator-phtize
  * @requires javelin-util
+ * @javelin-installs JX.phtize
  * @javelin
  */