text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>?1";
<|fim_prefix|>export * from "./missin<|fim_middle|>g1";
export * from "./a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "./a?2";
<|fim_prefix|>expor<|fim_middle|>t { a } from "./missing2";
export * from<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should error importModule when a cycle with 2 modules is req<|fim_suffix|>importModule when requesting itself", () => {
expect(require("./loader!./1/a")).toMatch(
/^err: There is a circular build dependency/
);
});
<|fim_middle|>uested", () => {
expect(require("./loader!./2/a")).toMatch(
/^sour... | fim | webpack/webpack | javascript |
<|fim_suffix|>N.stringify(`source: ${exports}`));
}
});
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
exports.default = function (source) {
const ref = JSON.parse(source);
const callback = this.async();
this.importModule("../loader!" + ref, {}, (err, exports) => {
if (err) {
callbac... | fim | webpack/webpack | javascript |
it("should error importModule when a cycle with 2 modules is requested", () => {
expect(require("./loader!./2/a")).toEqual([
["./b.json", [
["./a.json", "err: There is a circular build dependency, which makes it impossible to create this module"]
]]
]);
});
it("should error importModule when a cycle with 3 mod... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinitionFunction} */
exports.default = function (source) {
const content = JSON.parse(source);
// content is one reference or an array of references
const refs = Array.isArray(content) ? content : [content];
const callback = this.async();
const importReferenc... | fim | webpack/webpack | javascript |
<|fim_suffix|>d dependency/
);
});
<|fim_prefix|>it("should error loadModule when a cycle with 2 modules is requested", () => {
expect(require("./loader!./2/a")).toMatch(
/^source: err: There is a circular build dependency/
);
});
it("should error loadModule when a cycle with 3 modules is requested", () => {
expe... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
exports.default = function (source) {
const ref = JSON.parse(source);
const callback = this.async();
this.loadModule("../loader!" + ref, (err, source, so<|fim_suffix|>SON.stringify(`source: ${JSON.parse(/** @type {string} */ (source))}`));
}
});... | fim | webpack/webpack | javascript |
<|fim_suffix|>al([
["./b.json", [
["./c.json", []]
]],
["./b.json", [
["./c.json", []]
]]
]);
});
<|fim_prefix|>it("should error loadModule when a cycle with 2 modules is requested", () => {
expect(require("./loader!./2/a")).toEqual([
["./b.json", [
["./a.json", "err: There is a circular build depe... | fim | webpack/webpack | javascript |
<|fim_suffix|>Error} */ (_err);
loadedRefs.push([ref, `err: ${err && err.message}`]);
}
}
return loadedRefs;
}
loadReferencedModules().then((loadResults) => {
callback(null, JSON.stringify(loadResults));
});
};
<|fim_prefix|>const { promisify } = require(<|fim_middle|>"util");
/** @type {import("../..... | fim | webpack/webpack | javascript |
/** @type {import("../../../../types").LoaderDefinition} */
module.exports = function(source) {
const callback = this.async();
callback(new Error("err: abc"));
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should error loadModule when the referenced modu<|fim_suffix|>});
<|fim_middle|>le contains errors", () => {
expect(function() {
require("./loader!./a")
}).toThrow();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.exports = [
/^Pack got invalid because of write to: Compilation\/modules|json.+error-loader\.js!/
];
<|fim_prefix|>"use strict";
modul<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
exports.default = function (source) {
const callback = this.async();
const ref = JSON.parse(source);
this.loadModule("./error-loader!" + ref, (err, source, sourceMap, module) => {
if (err) {
callback(err);
} else {
callback(null, JSON.str... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../.<|fim_suffix|>ports = function (source) {
this.emitError(this.query.slice(1));
return source;
};
<|fim_middle|>./../../").LoaderDefinition<string>} */
module.ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
});
<|fim_prefix|>it("should emit the correct errors and warnings", function() {
require("./error-loader?ab<|fim_middle|>c!./a");
require("./error-loader?def!./a");
require("./warning-loader?xyz!./a");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("<|fim_suffix|>1));
return source;
};
<|fim_middle|>../../../../").LoaderDefinition<string>} */
module.exports = function (source) {
this.emitWarning(this.query.slice(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|><|fim_middle|>{};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it<|fim_suffix|>> {
await expect(import("./module.mjs")).rejects.toMatchObject({
code: "MODULE_NOT_FOUND"
});
});
<|fim_middle|>("should not resolve without extension", async () =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impor<|fim_suffix|><|fim_middle|>t "./dependency";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>ex<|fim_suffix|>{};
<|fim_middle|>port <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not resolve module requests relative<|fim_suffix|>c () => {
await expect(import("./module.mjs")).rejects.toMatchObject({
code: "MODULE_NOT_FOUND"
});
});
<|fim_middle|>", asyn<|endoftext|> | fim | webpack/webpack | javascript |
import "dependency.js";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default functi<|fim_suffix|>his;
};
<|fim_middle|>on dep() {
return t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> generate indirect call", () => {
expect(a()).toBeUndefined();
expect((a)()).toBeUndefined();
expect((a())).toBeUndefined();
expect(global).toBeUndefined();
});
<|fim_prefix|>import a from "./dep.js"
con<|fim_middle|>st global = a();
it("should<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export defa<|fim_suffix|>;
};
<|fim_middle|>ult function dep() {
return this<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function dep() {
<|fim_suffix|>rn this;
};
};
<|fim_middle|> return () => {
retu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import a from "./dep.js"
import b from "./dep1.js"
const global = a``;
it("should generate indirect call", () => {
expect(a``).toBeUndefine<|fim_suffix|>ct(b()``).toBeUndefined();
expect(global).toBeUndefined();
});
<|fim_middle|>d();
expect(a`${{a}}`).toBeUndefined();
expect((a)``).toBeUndefined();... | fim | webpack/webpack | javascript |
<|fim_suffix|>6Used).toBe(true);
}
});
<|fim_prefix|>import { o2, o3 } from "./module";
import {
exportUsed,
export2Used,
export3Used,
export4Used,
export5Used,
export6Used
} from "./inner";
it("some exports should be unused when no array expression use it", () => {
expect(o2[0]).toBe(42);
expect(o3[0].EXPOR... | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>export const EXPORT = 42;
export const EXPORT2 = 42;
export const EXPORT3 = 42;
export const EXPORT4 = 42;
export const EXPORT5 = () => 42;
export const EXPORT6 = () => 42;
export const exportUsed = __webpack_exports_info__.EXPORT.used;
export const export2Used = __webpack_exports_info__.E... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { EXPORT, EXPORT2, EXPORT3, EXPORT4, EXPORT5, EXPORT6 } from "./inner";
const o1 = [EXPORT2, EXPORT3<|fim_suffix|> }];
export { o1, o2, o3 };
<|fim_middle|>];
const o2 = [EXPORT4];
const o3 = [{ EXPORT5, EXPORT6<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>r";
<|fim_middle|>rt "./inne<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { exportAUsed, expo<|fim_suffix|>functions use it", () => {
expect(y("a")).toBe("okBAA");
expect(exportAUsed).toBe(true);
expect(exportBUsed).toBe(true);
if (process.env.NODE_ENV === "production") {
expect(exportCUsed).toBe(false);
}
return import("./chunk");
});
<|fim_middle|>rtBUsed, expo... | fim | webpack/webpack | javascript |
<|fim_suffix|>onst exportBUsed = __webpack_exports_info__.B.used;
export const exportCUsed = __webpack_exports_info__.C.used;
<|fim_prefix|>export function A(s) {
return s + "A<|fim_middle|>";
}
export function B(s) {
return s + "B";
}
export function C(s) {
return s + "C";
}
export const exportAUsed = __webpack_ex... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { A, B, C } from "./inner";
function x(type) {
switch (type) {
case "a":
return withA("b");
case "b":
return withB("c");
case "c":
return "ok";
}
}
function y(v) {
return withA(v);
}
function withA(v) {
const value = x(v);<|fim_suffix|>v);
return B(value);
}
function withC(... | fim | webpack/webpack | javascript |
<|fim_suffix|>> {
expect(x()).toEqual([y, z]);
const [_a, b, c, d] = a();
expect(b()).toEqual([a, b, c, d]);
expect(c()).toEqual([a, b, c, d]);
expect(d()).toEqual([a, b, c, d]);
const [f2, f4] = f3();
const [f1, _f3] = f2();
expect(_f3).toBe(f3);
expect(f3()).toEqual(f1());
expect(f2()).toEqual(f4());
});
<|... | fim | webpack/webpack | javascript |
function x() {
return [y, z];
}
function y() {
return [x, z];
}
function z() {
return [x, y];
}
export { x, y, z };
function a() {
return [a, b, c, d];
}
function b() {
return [a, b, c, d];
}
function c() {
return [a, b, c, d];
}
function d() {
return [a, b, c, d];
}
export { a };
function f1() {
retur... | fim | webpack/webpack | javascript |
it("should not throw when using dynamic properties in unused classes", () => {
require("./unused1");
});
it("should not throw when using dynamic properties in used classes", () => {
const exports = require("./used1");
const x = new exports.Used();
expect(x.a()).toBe("A");
expect(x.b).toBe("B");
expect(x.c).toBe(... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const a = () => "a";
export const A = "<|fim_suffix|>
<|fim_middle|>A";
export const b = "b";
export const B = "B";
export const c = "c";
export const C = "C";
export const d = () => "d";
export const D = "D";
export const e = "e";
export const E = "E";
export const f = "f";
export const F = "F";
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>../helpers/supportsClassFields");
module.exports = () => supportsClassFields();
<|fim_prefix|>"use strict";
const <|fim_middle|>supportsClassFields = require("../../<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, b, c, d, e, f, A, B, C, D, E, F, X } from "./modu<|fim_suffix|>tatic get [f]() {
return F;
}
}
export {};
<|fim_middle|>le";
class Unused {
[a()]() {
return A;
}
[b] = B;
get [c]() {
return C;
}
static [d()]() {
return D;
}
static [e] = E;
static get [f]() {
return F;
}
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, b, c, d, e, f, A, B, C, D, E, F, X } from "./module?1";
class Used {
[a()]() {
return A;
}
[b] = B;
get [c]() {
return C;
}
static [d()]() {
return D;
}
static [e] = E;
static get [f]() {
return F;
}
}
class Used2 extends X {
<|fim_suffix|>ic get [f]() {
return F;
}
}
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {<|fim_suffix|>unction abc() {
return x;
}
<|fim_middle|> x } from "./dep?a";
export default f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>i<|fim_suffix|><|fim_middle|>mport { x } from "./dep?b";
export default function abc() {
return x;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
abc();
<|fim_prefix|>import { x } from "./dep?<|fim_middle|>c";
export default function abc() {
return x;
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>hod() {
return x;
}
}
<|fim_prefix|>import { x }<|fim_middle|> from "./dep?d";
export default class def {
met<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const x = "x";
export default __webpa<|fim_suffix|>_info__.x.used;
<|fim_middle|>ck_exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> x;
}
}
<|fim_prefix|>import { x } from "./dep?e";
export default class def {
method() {
re<|fim_middle|>turn<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>new def().method();
<|fim_prefix|>import { x } from "./dep?f";
export default class def {<|fim_middle|>
method() {
return x;
}
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>om "./dep?f";
it("should generate valid code", () => {
expect(A()).toBe("x");
expect(new D().method()).toBe("x");
});
it("a should be used", () => {
expect(a).toBe(true);
});
if (process.env.NODE_ENV === "production") {
it("b should be unused", () => {
expect(b).toBe(false);
});
}
it("c should ... | fim | webpack/webpack | javascript |
<|fim_suffix|>);
}
}
<|fim_prefix|>import B from "./b.js";
i<|fim_middle|>mport { A1 } from "./dep1";
export default class A extends B {
constructor() {
super();
}
test() {
super.test();
this.b = new B();
this.a1 = new A1(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import A from "./a.js";
import { A1 } from "./dep1";
export default class B {
<|fim_suffix|>this.a2 = new A1();
}
}
<|fim_middle|> constructor() {}
test() {
this.a = new A();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>export class ExtendedError3 extends BaseError3 {}
export class ExtendedError4 extends Error {
constructor(message = 'ExtendedError') {
super(message);
}
}
<|fim_prefix|>import { BaseError, BaseError1, BaseError2, BaseError3 } from "./dep2";
export class ExtendedError extends BaseError {
constructor(... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { A, B, Z, W } from "./dep2";
export const A1 = <|fim_suffix|>port class E {}
class D {
foo() {
class B2 extends B {}
return B2;
}
}
export const isZ = (new Z1()) instanceof Z;
export { W };
<|fim_middle|>class A1 extends A {
render() {return new E();}
};
class B1 extends B {
render() {... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const A = class A {};
export class B {}
export class C {}
export class Y {}
export class Z {}
export function mixin1(_class) {return _class}
export function mixin2(_class) {return _class}
export function mixin3(_class) {return _class}
export function mixin4(_class) {return _class}
export function m... | fim | webpack/webpack | javascript |
<|fim_suffix|>#__PURE__*/ getField()] = 12;
}
export class E {}
const D = class D {};
<|fim_prefix|>import {mixin1, mixin2, mixin3, getField, A, B, C, Y, mixin4} from "./dep2";
export const A1 = class A1 extends A {
render() {return new E();}
};
export const B1 = class B1 extends /*#__PURE__*/ mixin1(B<|fim_middle|... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
exportsInfoForA,
exportsInfoForB,
exportsInfoForC,
exportsInfoForY,
exportsInfoForZ,
exportsInfoForW,
exportsInfoForJ,
exportsInfoForK,
exportsInfoForMixin1,
exportsInfoForMixin2,
exportsInfoForMixin3,
exportsInfoForMixin4,
exportsInfoForMixin5,
exportsInfoForBaseError,
exportsInfo... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {A1} from "./dep1";
ex<|fim_suffix|> A1();
<|fim_middle|>port default new<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>();
<|fim_middle|>import {A1} from "./dep3";
export default new A1<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t a = new A();
a.test();
<|fim_prefix|>import A from "./a.<|fim_middle|>js";
le<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>4()
<|fim_prefix|>import {ExtendedError4} from "./c.js";<|fim_middle|>
export default new ExtendedError<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { W } from "./d<|fim_suffix|>lass BaseW extends W {}
<|fim_middle|>ep2";
c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { J } from "./dep2";
class BaseJ extends J {}
class BaseBaseJ extend<|fim_suffix|>J {}
<|fim_middle|>s Base<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { K } from "./dep2";
class <|fim_suffix|>w BaseBaseK();
<|fim_middle|>BaseK extends K {}
class BaseBaseK extends BaseK {}
export default ne<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { mixin5 } from "./dep2";
class Bar extends /*#__PURE<|fim_suffix|>ull) {
static displayName = "Point";
}
function test() {
return Bar.displayName;
}
<|fim_middle|>__*/ mixin5(n<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>) {
super();
}
},
unusedVariable = new UnusedClass();
<|fim_prefix|>import { SuperClass } from "./dep2";
var UnusedClass = class extends <|fim_middle|>SuperClass {
constructor(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsClassStaticBlock = req<|fim_suffix|>sClassStaticBlock();
<|fim_middle|>uire("../../../helpers/supportsClassStaticBlock");
module.exports = () => support<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { A, B, getC, getD, getE, getF, Foo, Pure, DateFormatter, ConditionalExpression, LogicalExpression } from "./dep2?decl";
import { A3, B3, C3, D3, E3, F3, Pure3, ConditionalExpression3, LogicalExpression3 } from "./dep3?decl";
export class A1 extends A {
render() {
return new A2();
}
}
export ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {A, B, DateFormatter, getC, getD, getE, getF, Pure, ConditionalExpression, LogicalExpression} from "./dep2?expr";
import { A3, B3, C3, D3, E3, F3, Pure3} from "./dep3?expr";
export const A1 = class extends A {
render() {
return new A2();
}
};
export const B1 = class extends B {
render() {
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ortsInfoForDateFormatter = __webpack_exports_info__.DateFormatter.used;
export const exportsInfoForConditionalExpression = __webpack_exports_info__.ConditionalExpression.used;
export const exportsInfoForLogicalExpression = __webpack_exports_info__.LogicalExpression.used;
<|fim_prefix|>export class A {}
ex... | fim | webpack/webpack | javascript |
<|fim_prefix|>export class A3 {}
export class B3 {}
export class C3 {}
export class D3 {}
export class E3 {}
expo<|fim_suffix|>extends (true ? A3 : B3) {}
export class LogicalExpression3 extends (A3 || B3) {}
<|fim_middle|>rt class F3 {}
export class Pure3 {}
export class ConditionalExpression3 <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
exportsInfoForA as declA,
exportsInfoForB as declB,
exportsInfoForC as declC,
exportsInfoForD as declD,
exportsInfoForE as declE,
exportsInfoForF as declF,
exportsInfoForFoo as declFoo,
exportsInfoForPure as declPure,
exportsInf<|fim_suffix|>ormatter).toBe(true);
});
<|fim_middle|>oForDa... | fim | webpack/webpack | javascript |
<|fim_prefix|>impor<|fim_suffix|>/dep-decl";
export default [new A1().render(), new C1().render(), new E1().render(), new DateBar()];
<|fim_middle|>t { A1, C1, E1, DateBar } from ".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>i<|fim_suffix|>).render(), new E1().render(), new DateBar()];
<|fim_middle|>mport { A1, C1, E1, DateBar } from "./dep-expr";
export default [new A1().render(), new C1(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sStaticBlock();
<|fim_prefix|>"use strict";
const supportsClassStaticBlock = require("../../../helpers/suppor<|fim_middle|>tsClassStaticBlock");
module.exports = () => supportsClas<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ire("./module");
});
<|fim_prefix|>it("should be able to load package without side effects wh<|fim_middle|>ere modules are unused", () => {
requ<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a <|fim_suffix|> from "./package";
export default a;
<|fim_middle|>}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from<|fim_suffix|>t function a() {
return 42;
}
export function b() {
return value;
}
<|fim_middle|> "./unusedModule";
expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>export d<|fim_middle|>efault 42;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>se);
expect(export3Used).toBe(false);
expect(export4Used).toBe(true);
expect(export5Used).toBe(true);
expect(export6Used).toBe(true);
}
});
<|fim_prefix|>import { o2, o3 } from "./module";
import {
exportUsed,
export2Used,
export3Used,
export4Used,
export5Used,
export6Used
} from "./inner"... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const EXPORT = 42;
export const EXPORT2 = 42;
export const EX<|fim_suffix|>webpack_exports_info__.EXPORT4.used;
export const export5Used = __webpack_exports_info__.EXPORT5.used;
export const export6Used = __webpack_exports_info__.EXPORT6.used;
<|fim_middle|>PORT3 = 42;
export const EXPORT4 = 42;
ex... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { EXPORT, EXPORT2, EXPORT3, EXPORT4, EXPORT5, EXPORT6 } from "./inner";
con<|fim_suffix|>EXPORT5,
EXPORT6: EXPORT6
};
export { o1, o2, o3 };
<|fim_middle|>st o1 = {
EXPORT2: EXPORT2,
EXPORT3: EXPORT3
};
const o2 = {
EXPORT4: EXPORT4
};
const o3 = {
EXPORT5: <|endoftext|> | fim | webpack/webpack | javascript |
import "./module?1";
import { getX, getY } from "./module?2";
import { getX as getX2 } from "./module?3";
import { getY as getY2 } from "./module?4";
export function test() {
expect(getX()).toBe(42);
expect(getY()).toBe(42);
expect(getX2()).toBe(42);
expect(getY2()).toBe(42);
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ld generate correct code when pure expressions are in dead branches", () => {
require("./import-module").test();
});
<|fim_prefix|>it("s<|fim_middle|>hou<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function f() {
return 43;
}
if (true) {
var x <|fim_suffix|>();
var y = 43;
}
export const getX = () => x,
getY = () => y;
<|fim_middle|>= /*#__PURE__*/ f() - 1;
var y = 42;
} else {
var x = /*#__PURE__*/ f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>should be unused", () => {
expect(export1).toBe(false);
expect(export2).toBe(false);
});
}
it("default export should be used", () => {
expect(export3).toBe(true);
});
<|fim_prefix|>import { exportDefaultUsed as export1 } from "./package1/script";
import { exportDefaultUsed as export2 } from "./pack... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as script from "./package1/script"
import script1 fro<|fim_suffix|>ript1;
<|fim_middle|>m "./package2/script";
export const mod = sc<|endoftext|> | fim | webpack/webpack | javascript |
import mod from "./script1";
export default mod;
export * from "./script1";
export const exportDefaultUsed = __webpack_exports_info__.default.used;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>expo<|fim_suffix|>"
export default 1
<|fim_middle|>rt * from "./script2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import mod from "./script3";
export de<|fim_suffix|>rtDefaultUsed = __webpack_exports_info__.default.used;
<|fim_middle|>fault function () { return mod };
export * from "./script3";
export const expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>export default<|fim_middle|> 1
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import <|fim_suffix|>ck_exports_info__.default.used;
<|fim_middle|>mod from "./script1";
export default mod;
export * from "./script1";
export const exportDefaultUsed = __webpa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>t default 1
<|fim_middle|>or<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|><|fim_middle|>import "./inner";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>hould be unused when only unused functions use it", () => {
f1();
expect(pureUsed).toBe(42);
expect(fWithDefault()).toBe(42);
if (process.env.NODE_ENV === "production") {
expect(exportUsed).toBe(false);
expect(export2Used).toBe(true);
expect(export3Used).toBe(true);
expect(export4Used).toBe(tr... | fim | webpack/webpack | javascript |
<|fim_suffix|> 42;
export const EXPORT3 = 42;
export const EXPORT4 = 42;
export const EXPORT5 = () => 42;
export const EXPORT6 = () => 42;
export const exportUsed = __webpack_exports_info__.EXPORT.used;
export const export2Used = __webpack_exports_info__.EXPORT2.used;
export const export3Used = __webpack_exports_info_... | fim | webpack/webpack | javascript |
<|fim_suffix|>
export function fWithDefault(r = EXPORT4) {
return r;
}
export default (function () {
return EXPORT;
});
<|fim_prefix|>import { EXPORT, EXPORT2, EXPORT3, EXPORT4, EXPORT5, EXPORT6 } from "./inner";
export function f1() {
// no using EXPORT
}
export function f2() {
return EXPORT;
}
function f3() ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./other/module-unuse<|fim_suffix|>import "./other/module-used";
<|fim_middle|>d";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./module-unus<|fim_suffix|>tiveClass.f()).toBe(42);
expect(TranspiledClass.f()).toBe(42);
}
<|fim_middle|>ed";
import { NativeClass, TranspiledClass } from "./module-used";
export function test() {
expect(Na<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should genera<|fim_suffix|>;
});
<|fim_middle|>te correct code when pure expressions are in dead branches", () => {
require("./import-module").test();
return import("./chunk")<|endoftext|> | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.