text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>odule";
it("should work with destructuring", function() {
const key = "fo" + "o";
const { ...rest } = namespace;
expect(rest[key]).toBe("bar");
});
<|fim_prefix|>import * a<|fim_middle|>s namespace from "../destructuring-namespace-import/m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>onst foo = 'bar';
<|fim_prefix|>export <|fim_middle|>c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exp<|fim_suffix|>ion: {
concatenateModules: true
}
};
<|fim_middle|>orts = {
optimizat<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> __webpack_chunkname__;
<|fim_prefix|>export const h<|fim_middle|>ash = __webpack_hash__;
export const chunkName =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should hav<|fim_suffix|>webpack_hash__", function() {
expect(__webpack_hash__).toBeTypeOf("string");
expect(__webpack_hash__).toMatch(/^[0-9a-f]{20}$/);
return import("./chunk").then(({ hash }) => {
expect(hash).toBe(__webpack_hash__);
});
});
it("should have __webpack_chunkname__", function() {... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("<|fim_suffix|>entry: {
other: "./index"
}
};
<|fim_middle|>../../../../").Configuration} */
module.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should be able to use global <|fim_suffix|> module", function() {
var x = require("./module1");
expect(x.default === global).toBeTruthy();
});
<|fim_middle|>in a harmony<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export de<|fim_suffix|>
<|fim_middle|>fault 1;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>al;
<|fim_prefix|>var freeGlobal = typeof global === "object" && global && global.Object === Object && global;
<|fim_middle|>
export default freeGlob<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>../").Configuration} */
module.exports = {
target: "web",
performance: {
hints: false
}
};
<|fim_prefix|>"use strict";
/** @typ<|fim_middle|>e {import("../../../<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>this;
export const returnThisArrow = () => this;
export const returnThisMember = () => this.a;
export class C {
constructor() {
this.x = "bar";
}
foo() {
return this.x;
}
bar(x = this.x) {
return x;
}
}
export const extendThisClass = () => {
return class extends this.Buffer {};
};
export f... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
import {extendThisClass, returnThisArrow, returnThisMember, that} from "./abc";
import d, {a, b as B, C as _C, D as _D, E, F, f1, f2, f3, G} from "./abc";
import {bindThis, callT<|fim_suffix|>c.returnThisArrow())).toBe("undefined");
expect(function() {
returnThisMember();
}).toThrow();
... | fim | webpack/webpack | javascript |
<|fim_suffix|>is
}.bind(this);
export let callThis = function() {
return this
}.call(this)
export let applyThis = function() {
return this
}.apply(this)
<|fim_prefix|>// This helper is taken from Babel
function _newArrowCheck(innerThis, boundThis) {
if (innerThis !== boundThis) {
throw new TypeError("Cannot inst... | fim | webpack/webpack | javascript |
<|fim_suffix|>.pok = true;
export default C;
export {
C
};
<|fim_prefix|>function C() {
this.ok<|fim_middle|> = this.pok;
}
C.prototype<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{import("../../../../").Configuration} */
module.exports = {
module: {
strictThisContextOnImports: true
},
optimization: {
concatenateModules: false
}
};
<|fim_prefix|>"use <|fim_middle|>strict";
/** @type <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function returnThis() {
if (typeof this === "undefined") return "undefined";
return this;
}
var a = returnThis;
var b = returnThis;
export { a, b };
export const that = this;
export const returnThisArrow = () => this;
export const returnThisMember = () => this.a;
export class C {
constructor() {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
import {extendThisClass, returnThisArrow, returnThisMember, that} from "./abc";
import d, {a, b as B, C as _C, D as _D, E, F, f1, f2, f3, G} from "./abc";
import {bindThis, callThis, applyThis} from "./issue-7213";
import * as abc from "./abc";
it("should have this = undefined on harmony ... | fim | webpack/webpack | javascript |
// This helper is taken from Babel
function _newArrowCheck(innerThis, boundThis) {
if (innerThis !== boundThis) {
throw new TypeError("Cannot instantiate an arrow function");
}
}
let _this = this;
export let bindThis = function() {
_newArrowCheck(this, _this);
return this
}.bind(this);
export let callThis = fun... | fim | webpack/webpack | javascript |
<|fim_suffix|>t C;
export {
C
};
<|fim_prefix|>function C()<|fim_middle|> {
this.ok = this.pok;
}
C.prototype.pok = true;
export defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
strictThisContextOnImports: true
}
};
<|fim_prefix|><|fim_middle|>"use st<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>) => {
const source = fs.readFileSync(path.join(__dirname, "bundle1.js"), "utf-8");
expect(source).toMatch(`import(/* webpackIgnore: true */ "./other2.js")`);
expect(source).not.toMatch(`import(/* webpackIgnore: false */ "./other3.js")`);
});
<|fim_prefix|>const fs = require("fs");
const path = require... | fim | webpack/webpack | javascript |
<|fim_suffix|>"./other3.js");
<|fim_prefix|>import(/* webpackIgnore: true */ "./other2.js"<|fim_middle|>);
import(/* webpackIgnore: false */ <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export defaul<|fim_suffix|>
<|fim_middle|>t "other2";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>ult "other3";
<|fim_middle|>ort defa<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
bundle0: "./index.js",
bundle1: "./other.js"
},
output: {
filename: "[name].js"
},
node: {
__dirname: false
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should support computed property access with literal string on import.meta", () => {
con<|fim_suffix|>ort.meta[`url`]).toBe(url);
});
<|fim_middle|>st url = import.meta.url;
expect(import.meta["url"]).toBe(url);
});
it("should support computed property access with template string on import.meta", (... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
<|fim_suffix|>,
target: "node"
};
<|fim_middle|>module.exports = {
mode: "development",
devtool: false<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>1";
<|fim_prefix|>export default<|fim_middle|> "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>(false);
});
<|fim_prefix|>import { main } from "./module.js";
it("should handle import.meta.main", async () => {
expect(import.meta.main).toBe(true);
expect(typeof import.meta.main).toBe("boolean");
// Just for test, nobody uses this in real code
await import(<|fim_middle|>`./${typeof import.meta.m... | fim | webpack/webpack | javascript |
<|fim_prefix|>const main = import.meta.main;
export<|fim_suffix|>};
<|fim_middle|> { main <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "node",
optimization: {
concatenateModules: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../<|fim_middle|>../../").Configuration} */
module.exports = {
target:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ssed as an argument", () => {
function readUrl(meta) {
return meta.url;
}
expect(readUrl(import.meta)).toBe(url);
});
it("should return the same object for import.meta", () => {
expect(import.meta).toBe(import.meta);
const a = import.meta;
const b = import.meta;
expect(a).toBe(b);
});
it("shoul... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {<|fim_suffix|>",
experiments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module"
}
};
<|fim_middle|>
target: "node<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lue).toBe("ok");
});
<|fim_prefix|>it("should warn when the worker entry option is used in import(<|fim_middle|>)", async () => {
const { value } = await import(
/* webpackEntryOptions: { worker: true } */ "./module.js"
);
expect(va<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export co<|fim_suffix|>;
<|fim_middle|>nst value = "ok"<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = [[/`worker` entry option is not supported in `import\(\)`/]];
<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
devtool: false
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should provide a <|fim_suffix|> () {
var x = xxx.yyy(xxx.yyy, xxx.yyy);
expect(x).toBe("ok");
});
<|fim_middle|>module to a called free var", function<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ns: [
new ProvidePlugin({
"xxx.yyy": "aaa"
})
]
};
<|fim_prefix|>"use strict";
const ProvidePlugin = require("../../../../").ProvidePlugi<|fim_middle|>n;
/** @type {import("../../../../").Configuration} */
module.exports = {
plugi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should generate va<|fim_suffix|>(require("./module").obj.require).toEqual(require("./module").obj.r);
expect(require("./module").obj.require).toBeTypeOf("function");
});
<|fim_middle|>lid code when 'require' encounters object shorthand syntax", function() {
expect<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>equire, r: require}
<|fim_prefix|>exp<|fim_middle|>ort const obj = {r<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>prContextCritical: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
unknownContextRegExp: /^\.\//,
unknownContextCritical: false,
<|fim_middle|> exprContextRegExp: /^\.\//,
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should generate a chunk for a full require dependencies in require.ensure", done => {
require.ensure([], () => {
expect(require("./mo<|fim_suffix|>ect(__STATS__.chunks.length).toBe(2);
done();
});
});
<|fim_middle|>dule").property).toBe(42);
exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>2;
<|fim_prefix|>e<|fim_middle|>xports.property = 4<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("../../../../").Configuration} */
module.exports = {
mode: "production"
};
<|fim_prefix|>"use strict";
/** <|fim_middle|>@type {import<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should resolve absolute entr<|fim_suffix|>aths containing '#' in a directory name", () => {
expect(1 + 1).toBe(2);
});
<|fim_middle|>y p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"<|fim_suffix|>st `#`, failing to resolve.
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: `${path.join(__dirname, "index.js")}?protocol=ws&port=8080`
};
<|fim_middle|>use strict";
const path = require("path");
// Reproduces https://github.com/webpack/webpack/issues/16819:... | fim | webpack/webpack | javascript |
<|fim_suffix|>);<|fim_prefix|>it("should resolve relative entry paths containing '#' in a directory name", () => {
exp<|fim_middle|>ect(1 + 1).toBe(2);
}<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
// Companion to issue-16819-#-in-path-#: same project layout, but the entry is
// expressed as a relative request with a query string. Without escaping, the
// resolver mis-splits `#` in the directory portion and fails.
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: "./#di... | fim | webpack/webpack | javascript |
<|fim_suffix|>in();
done();
});
<|fim_prefix|>it("should compile and work", done => {
function main() {
if (!import.meta.webpackHot) {
return;
}
if (import.meta.webpackHot.status(<|fim_middle|>) !== "idle") {
console.log("idle");
}
}
ma<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ibrary: {
type: "commonjs"
}
},
optimization: {
minimize: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module<|fim_middle|>.exports = {
target: "node",
output: {
l<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
var x = System.anyNewItem;
expect((typeof x)).toBe("undefined");
})
<|fim_prefix|>it("should poly<|fim_middle|>fill System", function() {
if (typeof System === "object" && typeof System.register === "function") {
require("fail");
}
expect((typeof System)).toBe("object");
expect((typeof System.r... | fim | webpack/webpack | javascript |
<|fim_suffix|>type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /\.js$/,
parser: {
system: true
}
}
]
}
};
<|fim_prefix|>"us<|fim_middle|>e strict";
/** @<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nction() {
var x = aaa.test;
expect(x).toBe("test");
});
<|fim_prefix|>it("should provide a<|fim_middle|> module to a free var in a var decl", fu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const ProvidePlugin = require("../../../../").ProvidePlugin;
/** @type {import("../../../../").C<|fim_suffix|>gin({
aaa: "aaa"
})
]
};
<|fim_middle|>onfiguration} */
module.exports = {
plugins: [
new ProvidePlu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mode", () => {
if (false) {
function funcDecl() {}
}
expect(() => {
funcDecl;
}).not.toThrow();
});
it("should remove hoisted function declarations in strict mode", () => {
"use strict";
if (false) {
function funcDecl() {}
}
expect(() => {
funcDecl;
}).toThrow();
});
<|fim_prefix|>it("sh... | fim | webpack/webpack | javascript |
<|fim_suffix|>
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
optimizati<|fim_middle|>on: {
minimize: false
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as M from "./module";
it("should allow conditionals as callee", function() {
var x = (true ? M.fn : M.fn)();
expect(x)<|fim_suffix|>();
expect(x).toBe("ok");
});
<|fim_middle|>.toBe("ok");
});
it("should allow conditionals as object", function() {
var x = (true ? M : M).fn<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rn "ok";
}
<|fim_prefix|>export f<|fim_middle|>unction fn() {
retu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configurati<|fim_suffix|>
module: {
strictThisContextOnImports: true
}
};
<|fim_middle|>on} */
module.exports = {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>define([
`./${CONST_PREFIX0}/${DEFINED_EXPRESSION}/${CONST_SUFFIX0}`,
window.baz
? `./${CONST_PREFIX1}/${DEFINED_EXPRESSION}/${CONST_SUFFIX1}`
: `./${CONST_PREFIX2}/${DE<|fim_suffix|>? `./${CONST_PREFIX3}/${DEFINED_EXPRESSION}/${CONST_SUFFIX3}`
: `./${CONST_PREFIX4}/${DEFINED_EXPRESSION}/${CONST_S... | fim | webpack/webpack | javascript |
<|fim_prefix|>require([
`./${CONST_PREFIX0}/${DEFINED_EXPRESSION}/${CONST_SUFFIX0}`,
window.baz
? `./${CONST_PREFIX1}/${DEFINED_EXPRESSION}/${CONST_SUFFIX1}`
: `./${CONST_PREFIX2}/<|fim_suffix|>ypeof require === "function"
? `./${CONST_PREFIX3}/${DEFINED_EXPRESSION}/${CONST_SUFFIX3}`
: `./${CONST_PREFIX4}/${D... | fim | webpack/webpack | javascript |
<|fim_prefix|>require(`./${CONST_PREFIX0}/${DEFINED_EXPRESSION}/${CONST_SUFFIX0}`);
require(window.baz
? `./${CONST_PREFIX1}/${DEFINED_EXPRESSION}/$<|fim_suffix|>_EXPRESSION}/${CONST_SUFFIX4}`);
<|fim_middle|>{CONST_SUFFIX1}`
: `./${CONST_PREFIX2}/${DEFINED_EXPRESSION}/${CONST_SUFFIX2}`);
require(typeof require === "... | fim | webpack/webpack | javascript |
<|fim_prefix|>import(`./${CONST_PREFIX0}/${DEFINED_EXPRESSION}/${CONST_SUFFIX0}`);
import(window.baz
? `./${CONST_PREFIX1}/${DE<|fim_suffix|>/${DEFINED_EXPRESSION}/${CONST_SUFFIX4}`);
<|fim_middle|>FINED_EXPRESSION}/${CONST_SUFFIX1}`
: `./${CONST_PREFIX2}/${DEFINED_EXPRESSION}/${CONST_SUFFIX2}`);
import(typeof requir... | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = require("path");
["import", "amd-require", "amd-define", "commonjs", "require.resolve"].forEach(
method => {
it(`should be able to replace ${method} param in DefinePlugin`, function() {
const source = fs.readFileSync(
path.join(__dirname, `bundle-${method}... | fim | webpack/webpack | javascript |
<|fim_prefix|>e<|fim_suffix|><|fim_middle|>xport const test = 'test code 0';
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nst test = 'test code 1';
<|fim_prefix|>export<|fim_middle|> co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t test = 'test code 2';
<|fim_prefix|>export con<|fim_middle|>s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const<|fim_suffix|>est code 3';
<|fim_middle|> test = 't<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const test <|fim_suffix|>ode 4';
<|fim_middle|>= 'test c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>IX0}`);
require.resolve(
window.baz
? `./${CONST_PREFIX1}/${DEFINED_EXPRESSION}/${CONST_SUFFIX1}`
: `./${CONST_PREFIX2}/${DEFINED_EXPRESSION}/${CONST_SUFFIX2}`
);
require.resolve(
typeof require === "function"
? `./${CONST_PREFIX3}/${DEFINED_EXPRESSION}/${CONST_SUFFIX3}`
: `./${CONST_PREFIX4}/${... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
bundle0: "./index.js",
"bundle-import": "./import.js",
"bundle-amd-require": "./amd-define.js",
"bundle-amd-define": "./amd-require.js",
"bundle-commonjs": ".... | fim | webpack/webpack | javascript |
<|fim_suffix|>d") {
done.fail();
}
done();
});
<|fim_prefix|>it("should not evaluate __dirname or __filename when set to false", function(done) {
if (typeof __dirname !== "undefined") {
don<|fim_middle|>e.fail();
}
if (typeof __filename !== "undefine<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> scope.__dirname;
delete scope.__filename;
}
};
<|fim_prefix|>"use strict";<|fim_middle|>
module.exports = {
moduleScope(scope) {
delete<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e,
__dirname: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../<|fim_middle|>../").Configuration} */
module.exports = {
target: "web",
node: {
__filename: fals<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>d allow to access module.loaded when node option is set to false", function() {
expect(module.loaded).toBeDefined();
});
<|fim_prefix|>it("should al<|fim_middle|>low to access module.id when node option is set to false", function() {
expect(module.id).toBeDefined();
});
it("shoul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").C<|fim_suffix|>} */
module.exports = {
target: "web",
node: false
};
<|fim_middle|>onfiguration<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not load node bindi<|fim_suffix|>f global)).toBe("undefined");
});
<|fim_middle|>ngs when node option is false", function() {
expect((typeo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {imp<|fim_suffix|>web",
node: false
};
<|fim_middle|>ort("../../../../").Configuration} */
module.exports = {
target: "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not evaluate __dirname or __filename when node option is false", function(done) {
if (typeof __dirname !== "undefined") {
done.fail();
}
if (typeof __filename !== "undefi<|fim_suffix|>
done.fail();
}
done();
});
<|fim_middle|>ned") {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
delete scope.__dirname;
<|fim_suffix|>name;
}
};
<|fim_middle|> delete scope.__file<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("<|fim_suffix|>/../").Configuration} */
module.exports = {
target: "web",
node: false
};
<|fim_middle|>../../..<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not fail for optional<|fim_suffix|>existing");
} catch (e) {
error = e;
}
expect(() => {
throw error;
}).toThrow();
});
<|fim_middle|> modules with bail", () => {
let error;
try {
require("./not-<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").<|fim_suffix|>: true
};
<|fim_middle|>Configuration} */
module.exports = {
bail<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>FINED_ !== 2) require("fail");
if (_VALUE_?._PROP_?._DEFINED_ !== 2) require("fail");
if (typeof _VALUE_._PROP_._DEFINED_ !== "number") require("fail");
if (typeof _VALUE_?._PROP_?._DEFINED_ !== "number") require("fail");
if (typeof _VALUE_._PROP_ !== "object") require("fail");
if (typeof _VALUE_?._P... | fim | webpack/webpack | javascript |
<|fim_suffix|>ning = require("../../../helpers/supportsOptionalChaining");
module.exports = () => supportsOptionalChaining();
<|fim_prefix|>"use strict";
const <|fim_middle|>supportsOptionalChai<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { DefinePlugin } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
mo<|fim_suffix|>ment",
devtool: false,
target: "web",
plugins: [
new DefinePlugin({
_VALUE_: {
_DEFINED_: 1,
_PROP_: {
_DEFINED_: 2
}
}
})... | fim | webpack/webpack | javascript |
<|fim_suffix|>ng();
<|fim_prefix|>var a = 1<|fim_middle|>;
a.toStri<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>d in an IIFE", "because it needs to be in strict mode."].join(' ');
expect(code).not.toMatch(iifeComment);
});
<|fim_prefix|>import "./non<|fim_middle|>-strict"
import fs from "fs";
it("should not have iife for entry module when modules strict is different", () => {
const code = fs.readFileSync(__fil... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../.<|fim_suffix|>vascript: {
overrideStrict: "strict"
}
}
}
},
{
mode: "production",
entry: ["./strict"],
module: {
parser: {
javascript: {
overrideStrict: "non-strict"
}
}
}
}
];
<|fim_middle|>./").Configuration} */
modu... | fim | webpack/webpack | javascript |
<|fim_suffix|>fferent", () => {
const code = fs.readFileSync(__filename, "utf-8");
const iifeComment = [
"This entry needs to be wrapped in an IIFE",
"because it needs to be in strict mode."
].join(" ");
expect(code).not.toMatch(iifeComment);
});
<|fim_prefix|>import fs from "fs";
it("should import", async () ... | fim | webpack/webpack | javascript |
<|fim_suffix|> function () {}
<|fim_prefix|>export def<|fim_middle|>ault<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> javascript: {
overrideStrict: "strict"
}
}
}
};
<|fim_prefix|>"use strict";
/** @type <|fim_middle|>{import("../../../../").Configuration} */
module.exports = {
mode: "production",
entry: ["./strict"],
module: {
parser: {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>exports.filename = __filename;
exports.dirname = __dirname<|fim_middle|>;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should d<|fim_suffix|>name and __filename", function() {
expect(__dirname).toBe("");
expect(__filename).toBe("index.js");
expect(require("./dir/file").dirname).toBe("dir");
expect(require("./dir/file").filename).toMatch(/^dir[\\\/]file.js$/);
});
<|fim_middle|>efine __dir<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
node: {
__filename: true,
__dirname: true
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = req<|fim_suffix|>e = fs.readFileSync(path.join(__dirname, "bundle1.js"), "utf-8");
expect(source).toMatch(`require(/* webpackIgnore: true */ "./other2.js")`);
expect(source).not.toMatch(`require(/* webpackIgnore: false */ "./other3.js")`);
});
<|fim_middle|>uire("p... | fim | webpack/webpack | javascript |
<|fim_prefix|>require(/* webpackIgn<|fim_suffix|> webpackIgnore: false */ "./other3.js");
<|fim_middle|>ore: true */ "./other2.js");
require(/*<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default<|fim_suffix|>r2";
<|fim_middle|> "othe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>";
<|fim_prefix|>export default "other<|fim_middle|>3<|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.