text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>return import("./module.wat").then(function({get}) {
expect(get()).toBe(0xFFFFFFFFFF);
});
});
<|fim_prefix|>it("should preserve the valt<|fim_middle|>ype of the imported global", function() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>embly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|fim_prefix|>"use strict";
const supportsWe<|fim_middle|>bAss<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>al(11);
});
});
<|fim_prefix|>it("should allow to run a WebAssembly m<|fim_middle|>odule with imports", function() {
return import("./wasm.wat?1").then(function(wasm) {
const result = wasm.addNumber(3);
expect(result).toEqu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Number() {
return 8;
}
<|fim_prefix|>expo<|fim_middle|>rt function get<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.exports = () => supportsWebAssembly();
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../../helpers/su<|fim_middle|>pportsWebAssembly");
module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>orting JS circular", function() {
return import("./module").then(function(mod) {
expect(mod.result).toBe(42);
});
});
<|fim_prefix|>it("should allow<|fim_middle|> to run a WebAssembly module imp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { addNumber } from "<|fim_suffix|>r result = addNumber(22);
export function getNumber() {
return 20;
}
<|fim_middle|>./wasm.wat";
export va<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>xpect(result).toEqual(42);
});
});
<|fim_prefix|>it("should allow to run a WebAssembly module with non-js-compatible imports", function() {
<|fim_middle|>return import("./wasm.wasm").then(function(wasm) {
const result = wasm.testV128();
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stri<|fim_suffix|>pports.simd();
<|fim_middle|>ct";
const supports = require("webassembly-feature");
module.exports = () => su<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow to run a WebAssembly module with many direct wasm dependencies", function() {
retu<|fim_suffix|>("./wasm.wat").then(function(wasm) {
const result = wasm.testI64();
expect(result).toEqual(42);
});
});
<|fim_middle|>rn import<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rtsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|fim_prefix|>"use strict";
cons<|fim_middle|>t suppo<|endoftext|> | fim | webpack/webpack | javascript |
it("should allow to run a WebAssembly module importing from multiple modules", function() {
return import("./module").then(function(mod) {
expect(mod.result).toBe(42);
});
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t = getResult(1);
export function getNumber() {
return 20;
}
<|fim_prefix|>import { getResult<|fim_middle|> } from "./wasm.wasm";
export var resul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { getNumber as getN } from "./wasm.wasm";<|fim_suffix|>er() {
return getN();
}
<|fim_middle|>
export function getNumb<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../<|fim_suffix|> supportsWebAssembly();
<|fim_middle|>../helpers/supportsWebAssembly");
module.exports = () =><|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow direct memory connection between wasm modules", function() {
<|fim_suffix|>le.x1).toBe(42);
expect(module.x2).toBe(42);
expect(module.y1).toBe(11);
expect(module.y2).toBe(11);
});
});
<|fim_middle|> return import("./run").then(function(module) {
expect(modu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as a1 from "./mem-access.wat?1";
import * as a2 from "./mem-access.wat?2";
a1.set(42);
export const x1 = a1.get();
exp<|fim_suffix|>export const y2 = a2.get();
<|fim_middle|>ort const x2 = a2.get();
a2.set(11);
export const y1 = a1.get();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>WebAssembly();
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../../<|fim_middle|>helpers/supportsWebAssembly");
module.exports = () => supports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>export default results;
<|fim_prefix|>import { trackA, results } from "./tracker";
imp<|fim_middle|>ort "./b.js";
import "./wasm.wat";
trackA();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>m "./tracker";
trackB();
<|fim_prefix|>impo<|fim_middle|>rt { trackB } fro<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { trackC } from "./tracker";
trackC();
expo<|fim_suffix|>
<|fim_middle|>rt const magicNumber = 42;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>k", "wasm42", "a"]);
});
});
});
<|fim_prefix|>it("should be evaluated in the correct order", () => {
return import("./a").then(({ default: results }) => {
return Promise.re<|fim_middle|>solve().then(() => {
// wait an extra tick to get the tick from the tracker
expect(results).toEqual(["b", "... | fim | webpack/webpack | javascript |
<|fim_suffix|>/helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|fim_prefix|>"use strict";
c<|fim_middle|>onst supportsWebAssembly = require("../../..<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Promise.resolve().then(() => results.push("tick"));
<|fim_prefix|>export let results = [];
export<|fim_middle|> function trackA() { results.push("a"); }
export function trackB() { results.push("b"); }
export function trackC() { results.push("c"); }
export function trackWasm(number) { results.push("wasm" ... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow to run a WebAssembly module (indirect)", function() {
return import("./module").then(function(module) {
const result = module.run();
expect(result).toEqual(42);
});
});
it("shoul<|fim_suffix|>t)", function() {
return import("./wasm.wat?2").then(function(wasm) {
const result = wa... | fim | webpack/webpack | javascript |
<|fim_suffix|>m.wat?1";
export function run() {
return add(getNumber(), 2);
}
<|fim_prefix|>import { add, getNumber<|fim_middle|> } from "./was<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|fim_prefix|>"use strict";
const supportsWebAss<|fim_middle|>embly = require<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>_FUNCTION_TABLE);
});
});
<|fim_prefix|>// the message is inconsistency between some nodejs versions
const UNKNOWN_FUNCTION_TABLE = /table index is out of bounds|invalid index into function table|invalid function/;
it("should support tables", function () {
return import("./wasm-table.wat").then(functio... | fim | webpack/webpack | javascript |
<|fim_suffix|>portsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supportsWebAssembly();
<|fim_prefix|>"use <|fim_middle|>strict";
const sup<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>).toEqual("Hello World");
});
});
<|fim_prefix|>it("should be able to create two modules from loader", function() {
return import("./wrapper-load<|fim_middle|>er!./src/wasm.dat").then(function(wasm) {
expect(wasm.getString()).toEqual("Hello World");
});
});
it("should be able to create two modules f... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
mo<|fim_suffix|>embly();
<|fim_middle|>dule.exports = () => supportsWebAss<|endoftext|> | fim | webpack/webpack | javascript |
/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
module.exports.pitch = function (remainingRequest) {
return `
import { getString as _getString, memory } from ${
JSON.stringify(`${this.utils.contextify(this.context, this.resourcePath)}.wat!=!${this.utils.contextify(this.context, remainingRequest)... | fim | webpack/webpack | javascript |
/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
module.exports.pitch = function (remainingRequest) {
return `
import { getString as _getString, memory } from ${
JSON.stringify(`${this.utils.contextify(this.context, this.resourcePath)}.wat!=!${this.utils.contextify(this.context, remainingRequest)... | fim | webpack/webpack | javascript |
<|fim_suffix|>ect(result).toEqual(42);
});
});
<|fim_prefix|>it(<|fim_middle|>"should allow wasm with unused exports", function() {
return import("./module").then(function(module) {
const result = module.run();
exp<|endoftext|> | fim | webpack/webpack | javascript |
import { getNumber } from "./wasm.wat";
export function run() {
return getNumber();
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => supports<|fim_suffix|>ssembly();
<|fim_middle|>WebA<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>it("should support wasm compiled with v12<|fim_middle|>8", function() {
return import("./v128.wasm");
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>eturn supportsWebAssembly() && supportsFeature.simd();
false;
<|fim_prefix|>"use strict";
// const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
// const supportsFeature = require("webassembly-feature");
module.expo<|fim_middle|>rts = () =>
// TODO fails with CompileError: Web... | fim | webpack/webpack | javascript |
it("Q_rsqrt should work", function() {
return import("./Q_rsqrt.wasm").then(function(wasm) {
const result = wasm._Z7Q_rsqrtf(1/1764);
expect(result).toBeGreaterThan(41.9);
expect(result).toBeLessThan(42.1);
});
});
it("testFunction should work", function() {
return import("./testFunction.wasm").then(function(... | fim | webpack/webpack | javascript |
<|fim_suffix|>upportsWebAssembly();
<|fim_prefix|>"use strict";
const<|fim_middle|> supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () => s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("Q_rsqrt should work", function() {
return import("./tests").then(t => t.run_Q_rsqrt());
});
it("testFunction should work", function() {
return import("./tests").then(t => t.run_testFunction());
});
it("fact should work", function() {
return import("./tests").then(t => t.run_fact());
});
it("popc... | fim | webpack/webpack | javascript |
<|fim_suffix|>tsWebAssembly();
<|fim_prefix|>"use strict";
const supportsWebAssembly = require("../../../helpers/supportsWebAssembly");
module.exports = () =><|fim_middle|> suppor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>32Array(testFunction.memory.buffer);
view[0] = 123;
view[1] = 1;
view[2] = 2;
view[3] = 3;
const result = testFunction._Z12testFunctionPii(4, 3);
expect(result).toEqual(6);
}
export function run_fact() {
const result = fact._Z4facti(11);
expect(result).toEqual(39916800);
}
export function run_po... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
const fs = require("graceful-fs");
const { matchKindSnapshot } = require("./harness/snapshot");
/**
* @param {string} str string to escape for use in a RegExp
* @returns {string} escaped string
*/
const quoteMeta = (str) => str.replace(/[.*+?^${}()|[\]\\]/g... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const {
DELETE,
cachedCleverMerge,
cleverMerge,
removeOperations,
resolveByProperty
} = require("../lib/util/cleverMerge");
/** @typedef {Record<string, EXPECTED_ANY[]>} CasesMap */
describe("cleverMerge", () => {
const base = {
a1: [1],
a2: [1],
a3: [1],
b1: [1, "...", 2],
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { compareLocations } = require("../lib/util/comparators");
/** @typedef {import("../lib/Dependency").DependencyLocation} DependencyLocation */
/** @typedef {import("../lib/Dependency").SourcePosition} SourcePosition */
/** @typedef {import("../lib/Dependency").RealDependencyLocation}... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { sortWithSourceOrder } = require("../lib/util/comparators");
/** @typedef {import("../lib/Dependency")} Dependency */
/** @typedef {import("../lib/util/comparators").DependencySourceOrder} DependencySourceOrder */
describe("sortWithSourceOrder", () => {
/** @type {WeakMap<Dependen... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { compareStringsNumeric } = require("../lib/util/comparators");
/**
* @param {string} a string
* @param {string} b string
* @returns {-1 | 0 | 1} compare result
*/
const referenceComparer = (a, b) => {
const partsA = a.split(/(\d+)/);
const partsB = b.split(/(\d+)/);
const len... | fim | webpack/webpack | javascript |
<|fim_suffix|>pack_sharing_consume_default_react_react"
],
(e) =>
e.toMatchInlineSnapshot(
"webpack_sharing_consume_default_(|classnames_classnames\\-webpack_sharing_consume_default_)react_react"
)
);
});
<|fim_prefix|>"use strict";
/** @typedef {ReturnType<expect>} ExceptResult */
const { itemsToRegex... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should<|fim_suffix|>tion(done) {
done();
});
<|fim_middle|> compile", func<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").WebpackPluginFunction} */
function testPlugin() {
let counter = 1;
th<|fim_suffix|>ompilation.tap("TestPlugin", (compilation) => {
const nr = counter++;
compilation.hooks.needAdditionalPass.tap("TestPlugin", () => {
if (nr < 5) return true;
});
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ine).toBe('undefined')
done()
})
<|fim_prefix|>it("should compile<|fim_middle|>", function(done) {
done();
});
it("should disable define", function(done) {
expect(typeof def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
am<|fim_suffix|> false
};
<|fim_middle|>d:<|endoftext|> | fim | webpack/webpack | javascript |
import inner from "./inner";
it("should handle anonymous default function declaration under module concatenation", () => {
// When ConcatenationScope renames `__WEBPACK_DEFAULT_EXPORT__` to a
// module-scoped symbol, any Reflect.defineProperty InitFragment added
// for the anonymous default fix-up must reference th... | fim | webpack/webpack | javascript |
<|fim_suffix|>() {
return 42;
}
<|fim_prefix|>export default functi<|fim_middle|>on <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stric<|fim_suffix|>ype {import("../../../../").Configuration} */
module.exports = {
mode: "production",
devtool: false,
optimization: {
concatenateModules: true,
minimize: false
}
};
<|fim_middle|>t";
/** @t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import load from "./loader";
it("should handle anonymous async arrow default export in ES5 env", async () => {
// `export default async (v) => v * 2` — ArrowFunctionExpression (async),
// matches isAnonymousDefault. Ensure the Reflect fix-up references the
<|fim_suffix|>});
<|fim_middle|>// real assig... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default async (/** @type {number} */ valu<|fim_suffix|> * 2;
<|fim_middle|>e) => value<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>DefaultExportName: true
}
}
}
};
<|fim_prefix|>"use <|fim_middle|>strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
devtool: false,
output: {
environment: {
module: false,
const: false,
arrowFunction: false,
bigIntLiteral: false,
... | fim | webpack/webpack | javascript |
<|fim_prefix|>expor<|fim_suffix|>lo() {
return "world";
}
};
<|fim_middle|>t default class {
hel<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import Thing from "./Thing";
it("should not throw TDZ/ReferenceError for anonymous d<|fim_suffix|> spec, `export default class {}` should have .name === "default".
// The anonymous-default fix-up introduced in PR #20773 inserts an
// InitFragment that references `__WEBPACK_DEFAULT_EXPORT__` — ensure it... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module<|fim_suffix|>namicImport: false,
forOf: false
}
}
};
<|fim_middle|>.exports = {
mode: "development",
devtool: false,
output: {
environment: {
module: false,
const: false,
arrowFunction: false,
bigIntLiteral: f... | fim | webpack/webpack | javascript |
<|fim_prefix|>export class <|fim_suffix|>";
}
}
<|fim_middle|>Base {
kind() {
return "base<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { Base } <|fim_suffix|>fault class extends Base {
kind() {
return "derived";
}
};
<|fim_middle|>from "./Base";
export de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import Derived from "./Derived";
it("should handle anonymous default class with extends in ES5 env", () => {
const d = new Derived();
expect(d.kind()).t<|fim_suffix|>");
});
<|fim_middle|>oBe("derived");
expect(Derived.name).toBe("default<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
devtool: false,
output: {
environment: {
module: false,
const: false,
arrowFunction: false,
bigIntLiteral: false,
destructuring: false,
dynamicImport: false,
forOf: false
}
}
};
<|endo... | fim | webpack/webpack | javascript |
<|fim_suffix|>constant.js which triggered the regression
// in https://github.com/webpack/webpack/issues/20793
export default (x) => () => x;
<|fim_prefix|>// Mirrors d3-interpol<|fim_middle|>ate/src/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import constant from "./constant";
it("should not throw ReferenceError when importing an anonymous default export in an ES5 environment", () => {
// Regression test for https://github.com/webpack/webpack/issues/20793
// With `output.environment.const = false`, the harmony default export
// te<|fim_suf... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
<|fim_suffix|>forOf: false
}
}
};
<|fim_middle|> devtool: false,
output: {
environment: {
module: false,
const: false,
arrowFunction: false,
bigIntLiteral: false,
destructuring:... | fim | webpack/webpack | javascript |
<|fim_suffix|>t.toBe("default");
});
<|fim_prefix|>import Cls from "./lib";
it("should not inject .name fix-up when anonymousDefaultExportName is disabled", () => {
// Library authors don't nee<|fim_middle|>d the .name = "default" fix-up.
// When the option is off, the output should not contain any
// Object.define... | fim | webpack/webpack | javascript |
<|fim_suffix|>{
constructor() {
this.value = 42;
}
}
<|fim_prefix|>export d<|fim_middle|>efault class <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
devtool: <|fim_suffix|>
minimize: false
}
};
<|fim_middle|>false,
output: {
library: {
type: "commonjs2"
}
},
optimization: {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>st bar = "bar";
__webpack_global__.bar = "bar";<|fim_prefix|>expor<|fim_middle|>t con<|endoftext|> | fim | webpack/webpack | javascript |
__webpack_global__.myCustomProperty = "myCustomProperty";
"use strict";
var __webpack_require__ = {
test(__webpack_global__) {
__webpack_global__.test = 1;
}
};
(() => {
__webpack_require__.d = (exports1, definition) => {
for (var key in definition)
if (
__webpack_require__.o(definition, ke... | fim | webpack/webpack | javascript |
<|fim_suffix|>).toBe("myCustomProperty");
expect(__webpack_global__.anotherProperty).toBe("anotherProperty");
expect(__webpack_global__.bar).toBe("bar");
});<|fim_prefix|>import * as foo from "./foo";
import { bar } from "./bar";
it("should load module with nested __webpack_require__", () => {
expect(foo).toBeDe... | fim | webpack/webpack | javascript |
<|fim_suffix|>xports = [
{},
{
optimization: {
concatenateModules: true
}
}
];
<|fim_prefix|>"use strict";
/** @type {<|fim_middle|>import("../../../../").Configuration[]} */
module.e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = "index";
it("should get module id from __webpack_module__", () => {
expect(__webpack_module__.id).toBeDefined();
con<|fim_suffix|>expect(__webpack_module__.id).toBeDefined();
expect(typeof __webpack_module__).toBe("object");
});<|fim_middle|>st module = "layout";
expect(module).t... | fim | webpack/webpack | javascript |
<|fim_suffix|>./").Configuration} */
module.exports = {};
<|fim_prefix|>"<|fim_middle|>use strict";
/** @type {import("../../../.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rt default module;<|fim_prefix|>class module {
<|fim_middle|>}
module.id = __webpack_module__.id;
expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function mod<|fim_suffix|>ack_module__.id;
}
export default module;<|fim_middle|>ule() {
return __webp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import moduleFn from "./fn";
import moduleClass from "./class";
const module = <|fim_suffix|>f __webpack_module__).toBe("object");
});<|fim_middle|>"layout";
if (module === __webpack_module__) {
throw new Error("module is __webpack_module__, this should not happen");
}
it("should get module id from __... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import png from "../_images/file.png";
import svg from "../_images/file.svg";
import svg2 from "../_images/file.svg?custom2";
it("<|fim_suffix|>m-images/success.svg");
});
<|fim_middle|>should change filenames", () => {
expect(png).toEqual("images/[ext]/success-png.png");
expect(svg).toEqual("images/su... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
assetModuleFilename: ({ filename: _filename }) => {
const filename = /** @type {string} */ (_filename);
if (/.png$/.test(filename)) {
return "images/[\\ext\\]/success-png[ext]";
}
if ... | fim | webpack/webpack | javascript |
<|fim_suffix|> = new URL("../_images/file.png", import.meta.url);
expect(file.href).toMatch(/^https:\/\/example.com\/path\/[0-9a-f]+.png$/);
});
<|fim_prefix|>it("should handle different querystrings for assets correctly", () => {
__webpack_base_uri__ = "https:<|fim_middle|>//example.com";
const file<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports <|fim_suffix|>ent",
target: "web",
output: {
publicPath: "/path/"
}
};
<|fim_middle|>= {
mode: "developm<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const urlSvg = ne<|fim_suffix|>k/webpack/refs/heads/main/test/configCases/asset-modules/_images/file.svg",
import.meta.url
);
it("should work", () => {
expect(/[\da-f]{20}\.svg$/.test(urlSvg)).toBe(true);
});
<|fim_middle|>w URL(
"https://raw.githubusercontent.com/webpac<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e(__dirname, "./lock-files/test")
}
}
};
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "de<|fim_middle|>velopment",
experiments: {
buildHttp: {
allowedUris: [() => true],
lockfileLocation: path.resolve(... | fim | webpack/webpack | javascript |
<|fim_suffix|>on/octet-stream;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2MDAgNjAwIj48dGl0bGU+aWNvbi1zcXVhcmUtc21hbGw8L3RpdGxlPjxwYXRoIGZpbGw9IiNGRkYiIGQ9Ik0zMDAgLjFMNTY1IDE1MHYyOTkuOUwzMDAgNTk5LjggMzUgNDQ5LjlWMTUweiIvPjxwYXRoIGZpbGw9IiM4RUQ2RkIiIGQ9Ik01MTcuNyA0MzkuNUwzMDguOCA1NTcuOHY... | fim | webpack/webpack | javascript |
<|fim_suffix|>i === 2 ? "mjs" : "js"}`,
`bundle${i}.${i === 2 ? "mjs" : "js"}`
];
}
};
<|fim_prefix|>"use strict";
let run = 0;
module.exports = {
moduleScope(scope, options) {
if (!scope.window) {
return;
}
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.h... | fim | webpack/webpack | javascript |
<|fim_suffix|>rtsTextDecoder");
module.exports = () => supportsTextDecoder();
<|fim_prefix|>"use strict";
const supportsTextDecoder = require("../../<|fim_middle|>../helpers/suppo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>tModule: true,
css: true
},
module: {
rules: [
{
test: /\.svg$/,
type: "asset/bytes"
}
]
}
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
name: "web",
mode: "development",
target: "web",
experiments: {... | fim | webpack/webpack | javascript |
<|fim_suffix|>ecoded = new TextDecoder("utf-8").decode(textBytes);
expect(decoded).toBe("a Ā 𐀀 文 🦄 Text");
});
it("should fold every asset module into a single concatenated module", () => {
const concatModules = __STATS__.modules.filter((m) => m.modules);
expect(concatModules.length).toBe(1);
// index.js + 4 ass... | fim | webpack/webpack | javascript |
<|fim_suffix|>extDecoder");
module.exports = () => supportsTextDecoder();
<|fim_prefix|>"use strict";
const s<|fim_middle|>upportsTextDecoder = require("../../../helpers/supportsT<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>: false,
usedExports: true,
chunkIds: "named",
moduleIds: "named"
},
module: {
rules: [
{
test: /\.svg$/,
type: "asset/source"
},
{
test: /\.jpg$/,
type: "asset/inline"
},
{
test: /\.png$/,
type: "asset/resource"
},
{
test: /\.text$/,
type: "a... | fim | webpack/webpack | javascript |
<|fim_prefix|>import png from "../_images/file.png";
import svg from "../_images/file.svg";
import jpg from "../_images/file.jpg";
it("should generate various asset types by a custom encoder", () => {
expect(png).toMatch(/^data:image\/pn<|fim_suffix|>ect(jpg).toMatch(/^[\da-f]{20}\.jpg$/);
expect(svg).toMatch(/^[\da... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
const NormalModule = require("../../../../").NormalModule;
/** @typedef {import("../../../../").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
mod... | fim | webpack/webpack | javascript |
import png from "../_images/file.png";
import svg from "../_images/file.svg";
import jpg from "../_images/file.jpg";
it("should generate various asset types by a custom encoder", () => {
expect(png).toMatch(/^data:mimetype\/png;base64,[0-9a-zA-Z+/]+=*$/);
expect(jpg).toEqual("data:image/jpg;base64,custom-content");
... | fim | webpack/webpack | javascript |
<|fim_suffix|>").Configuration} */
module.exports = {
mode: "development",
module: {
rules: [
{
test: /\.png$/,
type: "asset/inline",
generator: {
dataUrl: {
mimetype: "mimetype/png"
}
}
},
{
test: /\.jpg$/,
type: "asset/inline",
generator: {
dataUrl() {
... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.