text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>urn ["./a.js", "./b.js"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
<|fim_middle|> ret<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.js"
}
};
<|fim_prefix|>"use strict";
/** @type {import(<|fim_middle|>"../../../../").Configuration} */
module.exports = {
entry() {
return Promise.resolve({
a: "./a",
b: ["./b"]
});
},
output: {
filename: "[name]<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>= ["a"];
<|fim_prefix|>global.or<|fim_middle|>der <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>global.order<|fim_middle|>.push("b");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>global.order.pu<|fim_middle|>sh("c");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>push("d");
<|fim_prefix|><|fim_middle|>global.order.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>l.order.push("e");
<|fim_prefix|>glo<|fim_middle|>ba<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>f");
<|fim_prefix|>global.order.p<|fim_middle|>ush("<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>glob<|fim_suffix|>ush("g");
<|fim_middle|>al.order.p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.push("h");
<|fim_prefix|>g<|fim_middle|>lobal.order<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>global.order.push(<|fim_suffix|>;
<|fim_middle|>"i")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>global.o<|fim_suffix|>;
<|fim_middle|>rder.push("j")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>gl<|fim_middle|>obal.order.push("k"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var order = global.order;
delete global.order;
it("should run the modules in the correct order", function() {
expect(order).toEqual([
"a",
"b",
"c",
"d"<|fim_suffix|>"h",
"i",
"j",
"k"
]);
});
<|fim_middle|>,
"e",
"f",
"g",
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>./j",
"./k",
"./test"
]
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: [
"./a",
"./b",
"./c",
"./d",
"./e",
"./f",
"./g",
<|fim_middle|> "./h",
"./i",
"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load", () <|fim_suffix|>));
<|fim_middle|>=> import("./test.js"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>=> {});
<|fim_prefix|>import log from <|fim_middle|>"./log";
log("Hi");
it("should load", () <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ction (msg) {
console.log.bind(console, msg);
}
<|fim_prefix|>expo<|fim_middle|>rt default fun<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./runtime.js", "./app.js", "./home.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>import <|fim_middle|>log from "./log";
log("Hi");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>entry: {
app: "./app.js",
home: {
import: "./home.js",
dependOn: "app"
}
},
output: {
pathinfo: "verbose",
filename: "[name].js"
},
optimization: {
runtimeChunk: "single"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.expo<|fim_middle|>r... | fim | webpack/webpack | javascript |
<|fim_prefix|>// This test verifies that the System.register context is made available to webpack bundles
it("should be able to use the System.register context in entries where<|fim_suffix|>xpect(__system_context__.meta).toBeTruthy();
expect(typeof __system_context__.import).toBe("function");
expect(typeof __syste... | fim | webpack/webpack | javascript |
<|fim_prefix|>// This test verifies that the System.register context is not available for non-system entries
it("should not be able to use the System.register context in entries where library.type is not sy<|fim_suffix|> {
expect(__system_context__).toBeUndefined();
});
<|fim_middle|>stem", function()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const System = require("../../../helpers/fakeSystem");
module.exports = {
beforeExecute: () => {
System.init();
},
moduleScope(scope) {
scope.System = System;
},
afterExecute: () => {
System.execute("(anonym)");
},
findBundle() {
<|fim_suffix|>s", "./main.umd.js"];
}
};
<|f... | fim | webpack/webpack | javascript |
<|fim_suffix|>},
"main-umd": {
import: "./index-umd.js",
library: {
type: "umd"
},
filename: "main.umd.js"
}
},
node: {
__dirname: false,
__filename: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
"main-system": {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import r<|fim_suffix|>t crash", () => {
return run().then(result => {
expect(result.default).toBe("ok");
});
})
<|fim_middle|>un from "./c";
import "./d";
it("should no<|endoftext|> | fim | webpack/webpack | javascript |
import run from "./c";
run();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>d");
}
<|fim_prefix|>export default function run() {<|fim_middle|>
return import("./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>";
<|fim_prefix|>expo<|fim_middle|>rt default "ok<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.ex<|fim_suffix|> }
};
<|fim_middle|>ports = {
entry: {
bundle0: "./a",
other: "./b"
},
output: {
filename: "[name].js"
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import fs from "fs";
it("should load chunks on demand", async () => {
expect((await import("./async")).default).toEqual(42);
expect((await (await import("<|fim_suffix|>unk"
);
expect(fs.readFileSync(__filename, "utf-8")).not.toContain(
"This is the" + " nested async chunk"
);
});
<|fim_middle|>./a... | fim | webpack/webpack | javascript |
<|fim_suffix|>fault 42;
export const nested = () => import("./nested");
<|fim_prefix|>// This is the async<|fim_middle|> chunk
export de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ync chunk"
);
expect(fs.readFileSync(__filename, "utf-8")).toContain(
"This is the nested async chunk"
);
});
<|fim_prefix|>import fs from "fs";
it("should include all async imports in the main chunk", async () => {
expect((await import("./async")).default).toEqual(42);
expect((await (await import... | fim | webpack/webpack | javascript |
// This is the nested async chunk
export default 43;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>b.js", "./c.js", "./runtime.js", "./d.js"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["./a.js", ".<|fim_middle|>/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
a: "./a.js",
b: {
import: "./b.js",
chunkLoading: false
},
c: {
import: "./b.js",
asyncChunks: false
},
d: {
import: "./b.js",
asyncChunks: false,
runtime: "ru<|fim_suffix|>als:... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should requ<|fim_suffix|>point2");
});
<|fim_middle|>ire entry points fine", function() {
require("./require-entry-point");
require("./entry-point");
require("./entry-<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
bundle0: "./require-entry-point",
a: "./entry-point",
b: [<|fim_suffix|><|fim_middle|>"./entry-point2"]
},
output: {
filename: "[name].js"
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ault 42;
<|fim_prefix|>export de<|fim_middle|>f<|endoftext|> | fim | webpack/webpack | javascript |
it("should not URL-encode '@' in chunk filenames", () =>
import(/* webpackChunkName: "@scope/chunk" */ "./chunk").then(r =>
expect(r).toEqual(expect.objectContaining({ default: 42 }))
));
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>atim at ${chunk} (no URL-encoding of '@'); see https://github.com/jantimon/html-webpack-plugin/issues/1771`
);
}
return [bundle];
}
};
<|fim_prefix|>"use strict";
const fs = require("fs");
const path = require("path");
module.exports = {
findBundle(i, options) {
const bundle = "./@scope/app.j... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use st<|fim_suffix|>",
chunkFilename: "chunks/[name].js"
}
};
<|fim_middle|>rict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
"@scope/app": "./index.js"
},
output: {
filename: "[name].js<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>fine", function() {
require("./single-entry-point");
});
<|fim_prefix|>it("should require entry poi<|fim_middle|>nts <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/**<|fim_suffix|>entry: "./single-entry-point"
};
<|fim_middle|> @type {import("../../../../").Configuration} */
module.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "./module";
it("should have usage info in this modul<|fim_suffix|>t(value).toBe(42);
})
<|fim_middle|>e", () => {
expec<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>fault 42;
<|fim_middle|> de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stri<|fim_suffix|> */
module.exports = {
entry: ["./a", "./b"]
};
<|fim_middle|>ct";
/** @type {import("../../../../").Configuration}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lt 42;
<|fim_prefix|>export<|fim_middle|> defau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "./chunk").then(r =>
expect(r).toEqual(expect.objectContaining({ default: 42 }))
));
<|fim_prefix|>it("should load on demand", () <|fim_middle|>=>
import(/* webpackChunkName: "././../chunk/chunk/./../" */<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle(i, options) {
return [
`./${options.target}/folder/entry/-x/file.js`,
`./${options.target}/folder/x-/-x/file.js`,
`./${options.target}/folder/x-../entry-x/file.js`
];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const entry = {
"././../entry/point/./../": "./index.js",
"/////": "./index.js",
"../entry": "./index.js"
};
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
target: "async-node",
entry<|fim_suffix|>s",
chunkFilename: "webworker/chunks/x-[name]-x/file.j... | fim | webpack/webpack | javascript |
export default 42;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should<|fim_suffix|> import(/* webpackChunkName: "././../chunk/chunk/./../" */ "./chunk").then(r =>
expect(r).toEqual(expect.objectContaining({ default: 42 }))
));
<|fim_middle|> load on demand", () =>
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict"<|fim_suffix|>target}.js`,
`../weird-names2-out/entry-${options.target}.js`
];
}
};
<|fim_middle|>;
module.exports = {
findBundle(i, options) {
return [
`../weird-names2-out/entry/entry-${options.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>y,
output: {
filename: "[name]-node.js",
chunkFilename: "chunks/[name]-node.js"
}
},
{
target: "webworker",
entry,
output: {
filename: "[name]-webworker.js",
chunkFilename: "chunks/[name]-webworker.js"
}
}
];
<|fim_prefix|>"use strict";
const entry = {
"././../weird-names2-out... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url<|fim_suffix|>"./text.txt";
<|fim_middle|> from <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../.<|fim_suffix|>: {
rules: [
{
test: /\.txt$/,
type: "asset/inline",
generator: {
filename: "[name].txt"
}
}
]
}
};
<|fim_middle|>./../../").Configuration} */
module.exports = {
module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>n casing/, /a\.js/, /A\.js/]];
<|fim_prefix|><|fim_middle|>"use strict";
module.exports = [[/only differs i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
modul<|fim_suffix|> = {
entry: {
a: "./index.js?1",
A: "./index.js?2"
},
output: {
filename: "[name].js"
}
};
<|fim_middle|>e.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
output: {
filename: "runtime-to-entrypoint-[name].js"
},
entry: {
a1: "./a",
b1: {
runtime: "a1",
import: "./b"
}
}
},
{
output: {
filename: "dependOn-plus-runtime-[name].js"
},
... | fim | webpack/webpack | javascript |
<|fim_suffix|> dependOn: ["foo"]
}
},
output: {
filename: "[name].js"
}
};
<|fim_prefix|>"use strict";
/** @type {<|fim_middle|>import("../../../../").Configuration} */
module.exports = {
entry: {
foo: "./file-does-not-exist.js",
bar: {
import: ["./index.js"],
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.Configuration} */
module.exports = {};
<|fim_prefix|>"use strict";
/** <|fim_middle|>@type {import("../../../../")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not crash when renderer throws exception", function<|fim_suffix|>
done();
});
<|fim_middle|>(done) {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Compiler} Compiler */
class ThrowsExceptionInRender {
/**
* @param {Compiler} compiler compiler
*/
apply(compiler) {
compiler.hooks.compilation.tap("ThrowsException", (compilation) => {
compilation.mainTemplate.hooks.requireExtensions.tap(
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should generate a custom error content", async () => {
expect(__STATS__.modules.filter(m => m.moduleType !== "runtime").length).toEqual(14);
expect(__STATS__.assets.length).toEqual(19);
expect(__STATS__.chunks.length).toEqual(12);
let errored;
let json;
try {
json = await import("./file.jso... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = (options) =<|fim_suffix|>ause of write to/];
}
return [];
};
<|fim_middle|>> {
if (options.cache && options.cache.type === "filesystem") {
return [/Pack got invalid bec<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> = this.getOptions();
callback(new Error(options.message || 'Message'));
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition<{ message: stri<|fim_middle|>ng }>} */
module.exports = function() {
const callback = this.async();
const options<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>test";
<|fim_prefix|>expor<|fim_middle|>t default "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const findOutputFiles = require("../../../helpers/findOutputFiles");
module.exports = {
findBundle<|fim_suffix|>);
}
};
<|fim_middle|>(i, options) {
const files = findOutputFiles(options, new RegExp(/\.js$/));
return files.sort((a, _b) => (a.startsWith("main") ? 1 : 0)<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e"
}
}
},
{
type: "javascript/auto",
test: /module\.js$/,
use: {
loader: "./loader.js",
options: {
message: "javascript/auto error message"
}
}
},
{
type: "json",
test: /file\.json$/,
use: {
loader: "./loader.js",
options: {
... | fim | webpack/webpack | javascript |
import value from "./my-errored-module.js"
it("should work and cache", function(done) {
done();
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = (options) => {
if (options.cache &&<|fim_suffix|>d because of write to/];
}
return [];
};
<|fim_middle|> options.cache.type === "filesystem") {
return [/Pack got invali<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ebpackError.js');
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function loader() {
const callback = this.async();
callback(new HookWebpackError(new Error("Error: test"), "hookName"));
};
<|fim_prefix|>const H<|fim_middle|>ookWebpackError = require('../../../../lib/errors/Ho... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /my-errored-module\.js$/i,
use: [
{
loade<|fim_suffix|>
}
]
}
};
<|fim_middle|>r: require.resolve("./loader.js")
}
]<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use s<|fim_suffix|> [[/Module not found/]];
<|fim_middle|>trict";
module.exports =<|endoftext|> | fim | webpack/webpack | javascript |
var never = false;
it("should not crash on missing requires", function() {
if (never) {
require("./a");
require("./b");
require("./c");
require("./d");
require("./e");
require("./f");
require("./h");
require("./i");
require("./j");
require("./k");
require("./l");
require("./m");
require("./n... | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>"use strict";
/** @type {import("../..<|fim_middle|>/../../").Configuration} */
module.exports = {
bail: true
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>should be evaluated correctly
});
it("should use WebpackMissingModule when evaluating missing modules", function() {
expect(function() {
require("./intentionally-missing-module");
}).toThrow("Cannot find module './intentionally-missing-module'");
});
<|fim_prefix|>it("should ignore missing module... | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>rts = "ignored";<|fim_middle|>module.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["./a.js", "./b.js", ".<|fim_middle|>/bundle0.js"]<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const IgnorePlugin = require("../../../../").IgnorePlugin;
<|fim_suffix|>ule.js"],
bundle0: ["./index"]
},
output: {
filename: "[name].js"
},
plugins: [
new IgnorePlugin({
resourceRegExp: new RegExp(/intentionally-missing-module/)
})
]
};
<|fim_middle|>/** @type {import("..... | fim | webpack/webpack | javascript |
<|fim_suffix|>om "./a";
<|fim_prefix|>export { som<|fim_middle|>ething } fr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>import <|fim_middle|>{ something } from "./a";
something(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>
import { something, other } from<|fim_suffix|>ther,
other as something
}
<|fim_middle|> "./b";
export {
something as o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {some<|fim_suffix|>;
something();
<|fim_middle|>thing} from "./b"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/c2";
<|fim_prefix|>export { something } from<|fim_middle|> ".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export { something } from<|fim_suffix|>./c1";
<|fim_middle|> "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>im<|fim_suffix|>{something} from "./c1";
something();
<|fim_middle|>port <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not crash on incorrect exports", function() {
if(Math.random() < -1) {<|fim_suffix|>/bb");
import(/* webpackChunkName: "c" */ "./cc");
}
});
<|fim_middle|>
import(/* webpackChunkName: "a" */ "./aa");
import(/* webpackChunkName: "b" */ ".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/**<|fim_suffix|>../../../../").Configuration} */
module.exports = {
mode: "production"
};
<|fim_middle|> @type {import("<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "promise-external";
import value2 from "module-promise-external";
import value3 from "object-promise-external";
import request from "import-external";
import request2 from "module-import-external";
import "./module.mjs";
it("should allow async externals", () => {
expect(value).toBe(42)... | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "promise-external";
import value2 from "module-promise-external";
import value3 from "object-promise-external";
import request from "<|fim_suffix|>ed: true });
expect(request).toBe("/hello/world.js");
});
it("should allow to catch errors of async externals (in strict esm)", () => {
re... | fim | webpack/webpack | javascript |
<|fim_suffix|>"request"]
}
};
<|fim_prefix|>"use strict";
module.exports = {
target: ["web", "es2020"],
output: {
libraryTarget: "commonjs-module",
importFunctionName: "((name) => Promise.resolve({ request: name }))"
},
externals: {
"promise-external":
"promise new Promise(resolve => setTimeout(() => res... | fim | webpack/webpack | javascript |
<|fim_prefix|>import externalValue, { named as externalValueNamed } from "externalValue";
it("should harmony import a external value", function () {
expect(externalValue).toBe("abc");
expect(externalValueNamed).toBe(undefined);
});
import externalObject, { named as externalObjectNamed } from "externalObject";
it("... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
externals: {
externalVal<|fim_suffix|>ed: 'named' }",
externalEsModule:
"var { __esModule: true, default: 'default', named: 'named' }"
},
optimization: {
concatenateModules: true,
usedExports: true,
provi... | fim | webpack/webpack | javascript |
<|fim_prefix|>import fs1 from "fs";
import fs2 from "module-fs";
import fsPromises1 from "fs-promises";
import fsPromises2 from "module-fs-promises";
import path1 from "path";
import path2 from "module-path";
import url1 from "url";
import url2 from "module-import-url"<|fim_suffix|>2).toBe(path1);
expect(fsPromises2).... | fim | webpack/webpack | javascript |
<|fim_suffix|>ion.startsWith("v10.") && !process.version.startsWith("v12.");
<|fim_prefix|>"use strict";
module.exports = () =>
<|fim_middle|> !process.vers<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {(variant: boolean) => import("../../../../").Configuration} */
const config = (o) => ({
externals: {
"module-fs": o ? "module fs" : "module fs/promises",
fs: o ? "node-commonjs fs" : "node-commonjs fs/promises",
"module-fs-promises": o ? ["module fs", "promises"] : "module fs/promises",... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { doSomethingWithFs, existsSync } from "./lib.js";
it("should map external imports in a concate<|fim_suffix|>le", function() {
expect(typeof doSomethingWithFs).toBe("function");
expect(typeof existsSync).toBe("function");
});
<|fim_middle|>nated modu<|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.