file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_minifier/tests/fixture/issues/6508/3/output/input.js | JavaScript | "use client";
export var Foo = {
foo: function foo() {}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6508/3/output/output.js | JavaScript | "use client";
export var Foo = {
foo: function() {}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6509/input.js | JavaScript |
function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
var offsets = [0, 0];
// Use height if placement is left or right and index is 0 otherwise use width
// in this way the first offset will use an axis and the second one
// will use the other one
var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
// Split the offset string to obtain a list of values and operands
// The regex addresses values with the plus or minus sign in front (+10, -20, etc)
var fragments = offset.split(/(\+|\-)/).map(function (frag) {
return frag.trim();
});
// Detect if the offset string contains a pair of values or a single one
// they could be separated by comma or space
var divider = fragments.indexOf(find(fragments, function (frag) {
return frag.search(/,|\s/) !== -1;
}));
if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
}
// If divider is found, we divide the list of values and operands to divide
// them by ofset X and Y.
var splitRegex = /\s*,\s*|\s+/;
var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
// Convert the values with units to absolute pixels to allow our computations
ops = ops.map(function (op, index) {
// Most of the units rely on the orientation of the popper
var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
var mergeWithPrevious = false;
return op
// This aggregates any `+` or `-` sign that aren't considered operators
// e.g.: 10 + +5 => [10, +, +5]
.reduce(function (a, b) {
if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
a[a.length - 1] = b;
mergeWithPrevious = true;
return a;
} else if (mergeWithPrevious) {
a[a.length - 1] += b;
mergeWithPrevious = false;
return a;
} else {
return a.concat(b);
}
}, [])
// Here we convert the string values into number values (in px)
.map(function (str) {
return toValue(str, measurement, popperOffsets, referenceOffsets);
});
});
// Loop trough the offsets arrays and execute the operations
ops.forEach(function (op, index) {
op.forEach(function (frag, index2) {
if (isNumeric(frag)) {
offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
}
});
});
return offsets;
}
function offset(data, _ref) {
var offset = _ref.offset;
var placement = data.placement,
_data$offsets = data.offsets,
popper = _data$offsets.popper,
reference = _data$offsets.reference;
var basePlacement = placement.split('-')[0];
var offsets = void 0;
if (isNumeric(+offset)) {
offsets = [+offset, 0];
} else {
offsets = parseOffset(offset, popper, reference, basePlacement);
}
if (basePlacement === 'left') {
popper.top += offsets[0];
popper.left -= offsets[1];
} else if (basePlacement === 'right') {
popper.top += offsets[0];
popper.left += offsets[1];
} else if (basePlacement === 'top') {
popper.left += offsets[0];
popper.top -= offsets[1];
} else if (basePlacement === 'bottom') {
popper.left += offsets[0];
popper.top += offsets[1];
}
data.popper = popper;
return data;
}
export var modifiers = {
offset: {
order: 200,
enabled: true,
fn: offset,
offset: 0
},
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6509/output.js | JavaScript | export var modifiers = {
offset: {
order: 200,
enabled: true,
fn: function(data, _ref) {
var offset = _ref.offset;
var placement = data.placement, _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
var basePlacement = placement.split('-')[0];
var offsets = void 0;
if (isNumeric(+offset)) offsets = [
+offset,
0
];
else {
var offset1, popperOffsets, referenceOffsets;
var offsets1;
// Use height if placement is left or right and index is 0 otherwise use width
// in this way the first offset will use an axis and the second one
// will use the other one
var useHeight;
// Split the offset string to obtain a list of values and operands
// The regex addresses values with the plus or minus sign in front (+10, -20, etc)
var fragments;
// Detect if the offset string contains a pair of values or a single one
// they could be separated by comma or space
var divider;
// If divider is found, we divide the list of values and operands to divide
// them by ofset X and Y.
var splitRegex;
var ops;
offsets1 = [
0,
0
], useHeight = -1 !== [
'right',
'left'
].indexOf(basePlacement), divider = (fragments = offset.split(/(\+|\-)/).map(function(frag) {
return frag.trim();
})).indexOf(find(fragments, function(frag) {
return -1 !== frag.search(/,|\s/);
})), fragments[divider] && -1 === fragments[divider].indexOf(',') && console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.'), splitRegex = /\s*,\s*|\s+/, // Loop trough the offsets arrays and execute the operations
// Convert the values with units to absolute pixels to allow our computations
(ops = (ops = -1 !== divider ? [
fragments.slice(0, divider).concat([
fragments[divider].split(splitRegex)[0]
]),
[
fragments[divider].split(splitRegex)[1]
].concat(fragments.slice(divider + 1))
] : [
fragments
]).map(function(op, index) {
// Most of the units rely on the orientation of the popper
var measurement = (1 === index ? !useHeight : useHeight) ? 'height' : 'width';
var mergeWithPrevious = false;
return op// This aggregates any `+` or `-` sign that aren't considered operators
// e.g.: 10 + +5 => [10, +, +5]
.reduce(function(a, b) {
if ('' === a[a.length - 1] && -1 !== [
'+',
'-'
].indexOf(b)) return a[a.length - 1] = b, mergeWithPrevious = true, a;
if (mergeWithPrevious) return a[a.length - 1] += b, mergeWithPrevious = false, a;
return a.concat(b);
}, [])// Here we convert the string values into number values (in px)
.map(function(str) {
return toValue(str, measurement, popper, reference);
});
})).forEach(function(op, index) {
op.forEach(function(frag, index2) {
isNumeric(frag) && (offsets1[index] += frag * ('-' === op[index2 - 1] ? -1 : 1));
});
}), offsets = offsets1;
}
return 'left' === basePlacement ? (popper.top += offsets[0], popper.left -= offsets[1]) : 'right' === basePlacement ? (popper.top += offsets[0], popper.left += offsets[1]) : 'top' === basePlacement ? (popper.left += offsets[0], popper.top -= offsets[1]) : 'bottom' === basePlacement && (popper.left += offsets[0], popper.top += offsets[1]), data.popper = popper, data;
},
offset: 0
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6628/input.js | JavaScript | (function () {
var Collector = function () {
var e = function e(e) { };
return e.usePlugin = function (t, i, n) {
}, e.plugins = [], e;
}();
var CallbackType;
!function (e) {
e[e.Var = 0] = "Var", e[e.All = 1] = "All";
}(CallbackType || (CallbackType = {}));
var CepRule = function () {
eval();
}();
Collector.usePlugin(CepRule, "cep");
exports.Collector = Collector;
})() | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6628/output.js | JavaScript | !function() {
var CallbackType, Collector = function() {
var n = function(n) {};
return n.usePlugin = function(n, u, l) {}, n.plugins = [], n;
}();
!function(n) {
n[n.Var = 0] = "Var", n[n.All = 1] = "All";
}(CallbackType || (CallbackType = {}));
var CepRule = function() {
eval();
}();
Collector.usePlugin(CepRule, "cep"), exports.Collector = Collector;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6636/input.js | JavaScript | export function memo(fn, opts) {
let result;
return () => {
result = fn(...newDeps);
opts?.onChange?.(result);
return result;
};
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6636/output.js | JavaScript | export function memo(fn, opts) {
let result;
return ()=>(result = fn(...newDeps), opts?.onChange?.(result), result);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6730/input.js | JavaScript | function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this, args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
export const styleLoader = () => {
return {
name: 'style-loader',
setup(build) {
build.onLoad({
filter: /.*/,
namespace: 'less'
}, function () {
var _ref = _asyncToGenerator(function* (args) { });
return function (args) {
return _ref.apply(this, arguments);
};
}());
}
};
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6730/output.js | JavaScript | function n(n, e, t, r, o, i, u) {
try {
var a = n[i](u);
var c = a.value;
} catch (n) {
t(n);
return;
}
if (a.done) e(c);
else Promise.resolve(c).then(r, o);
}
function e(e) {
return function() {
var t = this, r = arguments;
return new Promise(function(o, i) {
var u = e.apply(t, r);
function a(e) {
n(u, o, i, a, c, "next", e);
}
function c(e) {
n(u, o, i, a, c, "throw", e);
}
a(void 0);
});
};
}
export const styleLoader = ()=>({
name: 'style-loader',
setup (n) {
n.onLoad({
filter: /.*/,
namespace: 'less'
}, function() {
var n = e(function*(n) {});
return function(e) {
return n.apply(this, arguments);
};
}());
}
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6751/1/input.js | JavaScript | let current_component;
function set_current_component(component) {
current_component = component;
}
function f(component) {
const parent = current_component
set_current_component(component)
parent.m()
}
const obj = {
m() {
console.log("call m()")
}
}
try {
f(obj)
} catch (e) {
console.log('PASS')
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6751/1/output.js | JavaScript | let current_component;
try {
!function(component) {
const parent = current_component;
current_component = component, parent.m();
}({
m () {
console.log("call m()");
}
});
} catch (e) {
console.log('PASS');
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6791/1/input.js | JavaScript | import { test } from "test";
var Test;
(function (Test) {
Test["Hello"] = "World!";
})(Test || (Test = {}));
test(Test["Hello"]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6791/1/output.js | JavaScript | var o;
import { test as l } from "test";
!function(o) {
o.Hello = "World!";
}(o || (o = {}));
l(o.Hello);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6837/1/input.js | JavaScript | class Class1 { }
function isClass2(node) {
return node instanceof Class2;
}
Class1.isClass2 = isClass2;
export class Class2 extends Class1 {
constructor() {
super();
this.method1 = async () => {
let var1;
const function1 = () => { };
var1 = await Class2.method2();
await function1()
.then(() => {
console.log(var1);
})
.catch();
};
}
static async method2() { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6837/1/output.js | JavaScript | class Class1 {
}
function isClass2(node) {
return node instanceof Class2;
}
Class1.isClass2 = isClass2;
export class Class2 extends Class1 {
constructor(){
super();
this.method1 = async ()=>{
let var1;
var1 = await Class2.method2();
await (()=>{})().then(()=>{
console.log(var1);
}).catch();
};
}
static async method2() {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6837/2/input.js | JavaScript | export class Class2 extends Class1 {
constructor() {
this.method1 = async () => {
let var1;
const function1 = () => { };
var1 = await Class2.method2();
await function1()
.then(() => {
console.log(var1);
})
};
}
static async method2() { }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6837/2/output.js | JavaScript | export class Class2 extends Class1 {
constructor(){
this.method1 = async ()=>{
let var1;
var1 = await Class2.method2();
await (()=>{})().then(()=>{
console.log(var1);
});
};
}
static async method2() {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6864/input.js | JavaScript | export function removeFromMatrix(matrix, id) {
var newMatrix;
var indexOfIdToRemove;
var row = _.find(matrix, (entry, index) => {
if (_.includes(entry, id)) {
indexOfIdToRemove = index;
return entry;
}
});
if (!row) {
return matrix;
}
if (row.length === 1) {
newMatrix = _.without(matrix, row);
if (newMatrix[0].length === 2) {
const remainingEntry = newMatrix[0];
newMatrix = [[remainingEntry[0]], [remainingEntry[1]]];
}
} else {
newMatrix = [...matrix];
newMatrix[indexOfIdToRemove] = _.without(row, id);
}
return newMatrix || matrix;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6864/output.js | JavaScript | export function removeFromMatrix(matrix, id) {
var newMatrix, indexOfIdToRemove, row = _.find(matrix, (entry, index)=>{
if (_.includes(entry, id)) return indexOfIdToRemove = index, entry;
});
if (!row) return matrix;
if (1 === row.length) {
if (2 === (newMatrix = _.without(matrix, row))[0].length) {
const remainingEntry = newMatrix[0];
newMatrix = [
[
remainingEntry[0]
],
[
remainingEntry[1]
]
];
}
} else (newMatrix = [
...matrix
])[indexOfIdToRemove] = _.without(row, id);
return newMatrix || matrix;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/1/input.js | JavaScript | // prettier-ignore
export function foo() {
// actual | expected
alert(1..toFixed(1)) // '1.0' '1.0'
alert(0..toFixed(0)) // '0' '0'
alert(0..toFixed(1)) // '0' '0.0'
alert(0..toFixed(2)) // '0' '0.00'
alert(0..toFixed(3)) // '0' '0.000'
alert(10..toFixed(1)) // '10' '10.0'
alert(20..toFixed(2)) // '20.0' '20.00'
alert(30..toFixed(3)) // '30.00' '30.000'
alert(100..toFixed(1)) // '100' '100.0'
alert(100..toFixed(2)) // '100' '100.00'
alert(100..toFixed(3)) // '100.0' '100.000'
alert(110..toFixed(1)) // '110' '110.0'
alert(110..toFixed(2)) // '110' '110.00'
alert(110..toFixed(3)) // '110.0' '110.000'
alert(110..toFixed(4)) // '110.00' '110.000'
alert(1110..toFixed(4)) // '1110.0' '1110.0000'
alert(11110..toFixed(4)) // '11110' '11110.0000'
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/1/output.js | JavaScript | // prettier-ignore
export function foo() {
// actual | expected
alert("1.0") // '1.0' '1.0'
;
alert("0") // '0' '0'
;
alert("0.0") // '0' '0.0'
;
alert("0.00") // '0' '0.00'
;
alert("0.000") // '0' '0.000'
;
alert("10.0") // '10' '10.0'
;
alert("20.00") // '20.0' '20.00'
;
alert("30.000") // '30.00' '30.000'
;
alert("100.0") // '100' '100.0'
;
alert("100.00") // '100' '100.00'
;
alert("100.000") // '100.0' '100.000'
;
alert("110.0") // '110' '110.0'
;
alert("110.00") // '110' '110.00'
;
alert("110.000") // '110.0' '110.000'
;
alert("110.0000") // '110.00' '110.000'
;
alert("1110.0000") // '1110.0' '1110.0000'
;
alert("11110.0000") // '11110' '11110.0000'
;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/2/input.js | JavaScript | assertEquals("1", 0.5.toFixed(0), "0.5.toFixed(0)");
assertEquals("-1", (-0.5).toFixed(0), "(-0.5).toFixed(0)"); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/2/output.js | JavaScript | assertEquals("1", "1", "0.5.toFixed(0)");
assertEquals("-1", "-1", "(-0.5).toFixed(0)");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/exponential/input.js | JavaScript | // Copyright (C) 2016 The V8 Project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
esid: sec-number.prototype.toprecision
description: >
Return string values using exponential character
info: |
Number.prototype.toPrecision ( precision )
1. Let x be ? thisNumberValue(this value).
[...]
5. Let s be the empty String.
[...]
9. If x = 0, then
[...]
10. Else x ≠ 0,
[...]
c. If e < -6 or e ≥ p, then
[...]
vii. Return the concatenation of s, m, code unit 0x0065 (LATIN SMALL
LETTER E), c, and d.
[...]
---*/
assert.sameValue((10).toPrecision(1), "1e+1");
assert.sameValue((11).toPrecision(1), "1e+1");
assert.sameValue((17).toPrecision(1), "2e+1");
assert.sameValue((19).toPrecision(1), "2e+1");
assert.sameValue((20).toPrecision(1), "2e+1");
assert.sameValue((100).toPrecision(1), "1e+2");
assert.sameValue((1000).toPrecision(1), "1e+3");
assert.sameValue((10000).toPrecision(1), "1e+4");
assert.sameValue((100000).toPrecision(1), "1e+5");
assert.sameValue((100).toPrecision(2), "1.0e+2");
assert.sameValue((1000).toPrecision(2), "1.0e+3");
assert.sameValue((10000).toPrecision(2), "1.0e+4");
assert.sameValue((100000).toPrecision(2), "1.0e+5");
assert.sameValue((1000).toPrecision(3), "1.00e+3");
assert.sameValue((10000).toPrecision(3), "1.00e+4");
assert.sameValue((100000).toPrecision(3), "1.00e+5");
assert.sameValue((42).toPrecision(1), "4e+1");
assert.sameValue((-42).toPrecision(1), "-4e+1");
assert.sameValue((1.2345e+27).toPrecision(1), "1e+27");
assert.sameValue((1.2345e+27).toPrecision(2), "1.2e+27");
assert.sameValue((1.2345e+27).toPrecision(3), "1.23e+27");
assert.sameValue((1.2345e+27).toPrecision(4), "1.234e+27");
assert.sameValue((1.2345e+27).toPrecision(5), "1.2345e+27");
assert.sameValue((1.2345e+27).toPrecision(6), "1.23450e+27");
assert.sameValue((1.2345e+27).toPrecision(7), "1.234500e+27");
assert.sameValue((1.2345e+27).toPrecision(16), "1.234500000000000e+27");
assert.sameValue((1.2345e+27).toPrecision(17), "1.2345000000000000e+27");
assert.sameValue((1.2345e+27).toPrecision(18), "1.23449999999999996e+27");
assert.sameValue((1.2345e+27).toPrecision(19), "1.234499999999999962e+27");
assert.sameValue((1.2345e+27).toPrecision(20), "1.2344999999999999618e+27");
assert.sameValue((1.2345e+27).toPrecision(21), "1.23449999999999996184e+27");
assert.sameValue((-1.2345e+27).toPrecision(1), "-1e+27");
assert.sameValue((-1.2345e+27).toPrecision(2), "-1.2e+27");
assert.sameValue((-1.2345e+27).toPrecision(3), "-1.23e+27");
assert.sameValue((-1.2345e+27).toPrecision(4), "-1.234e+27");
assert.sameValue((-1.2345e+27).toPrecision(5), "-1.2345e+27");
assert.sameValue((-1.2345e+27).toPrecision(6), "-1.23450e+27");
assert.sameValue((-1.2345e+27).toPrecision(7), "-1.234500e+27");
assert.sameValue((-1.2345e+27).toPrecision(16), "-1.234500000000000e+27");
assert.sameValue((-1.2345e+27).toPrecision(17), "-1.2345000000000000e+27");
assert.sameValue((-1.2345e+27).toPrecision(18), "-1.23449999999999996e+27");
assert.sameValue((-1.2345e+27).toPrecision(19), "-1.234499999999999962e+27");
assert.sameValue((-1.2345e+27).toPrecision(20), "-1.2344999999999999618e+27");
assert.sameValue((-1.2345e+27).toPrecision(21), "-1.23449999999999996184e+27");
var n = new Number("1000000000000000000000"); // 1e+21
assert.sameValue((n).toPrecision(1), "1e+21");
assert.sameValue((n).toPrecision(2), "1.0e+21");
assert.sameValue((n).toPrecision(3), "1.00e+21");
assert.sameValue((n).toPrecision(4), "1.000e+21");
assert.sameValue((n).toPrecision(5), "1.0000e+21");
assert.sameValue((n).toPrecision(6), "1.00000e+21");
assert.sameValue((n).toPrecision(7), "1.000000e+21");
assert.sameValue((n).toPrecision(16), "1.000000000000000e+21");
assert.sameValue((n).toPrecision(17), "1.0000000000000000e+21");
assert.sameValue((n).toPrecision(18), "1.00000000000000000e+21");
assert.sameValue((n).toPrecision(19), "1.000000000000000000e+21");
assert.sameValue((n).toPrecision(20), "1.0000000000000000000e+21");
assert.sameValue((n).toPrecision(21), "1.00000000000000000000e+21");
var n = new Number("0.000000000000000000001"); // 1e-21
assert.sameValue((n).toPrecision(1), "1e-21");
assert.sameValue((n).toPrecision(2), "1.0e-21");
assert.sameValue((n).toPrecision(3), "1.00e-21");
assert.sameValue((n).toPrecision(4), "1.000e-21");
assert.sameValue((n).toPrecision(5), "1.0000e-21");
assert.sameValue((n).toPrecision(6), "1.00000e-21");
assert.sameValue((n).toPrecision(7), "1.000000e-21");
assert.sameValue((n).toPrecision(16), "9.999999999999999e-22");
assert.sameValue((n).toPrecision(17), "9.9999999999999991e-22");
assert.sameValue((n).toPrecision(18), "9.99999999999999908e-22");
assert.sameValue((n).toPrecision(19), "9.999999999999999075e-22");
assert.sameValue((n).toPrecision(20), "9.9999999999999990754e-22");
assert.sameValue((n).toPrecision(21), "9.99999999999999907537e-22");
assert.sameValue((0.00000001).toPrecision(1), "1e-8");
assert.sameValue((-0.00000001).toPrecision(1), "-1e-8");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/exponential/output.js | JavaScript | // Copyright (C) 2016 The V8 Project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
esid: sec-number.prototype.toprecision
description: >
Return string values using exponential character
info: |
Number.prototype.toPrecision ( precision )
1. Let x be ? thisNumberValue(this value).
[...]
5. Let s be the empty String.
[...]
9. If x = 0, then
[...]
10. Else x ≠ 0,
[...]
c. If e < -6 or e ≥ p, then
[...]
vii. Return the concatenation of s, m, code unit 0x0065 (LATIN SMALL
LETTER E), c, and d.
[...]
---*/ assert.sameValue("1e+1", "1e+1");
assert.sameValue("1e+1", "1e+1");
assert.sameValue("2e+1", "2e+1");
assert.sameValue("2e+1", "2e+1");
assert.sameValue("2e+1", "2e+1");
assert.sameValue("1e+2", "1e+2");
assert.sameValue("1e+3", "1e+3");
assert.sameValue("1e+4", "1e+4");
assert.sameValue("1e+5", "1e+5");
assert.sameValue("1.0e+2", "1.0e+2");
assert.sameValue("1.0e+3", "1.0e+3");
assert.sameValue("1.0e+4", "1.0e+4");
assert.sameValue("1.0e+5", "1.0e+5");
assert.sameValue("1.00e+3", "1.00e+3");
assert.sameValue("1.00e+4", "1.00e+4");
assert.sameValue("1.00e+5", "1.00e+5");
assert.sameValue("4e+1", "4e+1");
assert.sameValue("-4e+1", "-4e+1");
assert.sameValue("1e+27", "1e+27");
assert.sameValue("1.2e+27", "1.2e+27");
assert.sameValue("1.23e+27", "1.23e+27");
assert.sameValue("1.234e+27", "1.234e+27");
assert.sameValue("1.2345e+27", "1.2345e+27");
assert.sameValue("1.23450e+27", "1.23450e+27");
assert.sameValue("1.234500e+27", "1.234500e+27");
assert.sameValue("1.234500000000000e+27", "1.234500000000000e+27");
assert.sameValue("1.2345000000000000e+27", "1.2345000000000000e+27");
assert.sameValue("1.23449999999999996e+27", "1.23449999999999996e+27");
assert.sameValue("1.234499999999999962e+27", "1.234499999999999962e+27");
assert.sameValue("1.2344999999999999618e+27", "1.2344999999999999618e+27");
assert.sameValue("1.23449999999999996184e+27", "1.23449999999999996184e+27");
assert.sameValue("-1e+27", "-1e+27");
assert.sameValue("-1.2e+27", "-1.2e+27");
assert.sameValue("-1.23e+27", "-1.23e+27");
assert.sameValue("-1.234e+27", "-1.234e+27");
assert.sameValue("-1.2345e+27", "-1.2345e+27");
assert.sameValue("-1.23450e+27", "-1.23450e+27");
assert.sameValue("-1.234500e+27", "-1.234500e+27");
assert.sameValue("-1.234500000000000e+27", "-1.234500000000000e+27");
assert.sameValue("-1.2345000000000000e+27", "-1.2345000000000000e+27");
assert.sameValue("-1.23449999999999996e+27", "-1.23449999999999996e+27");
assert.sameValue("-1.234499999999999962e+27", "-1.234499999999999962e+27");
assert.sameValue("-1.2344999999999999618e+27", "-1.2344999999999999618e+27");
assert.sameValue("-1.23449999999999996184e+27", "-1.23449999999999996184e+27");
var n = new Number("1000000000000000000000"); // 1e+21
assert.sameValue(n.toPrecision(1), "1e+21");
assert.sameValue(n.toPrecision(2), "1.0e+21");
assert.sameValue(n.toPrecision(3), "1.00e+21");
assert.sameValue(n.toPrecision(4), "1.000e+21");
assert.sameValue(n.toPrecision(5), "1.0000e+21");
assert.sameValue(n.toPrecision(6), "1.00000e+21");
assert.sameValue(n.toPrecision(7), "1.000000e+21");
assert.sameValue(n.toPrecision(16), "1.000000000000000e+21");
assert.sameValue(n.toPrecision(17), "1.0000000000000000e+21");
assert.sameValue(n.toPrecision(18), "1.00000000000000000e+21");
assert.sameValue(n.toPrecision(19), "1.000000000000000000e+21");
assert.sameValue(n.toPrecision(20), "1.0000000000000000000e+21");
assert.sameValue(n.toPrecision(21), "1.00000000000000000000e+21");
var n = new Number("0.000000000000000000001"); // 1e-21
assert.sameValue(n.toPrecision(1), "1e-21");
assert.sameValue(n.toPrecision(2), "1.0e-21");
assert.sameValue(n.toPrecision(3), "1.00e-21");
assert.sameValue(n.toPrecision(4), "1.000e-21");
assert.sameValue(n.toPrecision(5), "1.0000e-21");
assert.sameValue(n.toPrecision(6), "1.00000e-21");
assert.sameValue(n.toPrecision(7), "1.000000e-21");
assert.sameValue(n.toPrecision(16), "9.999999999999999e-22");
assert.sameValue(n.toPrecision(17), "9.9999999999999991e-22");
assert.sameValue(n.toPrecision(18), "9.99999999999999908e-22");
assert.sameValue(n.toPrecision(19), "9.999999999999999075e-22");
assert.sameValue(n.toPrecision(20), "9.9999999999999990754e-22");
assert.sameValue(n.toPrecision(21), "9.99999999999999907537e-22");
assert.sameValue("1e-8", "1e-8");
assert.sameValue("-1e-8", "-1e-8");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/number-tostring/input.js | JavaScript | // Copyright 2008 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------
// toString
assertEquals("NaN", (NaN).toString());
assertEquals("Infinity", (1/0).toString());
assertEquals("-Infinity", (-1/0).toString());
assertEquals("0", (0).toString());
assertEquals("9", (9).toString());
assertEquals("90", (90).toString());
assertEquals("90.12", (90.12).toString());
assertEquals("0.1", (0.1).toString());
assertEquals("0.01", (0.01).toString());
assertEquals("0.0123", (0.0123).toString());
assertEquals("111111111111111110000", (111111111111111111111).toString());
assertEquals("1.1111111111111111e+21", (1111111111111111111111).toString());
assertEquals("1.1111111111111111e+22", (11111111111111111111111).toString());
assertEquals("0.00001", (0.00001).toString());
assertEquals("0.000001", (0.000001).toString());
assertEquals("1e-7", (0.0000001).toString());
assertEquals("1.2e-7", (0.00000012).toString());
assertEquals("1.23e-7", (0.000000123).toString());
assertEquals("1e-8", (0.00000001).toString());
assertEquals("1.2e-8", (0.000000012).toString());
assertEquals("1.23e-8", (0.0000000123).toString());
assertEquals("0", (-0).toString());
assertEquals("-9", (-9).toString());
assertEquals("-90", (-90).toString());
assertEquals("-90.12", (-90.12).toString());
assertEquals("-0.1", (-0.1).toString());
assertEquals("-0.01", (-0.01).toString());
assertEquals("-0.0123", (-0.0123).toString());
assertEquals("-111111111111111110000", (-111111111111111111111).toString());
assertEquals("-1.1111111111111111e+21", (-1111111111111111111111).toString());
assertEquals("-1.1111111111111111e+22", (-11111111111111111111111).toString());
assertEquals("-0.00001", (-0.00001).toString());
assertEquals("-0.000001", (-0.000001).toString());
assertEquals("-1e-7", (-0.0000001).toString());
assertEquals("-1.2e-7", (-0.00000012).toString());
assertEquals("-1.23e-7", (-0.000000123).toString());
assertEquals("-1e-8", (-0.00000001).toString());
assertEquals("-1.2e-8", (-0.000000012).toString());
assertEquals("-1.23e-8", (-0.0000000123).toString());
assertEquals("NaN", (NaN).toString(16));
assertEquals("Infinity", (1/0).toString(16));
assertEquals("-Infinity", (-1/0).toString(16));
assertEquals("0", (0).toString(16));
assertEquals("9", (9).toString(16));
assertEquals("5a", (90).toString(16));
assertEquals("5a.1eb851eb852", (90.12).toString(16));
assertEquals("0.1999999999999a", (0.1).toString(16));
assertEquals("0.028f5c28f5c28f6", (0.01).toString(16));
assertEquals("0.032617c1bda511a", (0.0123).toString(16));
assertEquals("605f9f6dd18bc8000", (111111111111111111111).toString(16));
assertEquals("3c3bc3a4a2f75c0000", (1111111111111111111111).toString(16));
assertEquals("25a55a46e5da9a00000", (11111111111111111111111).toString(16));
assertEquals("0.0000a7c5ac471b4788", (0.00001).toString(16));
assertEquals("0.000010c6f7a0b5ed8d", (0.000001).toString(16));
assertEquals("0.000001ad7f29abcaf48", (0.0000001).toString(16));
assertEquals("0.000002036565348d256", (0.00000012).toString(16));
assertEquals("0.0000021047ee22aa466", (0.000000123).toString(16));
assertEquals("0.0000002af31dc4611874", (0.00000001).toString(16));
assertEquals("0.000000338a23b87483be", (0.000000012).toString(16));
assertEquals("0.00000034d3fe36aaa0a2", (0.0000000123).toString(16));
assertEquals("0", (-0).toString(16));
assertEquals("-9", (-9).toString(16));
assertEquals("-5a", (-90).toString(16));
assertEquals("-5a.1eb851eb852", (-90.12).toString(16));
assertEquals("-0.1999999999999a", (-0.1).toString(16));
assertEquals("-0.028f5c28f5c28f6", (-0.01).toString(16));
assertEquals("-0.032617c1bda511a", (-0.0123).toString(16));
assertEquals("-605f9f6dd18bc8000", (-111111111111111111111).toString(16));
assertEquals("-3c3bc3a4a2f75c0000", (-1111111111111111111111).toString(16));
assertEquals("-25a55a46e5da9a00000", (-11111111111111111111111).toString(16));
assertEquals("-0.0000a7c5ac471b4788", (-0.00001).toString(16));
assertEquals("-0.000010c6f7a0b5ed8d", (-0.000001).toString(16));
assertEquals("-0.000001ad7f29abcaf48", (-0.0000001).toString(16));
assertEquals("-0.000002036565348d256", (-0.00000012).toString(16));
assertEquals("-0.0000021047ee22aa466", (-0.000000123).toString(16));
assertEquals("-0.0000002af31dc4611874", (-0.00000001).toString(16));
assertEquals("-0.000000338a23b87483be", (-0.000000012).toString(16));
assertEquals("-0.00000034d3fe36aaa0a2", (-0.0000000123).toString(16));
assertEquals("4294967296", Math.pow(2,32).toString());
assertEquals("ffffffff", (Math.pow(2,32)-1).toString(16));
assertEquals("11111111111111111111111111111111", (Math.pow(2,32)-1).toString(2));
assertEquals("5yc1z", (10000007).toString(36));
assertEquals("0", (0).toString(36));
assertEquals("0", (0).toString(16));
assertEquals("0", (0).toString(10));
assertEquals("0", (0).toString(8));
assertEquals("0", (0).toString(2));
assertEquals("100000000000000000000000000000000", Math.pow(2,32).toString(2));
assertEquals("100000000000000000000000000000001", (Math.pow(2,32) + 1).toString(2));
assertEquals("100000000000080", (0x100000000000081).toString(16));
assertEquals("1000000000000100", (-(-'0x1000000000000081')).toString(16));
assertEquals("1000000000000000", (-(-'0x1000000000000080')).toString(16));
assertEquals("1000000000000000", (-(-'0x100000000000007F')).toString(16));
assertEquals("100000000000000000000000000000000000000000000000010000000", (0x100000000000081).toString(2));
assertEquals("-11111111111111111111111111111111", (-(Math.pow(2,32)-1)).toString(2));
assertEquals("-5yc1z", (-10000007).toString(36));
assertEquals("-100000000000000000000000000000000", (-Math.pow(2,32)).toString(2));
assertEquals("-100000000000000000000000000000001", (-(Math.pow(2,32) + 1)).toString(2));
assertEquals("-100000000000080", (-0x100000000000081).toString(16));
assertEquals("-100000000000000000000000000000000000000000000000010000000", (-0x100000000000081).toString(2));
assertEquals("1000", (1000).toString());
assertEquals("0.00001", (0.00001).toString());
assertEquals("1000000000000000100", (1000000000000000128).toString());
assertEquals("1e+21", (1000000000000000012800).toString());
assertEquals("-1e+21", (-1000000000000000012800).toString());
assertEquals("1e-7", (0.0000001).toString());
assertEquals("-1e-7", (-0.0000001).toString());
assertEquals("1.0000000000000001e+21", (1000000000000000128000).toString());
assertEquals("0.000001", (0.000001).toString());
assertEquals("1e-7", (0.0000001).toString());
assertEquals("8.8", (8.5).toString(16));
assertEquals("-8.8", (-8.5).toString(16));
assertEquals("1.1", (4/3).toString(3));
assertEquals("11.1", (13/3).toString(3));
assertEquals("0.01", (1/9).toString(3));
assertEquals("10000", (81).toString(3));
assertEquals("10000.01", (81 + 1/9).toString(3));
assertEquals("0.0212010212010212010212010212010212", (2/7).toString(3));
// ----------------------------------------------------------------------
// toFixed
assertEquals("NaN", (NaN).toFixed(2));
assertEquals("Infinity", (1/0).toFixed(2));
assertEquals("-Infinity", (-1/0).toFixed(2));
assertEquals("1.1111111111111111e+21", (1111111111111111111111).toFixed(8));
assertEquals("0.1", (0.1).toFixed(1));
assertEquals("0.10", (0.1).toFixed(2));
assertEquals("0.100", (0.1).toFixed(3));
assertEquals("0.01", (0.01).toFixed(2));
assertEquals("0.010", (0.01).toFixed(3));
assertEquals("0.0100", (0.01).toFixed(4));
assertEquals("0.00", (0.001).toFixed(2));
assertEquals("0.001", (0.001).toFixed(3));
assertEquals("0.0010", (0.001).toFixed(4));
assertEquals("1.0000", (1).toFixed(4));
assertEquals("1.0", (1).toFixed(1));
assertEquals("1", (1).toFixed(0));
assertEquals("12", (12).toFixed(0));
assertEquals("1", (1.1).toFixed(0));
assertEquals("12", (12.1).toFixed(0));
assertEquals("1", (1.12).toFixed(0));
assertEquals("12", (12.12).toFixed(0));
assertEquals("0.0000006", (0.0000006).toFixed(7));
assertEquals("0.00000006", (0.00000006).toFixed(8));
assertEquals("0.000000060", (0.00000006).toFixed(9));
assertEquals("0.0000000600", (0.00000006).toFixed(10));
assertEquals("0", (0).toFixed(0));
assertEquals("0.0", (0).toFixed(1));
assertEquals("0.00", (0).toFixed(2));
assertEquals("-1.1111111111111111e+21", (-1111111111111111111111).toFixed(8));
assertEquals("-0.1", (-0.1).toFixed(1));
assertEquals("-0.10", (-0.1).toFixed(2));
assertEquals("-0.100", (-0.1).toFixed(3));
assertEquals("-0.01", (-0.01).toFixed(2));
assertEquals("-0.010", (-0.01).toFixed(3));
assertEquals("-0.0100", (-0.01).toFixed(4));
assertEquals("-0.00", (-0.001).toFixed(2));
assertEquals("-0.001", (-0.001).toFixed(3));
assertEquals("-0.0010", (-0.001).toFixed(4));
assertEquals("-1.0000", (-1).toFixed(4));
assertEquals("-1.0", (-1).toFixed(1));
assertEquals("-1", (-1).toFixed(0));
assertEquals("-1", (-1.1).toFixed(0));
assertEquals("-12", (-12.1).toFixed(0));
assertEquals("-1", (-1.12).toFixed(0));
assertEquals("-12", (-12.12).toFixed(0));
assertEquals("-0.0000006", (-0.0000006).toFixed(7));
assertEquals("-0.00000006", (-0.00000006).toFixed(8));
assertEquals("-0.000000060", (-0.00000006).toFixed(9));
assertEquals("-0.0000000600", (-0.00000006).toFixed(10));
assertEquals("0", (-0).toFixed(0));
assertEquals("0.0", (-0).toFixed(1));
assertEquals("0.00", (-0).toFixed(2));
assertEquals("1000", (1000).toFixed());
assertEquals("0", (0.00001).toFixed());
assertEquals("0.00001", (0.00001).toFixed(5));
assertEquals("0.00000000000000000010", (0.0000000000000000001).toFixed(20));
assertEquals("0.00001000000000000", (0.00001).toFixed(17));
assertEquals("1.00000000000000000", (1).toFixed(17));
assertEquals("1000000000000000128", (1000000000000000128).toFixed());
assertEquals("100000000000000128.0", (100000000000000128).toFixed(1));
assertEquals("10000000000000128.00", (10000000000000128).toFixed(2));
assertEquals("10000000000000128.00000000000000000000", (10000000000000128).toFixed(20));
assertEquals("0", (0).toFixed());
assertEquals("-42.000", ((-42).toFixed(3)));
assertEquals("-1000000000000000128", (-1000000000000000128).toFixed());
assertEquals("-0.00000000000000000010", (-0.0000000000000000001).toFixed(20));
assertEquals("0.12312312312312299889", (0.123123123123123).toFixed(20));
// Test that we round up even when the last digit generated is even.
// dtoa does not do this in its original form.
assertEquals("1", 0.5.toFixed(0), "0.5.toFixed(0)");
assertEquals("-1", (-0.5).toFixed(0), "(-0.5).toFixed(0)");
assertEquals("1.3", 1.25.toFixed(1), "1.25.toFixed(1)");
// This is bizare, but Spidermonkey and KJS behave the same.
assertEquals("234.2040", (234.20405).toFixed(4), "234.2040.toFixed(4)");
assertEquals("234.2041", (234.2040506).toFixed(4));
// ----------------------------------------------------------------------
// toExponential
assertEquals("1e+0", (1).toExponential());
assertEquals("1.1e+1", (11).toExponential());
assertEquals("1.12e+2", (112).toExponential());
assertEquals("1e+0", (1).toExponential(0));
assertEquals("1e+1", (11).toExponential(0));
assertEquals("1e+2", (112).toExponential(0));
assertEquals("1.0e+0", (1).toExponential(1));
assertEquals("1.1e+1", (11).toExponential(1));
assertEquals("1.1e+2", (112).toExponential(1));
assertEquals("1.00e+0", (1).toExponential(2));
assertEquals("1.10e+1", (11).toExponential(2));
assertEquals("1.12e+2", (112).toExponential(2));
assertEquals("1.000e+0", (1).toExponential(3));
assertEquals("1.100e+1", (11).toExponential(3));
assertEquals("1.120e+2", (112).toExponential(3));
assertEquals("1e-1", (0.1).toExponential());
assertEquals("1.1e-1", (0.11).toExponential());
assertEquals("1.12e-1", (0.112).toExponential());
assertEquals("1e-1", (0.1).toExponential(0));
assertEquals("1e-1", (0.11).toExponential(0));
assertEquals("1e-1", (0.112).toExponential(0));
assertEquals("1.0e-1", (0.1).toExponential(1));
assertEquals("1.1e-1", (0.11).toExponential(1));
assertEquals("1.1e-1", (0.112).toExponential(1));
assertEquals("1.00e-1", (0.1).toExponential(2));
assertEquals("1.10e-1", (0.11).toExponential(2));
assertEquals("1.12e-1", (0.112).toExponential(2));
assertEquals("1.000e-1", (0.1).toExponential(3));
assertEquals("1.100e-1", (0.11).toExponential(3));
assertEquals("1.120e-1", (0.112).toExponential(3));
assertEquals("-1e+0", (-1).toExponential());
assertEquals("-1.1e+1", (-11).toExponential());
assertEquals("-1.12e+2", (-112).toExponential());
assertEquals("-1e+0", (-1).toExponential(0));
assertEquals("-1e+1", (-11).toExponential(0));
assertEquals("-1e+2", (-112).toExponential(0));
assertEquals("-1.0e+0", (-1).toExponential(1));
assertEquals("-1.1e+1", (-11).toExponential(1));
assertEquals("-1.1e+2", (-112).toExponential(1));
assertEquals("-1.00e+0", (-1).toExponential(2));
assertEquals("-1.10e+1", (-11).toExponential(2));
assertEquals("-1.12e+2", (-112).toExponential(2));
assertEquals("-1.000e+0", (-1).toExponential(3));
assertEquals("-1.100e+1", (-11).toExponential(3));
assertEquals("-1.120e+2", (-112).toExponential(3));
assertEquals("-1e-1", (-0.1).toExponential());
assertEquals("-1.1e-1", (-0.11).toExponential());
assertEquals("-1.12e-1", (-0.112).toExponential());
assertEquals("-1e-1", (-0.1).toExponential(0));
assertEquals("-1e-1", (-0.11).toExponential(0));
assertEquals("-1e-1", (-0.112).toExponential(0));
assertEquals("-1.0e-1", (-0.1).toExponential(1));
assertEquals("-1.1e-1", (-0.11).toExponential(1));
assertEquals("-1.1e-1", (-0.112).toExponential(1));
assertEquals("-1.00e-1", (-0.1).toExponential(2));
assertEquals("-1.10e-1", (-0.11).toExponential(2));
assertEquals("-1.12e-1", (-0.112).toExponential(2));
assertEquals("-1.000e-1", (-0.1).toExponential(3));
assertEquals("-1.100e-1", (-0.11).toExponential(3));
assertEquals("-1.120e-1", (-0.112).toExponential(3));
assertEquals("NaN", (NaN).toExponential(2));
assertEquals("Infinity", (Infinity).toExponential(2));
assertEquals("-Infinity", (-Infinity).toExponential(2));
assertEquals("1e+0", (1).toExponential(0));
assertEquals("0e+0", (0).toExponential());
assertEquals("0.00e+0", (0).toExponential(2));
assertEquals("1e+1", (11.2356).toExponential(0));
assertEquals("1.1236e+1", (11.2356).toExponential(4));
assertEquals("1.1236e-4", (0.000112356).toExponential(4));
assertEquals("-1.1236e-4", (-0.000112356).toExponential(4));
assertEquals("1.12356e-4", (0.000112356).toExponential());
assertEquals("-1.12356e-4", (-0.000112356).toExponential());
// ----------------------------------------------------------------------
// toPrecision
assertEquals("NaN", (NaN).toPrecision(1));
assertEquals("Infinity", (Infinity).toPrecision(2));
assertEquals("-Infinity", (-Infinity).toPrecision(2));
assertEquals("0.000555000000000000", (0.000555).toPrecision(15));
assertEquals("5.55000000000000e-7", (0.000000555).toPrecision(15));
assertEquals("-5.55000000000000e-7", (-0.000000555).toPrecision(15));
assertEquals("1e+8", (123456789).toPrecision(1));
assertEquals("123456789", (123456789).toPrecision(9));
assertEquals("1.2345679e+8", (123456789).toPrecision(8));
assertEquals("1.234568e+8", (123456789).toPrecision(7));
assertEquals("-1.234568e+8", (-123456789).toPrecision(7));
assertEquals("-1.2e-9", Number(-.0000000012345).toPrecision(2));
assertEquals("-1.2e-8", Number(-.000000012345).toPrecision(2));
assertEquals("-1.2e-7", Number(-.00000012345).toPrecision(2));
assertEquals("-0.0000012", Number(-.0000012345).toPrecision(2));
assertEquals("-0.000012", Number(-.000012345).toPrecision(2));
assertEquals("-0.00012", Number(-.00012345).toPrecision(2));
assertEquals("-0.0012", Number(-.0012345).toPrecision(2));
assertEquals("-0.012", Number(-.012345).toPrecision(2));
assertEquals("-0.12", Number(-.12345).toPrecision(2));
assertEquals("-1.2", Number(-1.2345).toPrecision(2));
assertEquals("-12", Number(-12.345).toPrecision(2));
assertEquals("-1.2e+2", Number(-123.45).toPrecision(2));
assertEquals("-1.2e+3", Number(-1234.5).toPrecision(2));
assertEquals("-1.2e+4", Number(-12345).toPrecision(2));
assertEquals("-1.235e+4", Number(-12345.67).toPrecision(4));
assertEquals("-1.234e+4", Number(-12344.67).toPrecision(4));
// Test that we round up even when the last digit generated is even.
// dtoa does not do this in its original form.
assertEquals("1.3", 1.25.toPrecision(2), "1.25.toPrecision(2)");
assertEquals("1.4", 1.35.toPrecision(2), "1.35.toPrecision(2)");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/6957/number-tostring/output.js | JavaScript | // Copyright 2008 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------
// toString
assertEquals("NaN", NaN.toString());
assertEquals("Infinity", (1 / 0).toString());
assertEquals("-Infinity", (-1 / 0).toString());
assertEquals("0", "0");
assertEquals("9", "9");
assertEquals("90", "90");
assertEquals("90.12", "90.12");
assertEquals("0.1", "0.1");
assertEquals("0.01", "0.01");
assertEquals("0.0123", "0.0123");
assertEquals("111111111111111110000", "111111111111111110000");
assertEquals("1.1111111111111111e+21", "1.1111111111111111e+21");
assertEquals("1.1111111111111111e+22", "1.1111111111111111e+22");
assertEquals("0.00001", "0.00001");
assertEquals("0.000001", "0.000001");
assertEquals("1e-7", "1e-7");
assertEquals("1.2e-7", "1.2e-7");
assertEquals("1.23e-7", "1.23e-7");
assertEquals("1e-8", "1e-8");
assertEquals("1.2e-8", "1.2e-8");
assertEquals("1.23e-8", "1.23e-8");
assertEquals("0", "0");
assertEquals("-9", "-9");
assertEquals("-90", "-90");
assertEquals("-90.12", "-90.12");
assertEquals("-0.1", "-0.1");
assertEquals("-0.01", "-0.01");
assertEquals("-0.0123", "-0.0123");
assertEquals("-111111111111111110000", "-111111111111111110000");
assertEquals("-1.1111111111111111e+21", "-1.1111111111111111e+21");
assertEquals("-1.1111111111111111e+22", "-1.1111111111111111e+22");
assertEquals("-0.00001", "-0.00001");
assertEquals("-0.000001", "-0.000001");
assertEquals("-1e-7", "-1e-7");
assertEquals("-1.2e-7", "-1.2e-7");
assertEquals("-1.23e-7", "-1.23e-7");
assertEquals("-1e-8", "-1e-8");
assertEquals("-1.2e-8", "-1.2e-8");
assertEquals("-1.23e-8", "-1.23e-8");
assertEquals("NaN", NaN.toString(16));
assertEquals("Infinity", (1 / 0).toString(16));
assertEquals("-Infinity", (-1 / 0).toString(16));
assertEquals("0", "0");
assertEquals("9", "9");
assertEquals("5a", "5a");
assertEquals("5a.1eb851eb852", 90.12.toString(16));
assertEquals("0.1999999999999a", 0.1.toString(16));
assertEquals("0.028f5c28f5c28f6", 0.01.toString(16));
assertEquals("0.032617c1bda511a", 0.0123.toString(16));
assertEquals("605f9f6dd18bc8000", "605f9f6dd18bc8000");
assertEquals("3c3bc3a4a2f75c0000", "3c3bc3a4a2f75c0000");
assertEquals("25a55a46e5da9a00000", "25a55a46e5da9a00000");
assertEquals("0.0000a7c5ac471b4788", 0.00001.toString(16));
assertEquals("0.000010c6f7a0b5ed8d", 0.000001.toString(16));
assertEquals("0.000001ad7f29abcaf48", 0.0000001.toString(16));
assertEquals("0.000002036565348d256", 0.00000012.toString(16));
assertEquals("0.0000021047ee22aa466", 0.000000123.toString(16));
assertEquals("0.0000002af31dc4611874", 0.00000001.toString(16));
assertEquals("0.000000338a23b87483be", 0.000000012.toString(16));
assertEquals("0.00000034d3fe36aaa0a2", 0.0000000123.toString(16));
assertEquals("0", "0");
assertEquals("-9", "-9");
assertEquals("-5a", "-5a");
assertEquals("-5a.1eb851eb852", (-90.12).toString(16));
assertEquals("-0.1999999999999a", (-0.1).toString(16));
assertEquals("-0.028f5c28f5c28f6", (-0.01).toString(16));
assertEquals("-0.032617c1bda511a", (-0.0123).toString(16));
assertEquals("-605f9f6dd18bc8000", "-605f9f6dd18bc8000");
assertEquals("-3c3bc3a4a2f75c0000", "-3c3bc3a4a2f75c0000");
assertEquals("-25a55a46e5da9a00000", "-25a55a46e5da9a00000");
assertEquals("-0.0000a7c5ac471b4788", (-0.00001).toString(16));
assertEquals("-0.000010c6f7a0b5ed8d", (-0.000001).toString(16));
assertEquals("-0.000001ad7f29abcaf48", (-0.0000001).toString(16));
assertEquals("-0.000002036565348d256", (-0.00000012).toString(16));
assertEquals("-0.0000021047ee22aa466", (-0.000000123).toString(16));
assertEquals("-0.0000002af31dc4611874", (-0.00000001).toString(16));
assertEquals("-0.000000338a23b87483be", (-0.000000012).toString(16));
assertEquals("-0.00000034d3fe36aaa0a2", (-0.0000000123).toString(16));
assertEquals("4294967296", "4294967296");
assertEquals("ffffffff", "ffffffff");
assertEquals("11111111111111111111111111111111", "11111111111111111111111111111111");
assertEquals("5yc1z", "5yc1z");
assertEquals("0", "0");
assertEquals("0", "0");
assertEquals("0", "0");
assertEquals("0", "0");
assertEquals("0", "0");
assertEquals("100000000000000000000000000000000", "100000000000000000000000000000000");
assertEquals("100000000000000000000000000000001", "100000000000000000000000000000001");
assertEquals("100000000000080", "100000000000080");
assertEquals("1000000000000100", "1000000000000100");
assertEquals("1000000000000000", "1000000000000000");
assertEquals("1000000000000000", "1000000000000000");
assertEquals("100000000000000000000000000000000000000000000000010000000", "100000000000000000000000000000000000000000000000010000000");
assertEquals("-11111111111111111111111111111111", "-11111111111111111111111111111111");
assertEquals("-5yc1z", "-5yc1z");
assertEquals("-100000000000000000000000000000000", "-100000000000000000000000000000000");
assertEquals("-100000000000000000000000000000001", "-100000000000000000000000000000001");
assertEquals("-100000000000080", "-100000000000080");
assertEquals("-100000000000000000000000000000000000000000000000010000000", "-100000000000000000000000000000000000000000000000010000000");
assertEquals("1000", "1000");
assertEquals("0.00001", "0.00001");
assertEquals("1000000000000000100", "1000000000000000100");
assertEquals("1e+21", "1e+21");
assertEquals("-1e+21", "-1e+21");
assertEquals("1e-7", "1e-7");
assertEquals("-1e-7", "-1e-7");
assertEquals("1.0000000000000001e+21", "1.0000000000000001e+21");
assertEquals("0.000001", "0.000001");
assertEquals("1e-7", "1e-7");
assertEquals("8.8", 8.5.toString(16));
assertEquals("-8.8", (-8.5).toString(16));
assertEquals("1.1", (4 / 3).toString(3));
assertEquals("11.1", (13 / 3).toString(3));
assertEquals("0.01", (1 / 9).toString(3));
assertEquals("10000", "10000");
assertEquals("10000.01", (81 + 1 / 9).toString(3));
assertEquals("0.0212010212010212010212010212010212", (2 / 7).toString(3));
// ----------------------------------------------------------------------
// toFixed
assertEquals("NaN", NaN.toFixed(2));
assertEquals("Infinity", (1 / 0).toFixed(2));
assertEquals("-Infinity", (-1 / 0).toFixed(2));
assertEquals("1.1111111111111111e+21", "1.1111111111111111e+21");
assertEquals("0.1", "0.1");
assertEquals("0.10", "0.10");
assertEquals("0.100", "0.100");
assertEquals("0.01", "0.01");
assertEquals("0.010", "0.010");
assertEquals("0.0100", "0.0100");
assertEquals("0.00", "0.00");
assertEquals("0.001", "0.001");
assertEquals("0.0010", "0.0010");
assertEquals("1.0000", "1.0000");
assertEquals("1.0", "1.0");
assertEquals("1", "1");
assertEquals("12", "12");
assertEquals("1", "1");
assertEquals("12", "12");
assertEquals("1", "1");
assertEquals("12", "12");
assertEquals("0.0000006", "0.0000006");
assertEquals("0.00000006", "0.00000006");
assertEquals("0.000000060", "0.000000060");
assertEquals("0.0000000600", "0.0000000600");
assertEquals("0", "0");
assertEquals("0.0", "0.0");
assertEquals("0.00", "0.00");
assertEquals("-1.1111111111111111e+21", "-1.1111111111111111e+21");
assertEquals("-0.1", "-0.1");
assertEquals("-0.10", "-0.10");
assertEquals("-0.100", "-0.100");
assertEquals("-0.01", "-0.01");
assertEquals("-0.010", "-0.010");
assertEquals("-0.0100", "-0.0100");
assertEquals("-0.00", "-0.00");
assertEquals("-0.001", "-0.001");
assertEquals("-0.0010", "-0.0010");
assertEquals("-1.0000", "-1.0000");
assertEquals("-1.0", "-1.0");
assertEquals("-1", "-1");
assertEquals("-1", "-1");
assertEquals("-12", "-12");
assertEquals("-1", "-1");
assertEquals("-12", "-12");
assertEquals("-0.0000006", "-0.0000006");
assertEquals("-0.00000006", "-0.00000006");
assertEquals("-0.000000060", "-0.000000060");
assertEquals("-0.0000000600", "-0.0000000600");
assertEquals("0", "0");
assertEquals("0.0", "0.0");
assertEquals("0.00", "0.00");
assertEquals("1000", "1000");
assertEquals("0", "0");
assertEquals("0.00001", "0.00001");
assertEquals("0.00000000000000000010", "0.00000000000000000010");
assertEquals("0.00001000000000000", "0.00001000000000000");
assertEquals("1.00000000000000000", "1.00000000000000000");
assertEquals("1000000000000000128", "1000000000000000128");
assertEquals("100000000000000128.0", "100000000000000128.0");
assertEquals("10000000000000128.00", "10000000000000128.00");
assertEquals("10000000000000128.00000000000000000000", "10000000000000128.00000000000000000000");
assertEquals("0", "0");
assertEquals("-42.000", "-42.000");
assertEquals("-1000000000000000128", "-1000000000000000128");
assertEquals("-0.00000000000000000010", "-0.00000000000000000010");
assertEquals("0.12312312312312299889", "0.12312312312312299889");
// Test that we round up even when the last digit generated is even.
// dtoa does not do this in its original form.
assertEquals("1", "1", "0.5.toFixed(0)");
assertEquals("-1", "-1", "(-0.5).toFixed(0)");
assertEquals("1.3", "1.3", "1.25.toFixed(1)");
// This is bizare, but Spidermonkey and KJS behave the same.
assertEquals("234.2040", "234.2040", "234.2040.toFixed(4)");
assertEquals("234.2041", "234.2041");
// ----------------------------------------------------------------------
// toExponential
assertEquals("1e+0", "1e+0");
assertEquals("1.1e+1", "1.1e+1");
assertEquals("1.12e+2", "1.12e+2");
assertEquals("1e+0", "1e+0");
assertEquals("1e+1", "1e+1");
assertEquals("1e+2", "1e+2");
assertEquals("1.0e+0", "1.0e+0");
assertEquals("1.1e+1", "1.1e+1");
assertEquals("1.1e+2", "1.1e+2");
assertEquals("1.00e+0", "1.00e+0");
assertEquals("1.10e+1", "1.10e+1");
assertEquals("1.12e+2", "1.12e+2");
assertEquals("1.000e+0", "1.000e+0");
assertEquals("1.100e+1", "1.100e+1");
assertEquals("1.120e+2", "1.120e+2");
assertEquals("1e-1", "1e-1");
assertEquals("1.1e-1", "1.1e-1");
assertEquals("1.12e-1", "1.12e-1");
assertEquals("1e-1", "1e-1");
assertEquals("1e-1", "1e-1");
assertEquals("1e-1", "1e-1");
assertEquals("1.0e-1", "1.0e-1");
assertEquals("1.1e-1", "1.1e-1");
assertEquals("1.1e-1", "1.1e-1");
assertEquals("1.00e-1", "1.00e-1");
assertEquals("1.10e-1", "1.10e-1");
assertEquals("1.12e-1", "1.12e-1");
assertEquals("1.000e-1", "1.000e-1");
assertEquals("1.100e-1", "1.100e-1");
assertEquals("1.120e-1", "1.120e-1");
assertEquals("-1e+0", "-1e+0");
assertEquals("-1.1e+1", "-1.1e+1");
assertEquals("-1.12e+2", "-1.12e+2");
assertEquals("-1e+0", "-1e+0");
assertEquals("-1e+1", "-1e+1");
assertEquals("-1e+2", "-1e+2");
assertEquals("-1.0e+0", "-1.0e+0");
assertEquals("-1.1e+1", "-1.1e+1");
assertEquals("-1.1e+2", "-1.1e+2");
assertEquals("-1.00e+0", "-1.00e+0");
assertEquals("-1.10e+1", "-1.10e+1");
assertEquals("-1.12e+2", "-1.12e+2");
assertEquals("-1.000e+0", "-1.000e+0");
assertEquals("-1.100e+1", "-1.100e+1");
assertEquals("-1.120e+2", "-1.120e+2");
assertEquals("-1e-1", "-1e-1");
assertEquals("-1.1e-1", "-1.1e-1");
assertEquals("-1.12e-1", "-1.12e-1");
assertEquals("-1e-1", "-1e-1");
assertEquals("-1e-1", "-1e-1");
assertEquals("-1e-1", "-1e-1");
assertEquals("-1.0e-1", "-1.0e-1");
assertEquals("-1.1e-1", "-1.1e-1");
assertEquals("-1.1e-1", "-1.1e-1");
assertEquals("-1.00e-1", "-1.00e-1");
assertEquals("-1.10e-1", "-1.10e-1");
assertEquals("-1.12e-1", "-1.12e-1");
assertEquals("-1.000e-1", "-1.000e-1");
assertEquals("-1.100e-1", "-1.100e-1");
assertEquals("-1.120e-1", "-1.120e-1");
assertEquals("NaN", NaN.toExponential(2));
assertEquals("Infinity", (1 / 0).toExponential(2));
assertEquals("-Infinity", (-1 / 0).toExponential(2));
assertEquals("1e+0", "1e+0");
assertEquals("0e+0", "0e+0");
assertEquals("0.00e+0", "0.00e+0");
assertEquals("1e+1", "1e+1");
assertEquals("1.1236e+1", "1.1236e+1");
assertEquals("1.1236e-4", "1.1236e-4");
assertEquals("-1.1236e-4", "-1.1236e-4");
assertEquals("1.12356e-4", "1.12356e-4");
assertEquals("-1.12356e-4", "-1.12356e-4");
// ----------------------------------------------------------------------
// toPrecision
assertEquals("NaN", NaN.toPrecision(1));
assertEquals("Infinity", (1 / 0).toPrecision(2));
assertEquals("-Infinity", (-1 / 0).toPrecision(2));
assertEquals("0.000555000000000000", "0.000555000000000000");
assertEquals("5.55000000000000e-7", "5.55000000000000e-7");
assertEquals("-5.55000000000000e-7", "-5.55000000000000e-7");
assertEquals("1e+8", "1e+8");
assertEquals("123456789", "123456789");
assertEquals("1.2345679e+8", "1.2345679e+8");
assertEquals("1.234568e+8", "1.234568e+8");
assertEquals("-1.234568e+8", "-1.234568e+8");
assertEquals("-1.2e-9", Number(-0.0000000012345).toPrecision(2));
assertEquals("-1.2e-8", Number(-0.000000012345).toPrecision(2));
assertEquals("-1.2e-7", Number(-0.00000012345).toPrecision(2));
assertEquals("-0.0000012", Number(-0.0000012345).toPrecision(2));
assertEquals("-0.000012", Number(-0.000012345).toPrecision(2));
assertEquals("-0.00012", Number(-0.00012345).toPrecision(2));
assertEquals("-0.0012", Number(-0.0012345).toPrecision(2));
assertEquals("-0.012", Number(-0.012345).toPrecision(2));
assertEquals("-0.12", Number(-0.12345).toPrecision(2));
assertEquals("-1.2", Number(-1.2345).toPrecision(2));
assertEquals("-12", Number(-12.345).toPrecision(2));
assertEquals("-1.2e+2", Number(-123.45).toPrecision(2));
assertEquals("-1.2e+3", Number(-1234.5).toPrecision(2));
assertEquals("-1.2e+4", Number(-12345).toPrecision(2));
assertEquals("-1.235e+4", Number(-12345.67).toPrecision(4));
assertEquals("-1.234e+4", Number(-12344.67).toPrecision(4));
// Test that we round up even when the last digit generated is even.
// dtoa does not do this in its original form.
assertEquals("1.3", "1.3", "1.25.toPrecision(2)");
assertEquals("1.4", "1.4", "1.35.toPrecision(2)");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7004/input.js | JavaScript | function getDescription(option, parentGroup) {
return [
parentGroup && parentGroup.label,
option.__labelPrefix,
]
.concat(option.tags)
}
function printDescription() {
const option = {__labelPrefix: 'test', tags: []};
const parent = null
const desc = getDescription(option, parent);
console.log(desc);
}
printDescription(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7004/output.js | JavaScript | var option;
console.log([
null,
(option = {
__labelPrefix: 'test',
tags: []
}).__labelPrefix
].concat(option.tags));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7009/input.js | JavaScript | export const example1 = (param) =>
param => param["There is something wrong!"];
export const example2 = (param) =>
param => param["123 is fine"];
export const example3 = (param) =>
param => param["! That is fine !"];
export const example4 = (param) =>
param => param[" space in start works fine"];
export const example5 = (param) =>
param => param[123];
export class Foo extends Bar {
foo() {
super["a space b"]();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7009/output.js | JavaScript | export const example1 = (param)=>(param)=>param["There is something wrong!"];
export const example2 = (param)=>(param)=>param["123 is fine"];
export const example3 = (param)=>(param)=>param["! That is fine !"];
export const example4 = (param)=>(param)=>param[" space in start works fine"];
export const example5 = (param)=>(param)=>param[123];
export class Foo extends Bar {
foo() {
super["a space b"]();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7045/input.js | JavaScript | a = 1;
delete a;
console.log(typeof a); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7045/output.js | JavaScript | a = 1, delete a, console.log(typeof a);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7111/input.js | JavaScript | console.log(Math.random() > 0.5 ? -0 : 0)
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7111/output.js | JavaScript | console.log(Math.random() > 0.5 ? -0 : 0);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7194/1/input.js | JavaScript | function example() {
var MyEnum = /*#__PURE__*/function (MyEnumInner) {
MyEnumInner["First"] = "first";
MyEnumInner["Second"] = "second";
return MyEnumInner;
}(MyEnum || {});
return MyEnum
}
example() | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7194/1/output.js | JavaScript | function example() {
var MyEnum = /*#__PURE__*/ function(MyEnumInner) {
MyEnumInner["First"] = "first";
MyEnumInner["Second"] = "second";
return MyEnumInner;
}(MyEnum || {});
return MyEnum;
}
example();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7228/1/input.js | JavaScript | export function f() {
const foos = something.getFoos();
return foos?.[0];
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7228/1/output.js | JavaScript | export function f() {
const foos = something.getFoos();
return foos?.[0];
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7241/input.js | JavaScript | (function () {
function forwardRef() {
return something();
}
function Test() {
return 'Test';
}
const _Test = /*#__PURE__*/ (0, forwardRef)(Test);
function Other() {
return 'Other';
}
const _Other = /*#__PURE__*/ (0, forwardRef)(Other);
console.log((0, _Test));
})(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7241/output.js | JavaScript | console.log(something());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7287/1/input.js | JavaScript | (function () {
const r = f();
console.log(r)
function f() {
console.log("REQUIRE")
return 1
}
})();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7287/1/output.js | JavaScript | console.log((console.log("REQUIRE"), 1));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7331/1/input.js | JavaScript | export default function () {
function foo(arg) {
var arg = arg.slice()
return arg
}
foo([])
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7331/1/output.js | JavaScript | export default function() {
var arg;
var arg;
arg = (arg = []).slice();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7331/2/input.js | JavaScript | export default function () {
function foo(arg) {
var arg = arg.slice()
return arg
}
foo([])
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7331/2/output.js | JavaScript | export default function() {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7402/input.js | JavaScript | export function mutate(out) {
out[0] = 1;
out[1] = 2;
out[2] = 3;
return out;
}
export const myFunc = (function () {
const temp = [0, 0, 0];
return function (out) {
const scaling = temp;
mutate(scaling);
out[0] = 1 / scaling[0];
out[1] = 1 / scaling[1];
out[2] = 1 / scaling[2];
return out;
};
})();
const out = [1, 2, 3];
myFunc(out);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7402/output.js | JavaScript | export function mutate(out) {
return out[0] = 1, out[1] = 2, out[2] = 3, out;
}
export const myFunc = function() {
const temp = [
0,
0,
0
];
return function(out) {
return mutate(temp), out[0] = 1 / temp[0], out[1] = 1 / temp[1], out[2] = 1 / temp[2], out;
};
}();
myFunc([
1,
2,
3
]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7412/input.js | JavaScript | export function throttleTime(interval) {
let currentValue;
let timeout;
return (done) => (value) => {
currentValue = value;
if (timeout) {
return;
}
timeout = setTimeout(() => {
done(currentValue);
}, interval);
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7412/output.js | JavaScript | export function throttleTime(interval) {
let currentValue, timeout;
return (done)=>(value)=>{
currentValue = value, timeout || (timeout = setTimeout(()=>{
done(currentValue);
}, interval));
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7457/1/input.js | JavaScript | function bar() {
return function* () {
yield foo();
};
}
console.log(bar()); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7457/1/output.js | JavaScript | function bar() {
return function*() {
yield foo();
};
}
console.log(bar());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7472/1/input.js | JavaScript | const FluentV9ColorTokens = {
colorNeutralForeground1: '--colorNeutralForeground1',
colorNeutralForeground1Hover: '--colorNeutralForeground1Hover',
colorNeutralForeground1Pressed: '--colorNeutralForeground1Pressed',
colorNeutralForeground1Selected: '--colorNeutralForeground1Selected',
colorNeutralForeground2: '--colorNeutralForeground2',
colorNeutralForeground2Hover: '--colorNeutralForeground2Hover',
colorNeutralForeground2Pressed: '--colorNeutralForeground2Pressed',
colorNeutralForeground2Selected: '--colorNeutralForeground2Selected',
colorNeutralForeground2BrandHover: '--colorNeutralForeground2BrandHover',
colorNeutralForeground2BrandPressed: '--colorNeutralForeground2BrandPressed',
colorNeutralForeground2BrandSelected: '--colorNeutralForeground2BrandSelected',
colorNeutralForeground3: '--colorNeutralForeground3',
colorNeutralForeground3Hover: '--colorNeutralForeground3Hover',
colorNeutralForeground3Pressed: '--colorNeutralForeground3Pressed',
colorNeutralForeground3Selected: '--colorNeutralForeground3Selected',
colorNeutralForeground3BrandHover: '--colorNeutralForeground3BrandHover',
colorNeutralForeground3BrandPressed: '--colorNeutralForeground3BrandPressed',
colorNeutralForeground3BrandSelected: '--colorNeutralForeground3BrandSelected',
colorNeutralForeground4: '--colorNeutralForeground4',
colorNeutralForegroundDisabled: '--colorNeutralForegroundDisabled',
colorBrandForegroundLink: '--colorBrandForegroundLink',
colorBrandForegroundLinkHover: '--colorBrandForegroundLinkHover',
colorBrandForegroundLinkPressed: '--colorBrandForegroundLinkPressed',
colorBrandForegroundLinkSelected: '--colorBrandForegroundLinkSelected',
colorNeutralForeground2Link: '--colorNeutralForeground2Link',
colorNeutralForeground2LinkHover: '--colorNeutralForeground2LinkHover',
colorNeutralForeground2LinkPressed: '--colorNeutralForeground2LinkPressed',
colorNeutralForeground2LinkSelected: '--colorNeutralForeground2LinkSelected',
colorCompoundBrandForeground1: '--colorCompoundBrandForeground1',
colorCompoundBrandForeground1Hover: '--colorCompoundBrandForeground1Hover',
colorCompoundBrandForeground1Pressed: '--colorCompoundBrandForeground1Pressed',
colorNeutralForegroundOnBrand: '--colorNeutralForegroundOnBrand',
colorNeutralForegroundInverted: '--colorNeutralForegroundInverted',
colorNeutralForegroundInvertedHover: '--colorNeutralForegroundInvertedHover',
colorNeutralForegroundInvertedPressed: '--colorNeutralForegroundInvertedPressed',
colorNeutralForegroundInvertedSelected: '--colorNeutralForegroundInvertedSelected',
colorNeutralForegroundInverted2: '--colorNeutralForegroundInverted2',
colorNeutralForegroundStaticInverted: '--colorNeutralForegroundStaticInverted',
colorNeutralForegroundInvertedLink: '--colorNeutralForegroundInvertedLink',
colorNeutralForegroundInvertedLinkHover: '--colorNeutralForegroundInvertedLinkHover',
colorNeutralForegroundInvertedLinkPressed: '--colorNeutralForegroundInvertedLinkPressed',
colorNeutralForegroundInvertedLinkSelected: '--colorNeutralForegroundInvertedLinkSelected',
colorNeutralForegroundInvertedDisabled: '--colorNeutralForegroundInvertedDisabled',
colorBrandForeground1: '--colorBrandForeground1',
colorBrandForeground2: '--colorBrandForeground2',
colorNeutralForeground1Static: '--colorNeutralForeground1Static',
colorBrandForegroundInverted: '--colorBrandForegroundInverted',
colorBrandForegroundInvertedHover: '--colorBrandForegroundInvertedHover',
colorBrandForegroundInvertedPressed: '--colorBrandForegroundInvertedPressed',
colorBrandForegroundOnLight: '--colorBrandForegroundOnLight',
colorBrandForegroundOnLightHover: '--colorBrandForegroundOnLightHover',
colorBrandForegroundOnLightPressed: '--colorBrandForegroundOnLightPressed',
colorBrandForegroundOnLightSelected: '--colorBrandForegroundOnLightSelected',
colorNeutralBackground1: '--colorNeutralBackground1',
colorNeutralBackground1Hover: '--colorNeutralBackground1Hover',
colorNeutralBackground1Pressed: '--colorNeutralBackground1Pressed',
colorNeutralBackground1Selected: '--colorNeutralBackground1Selected',
colorNeutralBackground2: '--colorNeutralBackground2',
colorNeutralBackground2Hover: '--colorNeutralBackground2Hover',
colorNeutralBackground2Pressed: '--colorNeutralBackground2Pressed',
colorNeutralBackground2Selected: '--colorNeutralBackground2Selected',
colorNeutralBackground3: '--colorNeutralBackground3',
colorNeutralBackground3Hover: '--colorNeutralBackground3Hover',
colorNeutralBackground3Pressed: '--colorNeutralBackground3Pressed',
colorNeutralBackground3Selected: '--colorNeutralBackground3Selected',
colorNeutralBackground4: '--colorNeutralBackground4',
colorNeutralBackground4Hover: '--colorNeutralBackground4Hover',
colorNeutralBackground4Pressed: '--colorNeutralBackground4Pressed',
colorNeutralBackground4Selected: '--colorNeutralBackground4Selected',
colorNeutralBackground5: '--colorNeutralBackground5',
colorNeutralBackground5Hover: '--colorNeutralBackground5Hover',
colorNeutralBackground5Pressed: '--colorNeutralBackground5Pressed',
colorNeutralBackground5Selected: '--colorNeutralBackground5Selected',
colorNeutralBackground6: '--colorNeutralBackground6',
colorNeutralBackgroundInverted: '--colorNeutralBackgroundInverted',
colorNeutralBackgroundStatic: '--colorNeutralBackgroundStatic',
colorSubtleBackground: '--colorSubtleBackground',
colorSubtleBackgroundHover: '--colorSubtleBackgroundHover',
colorSubtleBackgroundPressed: '--colorSubtleBackgroundPressed',
colorSubtleBackgroundSelected: '--colorSubtleBackgroundSelected',
colorSubtleBackgroundLightAlphaHover: '--colorSubtleBackgroundLightAlphaHover',
colorSubtleBackgroundLightAlphaPressed: '--colorSubtleBackgroundLightAlphaPressed',
colorSubtleBackgroundLightAlphaSelected: '--colorSubtleBackgroundLightAlphaSelected',
colorSubtleBackgroundInverted: '--colorSubtleBackgroundInverted',
colorSubtleBackgroundInvertedHover: '--colorSubtleBackgroundInvertedHover',
colorSubtleBackgroundInvertedPressed: '--colorSubtleBackgroundInvertedPressed',
colorSubtleBackgroundInvertedSelected: '--colorSubtleBackgroundInvertedSelected',
colorTransparentBackground: '--colorTransparentBackground',
colorTransparentBackgroundHover: '--colorTransparentBackgroundHover',
colorTransparentBackgroundPressed: '--colorTransparentBackgroundPressed',
colorTransparentBackgroundSelected: '--colorTransparentBackgroundSelected',
colorNeutralBackgroundDisabled: '--colorNeutralBackgroundDisabled',
colorNeutralBackgroundInvertedDisabled: '--colorNeutralBackgroundInvertedDisabled',
colorNeutralStencil1: '--colorNeutralStencil1',
colorNeutralStencil2: '--colorNeutralStencil2',
colorNeutralStencil1Alpha: '--colorNeutralStencil1Alpha',
colorNeutralStencil2Alpha: '--colorNeutralStencil2Alpha',
colorBackgroundOverlay: '--colorBackgroundOverlay',
colorScrollbarOverlay: '--colorScrollbarOverlay',
colorBrandBackground: '--colorBrandBackground',
colorBrandBackgroundHover: '--colorBrandBackgroundHover',
colorBrandBackgroundPressed: '--colorBrandBackgroundPressed',
colorBrandBackgroundSelected: '--colorBrandBackgroundSelected',
colorCompoundBrandBackground: '--colorCompoundBrandBackground',
colorCompoundBrandBackgroundHover: '--colorCompoundBrandBackgroundHover',
colorCompoundBrandBackgroundPressed: '--colorCompoundBrandBackgroundPressed',
colorBrandBackgroundStatic: '--colorBrandBackgroundStatic',
colorBrandBackground2: '--colorBrandBackground2',
colorBrandBackgroundInverted: '--colorBrandBackgroundInverted',
colorBrandBackgroundInvertedHover: '--colorBrandBackgroundInvertedHover',
colorBrandBackgroundInvertedPressed: '--colorBrandBackgroundInvertedPressed',
colorBrandBackgroundInvertedSelected: '--colorBrandBackgroundInvertedSelected',
colorNeutralStrokeAccessible: '--colorNeutralStrokeAccessible',
colorNeutralStrokeAccessibleHover: '--colorNeutralStrokeAccessibleHover',
colorNeutralStrokeAccessiblePressed: '--colorNeutralStrokeAccessiblePressed',
colorNeutralStrokeAccessibleSelected: '--colorNeutralStrokeAccessibleSelected',
colorNeutralStroke1: '--colorNeutralStroke1',
colorNeutralStroke1Hover: '--colorNeutralStroke1Hover',
colorNeutralStroke1Pressed: '--colorNeutralStroke1Pressed',
colorNeutralStroke1Selected: '--colorNeutralStroke1Selected',
colorNeutralStroke2: '--colorNeutralStroke2',
colorNeutralStroke3: '--colorNeutralStroke3',
colorNeutralStrokeOnBrand: '--colorNeutralStrokeOnBrand',
colorNeutralStrokeOnBrand2: '--colorNeutralStrokeOnBrand2',
colorNeutralStrokeOnBrand2Hover: '--colorNeutralStrokeOnBrand2Hover',
colorNeutralStrokeOnBrand2Pressed: '--colorNeutralStrokeOnBrand2Pressed',
colorNeutralStrokeOnBrand2Selected: '--colorNeutralStrokeOnBrand2Selected',
colorBrandStroke1: '--colorBrandStroke1',
colorBrandStroke2: '--colorBrandStroke2',
colorCompoundBrandStroke: '--colorCompoundBrandStroke',
colorCompoundBrandStrokeHover: '--colorCompoundBrandStrokeHover',
colorCompoundBrandStrokePressed: '--colorCompoundBrandStrokePressed',
colorNeutralStrokeDisabled: '--colorNeutralStrokeDisabled',
colorNeutralStrokeInvertedDisabled: '--colorNeutralStrokeInvertedDisabled',
colorTransparentStroke: '--colorTransparentStroke',
colorTransparentStrokeInteractive: '--colorTransparentStrokeInteractive',
colorTransparentStrokeDisabled: '--colorTransparentStrokeDisabled',
colorStrokeFocus1: '--colorStrokeFocus1',
colorStrokeFocus2: '--colorStrokeFocus2',
colorNeutralShadowAmbient: '--colorNeutralShadowAmbient',
colorNeutralShadowKey: '--colorNeutralShadowKey',
colorNeutralShadowAmbientLighter: '--colorNeutralShadowAmbientLighter',
colorNeutralShadowKeyLighter: '--colorNeutralShadowKeyLighter',
colorNeutralShadowAmbientDarker: '--colorNeutralShadowAmbientDarker',
colorNeutralShadowKeyDarker: '--colorNeutralShadowKeyDarker',
colorBrandShadowAmbient: '--colorBrandShadowAmbient',
colorBrandShadowKey: '--colorBrandShadowKey',
colorPaletteDarkOrangeForeground1: '--colorPaletteDarkOrangeForeground1'
};
const AppIcon = (props) => {
const { dummyBool } = props;
if (dummyBool) {
console.log(`var(${FluentV9ColorTokens.colorNeutralForegroundDisabled}, ${theme?.palette.neutralTertiary ?? ThemeColorPalette.Neutral.neutralTertiary})`)
}
return null;
};
export default AppIcon; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7472/1/output.js | JavaScript | const FluentV9ColorTokens = {
colorNeutralForegroundDisabled: '--colorNeutralForegroundDisabled'
};
export default ((props)=>{
const { dummyBool } = props;
return dummyBool && console.log(`var(${FluentV9ColorTokens.colorNeutralForegroundDisabled}, ${theme?.palette.neutralTertiary ?? ThemeColorPalette.Neutral.neutralTertiary})`), null;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7500/input.js | JavaScript | var globalArray = [1, 1, 1];
module.exports = function () {
var localArray = globalArray;
localArray[0] = localArray[1] = localArray[2] = 0;
return localArray;
}; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7500/output.js | JavaScript | var globalArray = [
1,
1,
1
];
module.exports = function() {
return globalArray[0] = globalArray[1] = globalArray[2] = 0, globalArray;
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7568/1/input.js | JavaScript | var specific_microfront;
(function () { // webpackBootstrap
"use strict";
var __webpack_modules__ = ({
});
function __webpack_require__(moduleId) {
var module = __webpack_module_cache__[moduleId] = {
id: moduleId,
loaded: false,
exports: {}
};
__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
module.loaded = true;
return module.exports;
}
var __webpack_exports__ = __webpack_require__("webpack/container/entry/specific_page");
specific_microfront = __webpack_exports__;
})()
; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7568/1/output.js | JavaScript | var specific_microfront;
!function() {
"use strict";
var __webpack_modules__ = {};
specific_microfront = function __webpack_require__(moduleId) {
var module = __webpack_module_cache__[moduleId] = {
id: moduleId,
loaded: !1,
exports: {}
};
return __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__), module.loaded = !0, module.exports;
}("webpack/container/entry/specific_page");
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7575/1/input.js | JavaScript | export const envKey = "staging" || "production"
const environmentResolver = () => {
if (envKey === "production") {
return "production"
}
if (envKey === "staging") {
return "staging"
}
if (envKey === "test") {
return "test"
}
if (envKey === "development") {
return "development"
}
throw new Error(`Unknown environment: ${envKey}`)
}
export const environment = environmentResolver() | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7575/1/output.js | JavaScript | export const envKey = "staging";
export const environment = "staging";
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7591/input.js | JavaScript | var x = someFunction;
function someFunction() {
return 2;
}
console.log(x);
console.log(x);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7591/output.js | JavaScript | function someFunction() {
return 2;
}
console.log(someFunction), console.log(someFunction);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7634/1/input.js | JavaScript | import Foo from './foo.js';
export const Bar = Foo;
function someRecursiveFunction(value) {
return value.map(someRecursiveFunction);
}
export default someRecursiveFunction; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7634/1/output.js | JavaScript | import o from './foo.js';
export const Bar = o;
export default function r(o) {
return o.map(r);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7641/1/input.js | JavaScript | let a = () => a
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7678/input.js | JavaScript | export let str = "\\uD83D\\uDC68\\u200D\\uD83D\\uDE80";
export let obj = {
"\\uD83D\\uDC68\\u200D\\uD83D\\uDE80": "wrong"
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7678/output.js | JavaScript | export let str = "\\uD83D\\uDC68\\u200D\\uD83D\\uDE80";
export let obj = {
"\\uD83D\\uDC68\\u200D\\uD83D\\uDE80": "wrong"
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7683/1/input.js | JavaScript | {
let Infinity = 3;
console.log(Infinity);
if (Infinity > 4) console.log("Infinity");
}
{
let NaN = 3;
console.log(NaN);
if (NaN < 4) console.log("NaN");
}
{
let undefined = 3;
console.log(undefined);
if (undefined < 4) console.log("undefined");
}
{
let x = 3;
console.log(x);
if (x < 4) console.log("undefined");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7683/1/output.js | JavaScript | {
let Infinity = 3;
console.log(Infinity);
if (Infinity > 4) console.log("Infinity");
}{
let NaN = 3;
console.log(NaN);
if (NaN < 4) console.log("NaN");
}{
let undefined = 3;
console.log(undefined);
if (undefined < 4) console.log("undefined");
}{
let x = 3;
console.log(x);
if (x < 4) console.log("undefined");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7697/1/input.js | JavaScript | let id = 0;
export function getId() {
id = id % 9999;
return `${id++}`
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7697/1/output.js | JavaScript | let id = 0;
export function getId() {
return id %= 9999, `${id++}`;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7714/1/input.js | JavaScript | console.log(`${[1, 1]}`)
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7714/1/output.js | JavaScript | console.log("1,1");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7739/1/input.js | JavaScript | const formatterOpt = {
minimumFractionDigits: 0,
maximumFractionDigits: 0,
};
if (withCurrency) {
formatterOpt.style = 'currency';
}
const formatter = new Intl.NumberFormat('en', formatterOpt);
console.log(formatter.format(amount)); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7739/1/output.js | JavaScript | const formatterOpt = {
minimumFractionDigits: 0,
maximumFractionDigits: 0
};
withCurrency && (formatterOpt.style = 'currency'), console.log(new Intl.NumberFormat('en', formatterOpt).format(amount));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7742/1/input.js | JavaScript | console.log([1, 2].slice(1, undefined));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7742/1/output.js | JavaScript | console.log([
1,
2
].slice(1, void 0));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7749/input.js | JavaScript | let depth = 0;
function foo(n) {
depth += 1;
let k = visit(n);
depth -= 1;
return k;
}
blackbox(foo);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7749/output.js | JavaScript | let depth = 0;
blackbox(function(n) {
depth += 1;
let k = visit(n);
return depth -= 1, k;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7754/1/input.js | JavaScript | const foo = 1;
console.log(foo);
eval(`console.log(foo)`) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7754/1/output.js | JavaScript | const o = 1;
console.log(o), eval("console.log(foo)");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7754/2/input.js | JavaScript | const foo = 1;
console.log(foo);
eval(`console.log(foo)`) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7754/2/output.js | JavaScript | const foo = 1;
console.log(foo), eval("console.log(foo)");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7770/1/input.js | JavaScript | exports.MainCSS1 = foo`
\x<-invalid, so no cooked
${'this breaks splits the quasis'}
this should have a cooked
`;
exports.MainCSS2 = foo`
\x<-invalid, so no cooked
${'this breaks splits the quasis'}
this should have a cooked
${'this breaks splits the quasis'}
this should also have a cooked
`; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7770/1/output.js | JavaScript | exports.MainCSS1 = foo`
\x<-invalid, so no cooked
${'this breaks splits the quasis'}
this should have a cooked
`, exports.MainCSS2 = foo`
\x<-invalid, so no cooked
${'this breaks splits the quasis'}
this should have a cooked
${'this breaks splits the quasis'}
this should also have a cooked
`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7770/2/input.js | JavaScript | const sWidth = "asdasd";
function absolute() {
return `
`;
}
function flex() {
return `
`;
}
exports.MainCSS = `
.ThisshouldOnlyBeonTop {
${absolute()}
}
.abcBlablaOne .asdsad {
${flex()}
}
.aasdasdasd .asdsada {
we: ${sWidth} !important;
}
`; | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7770/2/output.js | JavaScript | exports.MainCSS = `
.ThisshouldOnlyBeonTop {
}
.abcBlablaOne .asdsad {
}
.aasdasdasd .asdsada {
we: asdasd !important;
}
`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7783/1/input.js | JavaScript | export default function Home() {
return React.createElement("div", null, foo.a);
}
const foo = {
get a() {
return `a ${this.b}`;
},
get b() {
return `b`;
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7783/1/output.js | JavaScript | export default function Home() {
return React.createElement("div", null, foo.a);
}
const foo = {
get a () {
return `a ${this.b}`;
},
get b () {
return "b";
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/1/input.js | JavaScript | let a = 1
function foo(g) {
var t = g()
a += t
}
function g() {
a = 2
return 1
}
foo(g)
console.log(a)
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/1/output.js | JavaScript | console.log(3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/2/input.js | JavaScript | let a = 1
function foo(g) {
var t = g()
a = a + t
}
function g() {
a = 2
return 1
}
foo(g)
console.log(a)
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/2/output.js | JavaScript | console.log(3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/3/input.js | JavaScript | export function f(i, e, cmp) {
function g() {
i ++
return e || 0;
}
if (e = g(e), cmp(i, e)) {
console.log(e)
}
return g
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7784/3/output.js | JavaScript | export function f(i, e, cmp) {
function g() {
return i++, e || 0;
}
return e = g(e), cmp(i, e) && console.log(e), g;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7821/input.js | JavaScript | var Blocks = {
Block1: function () {
return React.createElement(React.Fragment, null, "'Block1xx'");
},
Block2: function () {
return React.createElement(React.Fragment, null, "'Block2xx'");
},
Layout1: function () {
return RenderLayout(Blocks, [
"Block1"
]);
}
};
function RenderLayout(Comps, items) {
return items.map(function (item) {
return Comps[item];
});
}
export function render() {
return React.createElement(Blocks.Layout1, null);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7821/output.js | JavaScript | var Blocks = {
Block1: function() {
return React.createElement(React.Fragment, null, "'Block1xx'");
},
Block2: function() {
return React.createElement(React.Fragment, null, "'Block2xx'");
},
Layout1: function() {
return RenderLayout(Blocks, [
"Block1"
]);
}
};
function RenderLayout(Comps, items) {
return items.map(function(item) {
return Comps[item];
});
}
export function render() {
return React.createElement(Blocks.Layout1, null);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/fixture/issues/7839/1/input.js | JavaScript | export function createCaseFirst(g, methodName) {
var chr = g.get(0)
console.log(123)
return chr[methodName]() + trailing;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.