rollup 1.21.3 → 1.23.1

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v1.21.3
-	Sat, 14 Sep 2019 17:42:11 GMT - commit 13b27cac095d8a5b071c52cb6e8a0c25641c0cab
+	Rollup.js v1.23.1
+	Sat, 05 Oct 2019 06:08:56 GMT - commit 53266e6b971fff985b273800d808b17084d5c41b
 
 
 	https://github.com/rollup/rollup
@@ -969,22 +969,23 @@ Mappings.prototype.addEdit = function addEdit(sourceIndex, content, loc, nameInd
     this.pending = null;
 };
 Mappings.prototype.addUneditedChunk = function addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    var this$1 = this;
     var originalCharIndex = chunk.start;
     var first = true;
     while (originalCharIndex < chunk.end) {
-        if (this.hires || first || sourcemapLocations[originalCharIndex]) {
-            this.rawSegments.push([this.generatedCodeColumn, sourceIndex, loc.line, loc.column]);
+        if (this$1.hires || first || sourcemapLocations[originalCharIndex]) {
+            this$1.rawSegments.push([this$1.generatedCodeColumn, sourceIndex, loc.line, loc.column]);
         }
         if (original[originalCharIndex] === '\n') {
             loc.line += 1;
             loc.column = 0;
-            this.generatedCodeLine += 1;
-            this.raw[this.generatedCodeLine] = this.rawSegments = [];
-            this.generatedCodeColumn = 0;
+            this$1.generatedCodeLine += 1;
+            this$1.raw[this$1.generatedCodeLine] = this$1.rawSegments = [];
+            this$1.generatedCodeColumn = 0;
         }
         else {
             loc.column += 1;
-            this.generatedCodeColumn += 1;
+            this$1.generatedCodeColumn += 1;
         }
         originalCharIndex += 1;
         first = false;
@@ -992,14 +993,15 @@ Mappings.prototype.addUneditedChunk = function addUneditedChunk(sourceIndex, chu
     this.pending = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
 };
 Mappings.prototype.advance = function advance(str) {
+    var this$1 = this;
     if (!str) {
         return;
     }
     var lines = str.split('\n');
     if (lines.length > 1) {
         for (var i = 0; i < lines.length - 1; i++) {
-            this.generatedCodeLine++;
-            this.raw[this.generatedCodeLine] = this.rawSegments = [];
+            this$1.generatedCodeLine++;
+            this$1.raw[this$1.generatedCodeLine] = this$1.rawSegments = [];
         }
         this.generatedCodeColumn = 0;
     }
@@ -1094,6 +1096,8 @@ MagicString.prototype.clone = function clone() {
     Object.keys(this.sourcemapLocations).forEach(function (loc) {
         cloned.sourcemapLocations[loc] = true;
     });
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
     return cloned;
 };
 MagicString.prototype.generateDecodedMap = function generateDecodedMap(options) {
@@ -1136,6 +1140,7 @@ MagicString.prototype.getIndentString = function getIndentString() {
     return this.indentStr === null ? '\t' : this.indentStr;
 };
 MagicString.prototype.indent = function indent(indentStr, options) {
+    var this$1 = this;
     var pattern = /^[^\r\n]/gm;
     if (isObject(indentStr)) {
         options = indentStr;
@@ -1181,7 +1186,7 @@ MagicString.prototype.indent = function indent(indentStr, options) {
             charIndex = chunk.start;
             while (charIndex < end) {
                 if (!isExcluded[charIndex]) {
-                    var char = this.original[charIndex];
+                    var char = this$1.original[charIndex];
                     if (char === '\n') {
                         shouldIndentNextCharacter = true;
                     }
@@ -1191,7 +1196,7 @@ MagicString.prototype.indent = function indent(indentStr, options) {
                             chunk.prependRight(indentStr);
                         }
                         else {
-                            this._splitChunk(chunk, charIndex);
+                            this$1._splitChunk(chunk, charIndex);
                             chunk = chunk.next;
                             chunk.prependRight(indentStr);
                         }
@@ -1269,14 +1274,15 @@ MagicString.prototype.move = function move(start, end, index) {
     return this;
 };
 MagicString.prototype.overwrite = function overwrite(start, end, content, options) {
+    var this$1 = this;
     if (typeof content !== 'string') {
         throw new TypeError('replacement content must be a string');
     }
     while (start < 0) {
-        start += this.original.length;
+        start += this$1.original.length;
     }
     while (end < 0) {
-        end += this.original.length;
+        end += this$1.original.length;
     }
     if (end > this.original.length) {
         throw new Error('end is out of bounds');
@@ -1360,11 +1366,12 @@ MagicString.prototype.prependRight = function prependRight(index, content) {
     return this;
 };
 MagicString.prototype.remove = function remove(start, end) {
+    var this$1 = this;
     while (start < 0) {
-        start += this.original.length;
+        start += this$1.original.length;
     }
     while (end < 0) {
-        end += this.original.length;
+        end += this$1.original.length;
     }
     if (start === end) {
         return this;
@@ -1382,7 +1389,7 @@ MagicString.prototype.remove = function remove(start, end) {
         chunk.intro = '';
         chunk.outro = '';
         chunk.edit('');
-        chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        chunk = end > chunk.end ? this$1.byStart[chunk.end] : null;
     }
     return this;
 };
@@ -1444,15 +1451,16 @@ MagicString.prototype.lastLine = function lastLine() {
     return this.intro + lineStr;
 };
 MagicString.prototype.slice = function slice(start, end) {
+    var this$1 = this;
     if (start === void 0)
         start = 0;
     if (end === void 0)
         end = this.original.length;
     while (start < 0) {
-        start += this.original.length;
+        start += this$1.original.length;
     }
     while (end < 0) {
-        end += this.original.length;
+        end += this$1.original.length;
     }
     var result = '';
     // find start chunk
@@ -1497,6 +1505,7 @@ MagicString.prototype.snip = function snip(start, end) {
     return clone;
 };
 MagicString.prototype._split = function _split(index) {
+    var this$1 = this;
     if (this.byStart[index] || this.byEnd[index]) {
         return;
     }
@@ -1504,9 +1513,9 @@ MagicString.prototype._split = function _split(index) {
     var searchForward = index > chunk.end;
     while (chunk) {
         if (chunk.contains(index)) {
-            return this._splitChunk(chunk, index);
+            return this$1._splitChunk(chunk, index);
         }
-        chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+        chunk = searchForward ? this$1.byStart[chunk.end] : this$1.byEnd[chunk.start];
     }
 };
 MagicString.prototype._splitChunk = function _splitChunk(chunk, index) {
@@ -1560,6 +1569,7 @@ MagicString.prototype.trim = function trim(charType) {
     return this.trimStart(charType).trimEnd(charType);
 };
 MagicString.prototype.trimEndAborted = function trimEndAborted(charType) {
+    var this$1 = this;
     var rx = new RegExp((charType || '\\s') + '+$');
     this.outro = this.outro.replace(rx, '');
     if (this.outro.length) {
@@ -1571,12 +1581,12 @@ MagicString.prototype.trimEndAborted = function trimEndAborted(charType) {
         var aborted = chunk.trimEnd(rx);
         // if chunk was trimmed, we have a new lastChunk
         if (chunk.end !== end) {
-            if (this.lastChunk === chunk) {
-                this.lastChunk = chunk.next;
+            if (this$1.lastChunk === chunk) {
+                this$1.lastChunk = chunk.next;
             }
-            this.byEnd[chunk.end] = chunk;
-            this.byStart[chunk.next.start] = chunk.next;
-            this.byEnd[chunk.next.end] = chunk.next;
+            this$1.byEnd[chunk.end] = chunk;
+            this$1.byStart[chunk.next.start] = chunk.next;
+            this$1.byEnd[chunk.next.end] = chunk.next;
         }
         if (aborted) {
             return true;
@@ -1590,6 +1600,7 @@ MagicString.prototype.trimEnd = function trimEnd(charType) {
     return this;
 };
 MagicString.prototype.trimStartAborted = function trimStartAborted(charType) {
+    var this$1 = this;
     var rx = new RegExp('^' + (charType || '\\s') + '+');
     this.intro = this.intro.replace(rx, '');
     if (this.intro.length) {
@@ -1601,12 +1612,12 @@ MagicString.prototype.trimStartAborted = function trimStartAborted(charType) {
         var aborted = chunk.trimStart(rx);
         if (chunk.end !== end) {
             // special case...
-            if (chunk === this.lastChunk) {
-                this.lastChunk = chunk.next;
+            if (chunk === this$1.lastChunk) {
+                this$1.lastChunk = chunk.next;
             }
-            this.byEnd[chunk.end] = chunk;
-            this.byStart[chunk.next.start] = chunk.next;
-            this.byEnd[chunk.next.end] = chunk.next;
+            this$1.byEnd[chunk.end] = chunk;
+            this$1.byStart[chunk.next.start] = chunk.next;
+            this$1.byEnd[chunk.next.end] = chunk.next;
         }
         if (aborted) {
             return true;
@@ -1827,13 +1838,14 @@ Bundle.prototype.trim = function trim(charType) {
     return this.trimStart(charType).trimEnd(charType);
 };
 Bundle.prototype.trimStart = function trimStart(charType) {
+    var this$1 = this;
     var rx = new RegExp('^' + (charType || '\\s') + '+');
     this.intro = this.intro.replace(rx, '');
     if (!this.intro) {
         var source;
         var i = 0;
         do {
-            source = this.sources[i++];
+            source = this$1.sources[i++];
             if (!source) {
                 break;
             }
@@ -1842,13 +1854,14 @@ Bundle.prototype.trimStart = function trimStart(charType) {
     return this;
 };
 Bundle.prototype.trimEnd = function trimEnd(charType) {
+    var this$1 = this;
     var rx = new RegExp((charType || '\\s') + '+$');
     var source;
     var i = this.sources.length - 1;
     do {
-        source = this.sources[i--];
+        source = this$1.sources[i--];
         if (!source) {
-            this.intro = this.intro.replace(rx, '');
+            this$1.intro = this$1.intro.replace(rx, '');
             break;
         }
     } while (!source.content.trimEndAborted(charType));
@@ -8309,8 +8322,10 @@ function isReference(node, parent) {
             case 'MethodDefinition': return parent.computed;
             // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
             case 'Property': return parent.computed || node === parent.value;
-            // disregard the `bar` in `export { foo as bar }`
-            case 'ExportSpecifier': return node === parent.local;
+            // disregard the `bar` in `export { foo as bar }` or
+            // the foo in `import { foo as bar }`
+            case 'ExportSpecifier':
+            case 'ImportSpecifier': return node === parent.local;
             // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
             case 'LabeledStatement':
             case 'BreakStatement':
@@ -8324,43 +8339,54 @@ function isReference(node, parent) {
 const ValueProperties = Symbol('Value Properties');
 const PURE = { pure: true };
 const IMPURE = { pure: false };
-const OBJECT = {
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: IMPURE
 };
-const PURE_FUNCTION = {
+/* PURE FUNCTION */
+const PF = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: PURE
 };
-const CONSTRUCTOR = {
+/* CONSTRUCTOR */
+const C = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: IMPURE,
-    prototype: OBJECT
+    prototype: O
 };
-const PURE_CONSTRUCTOR = {
+/* PURE CONSTRUCTOR */
+const PC = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: PURE,
-    prototype: OBJECT
+    prototype: O
 };
 const ARRAY_TYPE = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: PURE,
-    from: PURE_FUNCTION,
-    of: PURE_FUNCTION,
-    prototype: OBJECT
+    from: PF,
+    of: PF,
+    prototype: O
 };
 const INTL_MEMBER = {
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: PURE,
-    supportedLocalesOf: PURE_CONSTRUCTOR
+    supportedLocalesOf: PC
 };
 const knownGlobals = {
+    // Placeholders for global objects to avoid shape mutations
+    global: O,
+    globalThis: O,
+    self: O,
+    window: O,
+    // Common globals
     // @ts-ignore
     __proto__: null,
     [ValueProperties]: IMPURE,
@@ -8368,188 +8394,188 @@ const knownGlobals = {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: IMPURE,
-        from: PURE_FUNCTION,
-        isArray: PURE_FUNCTION,
-        of: PURE_FUNCTION,
-        prototype: OBJECT
+        from: PF,
+        isArray: PF,
+        of: PF,
+        prototype: O
     },
     ArrayBuffer: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        isView: PURE_FUNCTION,
-        prototype: OBJECT
+        isView: PF,
+        prototype: O
     },
-    Atomics: OBJECT,
-    BigInt: CONSTRUCTOR,
-    BigInt64Array: CONSTRUCTOR,
-    BigUint64Array: CONSTRUCTOR,
-    Boolean: PURE_CONSTRUCTOR,
+    Atomics: O,
+    BigInt: C,
+    BigInt64Array: C,
+    BigUint64Array: C,
+    Boolean: PC,
     // @ts-ignore
-    constructor: CONSTRUCTOR,
-    DataView: PURE_CONSTRUCTOR,
+    constructor: C,
+    DataView: PC,
     Date: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        now: PURE_FUNCTION,
-        parse: PURE_FUNCTION,
-        prototype: OBJECT,
-        UTC: PURE_FUNCTION
+        now: PF,
+        parse: PF,
+        prototype: O,
+        UTC: PF
     },
-    decodeURI: PURE_FUNCTION,
-    decodeURIComponent: PURE_FUNCTION,
-    encodeURI: PURE_FUNCTION,
-    encodeURIComponent: PURE_FUNCTION,
-    Error: PURE_CONSTRUCTOR,
-    escape: PURE_FUNCTION,
-    eval: OBJECT,
-    EvalError: PURE_CONSTRUCTOR,
+    decodeURI: PF,
+    decodeURIComponent: PF,
+    encodeURI: PF,
+    encodeURIComponent: PF,
+    Error: PC,
+    escape: PF,
+    eval: O,
+    EvalError: PC,
     Float32Array: ARRAY_TYPE,
     Float64Array: ARRAY_TYPE,
-    Function: CONSTRUCTOR,
+    Function: C,
     // @ts-ignore
-    hasOwnProperty: OBJECT,
-    Infinity: OBJECT,
+    hasOwnProperty: O,
+    Infinity: O,
     Int16Array: ARRAY_TYPE,
     Int32Array: ARRAY_TYPE,
     Int8Array: ARRAY_TYPE,
-    isFinite: PURE_FUNCTION,
-    isNaN: PURE_FUNCTION,
+    isFinite: PF,
+    isNaN: PF,
     // @ts-ignore
-    isPrototypeOf: OBJECT,
-    JSON: OBJECT,
-    Map: PURE_CONSTRUCTOR,
+    isPrototypeOf: O,
+    JSON: O,
+    Map: PC,
     Math: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: IMPURE,
-        abs: PURE_FUNCTION,
-        acos: PURE_FUNCTION,
-        acosh: PURE_FUNCTION,
-        asin: PURE_FUNCTION,
-        asinh: PURE_FUNCTION,
-        atan: PURE_FUNCTION,
-        atan2: PURE_FUNCTION,
-        atanh: PURE_FUNCTION,
-        cbrt: PURE_FUNCTION,
-        ceil: PURE_FUNCTION,
-        clz32: PURE_FUNCTION,
-        cos: PURE_FUNCTION,
-        cosh: PURE_FUNCTION,
-        exp: PURE_FUNCTION,
-        expm1: PURE_FUNCTION,
-        floor: PURE_FUNCTION,
-        fround: PURE_FUNCTION,
-        hypot: PURE_FUNCTION,
-        imul: PURE_FUNCTION,
-        log: PURE_FUNCTION,
-        log10: PURE_FUNCTION,
-        log1p: PURE_FUNCTION,
-        log2: PURE_FUNCTION,
-        max: PURE_FUNCTION,
-        min: PURE_FUNCTION,
-        pow: PURE_FUNCTION,
-        random: PURE_FUNCTION,
-        round: PURE_FUNCTION,
-        sign: PURE_FUNCTION,
-        sin: PURE_FUNCTION,
-        sinh: PURE_FUNCTION,
-        sqrt: PURE_FUNCTION,
-        tan: PURE_FUNCTION,
-        tanh: PURE_FUNCTION,
-        trunc: PURE_FUNCTION
+        abs: PF,
+        acos: PF,
+        acosh: PF,
+        asin: PF,
+        asinh: PF,
+        atan: PF,
+        atan2: PF,
+        atanh: PF,
+        cbrt: PF,
+        ceil: PF,
+        clz32: PF,
+        cos: PF,
+        cosh: PF,
+        exp: PF,
+        expm1: PF,
+        floor: PF,
+        fround: PF,
+        hypot: PF,
+        imul: PF,
+        log: PF,
+        log10: PF,
+        log1p: PF,
+        log2: PF,
+        max: PF,
+        min: PF,
+        pow: PF,
+        random: PF,
+        round: PF,
+        sign: PF,
+        sin: PF,
+        sinh: PF,
+        sqrt: PF,
+        tan: PF,
+        tanh: PF,
+        trunc: PF
     },
-    NaN: OBJECT,
+    NaN: O,
     Number: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        isFinite: PURE_FUNCTION,
-        isInteger: PURE_FUNCTION,
-        isNaN: PURE_FUNCTION,
-        isSafeInteger: PURE_FUNCTION,
-        parseFloat: PURE_FUNCTION,
-        parseInt: PURE_FUNCTION,
-        prototype: OBJECT
+        isFinite: PF,
+        isInteger: PF,
+        isNaN: PF,
+        isSafeInteger: PF,
+        parseFloat: PF,
+        parseInt: PF,
+        prototype: O
     },
     Object: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        create: PURE_FUNCTION,
-        getNotifier: PURE_FUNCTION,
-        getOwn: PURE_FUNCTION,
-        getOwnPropertyDescriptor: PURE_FUNCTION,
-        getOwnPropertyNames: PURE_FUNCTION,
-        getOwnPropertySymbols: PURE_FUNCTION,
-        getPrototypeOf: PURE_FUNCTION,
-        is: PURE_FUNCTION,
-        isExtensible: PURE_FUNCTION,
-        isFrozen: PURE_FUNCTION,
-        isSealed: PURE_FUNCTION,
-        keys: PURE_FUNCTION,
-        prototype: OBJECT
+        create: PF,
+        getNotifier: PF,
+        getOwn: PF,
+        getOwnPropertyDescriptor: PF,
+        getOwnPropertyNames: PF,
+        getOwnPropertySymbols: PF,
+        getPrototypeOf: PF,
+        is: PF,
+        isExtensible: PF,
+        isFrozen: PF,
+        isSealed: PF,
+        keys: PF,
+        prototype: O
     },
-    parseFloat: PURE_FUNCTION,
-    parseInt: PURE_FUNCTION,
+    parseFloat: PF,
+    parseInt: PF,
     Promise: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: IMPURE,
-        all: PURE_FUNCTION,
-        prototype: OBJECT,
-        race: PURE_FUNCTION,
-        resolve: PURE_FUNCTION
+        all: PF,
+        prototype: O,
+        race: PF,
+        resolve: PF
     },
     // @ts-ignore
-    propertyIsEnumerable: OBJECT,
-    Proxy: OBJECT,
-    RangeError: PURE_CONSTRUCTOR,
-    ReferenceError: PURE_CONSTRUCTOR,
-    Reflect: OBJECT,
-    RegExp: PURE_CONSTRUCTOR,
-    Set: PURE_CONSTRUCTOR,
-    SharedArrayBuffer: CONSTRUCTOR,
+    propertyIsEnumerable: O,
+    Proxy: O,
+    RangeError: PC,
+    ReferenceError: PC,
+    Reflect: O,
+    RegExp: PC,
+    Set: PC,
+    SharedArrayBuffer: C,
     String: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        fromCharCode: PURE_FUNCTION,
-        fromCodePoint: PURE_FUNCTION,
-        prototype: OBJECT,
-        raw: PURE_FUNCTION
+        fromCharCode: PF,
+        fromCodePoint: PF,
+        prototype: O,
+        raw: PF
     },
     Symbol: {
         // @ts-ignore
         __proto__: null,
         [ValueProperties]: PURE,
-        for: PURE_FUNCTION,
-        keyFor: PURE_FUNCTION,
-        prototype: OBJECT
+        for: PF,
+        keyFor: PF,
+        prototype: O
     },
-    SyntaxError: PURE_CONSTRUCTOR,
+    SyntaxError: PC,
     // @ts-ignore
-    toLocaleString: OBJECT,
+    toLocaleString: O,
     // @ts-ignore
-    toString: OBJECT,
-    TypeError: PURE_CONSTRUCTOR,
+    toString: O,
+    TypeError: PC,
     Uint16Array: ARRAY_TYPE,
     Uint32Array: ARRAY_TYPE,
     Uint8Array: ARRAY_TYPE,
     Uint8ClampedArray: ARRAY_TYPE,
     // Technically, this is a global, but it needs special handling
     // undefined: ?,
-    unescape: PURE_FUNCTION,
-    URIError: PURE_CONSTRUCTOR,
+    unescape: PF,
+    URIError: PC,
     // @ts-ignore
-    valueOf: OBJECT,
-    WeakMap: PURE_CONSTRUCTOR,
-    WeakSet: PURE_CONSTRUCTOR,
+    valueOf: O,
+    WeakMap: PC,
+    WeakSet: PC,
     // Additional globals shared by Node and Browser that are not strictly part of the language
-    clearInterval: CONSTRUCTOR,
-    clearTimeout: CONSTRUCTOR,
-    console: OBJECT,
+    clearInterval: C,
+    clearTimeout: C,
+    console: O,
     Intl: {
         // @ts-ignore
         __proto__: null,
@@ -8561,12 +8587,595 @@ const knownGlobals = {
         PluralRules: INTL_MEMBER,
         RelativeTimeFormat: INTL_MEMBER
     },
-    setInterval: CONSTRUCTOR,
-    setTimeout: CONSTRUCTOR,
-    TextDecoder: CONSTRUCTOR,
-    TextEncoder: CONSTRUCTOR,
-    URL: CONSTRUCTOR,
-    URLSearchParams: CONSTRUCTOR
+    setInterval: C,
+    setTimeout: C,
+    TextDecoder: C,
+    TextEncoder: C,
+    URL: C,
+    URLSearchParams: C,
+    // Browser specific globals
+    AbortController: C,
+    AbortSignal: C,
+    addEventListener: O,
+    alert: O,
+    AnalyserNode: C,
+    Animation: C,
+    AnimationEvent: C,
+    applicationCache: O,
+    ApplicationCache: C,
+    ApplicationCacheErrorEvent: C,
+    atob: O,
+    Attr: C,
+    Audio: C,
+    AudioBuffer: C,
+    AudioBufferSourceNode: C,
+    AudioContext: C,
+    AudioDestinationNode: C,
+    AudioListener: C,
+    AudioNode: C,
+    AudioParam: C,
+    AudioProcessingEvent: C,
+    AudioScheduledSourceNode: C,
+    AudioWorkletNode: C,
+    BarProp: C,
+    BaseAudioContext: C,
+    BatteryManager: C,
+    BeforeUnloadEvent: C,
+    BiquadFilterNode: C,
+    Blob: C,
+    BlobEvent: C,
+    blur: O,
+    BroadcastChannel: C,
+    btoa: O,
+    ByteLengthQueuingStrategy: C,
+    Cache: C,
+    caches: O,
+    CacheStorage: C,
+    cancelAnimationFrame: O,
+    cancelIdleCallback: O,
+    CanvasCaptureMediaStreamTrack: C,
+    CanvasGradient: C,
+    CanvasPattern: C,
+    CanvasRenderingContext2D: C,
+    ChannelMergerNode: C,
+    ChannelSplitterNode: C,
+    CharacterData: C,
+    clientInformation: O,
+    ClipboardEvent: C,
+    close: O,
+    closed: O,
+    CloseEvent: C,
+    Comment: C,
+    CompositionEvent: C,
+    confirm: O,
+    ConstantSourceNode: C,
+    ConvolverNode: C,
+    CountQueuingStrategy: C,
+    createImageBitmap: O,
+    Credential: C,
+    CredentialsContainer: C,
+    crypto: O,
+    Crypto: C,
+    CryptoKey: C,
+    CSS: C,
+    CSSConditionRule: C,
+    CSSFontFaceRule: C,
+    CSSGroupingRule: C,
+    CSSImportRule: C,
+    CSSKeyframeRule: C,
+    CSSKeyframesRule: C,
+    CSSMediaRule: C,
+    CSSNamespaceRule: C,
+    CSSPageRule: C,
+    CSSRule: C,
+    CSSRuleList: C,
+    CSSStyleDeclaration: C,
+    CSSStyleRule: C,
+    CSSStyleSheet: C,
+    CSSSupportsRule: C,
+    CustomElementRegistry: C,
+    customElements: O,
+    CustomEvent: C,
+    DataTransfer: C,
+    DataTransferItem: C,
+    DataTransferItemList: C,
+    defaultstatus: O,
+    defaultStatus: O,
+    DelayNode: C,
+    DeviceMotionEvent: C,
+    DeviceOrientationEvent: C,
+    devicePixelRatio: O,
+    dispatchEvent: O,
+    document: O,
+    Document: C,
+    DocumentFragment: C,
+    DocumentType: C,
+    DOMError: C,
+    DOMException: C,
+    DOMImplementation: C,
+    DOMMatrix: C,
+    DOMMatrixReadOnly: C,
+    DOMParser: C,
+    DOMPoint: C,
+    DOMPointReadOnly: C,
+    DOMQuad: C,
+    DOMRect: C,
+    DOMRectReadOnly: C,
+    DOMStringList: C,
+    DOMStringMap: C,
+    DOMTokenList: C,
+    DragEvent: C,
+    DynamicsCompressorNode: C,
+    Element: C,
+    ErrorEvent: C,
+    Event: C,
+    EventSource: C,
+    EventTarget: C,
+    external: O,
+    fetch: O,
+    File: C,
+    FileList: C,
+    FileReader: C,
+    find: O,
+    focus: O,
+    FocusEvent: C,
+    FontFace: C,
+    FontFaceSetLoadEvent: C,
+    FormData: C,
+    frames: O,
+    GainNode: C,
+    Gamepad: C,
+    GamepadButton: C,
+    GamepadEvent: C,
+    getComputedStyle: O,
+    getSelection: O,
+    HashChangeEvent: C,
+    Headers: C,
+    history: O,
+    History: C,
+    HTMLAllCollection: C,
+    HTMLAnchorElement: C,
+    HTMLAreaElement: C,
+    HTMLAudioElement: C,
+    HTMLBaseElement: C,
+    HTMLBodyElement: C,
+    HTMLBRElement: C,
+    HTMLButtonElement: C,
+    HTMLCanvasElement: C,
+    HTMLCollection: C,
+    HTMLContentElement: C,
+    HTMLDataElement: C,
+    HTMLDataListElement: C,
+    HTMLDetailsElement: C,
+    HTMLDialogElement: C,
+    HTMLDirectoryElement: C,
+    HTMLDivElement: C,
+    HTMLDListElement: C,
+    HTMLDocument: C,
+    HTMLElement: C,
+    HTMLEmbedElement: C,
+    HTMLFieldSetElement: C,
+    HTMLFontElement: C,
+    HTMLFormControlsCollection: C,
+    HTMLFormElement: C,
+    HTMLFrameElement: C,
+    HTMLFrameSetElement: C,
+    HTMLHeadElement: C,
+    HTMLHeadingElement: C,
+    HTMLHRElement: C,
+    HTMLHtmlElement: C,
+    HTMLIFrameElement: C,
+    HTMLImageElement: C,
+    HTMLInputElement: C,
+    HTMLLabelElement: C,
+    HTMLLegendElement: C,
+    HTMLLIElement: C,
+    HTMLLinkElement: C,
+    HTMLMapElement: C,
+    HTMLMarqueeElement: C,
+    HTMLMediaElement: C,
+    HTMLMenuElement: C,
+    HTMLMetaElement: C,
+    HTMLMeterElement: C,
+    HTMLModElement: C,
+    HTMLObjectElement: C,
+    HTMLOListElement: C,
+    HTMLOptGroupElement: C,
+    HTMLOptionElement: C,
+    HTMLOptionsCollection: C,
+    HTMLOutputElement: C,
+    HTMLParagraphElement: C,
+    HTMLParamElement: C,
+    HTMLPictureElement: C,
+    HTMLPreElement: C,
+    HTMLProgressElement: C,
+    HTMLQuoteElement: C,
+    HTMLScriptElement: C,
+    HTMLSelectElement: C,
+    HTMLShadowElement: C,
+    HTMLSlotElement: C,
+    HTMLSourceElement: C,
+    HTMLSpanElement: C,
+    HTMLStyleElement: C,
+    HTMLTableCaptionElement: C,
+    HTMLTableCellElement: C,
+    HTMLTableColElement: C,
+    HTMLTableElement: C,
+    HTMLTableRowElement: C,
+    HTMLTableSectionElement: C,
+    HTMLTemplateElement: C,
+    HTMLTextAreaElement: C,
+    HTMLTimeElement: C,
+    HTMLTitleElement: C,
+    HTMLTrackElement: C,
+    HTMLUListElement: C,
+    HTMLUnknownElement: C,
+    HTMLVideoElement: C,
+    IDBCursor: C,
+    IDBCursorWithValue: C,
+    IDBDatabase: C,
+    IDBFactory: C,
+    IDBIndex: C,
+    IDBKeyRange: C,
+    IDBObjectStore: C,
+    IDBOpenDBRequest: C,
+    IDBRequest: C,
+    IDBTransaction: C,
+    IDBVersionChangeEvent: C,
+    IdleDeadline: C,
+    IIRFilterNode: C,
+    Image: C,
+    ImageBitmap: C,
+    ImageBitmapRenderingContext: C,
+    ImageCapture: C,
+    ImageData: C,
+    indexedDB: O,
+    innerHeight: O,
+    innerWidth: O,
+    InputEvent: C,
+    IntersectionObserver: C,
+    IntersectionObserverEntry: C,
+    isSecureContext: O,
+    KeyboardEvent: C,
+    KeyframeEffect: C,
+    length: O,
+    localStorage: O,
+    location: O,
+    Location: C,
+    locationbar: O,
+    matchMedia: O,
+    MediaDeviceInfo: C,
+    MediaDevices: C,
+    MediaElementAudioSourceNode: C,
+    MediaEncryptedEvent: C,
+    MediaError: C,
+    MediaKeyMessageEvent: C,
+    MediaKeySession: C,
+    MediaKeyStatusMap: C,
+    MediaKeySystemAccess: C,
+    MediaList: C,
+    MediaQueryList: C,
+    MediaQueryListEvent: C,
+    MediaRecorder: C,
+    MediaSettingsRange: C,
+    MediaSource: C,
+    MediaStream: C,
+    MediaStreamAudioDestinationNode: C,
+    MediaStreamAudioSourceNode: C,
+    MediaStreamEvent: C,
+    MediaStreamTrack: C,
+    MediaStreamTrackEvent: C,
+    menubar: O,
+    MessageChannel: C,
+    MessageEvent: C,
+    MessagePort: C,
+    MIDIAccess: C,
+    MIDIConnectionEvent: C,
+    MIDIInput: C,
+    MIDIInputMap: C,
+    MIDIMessageEvent: C,
+    MIDIOutput: C,
+    MIDIOutputMap: C,
+    MIDIPort: C,
+    MimeType: C,
+    MimeTypeArray: C,
+    MouseEvent: C,
+    moveBy: O,
+    moveTo: O,
+    MutationEvent: C,
+    MutationObserver: C,
+    MutationRecord: C,
+    name: O,
+    NamedNodeMap: C,
+    NavigationPreloadManager: C,
+    navigator: O,
+    Navigator: C,
+    NetworkInformation: C,
+    Node: C,
+    NodeFilter: O,
+    NodeIterator: C,
+    NodeList: C,
+    Notification: C,
+    OfflineAudioCompletionEvent: C,
+    OfflineAudioContext: C,
+    offscreenBuffering: O,
+    OffscreenCanvas: C,
+    open: O,
+    openDatabase: O,
+    Option: C,
+    origin: O,
+    OscillatorNode: C,
+    outerHeight: O,
+    outerWidth: O,
+    PageTransitionEvent: C,
+    pageXOffset: O,
+    pageYOffset: O,
+    PannerNode: C,
+    parent: O,
+    Path2D: C,
+    PaymentAddress: C,
+    PaymentRequest: C,
+    PaymentRequestUpdateEvent: C,
+    PaymentResponse: C,
+    performance: O,
+    Performance: C,
+    PerformanceEntry: C,
+    PerformanceLongTaskTiming: C,
+    PerformanceMark: C,
+    PerformanceMeasure: C,
+    PerformanceNavigation: C,
+    PerformanceNavigationTiming: C,
+    PerformanceObserver: C,
+    PerformanceObserverEntryList: C,
+    PerformancePaintTiming: C,
+    PerformanceResourceTiming: C,
+    PerformanceTiming: C,
+    PeriodicWave: C,
+    Permissions: C,
+    PermissionStatus: C,
+    personalbar: O,
+    PhotoCapabilities: C,
+    Plugin: C,
+    PluginArray: C,
+    PointerEvent: C,
+    PopStateEvent: C,
+    postMessage: O,
+    Presentation: C,
+    PresentationAvailability: C,
+    PresentationConnection: C,
+    PresentationConnectionAvailableEvent: C,
+    PresentationConnectionCloseEvent: C,
+    PresentationConnectionList: C,
+    PresentationReceiver: C,
+    PresentationRequest: C,
+    print: O,
+    ProcessingInstruction: C,
+    ProgressEvent: C,
+    PromiseRejectionEvent: C,
+    prompt: O,
+    PushManager: C,
+    PushSubscription: C,
+    PushSubscriptionOptions: C,
+    queueMicrotask: O,
+    RadioNodeList: C,
+    Range: C,
+    ReadableStream: C,
+    RemotePlayback: C,
+    removeEventListener: O,
+    Request: C,
+    requestAnimationFrame: O,
+    requestIdleCallback: O,
+    resizeBy: O,
+    ResizeObserver: C,
+    ResizeObserverEntry: C,
+    resizeTo: O,
+    Response: C,
+    RTCCertificate: C,
+    RTCDataChannel: C,
+    RTCDataChannelEvent: C,
+    RTCDtlsTransport: C,
+    RTCIceCandidate: C,
+    RTCIceTransport: C,
+    RTCPeerConnection: C,
+    RTCPeerConnectionIceEvent: C,
+    RTCRtpReceiver: C,
+    RTCRtpSender: C,
+    RTCSctpTransport: C,
+    RTCSessionDescription: C,
+    RTCStatsReport: C,
+    RTCTrackEvent: C,
+    screen: O,
+    Screen: C,
+    screenLeft: O,
+    ScreenOrientation: C,
+    screenTop: O,
+    screenX: O,
+    screenY: O,
+    ScriptProcessorNode: C,
+    scroll: O,
+    scrollbars: O,
+    scrollBy: O,
+    scrollTo: O,
+    scrollX: O,
+    scrollY: O,
+    SecurityPolicyViolationEvent: C,
+    Selection: C,
+    ServiceWorker: C,
+    ServiceWorkerContainer: C,
+    ServiceWorkerRegistration: C,
+    sessionStorage: O,
+    ShadowRoot: C,
+    SharedWorker: C,
+    SourceBuffer: C,
+    SourceBufferList: C,
+    speechSynthesis: O,
+    SpeechSynthesisEvent: C,
+    SpeechSynthesisUtterance: C,
+    StaticRange: C,
+    status: O,
+    statusbar: O,
+    StereoPannerNode: C,
+    stop: O,
+    Storage: C,
+    StorageEvent: C,
+    StorageManager: C,
+    styleMedia: O,
+    StyleSheet: C,
+    StyleSheetList: C,
+    SubtleCrypto: C,
+    SVGAElement: C,
+    SVGAngle: C,
+    SVGAnimatedAngle: C,
+    SVGAnimatedBoolean: C,
+    SVGAnimatedEnumeration: C,
+    SVGAnimatedInteger: C,
+    SVGAnimatedLength: C,
+    SVGAnimatedLengthList: C,
+    SVGAnimatedNumber: C,
+    SVGAnimatedNumberList: C,
+    SVGAnimatedPreserveAspectRatio: C,
+    SVGAnimatedRect: C,
+    SVGAnimatedString: C,
+    SVGAnimatedTransformList: C,
+    SVGAnimateElement: C,
+    SVGAnimateMotionElement: C,
+    SVGAnimateTransformElement: C,
+    SVGAnimationElement: C,
+    SVGCircleElement: C,
+    SVGClipPathElement: C,
+    SVGComponentTransferFunctionElement: C,
+    SVGDefsElement: C,
+    SVGDescElement: C,
+    SVGDiscardElement: C,
+    SVGElement: C,
+    SVGEllipseElement: C,
+    SVGFEBlendElement: C,
+    SVGFEColorMatrixElement: C,
+    SVGFEComponentTransferElement: C,
+    SVGFECompositeElement: C,
+    SVGFEConvolveMatrixElement: C,
+    SVGFEDiffuseLightingElement: C,
+    SVGFEDisplacementMapElement: C,
+    SVGFEDistantLightElement: C,
+    SVGFEDropShadowElement: C,
+    SVGFEFloodElement: C,
+    SVGFEFuncAElement: C,
+    SVGFEFuncBElement: C,
+    SVGFEFuncGElement: C,
+    SVGFEFuncRElement: C,
+    SVGFEGaussianBlurElement: C,
+    SVGFEImageElement: C,
+    SVGFEMergeElement: C,
+    SVGFEMergeNodeElement: C,
+    SVGFEMorphologyElement: C,
+    SVGFEOffsetElement: C,
+    SVGFEPointLightElement: C,
+    SVGFESpecularLightingElement: C,
+    SVGFESpotLightElement: C,
+    SVGFETileElement: C,
+    SVGFETurbulenceElement: C,
+    SVGFilterElement: C,
+    SVGForeignObjectElement: C,
+    SVGGElement: C,
+    SVGGeometryElement: C,
+    SVGGradientElement: C,
+    SVGGraphicsElement: C,
+    SVGImageElement: C,
+    SVGLength: C,
+    SVGLengthList: C,
+    SVGLinearGradientElement: C,
+    SVGLineElement: C,
+    SVGMarkerElement: C,
+    SVGMaskElement: C,
+    SVGMatrix: C,
+    SVGMetadataElement: C,
+    SVGMPathElement: C,
+    SVGNumber: C,
+    SVGNumberList: C,
+    SVGPathElement: C,
+    SVGPatternElement: C,
+    SVGPoint: C,
+    SVGPointList: C,
+    SVGPolygonElement: C,
+    SVGPolylineElement: C,
+    SVGPreserveAspectRatio: C,
+    SVGRadialGradientElement: C,
+    SVGRect: C,
+    SVGRectElement: C,
+    SVGScriptElement: C,
+    SVGSetElement: C,
+    SVGStopElement: C,
+    SVGStringList: C,
+    SVGStyleElement: C,
+    SVGSVGElement: C,
+    SVGSwitchElement: C,
+    SVGSymbolElement: C,
+    SVGTextContentElement: C,
+    SVGTextElement: C,
+    SVGTextPathElement: C,
+    SVGTextPositioningElement: C,
+    SVGTitleElement: C,
+    SVGTransform: C,
+    SVGTransformList: C,
+    SVGTSpanElement: C,
+    SVGUnitTypes: C,
+    SVGUseElement: C,
+    SVGViewElement: C,
+    TaskAttributionTiming: C,
+    Text: C,
+    TextEvent: C,
+    TextMetrics: C,
+    TextTrack: C,
+    TextTrackCue: C,
+    TextTrackCueList: C,
+    TextTrackList: C,
+    TimeRanges: C,
+    toolbar: O,
+    top: O,
+    Touch: C,
+    TouchEvent: C,
+    TouchList: C,
+    TrackEvent: C,
+    TransitionEvent: C,
+    TreeWalker: C,
+    UIEvent: C,
+    ValidityState: C,
+    visualViewport: O,
+    VisualViewport: C,
+    VTTCue: C,
+    WaveShaperNode: C,
+    WebAssembly: O,
+    WebGL2RenderingContext: C,
+    WebGLActiveInfo: C,
+    WebGLBuffer: C,
+    WebGLContextEvent: C,
+    WebGLFramebuffer: C,
+    WebGLProgram: C,
+    WebGLQuery: C,
+    WebGLRenderbuffer: C,
+    WebGLRenderingContext: C,
+    WebGLSampler: C,
+    WebGLShader: C,
+    WebGLShaderPrecisionFormat: C,
+    WebGLSync: C,
+    WebGLTexture: C,
+    WebGLTransformFeedback: C,
+    WebGLUniformLocation: C,
+    WebGLVertexArrayObject: C,
+    WebSocket: C,
+    WheelEvent: C,
+    Window: C,
+    Worker: C,
+    WritableStream: C,
+    XMLDocument: C,
+    XMLHttpRequest: C,
+    XMLHttpRequestEventTarget: C,
+    XMLHttpRequestUpload: C,
+    XMLSerializer: C,
+    XPathEvaluator: C,
+    XPathExpression: C,
+    XPathResult: C,
+    XSLTProcessor: C
 };
 for (const global of ['window', 'global', 'self', 'globalThis']) {
     knownGlobals[global] = knownGlobals;
@@ -8594,7 +9203,6 @@ function isGlobalMember(path) {
     }
     return getGlobalAtPath(path.slice(0, -1)) !== null;
 }
-// TODO add others to this list from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
 
 class GlobalVariable extends Variable {
     hasEffectsWhenAccessedAtPath(path) {
@@ -9096,18 +9704,14 @@ class NamespaceVariable extends Variable {
             const safeName = RESERVED_NAMES[name] ? `'${name}'` : name;
             return `${t}${safeName}: ${original.getName()}`;
         });
-        const name = this.getName();
-        const callee = options.freeze ? `/*#__PURE__*/Object.freeze` : '';
-        let output = `${options.varOrConst} ${name} = ${options.namespaceToStringTag
-            ? `{${n}${members.join(`,${n}`)}${n}};`
-            : `${callee}({${n}${members.join(`,${n}`)}${n}});`}`;
+        members.unshift(`${t}__proto__:${_}null`);
         if (options.namespaceToStringTag) {
-            output += `${n}if${_}(typeof Symbol${_}!==${_}'undefined'${_}&&${_}Symbol.toStringTag)${n}`;
-            output += `${t}Object.defineProperty(${name},${_}Symbol.toStringTag,${_}{${_}value:${_}'Module'${_}});${n}`;
-            output += `else${n || ' '}`;
-            output += `${t}Object.defineProperty(${name},${_}'toString',${_}{${_}value:${_}function${_}()${_}{${_}return${_}'[object Module]'${options.compact ? ';' : ''}${_}}${_}});${n}`;
-            output += `${callee}(${name});`;
+            members.unshift(`${t}[Symbol.toStringTag]:${_}'Module'`);
         }
+        const name = this.getName();
+        const callee = options.freeze ? `/*#__PURE__*/Object.freeze` : '';
+        const membersStr = members.join(`,${n}`);
+        let output = `${options.varOrConst} ${name}${_}=${_}${callee}({${n}${membersStr}${n}});`;
         if (options.format === 'system' && this.exportName) {
             output += `${n}exports('${this.exportName}',${_}${name});`;
         }
@@ -10968,12 +11572,9 @@ class ForOfStatement extends NodeBase {
     createScope(parentScope) {
         this.scope = new BlockScope(parentScope);
     }
-    hasEffects(options) {
-        return ((this.left &&
-            (this.left.hasEffects(options) ||
-                this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, options))) ||
-            (this.right && this.right.hasEffects(options)) ||
-            this.body.hasEffects(options.setIgnoreBreakStatements()));
+    hasEffects() {
+        // Placeholder until proper Symbol.Iterator support
+        return true;
     }
     include(includeChildrenRecursively) {
         this.included = true;
@@ -12649,6 +13250,8 @@ class UnaryExpression extends NodeBase {
         return unaryOperators[this.operator](argumentValue);
     }
     hasEffects(options) {
+        if (this.operator === 'typeof' && this.argument instanceof Identifier$1)
+            return false;
         return (this.argument.hasEffects(options) ||
             (this.operator === 'delete' &&
                 this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, options)));
@@ -14455,6 +15058,7 @@ function makeUnique(name, existingNames) {
     return uniqueName;
 }
 
+const NON_ASSET_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
 function getGlobalName(module, globals, graph, hasExports) {
     let globalName;
     if (typeof globals === 'function') {
@@ -14599,10 +15203,15 @@ class Chunk$1 {
         }), existingNames);
     }
     generateIdPreserveModules(preserveModulesRelativeDir, options, existingNames) {
-        const sanitizedId = index.sanitizeFileName(this.orderedModules[0].id);
+        const id = this.orderedModules[0].id;
+        const sanitizedId = index.sanitizeFileName(id);
         let path$1;
-        if (index.isAbsolute(this.orderedModules[0].id)) {
-            const name = renderNamePattern(options.entryFileNames || '[name].js', 'output.entryFileNames', {
+        if (index.isAbsolute(id)) {
+            const extension = path.extname(id);
+            const name = renderNamePattern(options.entryFileNames ||
+                (NON_ASSET_EXTENSIONS.includes(extension) ? '[name].js' : '[name][extname].js'), 'output.entryFileNames', {
+                ext: () => extension.substr(1),
+                extname: () => extension,
                 format: () => (options.format === 'es' ? 'esm' : options.format),
                 name: () => this.getChunkName()
             });
@@ -17541,7 +18150,9 @@ function writeOutputFile(graph, build, outputFile, outputOptions) {
                 url = `${path.basename(outputFile.fileName)}.map`;
                 writeSourceMapPromise = writeFile(`${fileName}.map`, outputFile.map.toString());
             }
-            source += `//# ${SOURCEMAPPING_URL}=${url}\n`;
+            if (outputOptions.sourcemap !== 'hidden') {
+                source += `//# ${SOURCEMAPPING_URL}=${url}\n`;
+            }
         }
     }
     return writeFile(fileName, source)