text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>"use strict";
const supportsNodePrefix = require("../../../hel<|fim_suffix|>NodePrefix");
module.exports = () => supportsNodePrefix();
<|fim_middle|>pers/supports<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const webpack = require("../../../../");
/** @type {(boolean | "warn-mock" | "mock" | "node-module" | "eval-only")[]} */
const values = [true, "warn-mock", "mock", "node-module", "eval-only"];
/** @type {import("../../../../").Configuration[]} */
const config = [];
// CommonJS
config.push(
...values
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ilename };
<|fim_prefix|>const dirname = __dirn<|fim_middle|>ame;
const filename = __filename;
module.exports = { dirname, f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const dirname = import.meta.dirname;
c<|fim_suffix|>ilename = import.meta.filename;
export { dirname, filename };
<|fim_middle|>onst f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>n(stats.outputPath, `./bundle${__STATS_I__}.${__STATS_I__ === 0 ? "js" : "mjs"}`));
} else {
expect(dirnameCjs).toBe(stats.outputPath);
expect(filenameCjs.endsWith(`bundle${__STATS_I__}.${__STATS_I__ === 3 ? "js" : "mjs"}`)).toBe(true)
expect(dirnameEsm).toBe(stats.outputPath);
expect(filenameEsm... | fim | webpack/webpack | javascript |
<|fim_suffix|>helpers/supportsNodePrefix");
module.exports = () => supportsNodePrefix();
<|fim_prefix|>"use strict";
const<|fim_middle|> supportsNodePrefix = require("../../../<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
target: "node",
node: {
__filename: "eval-only",
__dirname: "eval-only"
}
},
{
target: "node",
node: {
__filename: "eval-only",
__dirname: "eval-only"
},
output: {
module: true
},
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import pa<|fim_suffix|>bundle0.mjs"));
});
<|fim_middle|>th from "path";
it("should use custom name", () => {
expect(__dirname).toBe(__STATS__.outputPath);
expect(__filename).toBe(path.join(__STATS__.outputPath, "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
const { pathToFileURL } = require("url");
module.export<|fim_suffix|>cope, options) {
scope.custom = {
url: pathToFileURL(
path.join(options.output.path, "bundle0.mjs")
).toString()
};
}
};
<|fim_middle|>s = {
moduleScope(s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"u<|fim_suffix|>ePrefix");
module.exports = () => supportsNodePrefix();
<|fim_middle|>se strict";
const supportsNodePrefix = require("../../../helpers/supportsNod<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
experiments: {
outputModule: true
},
output: {
module: true,
importMetaName: "custom"
},
node: {
__filename: "node-module",
__dirname: "node-module"
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"custom.filename")).toBe(true);
});
<|fim_prefix|>import path from "path";
import fs from "fs";
it("should use custom name", () => {
expect(__dirname).toBe(__STATS__.outputPath);
const bundleFile = path.join(__STATS__.outputPath, "./bundle0.mjs");
expect(__filename).toBe(bundleFile);
const content... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
const { pathToFileURL } = require("url");
let counter = 0;
module.exports = {
moduleScope(scope, options) {
const bundleFilename = path.join(
options.output.path,
`bundle${counter++}.mjs`
<|fim_suffix|>;
<|fim_middle|>);
scope.custom = {
url: ... | fim | webpack/webpack | javascript |
<|fim_suffix|>fix();
<|fim_prefix|>"use strict";
const supportsNodePrefix = require("../../../helpers/supportsNodePrefix");
module.exports = () => supportsNode<|fim_middle|>Pre<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
experiments: {
outputModule: true
},
output: {
module: true,
importMetaName: "custom",
environment: {
importMetaDirnameAndFilename: true
}
},
node: {
__filename: "node-module",
__dirname: "node-m... | fim | webpack/webpack | javascript |
const isBrowser = typeof window !== "undefined"
it(`should work ${isBrowser ? "in browser env" : "in node env"}`, () => {
if (isBrowser) {
expect(true).toBe(true);
} else {
// We can't handle `parser.hooks.typeof` and `parser.hooks.evaluateTypeof` for `import.meta.dirname` and `import.meta.filename`
// because... | fim | webpack/webpack | javascript |
<|fim_suffix|>s = () => supportsNodePrefix();
<|fim_prefix|>"use strict";
const supportsNodePrefix = require("../../../helpers/supportsNode<|fim_middle|>Prefix");
module.export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = [
{
name: "web",
target: ["node", "web"],
output: {
module: true
},
experiments: {
<|fim_suffix|>et: ["node", "web"],
output: {
module: true
},
experiments: {
outputModule: true
}
},
{
name:... | fim | webpack/webpack | javascript |
<|fim_suffix|>ommon";<|fim_prefix|>expo<|fim_middle|>rt default "c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>oBe("separate");
});
export default "main";
<|fim_prefix|>import common from "./common";
import separate from <|fim_middle|>"./separate";
it("should compile", () => {
expect(common).toBe("common");
expect(separate).t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>parate";
<|fim_prefix|>export defau<|fim_middle|>lt "se<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"u<|fim_suffix|>dle() {
return ["./main.js"];
}
};
<|fim_middle|>se strict";
module.exports = {
findBun<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = () => ({
devtool: false,
mode: "development",
entry: {
main: {
import: "./index.js",
dependOn: "shared"
},
shared: "./common.js"
},
output: {
filename: "[name].js"
},
target: ["node"],
optimizati... | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>t default "common";<|fim_middle|>or<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import common from "./common";
import <|fim_suffix|>rate).toBe("separate");
});
export default "main";
<|fim_middle|>separate from "./separate";
it("should compile", () => {
expect(common).toBe("common");
expect(sepa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>ault "separate";
<|fim_middle|>export def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.js"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
ret<|fim_middle|>urn ["./main<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = () => ({
devtool: false,
mode: "development",
entry: {
main: {
import: "./index.js",
dependOn: "shared"
},
shared: "./common.js"
},
output: {
filename: "[name].js"
},
target: ["node"],
optimization: {
minimi... | fim | webpack/webpack | javascript |
<|fim_prefix|>import vm1 from "vm";
import vm2 from "node:vm";
it("should allow importing node bui<|fim_suffix|>("path"));
expect(vm2).toBe(vm1);
});
<|fim_middle|>ltin modules with the node: prefix", () => {
expect(require("node:fs")).toBe(require("fs"));
expect(require("node:path")).toBe(require<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>).Configuration} */
module.exports = {
target: "node"
};
<|fim_prefix|>"use strict";
<|fim_middle|>/** @type {import("../../../../"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
it("should load node builtins via dynamic import", async () => {
const load = async (modulePromise) => {
const imported = await modulePromise;
return imported.default || imported;
};
const expectIfAvailable = (imported, ... | fim | webpack/webpack | javascript |
const assertBuiltin = require("assert");
const asyncHooks = require("async_hooks");
const buffer = require("buffer");
const childProcess = require("child_process");
const cluster = require("cluster");
const consoleBuiltin = require("console");
const constants = require("constants");
const crypto = require("crypto");
co... | fim | webpack/webpack | javascript |
module.exports = require("stream")
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ort.mjs"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["r<|fim_middle|>equire.mjs", "imp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sRequireInModule");
module.exports = () => supportsRequireInModule();
<|fim_prefix|><|fim_middle|>"use strict";
const supportsRequireInModule = require("../../../helpers/support<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ODE_VERSION: JSON.stringify(
process.versions.node.split(".").map(Number)[0]
)
})
]
};
<|fim_prefix|>"use strict";
const { DefinePlugin } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
entry: {
require: "./require.js",
im... | fim | webpack/webpack | javascript |
<|fim_suffix|>`should have/have not 'node:' prefix ${__filename}`, () => {
const content = fs.readFileSync(__filename, "utf-8");
if (/bundle7\.js$/.test(__filename)) {
expect(content).toContain("require(\"fs\");");
} else if (/(bundle1\.mjs|bundle3\.mjs|bundle6\.mjs)$/.test(__filename)) {
expect(content).toCon... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const su<|fim_suffix|>;
module.exports = () => supportsNodePrefix();
<|fim_middle|>pportsNodePrefix = require("../../../helpers/supportsNodePrefix")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>riments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module"
}
},
{
target: "node14.18",
experiments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module"
}
},
{
target: "node15",
experiments: {
outputModule: true
},
outpu... | fim | webpack/webpack | javascript |
<|fim_suffix|>.children[__STATS_I__];
expect(stats.modules.length).toBe(__STATS_I__ === 0 ? 2 : 1);
});
<|fim_prefix|>it("should use/not use<|fim_middle|> globalThis", () => {
expect(global).toBeDefined();
const stats = __STATS__<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"u<|fim_suffix|>ortsGlobalThis");
module.exports = () => supportsGlobalThis();
<|fim_middle|>se strict";
const supportsGlobalThis = require("../../../helpers/supp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../<|fim_suffix|>
stats: {
runtimeModules: true
}
}
];
<|fim_middle|>../../").Configuration[]} */
module.exports = [
{
target: "web",
output: {
environment: { globalThis: false }
},
stats: {
runtimeModules: true
}
},
{
target: "web",
outp... | fim | webpack/webpack | javascript |
<|fim_suffix|>"hello";
<|fim_prefix|>module.exports =<|fim_middle|> <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>stic chunkIds", () => {});
<|fim_prefix|>it("should<|fim_middle|> run with determini<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>hunkIdsPlugin()]
};
<|fim_prefix|>"use strict";
const webpack = require("<|fim_middle|>../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
chunkIds: false
},
plugins: [new webpack.ids.DeterministicC<|endoftext|> | fim | webpack/webpack | javascript |
import { w, used } from "./module";
export default it =>
it("should have the correct exports", () => {
expect(w).toBe("w");
if (__webpack_runtime_id__ === "a") {
expect(used).toEqual({
w: true,
v: false,
x: true,
y: false,
z: false
});
} else if (__webpack_runtime_id__ === "b") {
ex... | fim | webpack/webpack | javascript |
import { x, used } from "./module";
it("should have the correct exports", () => {
expect(x).toBe("x");
expect(used).toEqual({
w: true,
v: false,
x: true,
y: false,
z: false
});
return import("./a-or-b").then(m => m.default(it));
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { v } from "./module";<|fim_suffix|>pect(v).toBe("v");
});
<|fim_middle|>
export default it =>
it("should have the correct exports", () => {
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>r-b").then(m => m.default(it)),
import("./b-or-c").then(m => m.default(it))
]);
});
<|fim_prefix|>import { y, used } from "./module";
it("should have the correct exports", () => {
expect(y).toBe("y");
expect(used).toEqual({
w: true,
v: true,
x: false,
y: t<|fim_middle|>rue,
z: false
});
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { z, used } from "./module";
it("should have the correct exports", () => {
expect(z).toBe("z");
expect<|fim_suffix|>lse,
z: true
});
return import("./b-or-c").then(m => m.default(it));
});
<|fim_middle|>(used).toEqual({
w: false,
v: true,
x: false,
y: fa<|endoftext|> | fim | webpack/webpack | javascript |
export const v = "v";
export const w = "w";
export const x = "x";
export const y = "y";
export const z = "z";
export const used = {
w: __webpack_exports_info__.w.used,
v: __webpack_exports_info__.v.used,
x: __webpack_exports_info__.x.used,
y: __webpack_exports_info__.y.used,
z: __webpack_exports_info__.z.used
};
<... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.expo<|fim_suffix|>{
return ["./a.js", "./b.js", "./runtime-c.js", "./c.js"];
}
};
<|fim_middle|>rts = {
findBundle() <|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
filename: "[name].js"
},
optimization: {
chunkIds: "named"
},
entry: {
a: "./a",
b: "./b",
c: {
import: "./c",
runtime: "runtime-c"
}
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e.id;
<|fim_prefix|>module.exports = mod<|fim_middle|>ul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>m<|fim_suffix|>= module.id;
<|fim_middle|>odule.exports <|endoftext|> | fim | webpack/webpack | javascript |
module.exports = module.id;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.e<|fim_suffix|>;
<|fim_middle|>xports = module.id<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>module.id;
<|fim_prefix|>mod<|fim_middle|>ule.exports = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should have named modules ids", function() {
for (va<|fim_suffix|>files/file" + i + ".js");
expect(moduleId).toMatch(/^[/=a-zA-Z0-9]{4,5}$/);
}
});
<|fim_middle|>r i = 1; i <= 5; i++) {
var moduleId = require("./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>odule.exports = {
optimization: {
moduleIds: "hashed"
}
};
<|fim_prefix|>"use strict";
/** @type {impor<|fim_middle|>t("../../../../").Configuration} */
m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports<|fim_suffix|>le.id;
<|fim_middle|> = modu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>mo<|fim_middle|>dule.exports = module.id<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module<|fim_suffix|>;
<|fim_middle|>.exports = module.id<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>ts = module.id;
<|fim_middle|>module.expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.expor<|fim_suffix|>s = module.id;
<|fim_middle|>t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should have module ids defined in sorted order", function () {
const ids = [];
for (var i = 1; i <= 5; i++) {
var moduleId = require("./files/file" + i + ".js");
<|fim_suffix|>xpectedIds = new Set(ids);
const moduleIds = Object.keys(__webpack_modules__).filter((id) =>
expectedIds.has(id)
);
... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
optimization: {
moduleIds: <|fim_middle|>"hashed"
}
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{})
<|fim_prefix|>it("s<|fim_middle|>hould compile", () => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const Compiler = require("../../../../").Compiler;
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
minimize: true,
minimizer: [
{
/**
* @param {Compiler} compiler the compiler
<|fim_suffix|>oBe(this);
expect(compiler).toBeIns... | fim | webpack/webpack | javascript |
<|fim_prefix|>modul<|fim_suffix|>e.id;
<|fim_middle|>e.exports = modul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>ts = module.id;
<|fim_middle|>module.expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>ports = module.id;
<|fim_middle|>module.ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.id;
<|fim_prefix|>module.e<|fim_middle|>xports = module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> module.id;
<|fim_prefix|><|fim_middle|>module.exports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>" + i + ".js");
expect(path.basename(moduleId)).toBe(expectedModuleId);
}
});
<|fim_prefix|>var path = require("path");
it("should have named modules ids", function() {
for (var i = 1; i <= 5; i++) {
var expectedModuleId = "file" + i + ".js";
var moduleId<|fim_middle|> = require("./files/file<|e... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @<|fim_suffix|>;
<|fim_middle|>type {import("../../../../").Configuration} */
module.exports = {
optimization: {
moduleIds: "named"
}
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
used,
partly,
whole,
provideLeaf,
provideMissing,
providePastLeaf,
usedLeaf,
usedOther,
usedUnused,
useInfoUsed,
canMangleLeaf
} from "./module.js";
it("should resolve deeply nested mangled used names to correct values", () => {
// Reaching these values requires getUsedName to walk t... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from "./data.json";
// These are evaluated after global usage/provision analysis, so they reflect how
// index.js consumes the re-exported nested JSON. Each one drives one of the
// iterative path walks in ExportsInfo at depth >= 3.
// isExportProvided(["used","deep","leaf"]) -> true
export con... | fim | webpack/webpack | javascript |
<|fim_suffix|>
};
<|fim_prefix|>"use strict";
module.export<|fim_middle|>s = {
findBundle(i) {
return `bundle.${i}.js`;
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/**
* @param {number} index config index
* @param {boolean} concatenateModules whether to enable module concatenation
* @returns {import("../../../../").Configuration} config
*/
const config = (index, concatenateModules) => ({
mode: "production",
output: {
filename: `bundle.${index}... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { x, xUsed, yUsed } from "./module";
import { x as xRe, xUsed as xUsedRe, yUsed as yUsedRe } from "./reexport";
import importDx from "./dx-importer";
it("should use only one export", () => {
expect(x).toBe("x");
expect(xUsed).toBe(true);
expect(yUsed).toBe(false);
});<|fim_suffix|>,
wUsed: t... | fim | webpack/webpack | javascript |
<|fim_suffix|>d: false,
zUsed: true,
identity
})
);
expect(dz).toEqual(
nsObj({
z: "z",
wUsed: true,
xUsed: true,
yUsed: false,
zUsed: true,
identity
})
);
expect(dw).toEqual(
nsObj({
w: "w",
wUsed: true,
xUsed: true,
yUsed: false,
zUsed: true,
identity
})
);
});... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("shoul<|fim_suffix|> also be here", () => {});
<|fim_middle|>d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export { w, wUsed, xUsed, yUsed, zUsed,<|fim_suffix|>y } from "./module?chunk";
<|fim_middle|> identit<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default func<|fim_suffix|>mport("./dx");
}
<|fim_middle|>tion importDx() {
return i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>";
<|fim_prefix|>e<|fim_middle|>xport { x, wUsed, xUsed, yUsed, zUsed, identity } from "./module?chunk<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export { y, wUsed, xUsed, yUsed, zUsed, identity } <|fim_suffix|>chunk";
<|fim_middle|>from "./module?<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>d, zUsed, identity } from "./module?chunk";
<|fim_prefix|>export <|fim_middle|>{ z, wUsed, xUsed, yUse<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts_info__.z.used;
export const identity = Symbol();
<|fim_prefix|>export const w = "w";
export const x = "x";
export const y = "y";
export const z = "z";
export const wUsed = __webpack_exports_info__<|fim_middle|>.w.used;
export const xUsed = __webpack_exports_info__.x.used;
export const yUsed = __webpac... | fim | webpack/webpack | javascript |
<|fim_prefix|>export *<|fim_suffix|>ed";
<|fim_middle|> from "./module?reexport<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>["./a.js", "./b.js"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundl<|fim_middle|>e() {
return <|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
filename: "[name].js"
},
optimization: {
chunkIds: "named"
},
entry: {
a: "./a",
b: "./b",
c: "./c"
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.a).toBe("a");
expect(_1.c).toBe("c");
expect(aUsed).toBe(true);
expect(bUsed).toBe(false);
expect(cUsed).toBe(true);
expect(dUsed).toBe(false);
expect(eUsed).toBe(true);
expect(fUsed).toBe(false);
});
<|fim_prefix|>import {
e,
_1
} from "./path1";
import {
aUsed,
bUsed,
cUsed
} from "root1";
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
b,
_2
} from "./pat<|fim_suffix|>;
import {
dUsed,
eUsed,
fUsed
} from "root2";
import {addFiles, isSame} from "./helper";
// should be the same as 3.js and reuse defaultVendors
it("should use only current entrypoint exports", () => {
expect(b).toBe("b");
expect(_2.f).toBe("f");
expect(a... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
b,
_2
} from "./path2";
import {
aUsed,
bUsed,
cUsed
} from "root1";
import {
dUsed,
eUsed,
fUsed
} from "root2";
import { addFiles, isSame } from "./helper";
// should be the same as 2.js and reuse defaultVendors
it("should use only current entrypoint exports", () => {
expect(b).toBe("... | fim | webpack/webpack | javascript |
<|fim_suffix|>ks) {
chunks.forEach(ch => ch.files.forEach(f => files.add(f)));
}
<|fim_prefix|>/**
* @template T
* @param {T[]} arr arr
* @param {T[]} expected expected
* @returns {boolean} is same
*/
export function isSame(arr, expected) {
const set = new Set(arr);
return expected.every(i => set.has(i<|fim_mid... | fim | webpack/webpack | javascript |
<|fim_suffix|>om "root2";
export { _1, e };
<|fim_prefix|>import <|fim_middle|>{ _1, _2 } from "./reexport-all";
import { e, d } fr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import <|fim_suffix|> b = _1.b;
export { b, _2 }
<|fim_middle|>{ _1 } from "./path1";
import { _2 } from "./reexport-all";
const<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
export * as _2 from "root2";
<|fim_prefix|>export * as _1 from "<|fim_middle|>root1"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict"<|fim_suffix|>Bundle() {
return ["./a.js", "./b.js", "./c.js"];
}
};
<|fim_middle|>;
module.exports = {
find<|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.