text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
bundle0: ".<|fim_suffix|>vascript: {
commonjsMagicComments: true
}
}
},
output: {
filename: "[name].js"
},
node: {
__dirname: false
}
};
<|fim_middle|>/index.js",
bundle1: "./other.js"
},... | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>const { main } = require("./module");
it("should handle require.main", async () => {
expect(require.main === module).toBe(true);
<|fim_middle|>
expect(main).toBe(false);
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const main = require.main ===<|fim_suffix|>ain };
<|fim_middle|> module;
module.exports = { m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type <|fim_suffix|>onfiguration} */
module.exports = {
target: "node",
optimization: {
concatenateModules: false
}
};
<|fim_middle|>{import("../../../../").C<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");<|fim_suffix|> to ignore require.resolve()", () => {
const source = fs.readFileSync(path.join(__dirname, "bundle1.js"), "utf-8");
expect(source).toMatch(`require.resolve(/* webpackIgnore: true */ "./non-exists")`);
expect(source).toMatch(`createRequire(import.meta.url).resolve(... | fim | webpack/webpack | javascript |
<|fim_suffix|>nst require = createRequire(import.meta.url);
const createRequireResolve2 = require.resolve(/* webpackIgnore: true */ "./non-exists");
export { resolve, createRequireResolve1, createRequireResolve2 }
<|fim_prefix|>import { createRequire } from<|fim_middle|> 'node:module';
const resolve = require.resolve... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
b<|fim_suffix|>
__dirname: false
}
};
<|fim_middle|>undle0: "./index.js",
bundle1: "./other.js"
},
module: {
parser: {
javascript: {
commonjsMagicComments: true
}
}
},
output: {
filen... | fim | webpack/webpack | javascript |
<|fim_suffix|>.main).toBe(module);
});
<|fim_prefix|>it("should define require.mai<|fim_middle|>n", function() {
expect(require<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../<|fim_suffix|>rts = {};
<|fim_middle|>").Configuration} */
module.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should ignore require.config", function() {
require.config({
});
requirejs.config({
});
});
it("should have a require.version", function() {
expect(require.version).toBeTypeOf("string");
});
it("should have a requi<|fim_suffix|>ror function", function(done) {
function f(){}
expect(requirejs.o... | fim | webpack/webpack | javascript |
<|fim_suffix|>: {
requireJs: true
}
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules: [
{
test: /\.js$/,
par<|fim_middle|>ser<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{
return this.a;
}
export const usedExports = __webpack_exports_info__.usedExports;
<|fim_prefix|>export const a = 1;
<|fim_middle|>export function f() <|endoftext|> | fim | webpack/webpack | javascript |
export const a = 1;
export const usedExports = __webpack_exports_info__.usedExports;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export function f() {
<|fim_suffix|>_.usedExports;
<|fim_middle|>return 1;
}
export const b = 2;
export const usedExports = __webpack_exports_info_<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sedExports = __webpack_exports_info__.usedExports;
<|fim_prefix|>export * as a from "./a";
export * as b from "./b";
export<|fim_middle|> const u<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>it import("./dir4/lib").then(m2 => {
expect(m2.b.f()).toBe(1);
expect(m2.b.usedExports).toBe(true);
expect(m2.usedExports).toEqual(["b", "usedExports"]);
});
})
<|fim_prefix|>it("should respect strictThisContextOnImports for member call", async () => {
let m = await import("./dir4/a");
expect(m.f... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
<|fim_suffix|>ts: true
}
};
<|fim_middle|> module: {
strictThisContextOnImpor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should answer typeof System correctly", () => {
if(__SYSTEM__) {
expect((typeof System)).toBe("object");
} else {
expect((typeof System)).toBe("undefined");
}
});
it("should answer typeof System<|fim_suffix|><|fim_middle|>.import correctly", () => {
if(__SYSTEM__) {
expect((typeof System.im... | fim | webpack/webpack | javascript |
<|fim_prefix|>export def<|fim_suffix|>ok";
<|fim_middle|>ault "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>[
[{compilerPath: /system_true/}, /System\.import\(\) is deprecated/]
];
<|fim_prefix|>"use strict";
<|fim_middle|>
module.exports = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>in({
__SYSTEM__: systemString
})
]
};
}
/** @type {import("../../../../").Configuration[]} */
module.exports = [
createConfig(undefined),
createConfig(true),
createConfig(false)
];
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/**
* @param {boolean | undefined} syst... | fim | webpack/webpack | javascript |
<|fim_suffix|>st a = 1;
<|fim_prefix|>export<|fim_middle|> con<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exports.b<|fim_suffix|>
<|fim_middle|> = 2;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export con<|fim_suffix|>= 3;
<|fim_middle|>st c <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port const d = 4;
<|fim_prefix|>e<|fim_middle|>x<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ontext();
const d = audioContext.audioWorklet.addModule(new URL("./d.js", import.meta.url));
it("should have correct top level declarations", async () => {
await d;
expect(a).toBe(1);
expect(b).toBe(2);
expect(c.pathname.endsWith(".js")).toBe(true);
})<|fim_prefix|>import { a } from "./a";
import { c... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
let outputDirectory;
module.exports = {
moduleScope(scope) {
const FakeWorker = require("../../../helpers/createFakeWorker")({
outputDirectory
});
scope.AudioContext = class AudioContext {
constructor() {
this.audioWorklet = {
addModule: (url) => Promise.resolve(Fake... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsWork<|fim_suffix|>odule.exports = () => supportsWorker();
<|fim_middle|>er = require("../../../helpers/supportsWorker");
m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
output: {
filename: "[name].js"
},
module: {
parser: {
javascript: {
createRequire: true,
worker: ["*audioContext.audioWorklet.addModule()"]
}
}
},
plugins: [
function testPlugi... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should igno<|fim_suffix|>")).toBe(true);
const url4 = new URL(/* webpackIgnore: false */ "fil" + "e4.css", import.meta.url);
expect(/\/public\/.+\.css/.test(url4.pathname)).toBe(true);
const url5 = new URL(/* webpackIgnore: "test" */ "file5.css", import.meta.url);
expect(url5.pathname.endsWith("fi... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
ou<|fim_suffix|>
publicPath: "/public/"
},
experiments: {
outputModule: true
},
target: ["web", "es2020"]
};
<|fim_middle|>tput: {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import promise from ".<|fim_suffix|> a module with many async imports in acceptable time", function(done) {
promise.then(() => done(), e => done(e));
});
<|fim_middle|>/start";
it("should compile<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ort("./start");
<|fim_prefix|><|fim_middle|>imp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>,\n`;
}
}
str += "]);";
return str;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
var str = "export default Promise.all([\n";
for (var i = 0; i < 6; i++) {
<|fim_middle|> for (var j = 0; j < 2; j++) {
str += `import("./reexport.loader.js!... | fim | webpack/webpack | javascript |
export { default } from "./reexport.loader.js!";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.exports = {
timeout: 10000
};
<|fim_prefix|>"use<|fim_middle|> strict";
module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configu<|fim_suffix|> = {
optimization: {
minimize: false
}
};
<|fim_middle|>ration} */
module.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ar i = 0; i < 1000; i++) {
str += `export var a${i} = ${i};\n`;
}
return str;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function<|fim_middle|> () {
var str = "";
for (v<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>from "./reexport.loader.js!";
it("should compile a module with many harmony exports in acceptable time", function() {
expect(sum).toBe(499500);
});
<|fim_middle|>rt sum <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>r += "export default sum;\n";
return str;
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function ()<|fim_middle|> {
var str = 'import * as i from "./file.loader.js!";\n';
str += "var sum = 0;\n";
for (var i = 0; i < 1000; i++) {
str += `sum += i.a${i};\n`;
... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>"use strict";
modu<|fim_middle|>le.exports = {
timeout: 10000
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.<|fim_suffix|>mization: {
minimize: false
}
};
<|fim_middle|>exports = {
opti<|endoftext|> | fim | webpack/webpack | javascript |
const fs = require("fs");
const path = require("path");
it("should contain banner in bundle0 chunk", () => {
const source = fs.readFileSync(__filename, "utf-8");
expect(source).toMatch("A test value");
expect(source).toMatch("banner is a string");
expect(source).toMatch("banner is a function");
expect(source).toM... | fim | webpack/webpack | javascript |
<|fim_prefix|>var f<|fim_suffix|>= {};
module.exports = foo;
<|fim_middle|>oo <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>va<|fim_suffix|>r = {};
module.exports = bar;
<|fim_middle|>r ba<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
node: {
__dirname: false,
__filename: false
},
entry: {
bundle0: ["./index.js"],
vendors: ["./vendors.js"]
},
output: {
filename: "[name].js"
},
plugins: [
new... | fim | webpack/webpack | javascript |
<|fim_prefix|>const parseBanner = banne<|fim_suffix|>Be("dist/banner.js");
});
it("should interpolate name in chunk banner", () => {
expect(banner["name"]).toBe("dist/banner");
});
it("should interpolate basename in chunk banner", () => {
expect(banner["base"]).toBe("banner.js");
});
it("should interpolate query i... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
<|fim_suffix|>ner.js";
}
};
<|fim_middle|>return "./dist/ban<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = foo;
<|fim_prefix|>var foo = {};
mod<|fim_middle|>ule.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> {};
module.exports = bar;
<|fim_prefix|>va<|fim_middle|>r bar =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
node: {
__dirname: false,
__filename: false
},
entry: {
"dist/banner": ["./index.js"],
vendors: ["./vendors.js"]
},
output: {
filename: "[name].js?value"
},
plug... | fim | webpack/webpack | javascript |
<|fim_prefix|>function donotcallme() {
expect("asi unsafe call happened").toBe(false);
}
it("should define FALSE", function () {
expect(FALSE).toBe(false);
expect(typeof FALSE).toBe("boolean");
var x = require(FALSE ? "fail" : "./dir/a");
var y = FALSE ? require("fail") : require("./dir/a");
});
it("should define... | fim | webpack/webpack | javascript |
<|fim_suffix|>rst": "typeof suppe",
"typeof suppe": "typeof wurst",
wurst: "suppe",
suppe: "wurst",
RUNTIMEVALUE_CALLBACK_ARGUMENT_IS_A_MODULE: DefinePlugin.runtimeValue(
({ module }) => module instanceof Module
),
A_DOT_J: '"a.j"',
OBJECT2: {
used: 1,
unused: "(() => throw new Error('u... | fim | webpack/webpack | javascript |
<|fim_suffix|>bigint") require("fail");
});
<|fim_prefix|>it("should define BIGINT", function() {
expect(BIGINT).toBe(9007199254740993n);
expect(typeof BIGINT).toBe("bigint");
if (BIGINT !== 9007199254740993n) require("fail");
if (typeof BIGINT !== "bigint") require("fail");
});
it("should define ZERO_BIGINT<|fim_m... | fim | webpack/webpack | javascript |
<|fim_suffix|> {
bigIntLiteral: true
}
},
plugins: [
new DefinePlugin({
BIGINT: BigInt("9007199254740993"),
ZERO_BIGINT: BigInt(0)
})
]
};
<|fim_prefix|>"use strict";
const DefinePlugin = require("../../../../").Defin<|fim_middle|>ePlugin;
/** @type {import("../../../../").Configuration} */
module.e... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should define a member of an import.meta object key", function () {
expect(import.meta.config.TOKEN).toBe("token");
});
it("should <|fim_suffix|>nst c = function () { return import.meta.config.MISSING?.(); };
expect(a.toString()).toBe("function () { return undefined; }");
expect(b.toString()).toBe(... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";<|fim_suffix|>ortsOptionalChaining = require("../../../helpers/supportsOptionalChaining");
module.exports = () => supportsOptionalChaining();
<|fim_middle|>
const supp<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const { DefinePlugin } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
mode: "development",
experiments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module"
},
optimization: {
minimize: false,
concatenat... | fim | webpack/webpack | javascript |
<|fim_suffix|>ional calls on an unknown member without inlining the object (issue 15559)", function () {
const a = function () { return OBJECT.SUB1.UNKNOWN?.(); };
const b = function () { return NOT_DEFINED.SUB2.b?.(); };
const c = function () { return OBJECT.SUB1?.UNKNOWN?.(); };
const d = function () { return OBJ... | fim | webpack/webpack | javascript |
<|fim_suffix|>./../helpers/supportsOptionalChaining");
module.exports = () => supportsOptionalChaining();
<|fim_prefix|>"use strict";
const supportsOptionalChaining =<|fim_middle|> require("../.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { DefinePlugin } = require("../../../../");
/** @type {im<|fim_suffix|>OT_DEFINED.SUB2": { a: 1 },
STRING: JSON.stringify("string")
})
]
};
<|fim_middle|>port("../../../../").Configuration} */
module.exports = {
plugins: [
new DefinePlugin({
OBJECT: { SUB1: { a: 1 } },
... | fim | webpack/webpack | javascript |
<|fim_suffix|>();
});
<|fim_prefix|>it("destructuring should work with 'process.env'", function () {
expect(process.env.NODE_ENV).toBe("production");
const { NODE_ENV } = process.env;
expect(NODE_ENV).toBe("production");
const { NODE_ENV: RENAME_NODE_ENV } = process.env;
expect(RENAME_NODE_ENV).toBe("production"... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const DefinePlugin = require("../../../../").DefinePlugin;
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
<|fim_suffix|>uction",
plugins: [
new DefinePlugin({
"process.env.ENVIRONMENT": JSON.stringify("node")
})
]
};
<|fim_middle|> mode: "p... | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>
bar: "test"
}
<|fim_middle|>
export default {<|endoftext|> | fim | webpack/webpack | javascript |
import foo from './foo.js';
function works1() {
return foo.bar;
}
function works2() {
const v = foo.bar;
return v;
}
function works3() {
const v = foo.bar.baz;
return v;
}
it("should compile and run", () => {
expect(works1()).toBe("test");
expect(works2()).toBe("test");
expect(works3()).toBe("test"... | fim | webpack/webpack | javascript |
<|fim_suffix|>)
]
};
<|fim_prefix|>"use strict";
const DefinePlugin = require("../../../../").DefinePlugin;
/** @ty<|fim_middle|>pe {import("../../../../").Configuration} */
module.exports = {
plugins: [
new DefinePlugin({
"foo.bar.baz": '"test"'
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>fixed vars should not be exposed
expect(typeof process.env.SECRET_KEY).toBe("undefined");
expect(typeof process.env.PRIVATE_VAR).toBe("undefined");
});
<|fim_prefix|>"<|fim_middle|>use strict";
it("should expose only WEBPACK_ prefixed env vars", () => {
expect(process.env.WEBPACK_API_URL).toBe("https:... | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>"use strict";
it("should load from custom dir", () => {
expect(process.env.WEBPACK_FROM_ENVS).toBe("loaded-from-envs-dir");
expect(process.env<|fim_middle|>.WEBPACK_API_URL).toBe("https://custom.example.com");
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
it("should expose only APP_ and CONFIG_ prefixed vars and built-in properties", () => {
expect(process.env.APP_NAME).toBe("MyApp");
expect(process.env.CONFIG_TIMEOUT).toBe("5000");
// WEBPACK_ prefixed should not be exposed
expect(typeof process.env.WEBPACK_API_URL).toBe("undefined");
... | fim | webpack/webpack | javascript |
<|fim_suffix|>WEBPACK_API_URL).toBe("https://prod-api.example.com");
// Custom template files should override .env values
expect(process.env.WEBPACK_OVERRIDE_VAR).toBe("myLocal-value");
});
<|fim_prefix|>"use strict";
it("should load env files based on custom template", () => {
// Should load from .env.myLocal (... | fim | webpack/webpack | javascript |
<|fim_suffix|>PRIVATE_VAR).toBe("undefined");
// Only pre-existing process.env variables with WEBPACK_ prefix should be available
// (if any were set before webpack runs)
});
<|fim_prefix|>"use strict";
it("should not load any .env files when dir is false", () => {
// When dir: false, no .env files should be load... | fim | webpack/webpack | javascript |
"use strict";
it("should expand variables by default", () => {
expect(process.env.WEBPACK_BASE).toBe("example.com");
expect(process.env.WEBPACK_API_URL).toBe("https://api.example.com");
expect(process.env.WEBPACK_FULL_URL).toBe("https://api.example.com/v1");
// Test default value operator
expect(process.env.WEB... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
it("should load .env.production and override .env values", () => {
// Value from .env.production should override .env
expect(process.env.WEBPACK_API_URL).toBe("https://prod-api.example.com");<|fim_suffix|> expect(process.env.WEBPACK_ENV).toBe("production");
// Value only in .env
expec... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {import("../../../../").Configuration[]} */
module.exports = [
// Test 1: Basic - default behavior with WEBPACK_ prefix
{
name: "basic",
mode: "development",
entry: "./basic.js",
dotenv: true
},
// Test 2: Expand - variables are always ex... | fim | webpack/webpack | javascript |
<|fim_suffix|>edErrors);
}
}
module.exports = regex;
<|fim_prefix|>"use strict";
const variables = [
"aaa",
"bbb",
"ccc",
"ddd",
"eee",
"fff",
"ggg",
"hhh",
"iii"
];
const modules = [
{
name: "aaa",
variab<|fim_middle|>les: ["aaa"]
},
{
name: "bbbccc",
variables: ["bbb", "ccc"]
},
{
name: "dd... | fim | webpack/webpack | javascript |
<|fim_suffix|>!== "eee") if (never) require("eee");
if (process.env.FFF !== "fff") if (never) require("fff");
});
it("should import multiple process.env var with default values", () => {
if (process.env.GGG !== "ggg") if (never) require("ggg");
if (process.env.HHH !== "hhh") if (never) require("hhh");
});
it("shou... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const EnvironmentPlugin = require("../../../../").EnvironmentPlugin;
process.env.AAA = "aaa<|fim_suffix|>tCritical: false
},
plugins: [
new EnvironmentPlugin({
GGG: "ggg-default",
HHH: "hhh"
})
]
},
{
name: "iii",
module: {
unknownContextRegExp: /$^/,
unknow... | fim | webpack/webpack | javascript |
it("should expose NODE_ENV from mode (WebpackOptionsApply)", () => {
const env = import.meta.env;
expect(env.NODE_ENV).toBe("production");
});
it("should expose variables from EnvironmentPlugin", () => {
const env = import.meta.env;
expect(env.ENV_VAR_FROM_ENV).toBe("from_environment_plugin");
});
it("should expo... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { DefinePlugin, EnvironmentPlugin } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
// Test 1: NODE_ENV from mode (WebpackOptionsApply)
mode: "production",
// Test 3: Doten<|fim_suffix|>{
ENV_VAR_FROM_ENV: "from_environment_plug... | fim | webpack/webpack | javascript |
<|fim_suffix|> "a";
<|fim_prefix|>modul<|fim_middle|>e.exports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/*! webtorrent. MIT License. WebTorrent LLC <https://webtorrent.io/opensource> */
import EventEmitter from 'events'
import path from 'path'
import Wire from 'bittorrent-protocol'
import createTorrent, { parseInput } from 'create-torrent'
import debugFactory from 'debug'
import { Client as DHT } from 'bitt... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>gConns.delete(conn)
}
}
}
}
ConnPool.UTP_SUPPORT = Object.keys(utp).length > 0
function noop () {}
<|fim_prefix|>import net from 'net' // browser exclude
import debugFactory from 'debug'
import queueMicrotask fro<|fim_middle|>m 'queue-microtask'
import Peer from './peer.js'
import utp from ... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|> Math.min(this._missing, this._pieceLength - this._offset)
pump(this._piece++, { length, offset: this._offset })
this._missing -= length
this._offset = 0
})
}
/**
* @returns {Promise<IteratorResult<Uint8Array>>}
*/
async return () {
this.destroy()
return { done:... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>iterator = this[Symbol.asyncIterator](opts)
},
async pull (controller) {
const { value, done } = await iterator.next()
if (done) {
controller.close()
} else {
controller.enqueue(value)
}
},
cancel () {
iterator.return()
... | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>import EventEmitter from 'events'
import { Transform, pipeline } from 'streamx'
import arrayRemove from 'unordered-array-remove'
import debugFactory from 'debug'
import Wire from 'bittorrent-protocol'
const CONNECT_TIMEOUT_TCP = 5_000
const CONNECT_TIMEOUT_UTP = 5_000
const CONNECT_TIMEOUT_WEBRTC = 25_00... | fim | webtorrent/webtorrent | javascript |
/**
* Mapping of torrent pieces to their respective availability in the torrent swarm. Used
* by the torrent manager for implementing the rarest piece first selection strategy.
*/
export default class RarityMap {
constructor (torrent) {
this._torrent = torrent
this._numPieces = torrent.pieces.length
th... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>= 0
}
/** @returns {Generator<SelectionItem & {remove: function}>} */
* [Symbol.iterator] () {
for (let i = 0; i < this._items.length; i++) {
const item = this._items[i]
item.remove = () => {
this._items.splice(i, 1)
i--
}
yield item
delete item.re... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>ostname
}
this.boundHandler = this.wrapRequest.bind(this)
navigator.serviceWorker.addEventListener('message', this.boundHandler)
// test if browser supports cancelling sw Readable Streams
fetch(`${this.pathname}/cancel/`).then(res => {
res.body.cancel()
})
}
wrapRequest... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|> have-all message, which means its a seeder
if (wire.peerPieces.buffer.length && !!wire.peerPieces.setAll) {
if (wire.peerPieces.buffer.length !== this.bitfield.buffer.length) return
for (i = 0; i < this.pieces.length; ++i) {
if (!wire.peerPieces.get(i)) return
}
... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>ks))
}
destroy () {
super.destroy()
this._torrent = null
}
}
<|fim_prefix|>import BitField from 'bitfield'
import debugFactory from 'debug'
import fetch from 'cross-fetch-ponyfill'
import ltDontHave from 'lt_donthave'
import { hash, concat } from 'uint8-util'
import Wire from 'bittorrent-pr... | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>const<|fim_suffix|> url, method, headers, destination } = request
const clientlist = await clients.matchAll({ type: 'window', includeUncontrolled: true })
const [data, port] = await new Promise(resolve => {
// Use race condition for whoever controls the response stream
for (const client of cl... | fim | webtorrent/webtorrent | javascript |
import fileResponse from './worker-server.js'
self.addEventListener('install', () => {
self.skipWaiting()
})
self.addEventListener('fetch', event => {
const res = fileResponse(event)
if (res) event.respondWith(res)
})
self.addEventListener('activate', () => {
self.clients.claim()
})
<|endoftext|> | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>ateSync = (buffer) => inflate(buffer, { to: 'string' })
<|fim_prefix|>import { inflate } from 'pako'
<|fim_middle|>
export const infl<|endoftext|> | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>/*!
* Fast node `require('process')` for modern browsers
*
* @author Mathias Ra<|fim_suffix|>OnceListener, nextTick, listeners, cwd, umask, binding, chdir
}
<|fim_middle|>smussen <mathiasvr@gmail.com>
* @license MIT
*/
import queueMicrotask from 'queue-microtask'
const title = 'browser'
const bro... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>ler'
import { createServer } from 'http'
createServer((req, res) => {
serve('./dist/')(req, res, finalhandler(req, res))
}).listen(process.env.AIRTAP_SUPPORT_PORT)
<|fim_prefix|>import serve from 'serve-static'
import final<|fim_middle|>handler from 'finalhand<|endoftext|> | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>: {
comments: false
}
},
extractComments: false
})]
}
}
<|fim_prefix|>import webpack from 'webpack'
import TerserPlugin from 'terser-webpack-plugin'
import info from '../package.json' with { type: 'json' }
/** @type {import('webpack').Configuration} */
export default {... | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>import webpack from 'webpack'
import TerserPlugin from 'terser-webpack-plugin'
import info from '../package.json' with { type: 'json' }
/** @type {import('webpack').Configuration} */
export default {
entry: './index.js',
devtool: 'source-map',
resolve: {
aliasFields: ['chromeapp'],
alias: {... | fim | webtorrent/webtorrent | javascript |
<|fim_suffix|>/lib/worker.js',
devtool: 'source-map',
output: {
filename: 'sw.min.js'
},
mode: 'production',
target: 'web'
}
<|fim_prefix|>/** @type {import('webpack').Configuration} */
export defaul<|fim_middle|>t {
entry: '.<|endoftext|> | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>import fixtures from 'webtorrent-fixtures'
import test from 'tape'
import WebTorrent from '../index.js'
test('preloaded bitfield: load files into filesystem', t => {
t.plan(2)
const client = new WebTorrent({ dht: false, utp: false, tracker: false, lsd: false, natUpnp: false, natPmp: false }<|fim_suf... | fim | webtorrent/webtorrent | javascript |
<|fim_prefix|>import test from 'tape'
import WebTorrent from '../../index.js'
test('WebTorrent.WEBRTC_SUPPORT', t => {
<|fim_suffix|>
t.equal(WebTorrent.WEBRTC_SUPPORT, true)
client.destroy(err => {
t.error(err, 'client destroyed')
})
})
<|fim_middle|>t.plan(2)
const client = new WebTorrent({ dht: fals... | fim | webtorrent/webtorrent | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.