text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>rue
}
}
}
},
entry: {
a: "./1",
b: "./2",
c: "./3"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../")<|fim_middle|>.Configuration} */
module.exports = {
output: {
filename: "[name].js"
},
target: "node",
optimization: {
chunkIds: "named",
splitChunks: {
chun... | fim | webpack/webpack | javascript |
<|fim_prefix|>// `export { const as default }` is immutable -> eligible for value binding
const con<|fim_suffix|>xport { constDefault as default };
<|fim_middle|>stDefault = "const-default";
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ort { aliased as "string-alias" };
<|fim_prefix|>export const literal = "literal";
const local = "local";
export { local as renamed };
const source = { destructured: "destructured" };<|fim_middle|>
export const { destructured } = source;
export const [arrayValue] = ["array"];
const aliased = "aliased"... | fim | webpack/webpack | javascript |
import { readFromB } from "./cycle-b";
export const cyclicConst = "cyclic";
export function readViaB() {
return readFromB();
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>./cycle-a";
export function readFromB() {
return cyclicConst;
}
<|fim_prefix|>import { cyclicCons<|fim_middle|>t } from "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e binding (unlike `export default <expr>`)
let mutableDefault = 0;
export function bumpDefault() {
mutableDefault++;
}
export { mutableDefault as default };
<|fim_prefix|>// `export { x as d<|fim_middle|>efault }` is a liv<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>42;
<|fim_prefix|>exp<|fim_middle|>ort default <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default <|fim_suffix|>unction() { return "default-anon"; }
<|fim_middle|>f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default<|fim_suffix|>; }
<|fim_middle|> function fn() { return "default-fn"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export function fn() {
return "fn";
}
<|fim_suffix|>nction fn2() {
return "fn2";
}
<|fim_middle|>
export fu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>riptor, "value")).toBe(false);
}
// === Direct exports ===
it("should bind const exports as readonly values (non-circular)", () => {
expectValueDescriptor(constExports, "literal");
expect(constExports.literal).toBe("literal");
expectValueDescriptor(constExports, "renamed");
expect(constExports.renam... | fim | webpack/webpack | javascript |
<|fim_prefix|>export let counter = 0;
export functi<|fim_suffix|>ounter++;
}
<|fim_middle|>on increment() {
c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// Various mutation forms on exported `let` must all stay observable as live bindings
export let viaAssign = 1;
export let viaCompound = 1;
export let viaUpdate = 1;
export fun<|fim_suffix|>() {
viaAssign = 10;
viaCompound += 5;
viaUpdate++;
}
<|fim_middle|>ction mutateAll<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// Re-export chain<|fim_suffix|>exports.js
export { literal as chainedLiteral } from "./reexport";
// A mutable binding re-exported through two hops must stay live
export { counter as chainedCounter, increment as chainedIncrement } from "./reexport";
<|fim_middle|>: this file re-exports from reexport.js w... | fim | webpack/webpack | javascript |
<|fim_suffix|> should use getter
export { cyclicConst as reCircular } from "./cycle-a";
<|fim_prefix|>// Re-ex<|fim_middle|>port from a circular module —<|endoftext|> | fim | webpack/webpack | javascript |
// Mixed: direct const export + re-exports in the same module
export const ownConst = "own";
export { literal as reConst } from "./const-exports";
export { fn as reFn } from "./function-exports";
export { counter as reCounter, increment as reIncrement } from "./mutable-exports";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// Star<|fim_suffix|> export should prevent value binding
export { literal as namedConst } from "./const-exports";
export * from "./function-exports";
<|fim_middle|> export mixed with named re-export — star<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export { literal, renamed, destructured, arrayValue } from "./const-exports";
export { fn } from "./function-exports";
export { count<|fim_suffix|>orts";
<|fim_middle|>er, increment } from "./mutable-exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nst;
}
<|fim_prefix|>// Self-cycle:<|fim_middle|> const must fall back to a getter so reading via the namespace works
import * as self from "./self-const";
export const selfConst = "self";
export function readSelf() {
return self.selfCo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ing must stay live
export * from "./mutable-exports";
<|fim_prefix|>// `export *` of a mut<|fim_middle|>able bind<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stric<|fim_suffix|>,
usedExports: false
}
};
<|fim_middle|>t";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
optimization: {
concatenateModules: false,
mangleExports: false<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>module.exports =<|fim_middle|> "a"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports<|fim_suffix|><|fim_middle|> = "b";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s = "c";
<|fim_prefix|>modul<|fim_middle|>e.export<|endoftext|> | fim | webpack/webpack | javascript |
const a = require("./a");
const b = require("./b");
const expectModuleIdInSource = (source, id) => {
expect(source).toMatch(new RegExp("/\\*\\*\\*/ " + id + "\\n"));
};
it("should sync module ids across compilers", () => {
expect(a + b).toBe("ab");
const fs = __non_webpack_require__("fs");
const path = __non_web... | fim | webpack/webpack | javascript |
<|fim_suffix|>b).toBe("ab");
});
}
<|fim_prefix|>const<|fim_middle|> a = require("./a");
const b = require("./b");
const expectModuleIdInSource = (source, id) => {
expect(source).toMatch(new RegExp("/\\*\\*\\*/ " + id + "\\n"));
};
if (__STATS_I__ === 3) {
it("should merge module ids with existing records", () => ... | fim | webpack/webpack | javascript |
<|fim_prefix|>const a = require("./a");
const expectModuleIdInSource = (source, id) => {
expect(source).toMatch(new RegExp("/\\*\\*\\*/ " + id + "\\n"));
};
if (__STATS_I__ === 5) {
it("should update module ids<|fim_suffix|>.readFileSync(
path.join(__dirname, "bundle" + __STATS_I__ + ".js"),
"utf-8"
);
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>th,
mode: "update"
})
]
}
];
};
<|fim_prefix|>"use strict";
const path = require("path");
const webpack = require("../../../../");
/** @type {(env: Env, options: TestOptions) => import("../../../../").Configuration[]} */
module.exports = (env, { testPath }) => {
const readIdsPath = path.... | fim | webpack/webpack | javascript |
export default function () {}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>pect(link.href).toBe("https://test.cases/path/chunk1.css");
expect(link.rel).toBe("stylesheet");
expect(link.getAttribute("charset")).toBeUndefined();
const script = document.head._children[document.head._children.length - 1];
__non_webpack_require__("./chunk1.js");
script.onload();
expect(script... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = scope.window.document.createEl<|fim_suffix|>d(link);
}
};
<|fim_middle|>ement("link");
link.rel = "stylesheet";
link.href = "chunk1.css";
scope.window.document.head.appendChil<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
target: "web",
output: {
chunkFilename: "[name].js",
charset: false
},
performance: {
hints: false
},
experiments: {
css: true
},
optimization: {
chunkIds: "named",
minimize: false
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{
expect(true).toBe(true)
});
<|fim_prefix|>it("should compile an<|fim_middle|>d run", () => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use<|fim_suffix|>.mjs"];
}
};
<|fim_middle|> strict";
module.exports = {
findBundle() {
return ["runtime.mjs", "main<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use st<|fim_suffix|>ments: {
outputModule: true
}
};
<|fim_middle|>rict";
module.exports = {
mode: "production",
entry: {
main: "./index.js"
},
optimization: {
runtimeChunk: "single"
},
output: {
filename: "[name].mjs",
module: true,
chunkFormat: "module"
},
experi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>let for module cache binding
expect(content).toMatch(/\blet\s+__webpack_module_cache__\s*=/);
expect(content).not.toMatch(/\bconst\s+__webpack_module_cache__\s*=/);
} else if (/bundle2\.js$/.test(__filename)) {
// neither supported -> fall back to var
expect(content).toMatch(/\bvar\s+__webpack_mo... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
mode: "production",
output: {
environment: {
const: true,
let: true
}
},
optimization: { minimize: false }
},
{
mode: "production",
output: {
environment: {
const: false,
let: ... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should output correctl<|fim_suffix|>
done();
});
<|fim_middle|>y with a function for output.filename", (done) => {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should output correctly with a function for output.fi<|fim_suffix|> done();
});
<|fim_middle|>lename", (done) => {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
<|fim_suffix|>"./b.js"];
}
};
<|fim_middle|> return ["./a.js", <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Chunk} Chunk */
/** @type {import("../../../../").Configuration} *<|fim_suffix|>name === "a"
? `${/** @type {Chunk} */ (data.chunk).name}.js`
: "[name].js"
}
};
<|fim_middle|>/
module.exports = {
entry() {
return {
a: "./a",
b: "./b"
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import mod from "./module.js";
it("should work", () => {
expect(mod(1, 2)).toBe(3);
expe<|fim_suffix|>ngth(25);
});
<|fim_middle|>ct(__STATS__.hash).toHaveLe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>export default function sum(a, b) {
<|fim_middle|> return a + b;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { createHash } = require("crypto");
/** @typedef {import("crypto").Encoding} Encoding */
/** @typedef {import("crypto").BinaryToTextEncoding} BinaryToTextEncoding */
class SHA256Hash {
constructor() {
this._hash = createHash("sha256");
}
/**
* Update hash {@<|fim_suffix|>/**... | fim | webpack/webpack | javascript |
export const url = import.meta.url;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("http://test.co/path/index.js");
});
it("should evaluate import.meta in runtime", () => {
expect(url).toBe(import.meta.url);
});
<|fim_prefix|>import { url } from "./a";
it("shou<|fim_middle|>ld evaluate import.meta to pseudoImport.meta", () => {
expect(url).toBe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Scope(scope) {
scope.pseudoImport = { meta: { url: "http://test.co/path/index.js" } };
}
};
<|fim_prefix|>"use strict";
module.exports = {
mo<|fim_middle|>dule<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use str<|fim_suffix|> "pseudoImport.meta"
},
module: {
parser: {
javascript: {
importMeta: false
}
}
}
};
<|fim_middle|>ict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
importMetaName:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import dummy from "dummy_module";
it("shoul<|fim_suffix|>");
return import("./inner-dir/b").then(importedModule => {
expect(importedModule.dummy()).toBe("this is just a dummy function");
});
});
<|fim_middle|>d load", () => {
expect(dummy()).toBe("this is just a dummy function<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import dummy from "dummy_module";
it("should load", () => {
expect(dummy()).toBe("thi<|fim_suffix|>e("this is just a dummy function");
});
});
export { dummy };
<|fim_middle|>s is just a dummy function");
return import("./some-module").then(importedModule => {
expect(importedModule.dummy()).toB<|en... | fim | webpack/webpack | javascript |
<|fim_suffix|>ort { dummy };
<|fim_prefix|>impo<|fim_middle|>rt dummy from "dummy_module";
exp<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./a.js", "./inner-dir/b.js", "./inner-dir/deep/deep/c.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "none",
entry: {
a: "./a?1",
"inner-dir/b": "./inner-dir/b",
"inner-dir/deep<|fim_suffix|> },
target: "node",
output: {
libraryTarget: "commonjs2",
pathinfo: true,
filename: "[name].js",
chunkFile... | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset from "./asset.jpg";
it("should define public p<|fim_suffix|>});
<|fim_middle|>ath", () => {
expect(asset).toBe("asset.jpg");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Config<|fim_suffix|>e: "[name][ext]"
},
module: {
rules: [
{
test: /\.jpg$/,
type: "asset/resource"
}
]
}
};
<|fim_middle|>uration} */
module.exports = {
mode: "none",
target: "node",
output: {
assetModuleFilenam<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset from "./asset.jpg";
it("should define public path", () => {
expect(asse<|fim_suffix|>o/path/asset.jpg");
});
<|fim_middle|>t).toBe("http://test.c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle()<|fim_suffix|>a: { url: "http://test.co/path/index.js" } };
}
};
<|fim_middle|> {
return ["./index.mjs"];
},
moduleScope(scope) {
scope.pseudoImport = { met<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t: /\.jpg$/,
type: "asset/resource"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.expor<|fim_middle|>ts = {
mode: "none",
target: "electron-renderer",
output: {
assetModuleFilename: "[name][ext]",
importMetaName: "pseudoImport.meta",
sc... | fim | webpack/webpack | javascript |
import asset from "./asset.jpg";
it("should define public path", () => {
expect(asset).toBe("https://test.cases/path/inner1/inner2/../../asset.jpg");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset from "./asset.jpg";<|fim_suffix|>.cases/path/asset.jpg");
});
<|fim_middle|>
it("should define public path", () => {
expect(asset).toBe("https://test<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset from "./asset.jpg";
it("should define public path", () => {
expect(asset).toBe("/other/inner1/inne<|fim_suffix|>;
});
<|fim_middle|>r2/../../asset.jpg")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset fro<|fim_suffix|>ct(asset).toBe("/other/asset.jpg");
});
<|fim_middle|>m "./asset.jpg";
it("should define public path", () => {
expe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.export<|fim_suffix|>r2/a.js", "./b.js"];
}
};
<|fim_middle|>s = {
findBundle() {
return ["./inner1/inne<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Chunk} Chunk */
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "none",
target: "web",
entry() {
return {
a: "./a",
b: "./b",
c: {
import: "./c",
publicPath: "/other/"
},
d: {
import: "./d",
... | fim | webpack/webpack | javascript |
<|fim_suffix|>(done) => {
done();
});
<|fim_prefix|>it("should output correctly with a s<|fim_middle|>tring for output.filename", <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return <|fim_suffix|>/a.js"];
}
};
<|fim_middle|>[".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{
filename: "[name].js"
}
};
<|fim_prefix|>"use strict";
<|fim_middle|>/** @type {import("../../../../").Configuration} */
module.exports = {
entry() {
return {
a: "./a"
};
},
output: <|endoftext|> | fim | webpack/webpack | javascript |
export default 42;
<|endoftext|> | fim | webpack/webpack | javascript |
it("should resolve [uniqueName] and [uniquename] in the filename template", () => {
expect(
__STATS__.assets.some((asset) => asset.name === "my-app-my-app-main.js")
).toBe(true);
});
it("should resolve [uniquename] in the publicPath template", () => {
expect(__webpack_public_path__).toBe("/my-app/");
});
it("sho... | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./my-app-my-app-main.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sset/resource"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.expor<|fim_middle|>ts = {
output: {
uniqueName: "my-app",
filename: "[uniqueName]-[uniquename]-[name].js",
chunkFilename: "[uniquename].[name].chunk.js",
assetModuleFilename: "[un... | fim | webpack/webpack | javascript |
<|fim_suffix|> path = require("path");
var source = fs.readFileSync(path.join(__dirname, "main.js"), "utf-8");
expect(source).toMatch("workerPublicPath2");
await worker.terminate()
});
<|fim_prefix|>import { Wor<|fim_middle|>ker } from "worker_threads";
it("should define public path", async () => {
const worker =... | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./main.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsWorker = require("../../../helpers/supportsWorker");
mod<|fim_suffix|>e.exports = () => supportsWorker();
<|fim_middle|>ul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "none",
target: "node",
no<|fim_suffix|>irname: false,
__filename: false
},
output: {
filename: "[name].js",
workerPublicPath: "/workerPublicPath2/"
}
};
<|fim_middle|>de: {
__d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>tr.toUpperCase();
}
onmessage = async event => {
postMessage(`data: ${upper(event.data)}, thanks`);
};
<|fim_prefix|>function <|fim_middle|>upper(str) {
return s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|>ault function test() {
return 1;
}
<|fim_middle|>def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ule.js"
const modules = await import("./dir/" + module);
expect(modules).toBeDefined();
});
<|fim_prefix|>import * as mod from "./module.js";
import * as style from "./style.css";
import * as text1 from "./text-with-bom.txt";
import * as text2 from "./test-without-bom.text";
it("should remove BOM", as... | fim | webpack/webpack | javascript |
<|fim_suffix|>return `module.exports = ${JSON.stringify(content)}`;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = functi<|fim_middle|>on loader(content) {
<|endoftext|> | fim | webpack/webpack | javascript |
export default function test() {
return 1;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const fs = require("fs");
const path = require("path");
module.exports = {
findBundle() {
return ["dir_module_js.bundle0.js", "bundle0.js"];
},
afterExecute(options) {
const outputPath = options.output.path;
const files = fs.readdirSync(outputPath);
for (const file of files) {
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ization: {
chunkIds: "named"
},
module: {
rules: [
{
test: /\.txt$/,
loader: require.resolve("./loader")
},
{
test: /\.text$/,
type: "asset/source"
}
]
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */... | fim | webpack/webpack | javascript |
it("should automatically create contexts", function() {
var template = "tmpl", templateFull = "./tmpl.js";
expect(require("../../../cases/parsing/context/templates/templateLoader")(templateFull)).toBe("test template");
expect(require("../../../cases/parsing/context/templates/templateLoaderIndirect")(templateFull)).t... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict"<|fim_suffix|>le\.txt/
];
<|fim_middle|>;
module.exports = [
/^Pack got invalid because of write to: Compilation\/modules|.+dump-fi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> /^\.\//,
exprContextCritical: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {<|fim_middle|>
unknownContextRegExp: /^\.\//,
unknownContextCritical: false,
exprContextRegExp:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>m1";
<|fim_prefix|>it("Should eliminate hoisted function in ESM because of default strict mode", () => {
expect(() => {
fnDecl;
}).toThrow();
try {
throw new Error();
} catch (e) {
return;
}
{
function fnDecl() {
expe<|fim_middle|>ct(true).toBe(true);
}
}
expect(true).toBe(false);
});... | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>t "esm2";
<|fim_middle|>ort defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>tion funcDecl() {}
expect(true).toBe(false);
}
});
if (true) {
return;
}
// We won't terminate in top level scope although it won't run.
require("./esm2");
<|fim_prefix|>const esm1 = require("./esm1");
expect(esm1.default).toBe("esm1");
it("Shouldn't eliminate hoisted function in current block scope... | fim | webpack/webpack | javascript |
<|fim_suffix|>rn ["test.js", "bundle0.js"];
}
};
<|fim_prefix|>"use strict";
module.e<|fim_middle|>xports = {
findBundle() {
retu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should work", () => {
const stat<|fim_suffix|>th("./esm")).length === 2
).toBe(true);
});
<|fim_middle|>s = __STATS__.children[__STATS_I__];
expect(
stats.modules.filter(m => m.name.startsWi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mpiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
},
() => {
const data = fs.readFileSync(
path.resolve(__dirname, "./test.js")
);
compilation.emitAsset(
"test.js",
new webpack.sources.RawSource(data)
);
}
);
... | fim | webpack/webpack | javascript |
<|fim_prefix|>expo<|fim_suffix|>fault "foo"<|fim_middle|>rt de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
}
);
});
<|fim_prefix|>it("should compile and work", done => {
require.ensure(
["./foo"],
() => {
<|fim_middle|>throw new Error("error");
},
() => {
import("./foo").then(m => {
expect(m.default).toBe("foo");
done();
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>e.exports = {
optimization: {
minimize: false
}
};
<|fim_middle|>"use strict";
/** @type {import("../../../../").Configuration} */
modul<|endoftext|> | fim | webpack/webpack | javascript |
import * as namespace from "../destructuring-namespace-import/module";
it("should work with destructuring", function() {
const key = "fo" + "o";
const {
[key]: a = "foo",
["fo" + "o"]: a1 = "foo",
[PROPERTY]: a2 = "foo",
["unkn" + "own"]: unknown = "foo",
unknown1 = "foo",
} = namespace;
expect(a).toBe(... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const <|fim_suffix|>'bar';
<|fim_middle|>foo = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>: [
new webpack.DefinePlugin({
PROPERTY: JSON.stringify("foo")
})
]
};
<|fim_prefix|>"use strict";
const webpa<|fim_middle|>ck = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
concatenateModules: true
},
plugins<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as namespace from "./module.js";
it("should work with destructuring", function() {
{
const { foo } = namespace;
expect(foo).toBe("bar");
}
{
let foo;
({ foo } = namespace);
expect(foo).toBe("bar");
}
{
<|fim_suffix|> }
});
<|fim_middle|> let foo;
({ foo = 'foo' } = namespace)... | fim | webpack/webpack | javascript |
export const foo = 'bar';
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ation: {
concatenateModules: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Confi<|fim_middle|>guration} */
module.exports = {
optimiz<|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.