text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> type: "assert" });
};
<|fim_prefix|>/** @type {impo<|fim_middle|>rt("../../../../").LoaderDefinition} */
module.exports = function (source) {
return JSON.stringify({<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type <|fim_suffix|>/../../../").LoaderDefinition} */
module.exports = function (source) {
return JSON.stringify({ type: "with" });
};
<|fim_middle|>{import("..<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
modul<|fim_suffix|>loader: require.resolve("./loader-with.js")
}
]
}
};
<|fim_middle|>e: {
rules: [
{
assert: { type: "json" },
loader: require.resolve("./loader-assert.js")
},
{
with: { typ... | fim | webpack/webpack | javascript |
<|fim_prefix|>export {b} from "./b" with {t<|fim_suffix|>"}<|fim_middle|>ype: "RANDOM<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>" + c();
}
<|fim_prefix|>import { c } from "./c.js";
export function b() {
return<|fim_middle|> "b<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>rt function c() {
return "c";
}
<|fim_middle|>expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { b } from "./a.js";
function foo() {
return<|fim_suffix|>expect(foo()).toEqual("ab");
});
<|fim_middle|> "a" + b();
}
it("should not duplicate modules", function() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>return "export function b() { return 'b'; }";
};
<|fim_prefix|>module.exports = function loader() {
<|fim_middle|> <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {imp<|fim_suffix|> with: { type: "RANDOM" },
use: require.resolve("./test-loader")
}
]
}
};
<|fim_middle|>ort("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>age:
/Using a string as loader options is deprecated \(ruleSet\[1\]\.rules\[3\]\.use\[0\]\.options\)/
}
];
<|fim_prefix|>"use strict";
module.exports = [
{
code: /DEP_WEBPACK_<|fim_middle|>RULE_LOADER_OPTIONS_STRING/,
message:
/Using a string as loader options is deprecated \(ruleSet\[1\]\.ru... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should resolve aliased loader module with query", function() {
var foo = require('./a');
expect(foo).toBe("someMessage");
});
it("should favor explicit loader query over aliased query (options in rule)", function() {
var foo = require('./b');
ex<|fim_suffix|> query (inline query in rule.use)", ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
resolveLoader: {
alias: {
"some-loader": "any-loader?foo=someMessage"
}
},
module: {
rules: [
{
test: /a\.js$/,
use: [
{
loader: "some-loader"
}
]
},
{
test: /b\.js$/,... | fim | webpack/webpack | javascript |
<|fim_prefix|>module.expo<|fim_suffix|>["b"];
<|fim_middle|>rts = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>];
<|fim_prefix|>module.exports<|fim_middle|> = ["c"<|endoftext|> | fim | webpack/webpack | javascript |
it("should apply inline loaders before matchResource", function() {
var foo = require("c.js!=!loader1!./b.js");
expect(foo).toEqual(["b", "1", "2"]);
});
it("should apply config loaders before inline loaders", function() {
var foo = require("loader1!./c.js");
expect(foo).toEqual(["c", "2", "1"]);
});
it("should... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stric<|fim_suffix|>test: /d\.js$/,
use: ["loader3"]
}
]
}
};
<|fim_middle|>t";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /c\.js$/,
use: ["loader2"]
},
{
<|endoftext|> | fim | webpack/webpack | javascript |
it("provides mode to loaders when the option is omitted", function() {
expect(require("./a")).toBe("production");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = "${this.mode}";`;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} *<|fim_middle|>/
module.exports = function (source) {
return `module.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>test: /a\.js$/,
use: "./loader"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
<|fim_middle|> {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("./a")).toBe("development");
});
<|fim_prefix|>i<|fim_middle|>t("provides mode to loaders when the option is 'development'", function() {
expect(require<|endoftext|> | fim | webpack/webpack | javascript |
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (source) {
return `module.exports = "${this.mode}";`;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
module: {
rules: [
{
test: /a\.js$/,
use: "<|fim_suffix|> }
]
}
};
<|fim_middle|>./loader"
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>function() {
expect(require("./a")).toBe("none");
});
<|fim_prefix|>it("provides m<|fim_middle|>ode to loaders when the option is 'none'", <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rn `module.exports = "${this.mode}";`;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
modu<|fim_middle|>le.exports = function (source) {
retu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
<|fim_suffix|>rules: [
{
test: /a\.js$/,
use: "./loader"
}
]
}
};
<|fim_middle|> mode: "none",
module: {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>equire("./a")).toBe("production");
});
<|fim_prefix|>it("provides mode to loaders when the option is 'produ<|fim_middle|>ction'", function() {
expect(r<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (source) {
return `module.e<|fim_suffix|>ports = "${this.mode}";`;
};
<|fim_middle|>x<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configur<|fim_middle|>ation} */
module.exports = {
mode: "production",
module: {
rules: [
{
test: /a\.js$/,
use: "./loader"
}
]
}
};<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = [
{ code: /DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING/ },
{ code: /DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING/ },
<|fim_suffix|>{ code: /DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING/ },
{ code: /DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING/ }
];
<|fim_middle|> { code: /DEP_WEBPACK_RULE_LOAD... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should get options", function<|fim_suffix|>"string",
arg5: [1, 2, 3],
arg6: { foo: "value", bar: { baz: "other-value" } }
});
expect(require("./d")).toStrictEqual({
arg4: "text"
});
expect(require("./e")).toStrictEqual({});
expect(require("./f")).toStrictEqual({
delicious: "",
name: "ch... | fim | webpack/webpack | javascript |
<|fim_suffix|>ror2`
/^Pack got invalid because of write to: Compilation\/modules.+loaders[/\\]options[/\\]error(1|2)\.js$/
];
<|fim_prefix|>"use strict";
module.exports = [
// We use (1|2), because both contain the problems, but due asynchronous natur<|fim_middle|>e the first module can be `error1` or `er<|endoftext... | fim | webpack/webpack | javascript |
const schema = /** @type {EXPECTED_ANY} */ (require("./loader-1.options.json"));
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const options = this.getOptions(schema);
const json = JSON.stringify(options)
.replace(/\u2028/g, "\\u2028")
.replace(/\u2029/g, "\\u2029");
re... | fim | webpack/webpack | javascript |
<|fim_suffix|>type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const options = this.getOptions(schema);
const json = JSON.stringify(options)
.replace(/\u2028/g, "\\u2028")
.replace(/\u2029/g, "\\u2029");
return `module.exports = ${json}`;
};
<|fim_prefix|>const schema = /** @typ... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */<|fim_suffix|>replace(/\u2028/g, "\\u2028")
.replace(/\u2029/g, "\\u2029");
return `module.exports = ${json}`;
};
<|fim_middle|>
module.exports = function () {
const options = this.getOptions();
const json = JSON.stringify(options)
.<|endoftex... | fim | webpack/webpack | javascript |
<|fim_suffix|>oader: "./loader",
options: "name=cheesecake&slices=8&delicious&warm=false"
},
{
test: /g\.js$/,
loader: "./loader",
options: "%3d=%3D"
},
{
test: /h\.js$/,
loader: "./loader",
options: "foo=bar"
},
{
test: /i\.js$/,
loader: "./loader",
options: `$... | fim | webpack/webpack | javascript |
<|fim_prefix|>const { NormalModule } = require("webpack");
const PLUGIN_NAME = "PluginWithLoader";
const loaderPath = require.resolve("./loader.js");
/<|fim_suffix|>/
apply(compiler) {
compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
NormalModule.getCompilationHooks(compilation).beforeLoaders.tap(
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("successfully loads a fi<|fim_suffix|>Be("success");
});
<|fim_middle|>le that gets its only loader from a plugins beforeLoaders hook", function() {
expect(require("./a")).to<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>ports = "success";`;
};
<|fim_middle|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
return `module.ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>odule.exports = {
plugins: [new PluginWithLoader()]
};
<|fim_prefix|>"use strict";
const PluginWithLoader = require("./PluginWithLoader<|fim_middle|>");
/** @type {import("../../../../").Configuration} */
m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>urce";
<|fim_prefix|>modu<|fim_middle|>le.exports = "reso<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>).toBe("resource");
expect(require("-!./a")).toBe("resource loader3");
});
<|fim_prefix|>it("should apply pre and post loaders correctly", function() {
expect(require("./a")).toBe("resource loader<|fim_middle|>2 loader1 loader3");
expect(require("!./a")).toBe("resource loader2 loader3");
expect(requir... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefin<|fim_suffix|>tion} */
module.exports = function (source) {
return source + 'module.exports += " loader1";\n';
};
<|fim_middle|>i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>source) {
return source + 'module.exports += " loader2";\n';
};
<|fim_prefix|>/** @type {import("../../../../").Loa<|fim_middle|>derDefinition} */
module.exports = function (<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>on} */
module.exports = function (source) {
return source + 'module.exports += " loader3";\n';
};
<|fim_prefix|>/** @type {import("../..<|fim_middle|>/../../").LoaderDefiniti<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /a\.js$/,
use: "./loader1"
},
{
test: /a\.js$/,
use: "./loader2",
enforce: "pre"
},
{
test: /a\.js$/,
use: "./loader3",
enforce: "post"
}
]
}
};
<|endo... | fim | webpack/webpack | javascript |
it("should correctly pass complex query object with remaining request (with custom ident)", function() {
expect(require("./a")).toBe("ok");
});
it("should correctly pass complex query object with remaining request (with default ident)", function() {
expect(require("./b")).toBe("ok");
});
it("should correctly pass c... | fim | webpack/webpack | javascript |
/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
module.exports.pitch = function (remainingRequest) {
return (
"module.exports = require(" + JSON.stringify("!!" + remainingRequest) + ");"
);
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").Loader<|fim_suffix|>t");
return "module.exports = " + JSON.stringify(this.query.f());
};
<|fim_middle|>Definition<{ f(): any }>} */
module.exports = function (source) {
if (typeof this.query === "string")
throw new Error("query must be an objec<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /a\.js$/,
use: [
"./loader1",
{
<|fim_suffix|>er2",
options: {
f() {
return "ok";
}
}
}
]
}
};
<|fim_middle|> loader: "./loader2",
... | fim | webpack/webpack | javascript |
<|fim_suffix|>Be("b.js");
});
<|fim_prefix|>it("re<|fim_middle|>solve should work in loader context", function() {
expect(require("./a")).to<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const pa<|fim_suffix|>e(this.context, "./b.js", (err, result) => {
callback(err, `module.exports = ${JSON.stringify(path.basename(/** @type {string} */ (result)))};`)
});
};
<|fim_middle|>th = require("path");
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const... | fim | webpack/webpack | javascript |
<|fim_suffix|>st: /a\.js$/,
use: "./loader"
}
]
}
};
<|fim_prefix|>"us<|fim_middle|>e strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "none",
module: {
rules: [
{
te<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ult "test";
<|fim_prefix|><|fim_middle|>export defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "test";
<|fim_prefix|>export<|fim_middle|> default<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default "test<|fim_suffix|><|fim_middle|>";
<|endoftext|> | fim | webpack/webpack | javascript |
import foo from "./foo.js?external";
import bar from "./bar.js";
import baz from "./baz.js?custom-use";
import other from "./other.js";
it("should work with falsy plugins and loaders", function() {
expect(ONE).toBe("ONE");
expect(foo.endsWith("?external")).toBe(true);
expect(bar).toBe("test");
expect(baz).toBe("te... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").Loader<|fim_suffix|>*/
module.exports = function loader(content) {
return content.replace(/test/, "NEW");
};
<|fim_middle|>Definition<{ value: any }>} <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|>est";
<|fim_middle|>default "t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>new FailPlugin(),
emptyStringValue && new FailPlugin()
]
);
child.runAsChild((err) => {
cb(err);
});
}
);
}
}
/** @type {import("../../../../").Configuration} */
module.exports = {
// Will failed because we don't have unknown-loader
module: {
defaultRules: [
null... | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>value).toBe(42);
});
<|fim_middle|>import value from "package";
it("should work", () => {
expect(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Confi<|fim_middle|>guration} */
module.exports = {
experiments: {
futureDefaults: true
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ngle = __webpack_exports_info__.aaa.canMangle;
<|fim_prefix|>export con<|fim_middle|>st aaa = "aaa";
export const aaaCanMa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nfo__.bbb.canMangle;
<|fim_prefix|>export const bbb = "bbb";
export const bbbCanM<|fim_middle|>angle = __webpack_exports_i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> const ca_aaaCanMangle = __webpack_exports_info__.ca.aaa.canMangle;
export const cb_bbbCanMangle = __webpack_exports_info__.cb.bbb.canMangle;<|fim_prefix|>export * as ca from "./a";
export * as cb from "./b";
export const caCanMangle = __webpack_exports_info__.ca.canMangle;
export const cbCanMangle = __we... | fim | webpack/webpack | javascript |
<|fim_suffix|>bbCanMangle);
});
<|fim_prefix|>import { aaa, aaaCanMangle } from "./a";
import * as b from "./b"
import { ca, cb, caCanMangle, cbCanMangle, ca_aaaCanMangle, cb_bbbCanMangle } from "./c";
it("__webpack_exports_info__.xxx.canMangle should be correct", () => {
expect(aaa).toBe("aaa");
expect(aaaCanMangle... | fim | webpack/webpack | javascript |
<|fim_suffix|>e,
providedExports: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").<|fim_middle|>Configuration} */
module.exports = {
optimization: {
mangleExports: true,
usedExports: tru<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import path from "path";
import * as module from "./module";
import { obj3, obj3CanMangle, obj4, obj4CanMangle } from "./reexport?side-effects" // enable side effects to ensure reexport is not skipped
import data from "./data.json";
import data2 from "./data.json?2";
it("should mangle export when destruc... | fim | webpack/webpack | javascript |
<|fim_suffix|>: "a", b: "b" }
export const objCanMangle = __webpack_exports_info__.obj.canMangle;
export const obj2 = { a: "a", b: "b" }
export const obj2CanMangle = __webpack_exports_info__.obj2.canMangle;
export default "default";
export const defaultCanMangle = __webpack_exports_info__.default.canMangle;
<|fim_pre... | fim | webpack/webpack | javascript |
<|fim_suffix|>= "b";
<|fim_prefix|>export const aaa = "a";<|fim_middle|>
export const bbb <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>bb = "b";
<|fim_prefix|>export const aaa = "a";
export cons<|fim_middle|>t b<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>bj4 = { nested: reexport2 }
export const obj4CanMangle = __webpack_exports_info__.reexport2.canMangle;
<|fim_prefix|>export * as obj3 fro<|fim_middle|>m "./module2"
export const obj3CanMangle = __webpack_exports_info__.obj3.canMangle;
import * as reexport2 from "./reexport2?side-effects"
export const o<|... | fim | webpack/webpack | javascript |
<|fim_prefix|>expor<|fim_suffix|>j5 from "./module3"
export const obj5CanMangle = __webpack_exports_info__.obj5.canMangle;
<|fim_middle|>t * as ob<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("webpack").CodeGenerationResults} CodeGenerationResults */
/** @typedef {import("webpack-sources").Source} Source */
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
resourceQuery: /side-effects/,
sideEffects: tr... | fim | webpack/webpack | javascript |
exports.abc = "abc";
exports.def = "def";
exports.setToString = () => {
exports.toString = () => "toString";
};
exports.moduleId = module.id;
exports.a = "single char";
exports["="] = "single char non-identifier";
exports.$1 = "double char";
exports.__1 = "3 chars";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { moduleId, setToString, toString, abc, a, $1, __1 } from "./module";
const moduleId2 = require("./commonjs").moduleId;
const toString2 = require("./commonjs").toString;
const setToString2 = require("./commonjs").setToString;
const abc2 = require("./commonjs").abc;
const a2 = require("./commonjs").... | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>c = "abc";
export const def = "def";
export let toString;
export const setToString = () => {
toString = () => "toString";
};
export const moduleId = module.id;
export const a = "single char";
export const $1 = "double char";
export const __1 = "3 chars";
<|fim_middle|>export const ab<|endof... | fim | webpack/webpack | javascript |
<|fim_suffix|>/size.js"];
}
};
<|fim_prefix|>"use strict";
module.<|fim_middle|>exports = {
findBundle() {
return ["./deterministic.js", ".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { DefinePlugin } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = [
{
output: {
filename: "deterministic.js"
},
optimiza<|fim_suffix|>
plugins: [
new DefinePlugin({
OPTIMIZATION: JSON.stringify("size")
})
]
}
];
... | fim | webpack/webpack | javascript |
<|fim_suffix|>o } = namespace;
expect(foo).toBe('foo')
});
<|fim_prefix|>import namespace from "./re-exports";
it("should man<|fim_middle|>gle exports imported", () => {
const { fo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>expor<|fim_suffix|>
<|fim_middle|>t const foo = 'foo';<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>as default };
<|fim_prefix|>import * as namespace from './module';
export { namesp<|fim_middle|>ace <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sideEffects: false // disable reexports optimization
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
o<|fim_middle|>ptimization: {
mangleExports: true,
usedExports: true,
providedExports: true,
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should compile and run", ()<|fim_suffix|>toBe(import.meta.url);
});
<|fim_middle|> => {
expect(import.meta.url).<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use s<|fim_suffix|>le.exports = (config) => !config.cache;
<|fim_middle|>trict";
modu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|>rget: "web"
},
{
experiments: {
outputModule: true
},
devtool: false,
target: "node10"
}
];
<|fim_middle|>
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
experiments: {
outputModule: true
},
devtool: false,
ta<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> 'MAIN';
<|fim_prefix|>export const<|fim_middle|> main =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
});
<|fim_prefix|>import { main<|fim_middle|> } from "./dep.js";
it("should work by default", () => {
expect(main).toBe("MAIN");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBu<|fim_suffix|>runtime.mjs", "./main.mjs"];
}
};
<|fim_middle|>ndle() {
return ["<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ments: {
outputModule: true
},
mode: "development",
devtool: false
};
<|fim_prefix|>"use st<|fim_middle|>rict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
main: {
import: "./index.js",
library: { type: "module" }
}
},
output: {
filename: "[name].mj... | fim | webpack/webpack | javascript |
<|fim_suffix|>tB as getOtherValue };
<|fim_prefix|>import { externalValue as valueB, getOtherExternal as getB } from "./external-b.mjs";
export const e<|fim_middle|>xternalValue = "external-A";
export function getOtherExternal() {
return valueB;
}
// Re-export to test circular re-exports
export { ge<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>imp<|fim_suffix|>alue = "external-B";
export function getOtherExternal() {
return valueA;
}
// Re-export to test circular re-exports
export { getA as getOtherValue };
<|fim_middle|>ort { externalValue as valueA, getOtherExternal as getA } from "./external-a.mjs";
export const externalV<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>) => {
expect(valueA).toBe("module-A");
expect(valueB).toBe("module-B");
expect(callB()).toBe("module-B");
expect(callA()).toBe("module-A");
});
it("should handle imports from external modules", () => {
expect(getFromExternalA()).toBe("external-A");
expect(getFromExternalB()).toBe("external-B");
})... | fim | webpack/webpack | javascript |
<|fim_suffix|>xternal-module-a";
export const valueA = "module-A";
export function getFromExternalA() {
return externalValue;
}
export function callB() {
return valueB;
}
<|fim_prefix|>import { valueB } from "./mo<|fim_middle|>dule-b.js";
import { externalValue } from "e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>onst valueB = "module-B";
export function getFromExternalB() {
return externalValue;
}
export function callA() {
return valueA;
}
<|fim_prefix|>import { valueA } from "./module-a.js";
import { externalValue } f<|fim_middle|>rom "external-module-b";
export c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>in.mjs";
}
};
<|fim_prefix|>"use stric<|fim_middle|>t";
module.exports = {
findBundle() {
return "./ma<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"u<|fim_suffix|>nkFormat: "module"
},
externals: {
"external-module-a": "module ./external-a.mjs",
"external-module-b": "module ./external-b.mjs"
},
externalsType: "module",
optimization: {
concatenateModules: false
},
plugins: [
{
apply(compiler) {
compiler.hooks.thisCompilation.tap... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { __webpack_require__ as namedUse } from './runtime-export-named'
import defaultUse from './runtime-export-default'
import { __webpack_require__ as namedDeclUse } from './runtime-export-decl'
import { __webpack_require__ as objectRequire, __webpack_exports__ as objectExport } from './runtime-single... | fim | webpack/webpack | javascript |
<|fim_suffix|> require("./shared");
try{
__webpack_require__()
} catch {}
})
];
modules[0](__webpack_require__);
<|fim_prefix|>function __webpack_require__() {
throw new Error("Should be unreached");
}
const modules = [
// `__webpack<|fim_middle|>_require__` as arrow fn params should be replaced
((__webpa... | fim | webpack/webpack | javascript |
<|fim_prefix|>expo<|fim_suffix|>_webpack_require__() { return 42}
__webpack_require__.m = () => {}
<|fim_middle|>rt function _<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function __webpack_requir<|fim_suffix|>lt __webpack_require__
<|fim_middle|>e__() {return 42}
__webpack_require__.m = () => {}
export defau<|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.