text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>();
export { NativeClass, TranspiledClass };
<|fim_prefix|>import { x } from "./other/module-unused";
class NativeClass {
static f() {
return 42;
}
}
var TranspiledClass = /*#__PURE__*/ (function() {
x();
function C() {}
C.f = funct<|fim_middle|>ion() {
return 42;
};
return C;
})<|endoftext|... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { x } from "./other/module-used";
class NativeClass {
static f() {
return 42;
}
}
var TranspiledClass = /*#__PURE__*/ (function() {
x()<|fim_suffix|>;
return C;
})();
export { NativeClass, TranspiledClass };
<|fim_middle|>;
function C() {}
C.f = function() {
return 42;
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>ex<|fim_suffix|>x() {}
<|fim_middle|>port function <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>) {}
<|fim_prefix|>export <|fim_middle|>function x(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>imp<|fim_suffix|>e-module";
<|fim_middle|>ort "./som<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import doSomething from "./module";
export function t<|fim_suffix|>);
}
<|fim_middle|>est() {
doSomething({
type: "inline"
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port("./chunk")]);
});
<|fim_prefix|>it("should generate correct code when pure ex<|fim_middle|>pressions are in dead branches", () => {
require("./import-module").test();
return Promise.all([import("./some-module"), im<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ype(obj) {
return obj.type;
}
// Local functions
function doSomethingWithBlock(obj) {
return Block.doSomething(obj);
}
function doSomethingWithInline(obj) {
return Inline.doSomething(obj);
}
function doSomethingWithDocument(obj) {
return Document.doSomething(obj);
}
// Exported functions
function ... | fim | webpack/webpack | javascript |
<|fim_suffix|>xport { Block, Inline, Document };
<|fim_prefix|>class Block {
static doSomething() {}
}
class Inline {
static doSomething() {}
}
class Documen<|fim_middle|>t {
static doSomething() {}
}
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>imp<|fim_suffix|>
expect(ok).toBe(true);
expect(ok2).toBe(true);
<|fim_middle|>ort { ok, ok2 } from "./module";
<|endoftext|> | fim | webpack/webpack | javascript |
it("should not threat globals as pure", () => {
require("./import-module");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> {
const b = a;
var c = b;
const a = 42;
var ok2 = false;
eval(""); // TODO terser has a bug and incorrectly remove this code, eval opts out
} catch (e) {
var ok2 = true;
}
export { x, y, c, ok, ok2 };
<|fim_prefix|>try {
v<|fim_middle|>ar x = NOT_DEFINED;
var y = x;
var ok = false;
} catch (e) ... | fim | webpack/webpack | javascript |
<|fim_suffix|>e("./b.json") }).toEqual({ data: 123 });
expect({ data: require("./c.json") }).toEqual({ data: [1, 2, 3, 4] });
expect({ data: require("./e.json") }).toEqual({ data: {
"aa": 1,
"bb": 2,
"1": "x"
} });
});
<|fim_prefix|>it("should require json via require", function() {
expect({ data: require("./... | fim | webpack/webpack | javascript |
<|fim_suffix|>lt");
});
<|fim_prefix|>import { default as f } from "../data/f.json?default<|fim_middle|>-imported";
import * as fStar from "../data/f.json?ns-imported";
it("should be possible to access a default key", () => {
expect(f.default).toBe("default");
expect(fStar.default.default).toBe("defau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>default-default";
<|fim_prefix|><|fim_middle|>import "../<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import poison from ".<|fim_suffix|>
<|fim_middle|>./data/poison" assert { type: "json" };
export default poison;<|endoftext|> | fim | webpack/webpack | javascript |
import c from "../data/c.json" assert { type: "json" };
import unknownJson from "../data/unknown" assert { type: "json" };
import unknownJs from "../data/unknown";
it("should be possible to import json data with import assertion", function () {
expect(c).toEqual([1, 2, 3, 4]);
});
it("should be possible to import js... | fim | webpack/webpack | javascript |
<|fim_suffix|>= [
/^Pack got invalid because of write to: Compilation\/modules|json.+json\/data\/poison$/
];
<|fim_prefix|>"use str<|fim_middle|>ict";
module.exports <|endoftext|> | fim | webpack/webpack | javascript |
import * as c from "../data/c.json";
import * as d from "../data/d.json";
import { bb, aa } from "../data/e.json";
import f, { named } from "../data/f.json";
import g, { named as gnamed } from "../data/g.json";
it("should be possible to import json data", function() {
expect(c[2]).toBe(3);
expect(Object.keys(d)).toE... | fim | webpack/webpack | javascript |
<|fim_prefix|>import "../impor<|fim_suffix|>ame";
<|fim_middle|>t-by-n<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}));
expect(d).toEqual(nsObj({
default: {}
}));
expect(e).toEqual(nsObj({
aa: 1,
bb: 2,
1: "x",
default: {
aa: 1,
bb: 2,
"1": "x"
}
}));
expect(f).toEqual(nsObj({
named: "named",
default: {
named: "named",
"default": "default",
__esModule: true
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { aa } from "../data/e.json" with { type: "json" };
import { named } from '../data/f.json' with { t<|fim_suffix|>ined);
expect(named).toEqual(undefined);
});
<|fim_middle|>ype: "json" };
it("should not allow named import with import assertion", function () {
expect(aa).toEqual(undef<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import a from "../data/a.json";
import b from "../data/b.json";
import c from "../data/c.json";
import d from "../data/d.json";
import e from "../data/e.json";
import f from "../data/f.json";
it("should be possible to import json data<|fim_suffix|>pect(c).toEqual([1, 2, 3, 4]);
expect(d).toEqual({});
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>h-default";
<|fim_prefix|>import<|fim_middle|> "../import-wit<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import poison from "../data/poison" with { type: "json" };
export <|fim_suffix|>;
<|fim_middle|>default poison<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>, function () {
expect(c).toEqual([1, 2, 3, 4]);
});
it("should be possible to import json data without extension with import assertion", function () {
expect(unknownJson).toEqual([1, 2, 3, 4]);
});
it("should be possible to import js without extension without import assertion in the same file", funct... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = [
/^Pa<|fim_suffix|>;
<|fim_middle|>ck got invalid because of write to: Compilation\/modules|json.+json\/data\/poison$/
]<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import data1 from "./array.json?1";
import data2 from "./array.json?2";
it("should allow to call prototype methods", () => {
expect(data1.map(d => d * 2)).toE<|fim_suffix|>totype.smoosh;
}
});
<|fim_middle|>qual([2, 2, 4, 6, 10]);
expect(data2.map(d => d * 2)).toEqual([2, 2, 4, 6, 10]);
expect(requir... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { e, f, fNamed, fStar, fStarPartial, fStarPartial2 } from "./reexport";
it("sh<|fim_suffix|> const _fStar = fStar;
expect(_fStar).toEqual(
nsObj({
named: "named",
default: { named: "named", default: "default", __esModule: true }
})
);
expect(_fStar.__esModule).toBe(true);
expect(fSta... | fim | webpack/webpack | javascript |
<|fim_suffix|>};
import * as fStarPartial from "../data/f.json?namespace-object-exported-but-only-default-named-used";
export { fStarPartial };
import * as fStarPartial2 from "../data/f.json?namespace-object-exported-but-only-named-used";
export { fStarPartial2 };
<|fim_prefix|>export { default as e } from "../data/e.j... | fim | webpack/webpack | javascript |
<|fim_prefix|>import globals from "./globals.json?all";
import someGl<|fim_suffix|>
expect(child).toBeTypeOf("boolean");
}
}
};
walk(globals);
});
it("should allow accessing some properties with tree-shaking", () => {
expect(someGlobals.builtin.constructor).toBe(false);
expect(someGlobals.es5.eval).toBe(f... | fim | webpack/webpack | javascript |
<|fim_suffix|>uffer.alloc(+options.size).fill(0xa5);
};
module.exports.raw = true;
<|fim_prefix|>/** @type {import("../../../../").RawLoaderDefinition<{ size: string }>} */
module.exports = function () {
const opti<|fim_middle|>ons = this.getOptions();
return B<|endoftext|> | fim | webpack/webpack | javascript |
const createHash = require("../../../../lib/util/hash/xxhash64");
const fs = require("fs");
const h = url => {
const hash = createHash();
hash.update(fs.readFileSync(url));
return hash.digest("hex");
};
it("should compile fine", () => {
const a = new URL(
"./generate-big-asset-loader.js?size=100000000!",
impo... | fim | webpack/webpack | javascript |
"use strict";
const path = require("path");
const { parseResource } = require("../../../../lib/util/identifier");
module.exports = {
timeout: 120000,
findBundle(_, options) {
const ext = path.extname(parseResource(options.output.filename).path);
return `./bundle${ext}`;
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
// Only run in the normal suite in CI — source-map and other suites
<|fim_suffix|>I || config.name === "normal";
<|fim_middle|>// multiply output size and exhaust CI disk space (ENOSPC).
module.exports = (config) => !process.env.C<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = [
// ObjectMiddleware, loader-runner, jest-worker, minimizer-webpack-plugin/utils.js
/Critical dependency: the request of a dependency is an expression/,
/Critical dependency: the request of a dependency is an expression/,
/Critical dependency: the request of a dependen... | fim | webpack/webpack | javascript |
<|fim_suffix|>n(
", "
)}].reduce((a, b) => a + b);`;
};
<|fim_prefix|>/** @type {import("../../../../").RawLoaderDefinition<{ count: string }>} */
module.exports = function () {
const options = this.getOptions();
return `import thing from "./module";
expor<|fim_middle|>t default [${Array.from({ length: +options.co... | fim | webpack/webpack | javascript |
<|fim_suffix|>000);
expect(d).toBe(1000000);
});
<|fim_prefix|>impo<|fim_middle|>rt a from "./generate-many-replacements-loader?count=1000!./module";
import b from "./generate-many-replacements-loader?count=10000!./module";
import c from "./generate-many-replacements-loader?count=100000!./module";
import d from "./gen... | fim | webpack/webpack | javascript |
<|fim_suffix|>lt 1;
<|fim_prefix|>export <|fim_middle|>defau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t: 120000
};
<|fim_prefix|>"use strict";
module.<|fim_middle|>exports = {
timeou<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = () => !process.env.CI;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var fs =<|fim_suffix|>"), "utf-8") + "\n.generated { color: red; }"
};
};
<|fim_middle|> require("fs");
var path = require("path");
module.exports = function() {
return {
code: fs.readFileSync(path.join(path.dirname(__filename), "stylesheet.css<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>!")).toBe("module");
expect(require("./loader.mjs!")).toBe("module");
});
<|fim_prefix|>it("should pass package.json type to loader", function () {<|fim_middle|>
expect(require("esm/loader.js!")).toBe("module");
});
it("should pass 'module' type to loader for .mjs", function () {
expect(require("cjs/l... | fim | webpack/webpack | javascript |
/** @type {import("../../../../").LoaderDefinition} */
export default function loader() {
return `export default "${this.loaders[this.loaderIndex].type}";`;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
mod<|fim_suffix|> // TODO need fix in v8 https://github.com/nodejs/node/issues/35889
// TODO otherwise this test case cause segment fault
false;
<|fim_middle|>ule.exports = () =>
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.e<|fim_suffix|>ts = "a";<|fim_middle|>xpor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("a");
expect(require("./loaders/syncloader!./loaders/syncloader!./a")).toBe("a");
expect(require("./loaders/syncloader!./loaders/asyncloader!./a")).toBe("a");
expect(require("./loaders/asyncloader!./loaders/syncloader!./a")).toBe("a");
expect(require("./loaders/asyncloader!./loaders/asyncloader!./a"... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../../").LoaderDefinition} */
mo<|fim_suffix|>;
};
<|fim_middle|>dule.exports = function (content) {
var cb = this.async();
if (!cb) throw new Error("Loader should allow async mode");
if (cb !== this.callback)
throw new Error("result of this.async() should be equal to this... | fim | webpack/webpack | javascript |
<|fim_suffix|>type {import("../../../../../").LoaderDefinition} */
module.exports = function (content) {
return content;
};
<|fim_prefix|>/** <|fim_middle|>@<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>erwise this test case cause segment fault
// expect(require("esm/loader.cjs!")).toBe("commonjs");
});
<|fim_prefix|>it("should pass package.json type to loader", function () {
expect(require("cjs/loader.js!")).toBe("commonjs");
expect(require("./loader.js!")).toBe("undefined");
});
it("should pass 'co... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** <|fim_suffix|>erIndex].type}";`;
};
<|fim_middle|>@type {import("../../../../").LoaderDefinition} */
module.exports = function loader() {
return `module.exports = "${this.loaders[this.load<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>-only.coffee");
});
<|fim_prefix|>it("should handle the coffee loader correctly", function() {
expect(require("!coffee-loader!../_resources/script.coffee"<|fim_middle|>)).toBe("coffee test");
expect(require("../_resources/script.coffee")).toBe("coffee test");
});
it("should handle literate coffee scrip... | fim | webpack/webpack | javascript |
<|fim_suffix|>raw-loader!../_resources/" + abc + ".txt").default).toBe(
"abc"
);
});
<|fim_prefix|>it("should be able to use a context with a loader", function() {
var abc = "abc",
scr = "script.coffee";
expect(require("../_resources/" + scr)).toBe("coffee test");
expect(req<|fim_middle|>uire("<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const majorVersion = Number.parseInt(process.versions.node.split(".")[0], 10);
const support<|fim_suffix|>exports = (config) =>
majorVersion >= 16 && (!config.module || supportsRequireInModule());
<|fim_middle|>sRequireInModule = require("../../../helpers/supportsRequireInModule");
modul... | fim | webpack/webpack | javascript |
<|fim_suffix|>heet.css").default + "").toContain(
".rule-direct"
);
expect(require("!css-loader!../_css/stylesheet.css").default + "").toContain(
".rule-import1"
);
expect(require("!css-loader!../_css/stylesheet.css").default + "").toContain(
".rule-import2"
);
});
<|fim_prefix|>it("should handle the css loa... | fim | webpack/webpack | javascript |
module.exports = "ok";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./loader!./file";
it("should have the file emitted", () => {
<|fim_suffix|>bpack_require__("./extra-file.js");
expect(result).toBe("ok");
});
<|fim_middle|>const result = __non_we<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>", content);
return "";
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (content) {
this.emitFile("ex<|fim_middle|>tra-file.js<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|> = (config) => !config.module;
<|fim_middle|>module.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>loader!!";
it("should compile", () => {
expect(typeof content).toBe("string");
expect(content.startsWith("webpack://")).toBe(true);
});
<|fim_prefix|>i<|fim_middle|>mport content from "./<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const path = require("path");
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const callback = this.async();
this.importModule(
path.resolve(__dirname, "module.js"),
{ baseUri: "webpack://" },
(error, exports) => {
if (error) {
callback(error);
re... | fim | webpack/webpack | javascript |
<|fim_prefix|>const asset =<|fim_suffix|>, import.meta.url);
export { asset }
<|fim_middle|> new URL("./a.json"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use str<|fim_suffix|>module;
<|fim_middle|>ict";
module.exports = (config) => !config.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s!./text.txt");
expect(result.default).toEqual(answer);
});
<|fim_prefix|>import { answer } from './lib';
it("should load module correctly", function() {
var result = require("./text.<|fim_middle|>txt.js!=!./loader.j<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export co<|fim_suffix|>2;
<|fim_middle|>nst answer = 4<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const loaderPath = require.resolve("./loader");
/** @type {import("../../../..<|fim_suffix|>r, source) => {
this.callback(err, source);
});
};
<|fim_middle|>/").LoaderDefinition} */
module.exports = function () {
if (this.query === "?load") {
return `
import { answer } from "./lib";
export default... | fim | webpack/webpack | javascript |
it("should be able to use loadModule multiple times within a loader, on files in different directories", function() {
const data = require("!./loader/index.js!./a.data");
expect(data).toHaveProperty("a");
expect(data).toHaveProperty("b");
expect(data).toHaveProperty("c");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var asyncLib = require("neo-async");
module.exports = function(content) {
var cb = this.async();
var json = JSON.parse(content);
asyncLib.mapSeries(
json.impo<|fim_suffix|>tion(err, source, map, module) {
if (err) {
return callback(err);
}
callback(null, JSON.parse(source));
});
... | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>modul<|fim_middle|>e.exports = "a";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"c");
<|fim_prefix|>module.exports = requ<|fim_middle|>ire(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>m<|fim_suffix|><|fim_middle|>odule.exports = "c";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>")).toBe("c");
});
<|fim_prefix|>it("should resolve module dependencies recursively", function() {
expect(require("!./<|fim_middle|>loaders/index!a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = function() {
var ca<|fim_suffix|>or) {
return callback(error);
}
callback(null, "module.exports = require('b');");
});
};
<|fim_middle|>llback = this.async();
this.loadModule("b", function(error) {
if (err<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
});
<|fim_prefix|>it("should be able to load JSON files without loader", function() {
var someJson = require("./some.json");
expect(someJson).toHaveProperty("it", "works");
expect(someJson).toHaveProperty("number", 42);
});
it("should also work when the json extensio<|fim_middle|>n is omitted", func... | fim | webpack/webpack | javascript |
<|fim_suffix|>oContain(".less-rule-import1");
expect(
require("!raw-loader!less-loader!./less/stylesheet.less").default
).toContain(".less-rule-import2");
});
<|fim_prefix|>it("should handle<|fim_middle|> the less loader (piped with raw loader) correctly", function() {
expect(
require("!raw-loader!less-loader!./... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should run a loader from package.json", function() {
expect(require("testloader!../_resources/abc.txt")).toBe("abcwebpack");
expect(require("testloader/lib/loader2!../_resources/abc.txt")).toBe("abcweb");
expect(require("testloader/lib/loader3!../_resources/abc.txt")).toBe("abcloader");
expect(req... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../.<|fim_suffix|>join("");
};
<|fim_middle|>./../../").LoaderDefinition} */
module.exports = function (content) {
return content.split("").reverse().<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>123<|fim_middle|>
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("shoul<|fim_suffix|>.js!./file.js")).toThrow(
/Module build failed/
);
});
<|fim_middle|>d emit the correct error for loaders not returning buffer or string", function() {
expect(() => require("./loader.js!./file.js")).toThrow(
/Module build failed/
);
expect(() => require("./loader.js!./pitch-... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = [
/^Pack got invalid because of wr<|fim_suffix|>o: Compilation\/modules.+no-string[/\\]loader\.js!.+no-string[/\\]file\.js$/
];
<|fim_middle|>ite t<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = () => {
return 123;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = () => {
return 1<|fim_suffix|>3;
};
<|fim_middle|>2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|></p><h1>included</h1>");
expect(require("../_resources/template.pug")({ abc: "abc" })).toBe("<p>abc</p><h1>included</h1>");
});
<|fim_prefix|>it("should handle the pug loader correctly",<|fim_middle|> function() {
expect(require("!@webdiscus/pug-loader?self=true!../_resources/template.pug")({ abc: "abc"... | fim | webpack/webpack | javascript |
<|fim_suffix|>ersion = Number.parseInt(process.versions.node.split(".")[0], 10);
const supportsRequireInModule = require("../../../helpers/supportsRequireInModule");
module.exports = (config) =>
majorVersion >= 16 && (!config.module || supportsRequireInModule());
<|fim_prefix|>"us<|fim_middle|>e strict";
const majo... | fim | webpack/webpack | javascript |
<|fim_suffix|>ts = "a";<|fim_prefix|>module.exp<|fim_middle|>or<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>tes<|fim_suffix|>content<|fim_middle|>t <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> expect(result).toBeTypeOf("object");
expect(result).toHaveProperty("resourceQuery", "?resourcequery");
expect(result).toHaveProperty("query", "?query1");
expect(result).toHaveProperty("prev", "module.exports = " + JSON.stringify({
resourceQuery: "?resourcequery",
query: "?query2",
prev: "module.... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @<|fim_suffix|>tent
})
);
};
<|fim_middle|>type {import("../../../../../").LoaderDefinition} */
module.exports = function (content) {
return (
"module.exports = " +
JSON.stringify({
resourceQuery: this.resourceQuery,
query: this.query,
prev: con<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle the r<|fim_suffix|>", function() {
expect(require("raw-loader!../_resources/abc.txt").default).toBe("abc");
});
<|fim_middle|>aw loader correctly<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>js",
four: "index.xyz",
five: "index.js"
});
});
<|fim_prefix|>it("should be possible to create resol<|fim_middle|>ver with different options", () => {
const result = require("./loader!");
expect(result).toEqual({
one: "index.js",
two: "index.xyz",
three: "index.<|endoftext|> | fim | webpack/webpack | javascript |
const path = require("path");
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const resolve1 = this.getResolve();
const resolve2 = this.getResolve({
extensions: [".xyz", ".js"]
});
const resolve3 = this.getResolve({
extensions: [".hee", "..."]
});
const resolve4 = this.ge... | fim | webpack/webpack | javascript |
<|fim_suffix|>qual({
request1: "./index.js",
request2: "./index.js"
});
});
<|fim_prefix|>it("should allow to access utils in loader", () => {
expect(require("./loader!" + __filen<|fim_middle|>ame)).toE<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module<|fim_suffix|>ports = function () {
return `module.exports = {
request1: ${JSON.stringify(
this.utils.contextify(
this.context,
this.utils.absolutify(this.context, "./index.js")
)
)},
request2: ${JSON.stringify(
this.utils.contex... | fim | webpack/webpack | javascript |
<|fim_suffix|>t"
};
<|fim_prefix|>module.exports = {
da<|fim_middle|>ta: "ok",
default: "defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s.data = "ok";
exports.default = "default";
<|fim_prefix|>exports.__es<|fim_middle|>Module = Math.random() < -1;
export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> -1;
exports.data = "ok";
exports.default = "default";
<|fim_prefix|>exports.__esModule = Math<|fim_middle|>.random() ><|endoftext|> | fim | webpack/webpack | javascript |
exports.__esModule = true;
exports.data = "ok";
exports.default = "default";
<|endoftext|> | fim | webpack/webpack | javascript |
import { data } from "./cjs.js";
import * as star from "./cjs.js";
import def from "./cjs.js";
import {
ns,
default as def1,
def as def2,
data as data2
} from "./reexport.mjs";
import * as reexport from "./reexport.mjs";
import { data as dynamicData } from "./dynamic.js";
import * as dynamicStar from "./dynamic.js... | fim | webpack/webpack | javascript |
<|fim_suffix|> from "./cjs.js";
<|fim_prefix|>import * as ns from "./cjs.js";<|fim_middle|>
export { ns };
export { default } from "./cjs.js";
export { default as def } from "./cjs.js";
export { data as data }<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>require("./index.mjs<|fim_middle|>").setOk()<|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.