text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>/**
* Copy from @atlaskit/button
*/
import _extends from 'babel-runtime/helpers/extends';
import _Object$getPrototypeOf from 'babel-runtime/core-js/object/get-prototype-of';
import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
import _createClass from 'babel-runtime/helpers/createClass';... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"babel-runtime/helpers/extends": ["default"],
"babel-runtime/core-js/object/get-prototype-of": ["default"],
"babel-runtime/helpers/classCal... | fim | webpack/webpack | javascript |
<|fim_suffix|>eq();
<|fim_prefix|>import { equal as eq, deepEqual } from "./assert";
export function myFunction() {
function it() {
eq(1, arguments[0]);
}
deepEqual(1, 1);
it();
}
const bb =<|fim_middle|> <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rs/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"./assert": ["equal"]
}
},
myFunction: {
usedExports: ["myFunction"],
expect: {
"./assert": ["deepEqual", "equal"]
}
}
});
<|fim_prefix|>"use strict";
const c<|fim_middle|>reateTestCases ... | fim | webpack/webpack | javascript |
import { A, B, C1, C2, D1, D2, E1, E2, E3, F, G } from "./test";
export { a, b, c, d };
if (Math.random() > 0.5) {
var a = () => A;
let b = () => B;
}
let b;
var c = () => C1;
couldCallExportC();
var c = () => C2;
couldCallExportC();
while (Math.random() > 0.5) {
let d = () => D1;
}
while (Math.random() > 0.5)... | fim | webpack/webpack | javascript |
<|fim_suffix|>"g"],
expect: {
"./test": ["G"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"./test": []
}
},
a: {
usedExports: ["a"],
expect: {
"./test": ["A"]
}... | fim | webpack/webpack | javascript |
<|fim_suffix|> {
add = () => {
maybeEqual();
};
}
export class ExportCls7 {
add = definiteEqual();
}
<|fim_prefix|>import {
deepEqual,
equal,
strictEqual,
notEqual,
maybeEqual,
definiteEqual,
getNameA,
getNameB
} from "./assert";
function fun1() {
deepEqual(1, 1);
}
function fun2() {
fun1();<|fim_midd... | fim | webpack/webpack | javascript |
<|fim_suffix|>ortsClassFields");
module.exports = () => supportsClassFields();
<|fim_prefix|>"use strict";
const supportsClassFields = r<|fim_middle|>equire("../../../helpers/supp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ports: [
"ExportCls1",
"ExportCls2",
"ExportCls3",
"ExportCls4",
"ExportCls5a",
"ExportCls5b",
"ExportCls6",
"ExportCls7"
],
expect: {
"./assert": [
...base,
"deepEqual",
"equal",
"strictEqual",
"notEqual",
"maybeEqual",
"definiteEqual"
]
}
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { im1, im2 } from "any";
const exp1 = function() {
console.log(im1);
};
const exp2 = () => {
console.log(im2);
};
export con<|fim_suffix|> {
exp1();
}
};
export { exp1, exp2 };
<|fim_middle|>st exp4 = () => {
exp2();
};
export const expCls = class {
constructor()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> any: ["im1", "im2"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
}
},
exp1: {
usedExports: ["exp1"],
expect: {
any: ["im1"]
}
},
exp2: {
u... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as ns from "./pure-source";
const pure1 = ns.pureExport1(1);
const pure2 = ns.pureExport2(1);
const pure3 = ns.pureExport3(1);
const pure4 = ns.pureExport4(1);
const pure5 = ns.pureExport5(1);
co<|fim_suffix|>(1);
const impure = ns.impureExport(2);
it("should compile successfully", () => {
ex... | fim | webpack/webpack | javascript |
<|fim_suffix|>
const pureExport5 = (x) => {
return x;
};
export const impureExport = (x) => {
return x;
};
export const usedExportsOfPureSource = __webpack_exports_info__.usedExports;
export { fn4 as pureExport4, pureExport5 };
<|fim_prefix|>/*#__NO_SIDE_EFFECTS__*/
export function pureExport1(x) {
return x;
}
/... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
name: "cross-module-pure-namespace-import without module concatenation",
mode: "production",
optimization: {
concatenateModules: false
}
},
{
name: "cross-module-pure-namespace-import with module concatenation",
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import pureDefaultExport, {
pureExport1,
impureExport,
pureExport2,
pureExport3,
pureExport4,
pureExport5,
usedExportsOfPureSource
} from ".<|fim_suffix|>eSource.sort()).toEqual(
["impureExport", "usedExportsOfPureSource"].sort()
);
});
<|fim_middle|>/pure-source";
const pure1 = pureExport1(1);... | fim | webpack/webpack | javascript |
<|fim_suffix|>onst pureExport2 = (x) => {
return x;
};
export var pureExport3 = /*#__NO_SIDE_EFFECTS__*/ (x) => {
return x;
};
/*#__NO_SIDE_EFFECTS__*/
function fn4(x) {
return x;
}
/*#__NO_SIDE_EFFECTS__*/
const pureExport5 = (x) => {
return x;
};
export const impureExport = (x) => {
return x;
};
export cons... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.<|fim_suffix|>oncatenation",
mode: "production"
}
];
<|fim_middle|>exports = [
{
name: "cross-module-pure-normal without module concatenation",
mode: "production",
optimization: {
concatenateModules: false
}
},
{
... | fim | webpack/webpack | javascript |
<|fim_suffix|>1);
const pure5 = pure.pureExport5(1);
const pureDefault = pureDefaultExport(1);
const impure = impureExport(2);
it("should compile successfully", () => {
expect(usedExportsOfPureSource.sort()).toEqual(
["impureExport", "usedExportsOfPureSource"].sort()
);
});
<|fim_prefix|>import pureDefaultExport,... | fim | webpack/webpack | javascript |
<|fim_prefix|>/*#__NO_SIDE_EFFECTS__*/
export function pureExport1(x) {
return x;
}
/*#__NO_SIDE_EFFECTS__*/
export default function pureDefaultExport(x) {
return x;
}
/*#__NO_SIDE_EFFECTS__*/
export const pureExport2 = (x) => {
return x;
};
export var pureExport3 = /*#__NO_SIDE_EFFECTS__*/ (x<|fim_suffix|>rn x;
... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from<|fim_suffix|>pure-source";
<|fim_middle|> "./pure-source";
export { default } from "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export * as pure from "./pure-so<|fim_suffix|>re-source";
<|fim_middle|>urce";
export { pureExport4 } from "./pu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
name: "cross-module-pure-reexport-target without module concatenation",
mode: "production",
optimization: {
concatenateModules: false
}
},
{<|fim_middle|>
name: "cross-module-pure... | fim | webpack/webpack | javascript |
<|fim_suffix|> b();
<|fim_prefix|>import { a, b } from "dep";
// pure export default expression: statementPurePart path
export default /*#_<|fim_middle|>_PURE__*/ a();
// pure declarator, independent usage
export const other = /*#__PURE__*/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> ["default", "other"],
expect: {
dep: ["a", "b"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
// pure default expression drops its import unless the default export is used
module.exports = createTestCases({
nothing: {
usedExports: [],
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>any";
export default () => {
fun1();
};
<|fim_prefix|>import { fun1, fun2 } <|fim_middle|>from "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>: {
any: []
}
},
exp1: {
usedExports: ["default"],
expect: {
any: ["fun1"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expec<|fim_middle|>t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { uniq } from "<|fim_suffix|>odash-es";
export default class SomeClass {
message(...args) {
console.log(...args);
}
unusedUniq(array) {
uniq(array);
}
}
<|fim_middle|>l<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: <|fim_suffix|>
"lodash-es": []
}
},
all: {
usedExports: ["default"],
expect: {
"lodash-es": ["uniq"]
}
}
});
<|fim_middle|>[],
expect: {<|endofte... | fim | webpack/webpack | javascript |
import { var1, fun2 } from "any";
export default var1 + fun2();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/crea<|fim_suffix|>"var1"]
}
}
});
<|fim_middle|>teTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: ["fun2", "var1"]
}
},
all: {
usedExports: ["default"],
expect: {
any: ["fun2", <|e... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fun1, fun2 } from "any";
export<|fim_suffix|> function() {
fun1();
}
<|fim_middle|> default<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}
},
default: {
usedExports: ["default"],
expect: {
any: ["fun1"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.<|fim_middle|>exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fun<|fim_suffix|>});
<|fim_middle|>1, fun2 } from "any";
export default (function() {
fun1();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> }
},
default: {
usedExports: ["default"],
expect: {
any: ["fun1"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/<|fim_middle|>createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ult fun3;
<|fim_prefix|>import<|fim_middle|> { fun1, fun2 } from "any";
function fun3() {
fun1();
}
export defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>"use strict";
const createTestCases = require("../_<|fim_middle|>helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
}
},
default: {
usedExports: ["default"],
expect: {
any: ["fun1"]
}
}
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fun1, fun2 } from "a<|fim_suffix|> fun1();
}
<|fim_middle|>ny";
export default function withName() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
expect: {
any: ["fun1"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
}
},
default: {
<|fim_middle|> usedExports: ["default"],<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fun1, fun2 } from "an<|fim_suffix|>fault (function withName() {
fun1();
});
<|fim_middle|>y";
export de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_<|fim_suffix|>ts: ["default"],
expect: {
any: ["fun1"]
}
}
});
<|fim_middle|>helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
}
},
default: {
usedExpor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> c();
y();
}
<|fim_prefix|>import { a, b, c } from "<|fim_middle|>./test";
export function x() {
a();
}
export function y() {
b();
eval("x()");
}
export function z() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"./test": []
}
},
nonEval: {
usedExports: ["x"],
expect: {
"./test": ["a"]
}
},
directEval: {
u<|fim_suffix|>ctEval: {
usedExp... | fim | webpack/webpack | javascript |
export { default } from "./components/Button";
export { default as ButtonGroup } from "./components/ButtonGroup";
export { themeNamespace } from "./theme";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"./components/<|fim_suffix|>: ["default", "ButtonGroup", "themeNamespace"],
expect: {
"./components/Button": ["default"],
"./components/B... | fim | webpack/webpack | javascript |
<|fim_suffix|>Component };
export function View_AppComponent_0(_l) { return i0.ɵvid(0, [(_l()(), i0.ɵeld(0, 0, null, null, 1, "h1", [], null, null, null, null, null)), (_l()(), i0.ɵted(-1, null, ["Hello World"]))], null, null); }
export function View_AppComponent_Host_0(_l) { return i0.ɵvid(0, [(_l()(), i0.ɵeld(0, 0, n... | fim | webpack/webpack | javascript |
"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"@angular/core": ["ɵccf", "ɵcrt", "ɵdid", "ɵeld", "ɵted", "ɵvid"],
"./app.component": ["AppComponent"]
}
},
AppComponentNgFactory: {
usedExports: ["Ap... | fim | webpack/webpack | javascript |
<|fim_suffix|>ss declaration: dropped when unused
export class PureClass {
method() {
classPureCall();
}
}
// impure class declaration (side effect in extends): always kept
export class ImpureClass extends classImpureCall() {}
// pure declarator: dropped when unused
export const usedPureConst = /*#__PURE__*/ pure... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
// impure top-level symbols stay; pure ones drop unless their export is used
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
dep: ["impureCall", <|fim_suffix|>},
usedPureConst: {
usedExports... | fim | webpack/webpack | javascript |
<|fim_suffix|>tValueAsNumber();
});
if (data.askSplitPos) {
elements.chbox.bindEvents();
}
if (data.askHowToCharge) {
elements.radio.bindEvents();
}
await dialog.open();
}
async function getSortDialog() {
let sortOrder = 1;
const NAME = "sortPosition";
const elements = {
radio: new UiElementRadio({
na... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"resize-observer": ["ResizeObserver"],
"Source_Data/employee": [],
"Source_Data/services": [],
"Source_Framework/splitview/page": [],
... | fim | webpack/webpack | javascript |
<|fim_suffix|>onad);
export const bind = /*#__PURE__*/ P.bindF(Monad);
const do_ = /*#__PURE__*/ P.doF(Monad);
export { do_ as do };
export { branch as if, branch_ as if_ };
export const struct = /*#__PURE__*/ P.structF(
/*#__PURE__*/ Object.assign(
/*#__PURE__*/ Object.assign({}, Monad),
Applicative
)
);
export ... | fim | webpack/webpack | javascript |
"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
"@effect-ts/tracing-utils": [],
"@effect-ts/system/Option": [
"extend",
"flatten",
"getLeft",
"getRight",
"isNone",
"map",
"map_... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { x, y } from "./dependency";
<|fim_suffix|>x();
// export const b = /*#__PURE__*/ y();
<|fim_middle|>
export { a };
const a = /*#__PURE__*/ <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
<|fim_suffix|>ts: ["a"],
expect: {
"./dependency": ["x"]
}
}
// b: {
// usedExports: ["b"],
// expect: {
// "./dependency": ["y"]
// }
// }
});
<|fim_middle|>
module.exports = createTestCases({
// nothing: {... | fim | webpack/webpack | javascript |
<|fim_suffix|>nction expression that closes over `y`.
// innerGraph only treats `y` as used when `callback` itself is referenced
// at top level — and the only reference is via `define(callback)`, which
// the buggy code also skipped.
const callback = function () {
return y;
};
function useY() {
define(callback);
}
... | fim | webpack/webpack | javascript |
<|fim_suffix|>: ["x"]
}
},
useY: {
usedExports: ["useY"],
expect: {
"./dependency": ["y"]
}
},
both: {
usedExports: ["useX", "useY"],
expect: {
"./dependency": ["x", "y"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCa<|fim_middle|>ses");
module.e... | fim | webpack/webpack | javascript |
<|fim_suffix|>s Error {},
cls3 = class {
constructor(t) {
if (!arr2.includes(t.version)) throw "invalid parquet version";
}
async *[Symbol.asyncIterator]() {
yield "";
}
};
var arr3 = C1;
var cls4 = class {
constructor() {}
},
cls5 = class {
constructor(t) {
if (!arr3.includes(t.version)) thro... | fim | webpack/webpack | javascript |
<|fim_suffix|>supportsClassFields");
module.exports = () => supportsClassFields();
<|fim_prefix|>"use strict";
const supportsClassFields = require("../../../helpe<|fim_middle|>rs/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
e<|fim_suffix|>A", "B", "C1", "C2"]
}
},
all: {
usedExports: ["cls1", "cls3", "cls5", "cls7", "cls9"],
expect: {
"./test": ["A", "B", "C1", "C2"]
... | fim | webpack/webpack | javascript |
<|fim_prefix|>const doSometh<|fim_suffix|> __( v ) {
doSomething( v );
}
export default {
__,
};
<|fim_middle|>ing = () => {};
export function<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>aration.id.type === "Identifier" && declaration.id.name === "__"
)
)
).toBe(true);
});
<|fim_prefix|>import i18n from "./i18n.js";
import { used } from "./wtf.js";
import { parse } from "acorn";
import fs from "fs";
const __ = i18n.__;
function xyz() {
used();
__("abc");
}
xyz();
it("Should ke... | fim | webpack/webpack | javascript |
"use strict";
const supportsRequireInModule = require("../../../helpers/supportsRequireInModule");
module.exports = () => supportsRequireInModule();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
target: "node14",
optimization: {
minimize: false,
mangleExports: false,
concatenateModules: false,
emitOnErrors: true
},
output: {
module: true
},
experiments: {
outp<|fim_suffix|>... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { __ } from './i18n.js';
export function unused() {
return __( "wtf" );
}
exp<|fim_suffix|>tion used() {
return __( "ok" );
}
<|fim_middle|>ort func<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { deepEqual, equal } fro<|fim_suffix|>ion fun2() {
fun1();
}
function fun3() {
fun2();
}
function notExport() {
fun3();
}
notExport();
<|fim_middle|>m "./assert";
function fun1() {
deepEqual(1, 1);
}
funct<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>,
expect: {
"./assert": ["deepEqual"]
}
}
});
<|fim_prefix|>"use strict";
const creat<|fim_middle|>eTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: []<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { deepEqual, equal } from "./assert";
function fun1() {
deepEqual(1, 1);
}
function fun2() {
fun1();
}
function fun3() {
fun2();
}
functi<|fim_suffix|>n4();
}
export function fun6() {
equal(1, 1);
}
<|fim_middle|>on fun4() {
fun3();
}
export function fun5() {
fu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_<|fim_suffix|>["equal"]
}
},
all: {
usedExports: ["fun5", "fun6"],
expect: {
"./assert": ["deepEqual", "equal"]
}
}
});
<|fim_middle|>helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
... | fim | webpack/webpack | javascript |
<|fim_suffix|>fnI(i);
export const callAll = /*#__PURE__*/ fnAll();
<|fim_prefix|>import { a, b, c, d, effect_e, effect_f, effect_g, effect_h, i } from "./inner";
/*#__NO_SIDE_EFFECTS__*/
function fnA(args) {
return args;
}
/*#__NO_SIDE_EFFECTS__*/
export function fnB(args) {
return args;
}
var fnC = /*#__NO_SIDE... | fim | webpack/webpack | javascript |
<|fim_suffix|>"b",
"c",
"d",
"effect_e",
"effect_f",
"effect_g",
"effect_h"
]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports <|fim_middle|>= createTestCases({
nothing: {
usedExports: [],
expect: {
"./inner": ["ef... | fim | webpack/webpack | javascript |
import pure from './pure'
export default () => {
pure()
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>1;
}
export default pure
<|fim_prefix|><|fim_middle|>function pure() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import common from "../common";
it("entry1 should compile and run", () => {
c<|fim_suffix|>();
expect(true).toBe(true)
});
<|fim_middle|>ommon<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("entry2 should compile and run", () =><|fim_suffix|>hunkName" */'../common').then(common => {
common.default();
expect(true).toBe(true)
})
});
<|fim_middle|> {
import(/* webpackChunkName: "chunk-reason-webpackC<|endoftext|> | fim | webpack/webpack | javascript |
export default 'a'
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function nothing() {}
it("entry3 should compile and run", <|fim_suffix|>
})
});
<|fim_middle|>() => {
import(/* webpackChunkName: "chunk-reason-webpackChunkName" */'./a.js').then(a => {
nothing(a.default);
expect(true).toBe(true)<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const findOutputFiles = require("../.<|fim_suffix|>turn files;
}
};
<|fim_middle|>./../helpers/findOutputFiles");
module.exports = {
findBundle(_, options) {
const files = findOutputFiles(options, /^entry/);
re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
target: ["node"],
entry: {
entry1: ["./entry1/index.js"],
entry2: ["./entry2/index.js"],
entry3: ["./entry3/index.js"]
},
output: {
file<|fim_suffix|>[name].js",
chunkFilename: "[name].chunk.js"
},
optimization: {
minimize: false,
runtimeChunk: true,
... | fim | webpack/webpack | javascript |
<|fim_suffix|>.0
* @category Logic
* @sig [(*... -> Boolean)] -> (*... -> Boolean)
* @param {Array} predicates An array of predicates to check
* @return {Function} The combined predicate
* @see R.anyPass
* @example
*
* var isQueen = R.propEq('rank', 'Q');
* var isSpade = R.propEq('suit', '♠︎');
* ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = create<|fim_suffix|> "./pluck": ["default"]
}
}
});
<|fim_middle|>TestCases({
nothing: {
usedExports: [],
expect: {
"./internal/_curry1": [],
"./curryN": [],
"./reduce": [],
"./max": [],
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, b, c } from "dep";
export const arr = [a, 1<|fim_suffix|> 2];
export const obj = { key: b };
export const inst = /*#__PURE__*/ new c();
<|fim_middle|>,<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
usedExports: ["inst"],
expect: {
dep: ["c"]
}
},
all: {
usedExports: ["arr", "obj", "inst"],
expect: {
dep: ["a", "b", "c"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases <|fim_middle|>= require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing:... | fim | webpack/webpack | javascript |
<|fim_suffix|>typeof d;
export const voided = void e;
export const eqStrict = f === undefined;
export const neStrict = g !== null;
export const tplPure = `wrap ${/*#__PURE__*/ h()}`;
<|fim_prefix|>import { a, b, c, d, e, f, g, h } from "dep";
export const chained = /*#__PURE__*/ a?.();
export<|fim_middle|> const tagge... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsOptionalChaining = require("../../../helpers/supp<|fim_suffix|>OptionalChaining");
module.exports = () => supportsOptionalChaining();
<|fim_middle|>orts<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
expect: {
dep: ["h"]
}
},
all: {
usedExports: [
"chained",
"tagged",
"negated",
"typed",
"voided",
"eqStrict",
"neStrict",
"tplPure"
],
expect: {
dep: ["a", "b", "c", "d", "e", "f", "g", "h"]
}
}
});
<|fim_prefix|>"use strict";
const createTestCases = require... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, b, c } from "dep";
// A PURE annotation attached to a preceding property's value must not leak
// into a lat<|fim_suffix|>b)`
// is treated as pure (because the comment before `Boolean(a)` falls into the
// scanned range) and the whole object is wrongly considered pure.
export const leak = {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
dep: ["a", "b", "c"]
}
},
leak: {
usedExports: ["leak"],<|fim_suffix|>["a", "b", "c"]
}
}
});
<|fim_middle|>
expect: {
dep: <|endof... | fim | webpack/webpack | javascript |
<|fim_suffix|>sedExportsOfPureSource.sort()).toEqual(
["impureExport", "usedExportsOfPureSource"].sort()
);
});
<|fim_prefix|>import pureDefault, {
pureFn,
pureArrow,
impureExport,
usedExportsOfPureSource
} from "./pure-source";
const usePureFn = pureFn(1);
const usePureArrow = pureArrow(1);
const usePureDefaul... | fim | webpack/webpack | javascript |
<|fim_prefix|>export function pureFn(x) {
return x;
}
export const pureArrow = (x) => {
return x;
};
export const impureExport = (x) => {
retur<|fim_suffix|> x;
};
<|fim_middle|>n x;
};
export const usedExportsOfPureSource = __webpack_exports_info__.usedExports;
export default (x) => {
return<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>zation: {
concatenateModules: false
}
},
{
...base,
name: "pure-functions-option with module concatenation"
}
];
<|fim_prefix|>"use strict";
const base = {
mode: "production",
module: {
rules: [
{
test: /pure-source\.js$/,
parser: {
pureFunctions: ["pureFn", "pureArrow", "... | fim | webpack/webpack | javascript |
import { im1, fn } from "any";
export const pureTpl = `${im1}`;
export const impureTpl = `${fn()}`;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>pers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: ["fn"]
}
},
pureTpl: {
usedExports: ["pureTpl"],
expect: {
any: ["fn", "im1"]
}
},
impureTpl: {
usedExports: ["impureTpl"],
expect: {
any: ["fn"]
}
}
});
<|fim_prefix|>"u... | fim | webpack/webpack | javascript |
<|fim_suffix|>e if its arguments are identical, false otherwise. Values are
* identical if they reference the same memory. `NaN` is identical to `NaN`;
* `0` and `-0` are not identical.
*
* @func
* @memberOf R
* @since v0.15.0
* @category Relation
* @sig a -> a -> Boolean
* @param {*} a
* @param {*} b
* @ret... | fim | webpack/webpack | javascript |
<|fim_suffix|>ateTestCases({
nothing: {
usedExports: [],
expect: {
"./internal/_curry2": []
}
},
all: {
usedExports: ["default"],
expect: {
"./internal/_curry2": ["default"]
}
}
});
<|fim_prefix|>"use strict";
<|fim_middle|>const createTestCases = require("../_helpers/createTestCases");
module.e... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { equal as eq, deepEqual } from "./assert";
function myFunction() {
function it() {
eq(1, arguments[0]);
}
deepEqual(1, 1);
it();
}
f<|fim_suffix|>al(1, 1);
}
export { myFunction as fun1, fun2 };
<|fim_middle|>unction fun2() {
deepEqu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"us<|fim_suffix|>{
usedExports: ["fun1"],
expect: {
"./assert": ["deepEqual", "equal"]
}
},
fun2: {
usedExports: ["fun2"],
expect: {
"./assert": ["deepEqual"]
}
},
all: {
usedExports: ["fun1", "fun2"],
expect: {
"./assert": ["deepEqual", "equal"]
}
}
});
<|fim_middle|>e str... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { im1, im2, im3 } from "any";
var exp1 = function() {
console.log(im1);
};
var exp2 = () => {
console.log(im2);
};
var exp3 = function() {
console.log(im3);
};
export var exp4 = () => {
exp2();
};
expo<|fim_suffix|>
<|fim_middle|>rt var expCls = class {
constructor() {
exp1();
}
};
ex... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const createTestCases = require("../_helpers/createTestCases");
module.exports = createTestCases({
nothing: {
usedExports: [],
expect: {
any: []
}
},
exp1: {
usedExports: ["exp1"],
expect: {
any: ["im1"]
}
},
exp2: {
usedExports: ["exp2"],
expect: {
any: ["im2... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { im1, im2, im3 } from "any";
var exp1 = function() {
console.log(im1);
};
var exp2 = () => {
console.log(im2);
exp1 = 3;
};
var exp3 = function() {
console.log(im3);
<|fim_suffix|>or() {
exp1();
}
};
export { exp1, exp2, exp3 };
<|fim_middle|>};
export var exp4 = () => {
exp2();
};
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>rts: ["exp1"],
expect: {
any: ["im1"]
}
},
exp2: {
usedExports: ["exp2"],
expect: {
any: ["im2"]
}
},
exp3: {
usedExports: ["exp3"],
expect: {
any: ["im3"]
}
},
exp4: {
usedExports: ["exp4"],
expect: {
any: ["im2"]
}
},
expCls: {
usedExports: ["expCls"],
expec... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.