Use const for const/final top-levels, types, symbols.

lib/runtime/dart/math.js

 dart_library.library('dart/math', null, /* Imports */[
   "dart/_runtime",
   'dart/core'
 ], /* Lazy imports */[
   'dart/_js_helper'
 ], function(exports, dart, core, _js_helper) {
   'use strict';
   let dartx = dart.dartx;
   class _JenkinsSmiHash extends core.Object {
     static combine(hash, value) {
@@ skipping 15 matching lines @@
   }
   dart.setSignature(_JenkinsSmiHash, {
     statics: () => ({
       combine: [core.int, [core.int, core.int]],
       finish: [core.int, [core.int]],
       hash2: [core.int, [dart.dynamic, dart.dynamic]],
       hash4: [core.int, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]]
     }),
     names: ['combine', 'finish', 'hash2', 'hash4']
   });
-  let Point$ = dart.generic(function(T) {
+  const Point$ = dart.generic(function(T) {
     class Point extends core.Object {
       Point(x, y) {
         this.x = x;
         this.y = y;
       }
       toString() {
         return `Point(${this.x}, ${this.y})`;
       }
       ['=='](other) {
         if (!dart.is(other, Point$()))
@@ skipping 46 matching lines @@
   class Random extends core.Object {
     static new(seed) {
       if (seed === void 0)
         seed = null;
       return seed == null ? dart.const(new _JSRandom()) : new _Random(seed);
     }
   }
   dart.setSignature(Random, {
     constructors: () => ({new: [Random, [], [core.int]]})
   });
-  let _RectangleBase$ = dart.generic(function(T) {
+  const _RectangleBase$ = dart.generic(function(T) {
     class _RectangleBase extends core.Object {
       _RectangleBase() {
       }
       get right() {
         return dart.notNull(this.left) + dart.notNull(this.width);
       }
       get bottom() {
         return dart.notNull(this.top) + dart.notNull(this.height);
       }
       toString() {
@@ skipping 56 matching lines @@
         intersection: [Rectangle$(T), [Rectangle$(T)]],
         intersects: [core.bool, [Rectangle$(core.num)]],
         boundingBox: [Rectangle$(T), [Rectangle$(T)]],
         containsRectangle: [core.bool, [Rectangle$(core.num)]],
         containsPoint: [core.bool, [Point$(core.num)]]
       })
     });
     return _RectangleBase;
   });
   let _RectangleBase = _RectangleBase$();
-  let Rectangle$ = dart.generic(function(T) {
+  const Rectangle$ = dart.generic(function(T) {
     class Rectangle extends _RectangleBase$(T) {
       Rectangle(left, top, width, height) {
         this.left = left;
         this.top = top;
         this.width = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
         this.height = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
         super._RectangleBase();
       }
       static fromPoints(a, b) {
         let left = min(a.x, b.x);
         let width = dart.notNull(max(a.x, b.x)) - dart.notNull(left);
         let top = min(a.y, b.y);
         let height = dart.notNull(max(a.y, b.y)) - dart.notNull(top);
         return new (Rectangle$(T))(left, top, width, height);
       }
     }
     dart.setSignature(Rectangle, {
       constructors: () => ({
         Rectangle: [Rectangle$(T), [T, T, T, T]],
         fromPoints: [Rectangle$(T), [Point$(T), Point$(T)]]
       })
     });
     return Rectangle;
   });
   let Rectangle = Rectangle$();
-  let _width = Symbol('_width');
-  let _height = Symbol('_height');
-  let MutableRectangle$ = dart.generic(function(T) {
+  const _width = Symbol('_width');
+  const _height = Symbol('_height');
+  const MutableRectangle$ = dart.generic(function(T) {
     class MutableRectangle extends _RectangleBase$(T) {
       MutableRectangle(left, top, width, height) {
         this.left = left;
         this.top = top;
         this[_width] = dart.notNull(width) < 0 ? _clampToZero(width) : width;
         this[_height] = dart.notNull(height) < 0 ? _clampToZero(height) : height;
         super._RectangleBase();
       }
       static fromPoints(a, b) {
         let left = min(a.x, b.x);
@@ skipping 29 matching lines @@
       })
     });
     return MutableRectangle;
   });
   let MutableRectangle = MutableRectangle$();
   function _clampToZero(value) {
     dart.assert(dart.notNull(value) < 0);
     return -dart.notNull(value) * 0;
   }
   dart.fn(_clampToZero, core.num, [core.num]);
-  let E = 2.718281828459045;
-  let LN10 = 2.302585092994046;
-  let LN2 = 0.6931471805599453;
-  let LOG2E = 1.4426950408889634;
-  let LOG10E = 0.4342944819032518;
-  let PI = 3.141592653589793;
-  let SQRT1_2 = 0.7071067811865476;
-  let SQRT2 = 1.4142135623730951;
+  const E = 2.718281828459045;
+  const LN10 = 2.302585092994046;
+  const LN2 = 0.6931471805599453;
+  const LOG2E = 1.4426950408889634;
+  const LOG10E = 0.4342944819032518;
+  const PI = 3.141592653589793;
+  const SQRT1_2 = 0.7071067811865476;
+  const SQRT2 = 1.4142135623730951;
   function min(a, b) {
     if (!(typeof a == 'number'))
       dart.throw(new core.ArgumentError(a));
     if (!(typeof b == 'number'))
       dart.throw(new core.ArgumentError(b));
     if (dart.notNull(a) > dart.notNull(b))
       return b;
     if (dart.notNull(a) < dart.notNull(b))
       return a;
     if (typeof b == 'number') {
@@ skipping 72 matching lines @@
   }
   dart.fn(sqrt, core.double, [core.num]);
   function exp(x) {
     return Math.exp(_js_helper.checkNum(x));
   }
   dart.fn(exp, core.double, [core.num]);
   function log(x) {
     return Math.log(_js_helper.checkNum(x));
   }
   dart.fn(log, core.double, [core.num]);
-  let _POW2_32 = 4294967296;
+  const _POW2_32 = 4294967296;
   class _JSRandom extends core.Object {
     _JSRandom() {
     }
     nextInt(max) {
       if (dart.notNull(max) <= 0 || dart.notNull(max) > dart.notNull(_POW2_32)) {
         dart.throw(new core.RangeError(`max must be in range 0 < max ≤ 2^32, was ${max}`));
       }
       return Math.random() * max >>> 0;
     }
     nextDouble() {
       return Math.random();
     }
     nextBool() {
       return Math.random() < 0.5;
     }
   }
   _JSRandom[dart.implements] = () => [Random];
   dart.setSignature(_JSRandom, {
     constructors: () => ({_JSRandom: [_JSRandom, []]}),
     methods: () => ({
       nextInt: [core.int, [core.int]],
       nextDouble: [core.double, []],
       nextBool: [core.bool, []]
     })
   });
-  let _lo = Symbol('_lo');
-  let _hi = Symbol('_hi');
-  let _nextState = Symbol('_nextState');
+  const _lo = Symbol('_lo');
+  const _hi = Symbol('_hi');
+  const _nextState = Symbol('_nextState');
   class _Random extends core.Object {
     _Random(seed) {
       this[_lo] = 0;
       this[_hi] = 0;
       let empty_seed = 0;
       if (dart.notNull(seed) < 0) {
         empty_seed = -1;
       }
       do {
         let low = dart.notNull(seed) & dart.notNull(_Random._MASK32);
@@ skipping 121 matching lines @@
   exports.sin = sin;
   exports.cos = cos;
   exports.tan = tan;
   exports.acos = acos;
   exports.asin = asin;
   exports.atan = atan;
   exports.sqrt = sqrt;
   exports.exp = exp;
   exports.log = log;
 });