boudjeml/parcoursup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

$

Browse Source
This commit is contained in:
lalBi94
2023-03-05 13:23:23 +01:00
commit 7bc56c09b5
14034 changed files with 1834369 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

747
node_modules/html-webpack-plugin/CHANGELOG.md generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

20
node_modules/html-webpack-plugin/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,20 @@
Copyright JS Foundation and other contributors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

667
node_modules/html-webpack-plugin/README.md generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

9
node_modules/html-webpack-plugin/default_index.ejs generated vendored Normal file
View File

@@ -0,0 +1,9 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title><%= htmlWebpackPlugin.options.title %></title>
</head>
<body>
</body>
</html>

1125
node_modules/html-webpack-plugin/index.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

379
node_modules/html-webpack-plugin/lib/cached-child-compiler.js generated vendored Normal file
View File

@@ -0,0 +1,379 @@
// @ts-check
/**
* @file
* Helper plugin manages the cached state of the child compilation
*
* To optimize performance the child compilation is running asyncronously.
* Therefore it needs to be started in the compiler.make phase and ends after
* the compilation.afterCompile phase.
*
* To prevent bugs from blocked hooks there is no promise or event based api
* for this plugin.
*
* Example usage:
*
* ```js
const childCompilerPlugin = new PersistentChildCompilerPlugin();
childCompilerPlugin.addEntry('./src/index.js');
compiler.hooks.afterCompile.tapAsync('MyPlugin', (compilation, callback) => {
console.log(childCompilerPlugin.getCompilationResult()['./src/index.js']));
return true;
});
* ```
*/
// Import types
/** @typedef {import("webpack/lib/Compiler.js")} WebpackCompiler */
/** @typedef {import("webpack/lib/Compilation.js")} WebpackCompilation */
/** @typedef {{hash: string, entry: any, content: string }} ChildCompilationResultEntry */
/** @typedef {import("./file-watcher-api").Snapshot} Snapshot */
/** @typedef {{fileDependencies: string[], contextDependencies: string[], missingDependencies: string[]}} FileDependencies */
/** @typedef {{
dependencies: FileDependencies,
compiledEntries: {[entryName: string]: ChildCompilationResultEntry}
} | {
dependencies: FileDependencies,
error: Error
}} ChildCompilationResult */
'use strict';
const { HtmlWebpackChildCompiler } = require('./child-compiler');
const fileWatcherApi = require('./file-watcher-api');
/**
* This plugin is a singleton for performance reasons.
* To keep track if a plugin does already exist for the compiler they are cached
* in this map
* @type {WeakMap<WebpackCompiler, PersistentChildCompilerSingletonPlugin>}}
*/
const compilerMap = new WeakMap();
class CachedChildCompilation {
/**
* @param {WebpackCompiler} compiler
*/
constructor (compiler) {
/**
* @private
* @type {WebpackCompiler}
*/
this.compiler = compiler;
// Create a singleton instance for the compiler
// if there is none
if (compilerMap.has(compiler)) {
return;
}
const persistentChildCompilerSingletonPlugin = new PersistentChildCompilerSingletonPlugin();
compilerMap.set(compiler, persistentChildCompilerSingletonPlugin);
persistentChildCompilerSingletonPlugin.apply(compiler);
}
/**
* apply is called by the webpack main compiler during the start phase
* @param {string} entry
*/
addEntry (entry) {
const persistentChildCompilerSingletonPlugin = compilerMap.get(this.compiler);
if (!persistentChildCompilerSingletonPlugin) {
throw new Error(
'PersistentChildCompilerSingletonPlugin instance not found.'
);
}
persistentChildCompilerSingletonPlugin.addEntry(entry);
}
getCompilationResult () {
const persistentChildCompilerSingletonPlugin = compilerMap.get(this.compiler);
if (!persistentChildCompilerSingletonPlugin) {
throw new Error(
'PersistentChildCompilerSingletonPlugin instance not found.'
);
}
return persistentChildCompilerSingletonPlugin.getLatestResult();
}
/**
* Returns the result for the given entry
* @param {string} entry
* @returns {
| { mainCompilationHash: string, error: Error }
| { mainCompilationHash: string, compiledEntry: ChildCompilationResultEntry }
}
*/
getCompilationEntryResult (entry) {
const latestResult = this.getCompilationResult();
const compilationResult = latestResult.compilationResult;
return 'error' in compilationResult ? {
mainCompilationHash: latestResult.mainCompilationHash,
error: compilationResult.error
} : {
mainCompilationHash: latestResult.mainCompilationHash,
compiledEntry: compilationResult.compiledEntries[entry]
};
}
}
class PersistentChildCompilerSingletonPlugin {
constructor () {
/**
* @private
* @type {
| {
isCompiling: false,
isVerifyingCache: false,
entries: string[],
compiledEntries: string[],
mainCompilationHash: string,
compilationResult: ChildCompilationResult
}
| Readonly<{
isCompiling: false,
isVerifyingCache: true,
entries: string[],
previousEntries: string[],
previousResult: ChildCompilationResult
}>
| Readonly <{
isVerifyingCache: false,
isCompiling: true,
entries: string[],
}>
} the internal compilation state */
this.compilationState = {
isCompiling: false,
isVerifyingCache: false,
entries: [],
compiledEntries: [],
mainCompilationHash: 'initial',
compilationResult: {
dependencies: {
fileDependencies: [],
contextDependencies: [],
missingDependencies: []
},
compiledEntries: {}
}
};
}
/**
* apply is called by the webpack main compiler during the start phase
* @param {WebpackCompiler} compiler
*/
apply (compiler) {
/** @type Promise<ChildCompilationResult> */
let childCompilationResultPromise = Promise.resolve({
dependencies: {
fileDependencies: [],
contextDependencies: [],
missingDependencies: []
},
compiledEntries: {}
});
/**
* The main compilation hash which will only be updated
* if the childCompiler changes
*/
let mainCompilationHashOfLastChildRecompile = '';
/** @typedef{Snapshot|undefined} */
let previousFileSystemSnapshot;
let compilationStartTime = new Date().getTime();
compiler.hooks.make.tapAsync(
'PersistentChildCompilerSingletonPlugin',
(mainCompilation, callback) => {
if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
return callback(new Error('Child compilation has already started'));
}
// Update the time to the current compile start time
compilationStartTime = new Date().getTime();
// The compilation starts - adding new templates is now not possible anymore
this.compilationState = {
isCompiling: false,
isVerifyingCache: true,
previousEntries: this.compilationState.compiledEntries,
previousResult: this.compilationState.compilationResult,
entries: this.compilationState.entries
};
// Validate cache:
const isCacheValidPromise = this.isCacheValid(previousFileSystemSnapshot, mainCompilation);
let cachedResult = childCompilationResultPromise;
childCompilationResultPromise = isCacheValidPromise.then((isCacheValid) => {
// Reuse cache
if (isCacheValid) {
return cachedResult;
}
// Start the compilation
const compiledEntriesPromise = this.compileEntries(
mainCompilation,
this.compilationState.entries
);
// Update snapshot as soon as we know the filedependencies
// this might possibly cause bugs if files were changed inbetween
// compilation start and snapshot creation
compiledEntriesPromise.then((childCompilationResult) => {
return fileWatcherApi.createSnapshot(childCompilationResult.dependencies, mainCompilation, compilationStartTime);
}).then((snapshot) => {
previousFileSystemSnapshot = snapshot;
});
return compiledEntriesPromise;
});
// Add files to compilation which needs to be watched:
mainCompilation.hooks.optimizeTree.tapAsync(
'PersistentChildCompilerSingletonPlugin',
(chunks, modules, callback) => {
const handleCompilationDonePromise = childCompilationResultPromise.then(
childCompilationResult => {
this.watchFiles(
mainCompilation,
childCompilationResult.dependencies
);
});
handleCompilationDonePromise.then(() => callback(null, chunks, modules), callback);
}
);
// Store the final compilation once the main compilation hash is known
mainCompilation.hooks.additionalAssets.tapAsync(
'PersistentChildCompilerSingletonPlugin',
(callback) => {
const didRecompilePromise = Promise.all([childCompilationResultPromise, cachedResult]).then(
([childCompilationResult, cachedResult]) => {
// Update if childCompilation changed
return (cachedResult !== childCompilationResult);
}
);
const handleCompilationDonePromise = Promise.all([childCompilationResultPromise, didRecompilePromise]).then(
([childCompilationResult, didRecompile]) => {
// Update hash and snapshot if childCompilation changed
if (didRecompile) {
mainCompilationHashOfLastChildRecompile = mainCompilation.hash;
}
this.compilationState = {
isCompiling: false,
isVerifyingCache: false,
entries: this.compilationState.entries,
compiledEntries: this.compilationState.entries,
compilationResult: childCompilationResult,
mainCompilationHash: mainCompilationHashOfLastChildRecompile
};
});
handleCompilationDonePromise.then(() => callback(null), callback);
}
);
// Continue compilation:
callback(null);
}
);
}
/**
* Add a new entry to the next compile run
* @param {string} entry
*/
addEntry (entry) {
if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
throw new Error(
'The child compiler has already started to compile. ' +
"Please add entries before the main compiler 'make' phase has started or " +
'after the compilation is done.'
);
}
if (this.compilationState.entries.indexOf(entry) === -1) {
this.compilationState.entries = [...this.compilationState.entries, entry];
}
}
getLatestResult () {
if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
throw new Error(
'The child compiler is not done compiling. ' +
"Please access the result after the compiler 'make' phase has started or " +
'after the compilation is done.'
);
}
return {
mainCompilationHash: this.compilationState.mainCompilationHash,
compilationResult: this.compilationState.compilationResult
};
}
/**
* Verify that the cache is still valid
* @private
* @param {Snapshot | undefined} snapshot
* @param {WebpackCompilation} mainCompilation
* @returns {Promise<boolean>}
*/
isCacheValid (snapshot, mainCompilation) {
if (!this.compilationState.isVerifyingCache) {
return Promise.reject(new Error('Cache validation can only be done right before the compilation starts'));
}
// If there are no entries we don't need a new child compilation
if (this.compilationState.entries.length === 0) {
return Promise.resolve(true);
}
// If there are new entries the cache is invalid
if (this.compilationState.entries !== this.compilationState.previousEntries) {
return Promise.resolve(false);
}
// Mark the cache as invalid if there is no snapshot
if (!snapshot) {
return Promise.resolve(false);
}
return fileWatcherApi.isSnapShotValid(snapshot, mainCompilation);
}
/**
* Start to compile all templates
*
* @private
* @param {WebpackCompilation} mainCompilation
* @param {string[]} entries
* @returns {Promise<ChildCompilationResult>}
*/
compileEntries (mainCompilation, entries) {
const compiler = new HtmlWebpackChildCompiler(entries);
return compiler.compileTemplates(mainCompilation).then((result) => {
return {
// The compiled sources to render the content
compiledEntries: result,
// The file dependencies to find out if a
// recompilation is required
dependencies: compiler.fileDependencies,
// The main compilation hash can be used to find out
// if this compilation was done during the current compilation
mainCompilationHash: mainCompilation.hash
};
}, error => ({
// The compiled sources to render the content
error,
// The file dependencies to find out if a
// recompilation is required
dependencies: compiler.fileDependencies,
// The main compilation hash can be used to find out
// if this compilation was done during the current compilation
mainCompilationHash: mainCompilation.hash
}));
}
/**
* @private
* @param {WebpackCompilation} mainCompilation
* @param {FileDependencies} files
*/
watchFiles (mainCompilation, files) {
fileWatcherApi.watchFiles(mainCompilation, files);
}
}
module.exports = {
CachedChildCompilation
};

206
node_modules/html-webpack-plugin/lib/child-compiler.js generated vendored Normal file
View File

@@ -0,0 +1,206 @@
// @ts-check
/** @typedef {import("webpack/lib/Compilation.js")} WebpackCompilation */
/** @typedef {import("webpack/lib/Compiler.js")} WebpackCompiler */
/** @typedef {import("webpack/lib/Chunk.js")} WebpackChunk */
'use strict';
/**
* @file
* This file uses webpack to compile a template with a child compiler.
*
* [TEMPLATE] -> [JAVASCRIPT]
*
*/
'use strict';
let instanceId = 0;
/**
* The HtmlWebpackChildCompiler is a helper to allow reusing one childCompiler
* for multiple HtmlWebpackPlugin instances to improve the compilation performance.
*/
class HtmlWebpackChildCompiler {
/**
*
* @param {string[]} templates
*/
constructor (templates) {
/** Id for this ChildCompiler */
this.id = instanceId++;
/**
* @type {string[]} templateIds
* The template array will allow us to keep track which input generated which output
*/
this.templates = templates;
/**
* @type {Promise<{[templatePath: string]: { content: string, hash: string, entry: WebpackChunk }}>}
*/
this.compilationPromise; // eslint-disable-line
/**
* @type {number}
*/
this.compilationStartedTimestamp; // eslint-disable-line
/**
* @type {number}
*/
this.compilationEndedTimestamp; // eslint-disable-line
/**
* All file dependencies of the child compiler
* @type {{fileDependencies: string[], contextDependencies: string[], missingDependencies: string[]}}
*/
this.fileDependencies = { fileDependencies: [], contextDependencies: [], missingDependencies: [] };
}
/**
* Returns true if the childCompiler is currently compiling
* @returns {boolean}
*/
isCompiling () {
return !this.didCompile() && this.compilationStartedTimestamp !== undefined;
}
/**
* Returns true if the childCompiler is done compiling
*/
didCompile () {
return this.compilationEndedTimestamp !== undefined;
}
/**
* This function will start the template compilation
* once it is started no more templates can be added
*
* @param {import('webpack').Compilation} mainCompilation
* @returns {Promise<{[templatePath: string]: { content: string, hash: string, entry: WebpackChunk }}>}
*/
compileTemplates (mainCompilation) {
const webpack = mainCompilation.compiler.webpack;
const Compilation = webpack.Compilation;
const NodeTemplatePlugin = webpack.node.NodeTemplatePlugin;
const NodeTargetPlugin = webpack.node.NodeTargetPlugin;
const LoaderTargetPlugin = webpack.LoaderTargetPlugin;
const EntryPlugin = webpack.EntryPlugin;
// To prevent multiple compilations for the same template
// the compilation is cached in a promise.
// If it already exists return
if (this.compilationPromise) {
return this.compilationPromise;
}
const outputOptions = {
filename: '__child-[name]',
publicPath: '',
library: {
type: 'var',
name: 'HTML_WEBPACK_PLUGIN_RESULT'
},
scriptType: /** @type {'text/javascript'} */('text/javascript'),
iife: true
};
const compilerName = 'HtmlWebpackCompiler';
// Create an additional child compiler which takes the template
// and turns it into an Node.JS html factory.
// This allows us to use loaders during the compilation
const childCompiler = mainCompilation.createChildCompiler(compilerName, outputOptions, [
// Compile the template to nodejs javascript
new NodeTargetPlugin(),
new NodeTemplatePlugin(),
new LoaderTargetPlugin('node'),
new webpack.library.EnableLibraryPlugin('var')
]);
// The file path context which webpack uses to resolve all relative files to
childCompiler.context = mainCompilation.compiler.context;
// Generate output file names
const temporaryTemplateNames = this.templates.map((template, index) => `__child-HtmlWebpackPlugin_${index}-${this.id}`);
// Add all templates
this.templates.forEach((template, index) => {
new EntryPlugin(childCompiler.context, 'data:text/javascript,__webpack_public_path__ = __webpack_base_uri__ = htmlWebpackPluginPublicPath;', `HtmlWebpackPlugin_${index}-${this.id}`).apply(childCompiler);
new EntryPlugin(childCompiler.context, template, `HtmlWebpackPlugin_${index}-${this.id}`).apply(childCompiler);
});
// The templates are compiled and executed by NodeJS - similar to server side rendering
// Unfortunately this causes issues as some loaders require an absolute URL to support ES Modules
// The following config enables relative URL support for the child compiler
childCompiler.options.module = { ...childCompiler.options.module };
childCompiler.options.module.parser = { ...childCompiler.options.module.parser };
childCompiler.options.module.parser.javascript = { ...childCompiler.options.module.parser.javascript,
url: 'relative' };
this.compilationStartedTimestamp = new Date().getTime();
this.compilationPromise = new Promise((resolve, reject) => {
const extractedAssets = [];
childCompiler.hooks.thisCompilation.tap('HtmlWebpackPlugin', (compilation) => {
compilation.hooks.processAssets.tap(
{
name: 'HtmlWebpackPlugin',
stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
},
(assets) => {
temporaryTemplateNames.forEach((temporaryTemplateName) => {
if (assets[temporaryTemplateName]) {
extractedAssets.push(assets[temporaryTemplateName]);
compilation.deleteAsset(temporaryTemplateName);
}
});
}
);
});
childCompiler.runAsChild((err, entries, childCompilation) => {
// Extract templates
const compiledTemplates = entries
? extractedAssets.map((asset) => asset.source())
: [];
// Extract file dependencies
if (entries && childCompilation) {
this.fileDependencies = { fileDependencies: Array.from(childCompilation.fileDependencies), contextDependencies: Array.from(childCompilation.contextDependencies), missingDependencies: Array.from(childCompilation.missingDependencies) };
}
// Reject the promise if the childCompilation contains error
if (childCompilation && childCompilation.errors && childCompilation.errors.length) {
const errorDetails = childCompilation.errors.map(error => {
let message = error.message;
if (error.stack) {
message += '\n' + error.stack;
}
return message;
}).join('\n');
reject(new Error('Child compilation failed:\n' + errorDetails));
return;
}
// Reject if the error object contains errors
if (err) {
reject(err);
return;
}
if (!childCompilation || !entries) {
reject(new Error('Empty child compilation'));
return;
}
/**
* @type {{[templatePath: string]: { content: string, hash: string, entry: WebpackChunk }}}
*/
const result = {};
compiledTemplates.forEach((templateSource, entryIndex) => {
// The compiledTemplates are generated from the entries added in
// the addTemplate function.
// Therefore the array index of this.templates should be the as entryIndex.
result[this.templates[entryIndex]] = {
content: templateSource,
hash: childCompilation.hash || 'XXXX',
entry: entries[entryIndex]
};
});
this.compilationEndedTimestamp = new Date().getTime();
resolve(result);
});
});
return this.compilationPromise;
}
}
module.exports = {
HtmlWebpackChildCompiler
};

40
node_modules/html-webpack-plugin/lib/chunksorter.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
// @ts-check
/** @typedef {import("webpack/lib/Compilation.js")} WebpackCompilation */
'use strict';
/**
* @type {{[sortmode: string] : (entryPointNames: Array<string>, compilation, htmlWebpackPluginOptions) => Array<string> }}
* This file contains different sort methods for the entry chunks names
*/
module.exports = {};
/**
* Performs identity mapping (no-sort).
* @param {Array} chunks the chunks to sort
* @return {Array} The sorted chunks
*/
module.exports.none = chunks => chunks;
/**
* Sort manually by the chunks
* @param {string[]} entryPointNames the chunks to sort
* @param {WebpackCompilation} compilation the webpack compilation
* @param htmlWebpackPluginOptions the plugin options
* @return {string[]} The sorted chunks
*/
module.exports.manual = (entryPointNames, compilation, htmlWebpackPluginOptions) => {
const chunks = htmlWebpackPluginOptions.chunks;
if (!Array.isArray(chunks)) {
return entryPointNames;
}
// Remove none existing entries from
// htmlWebpackPluginOptions.chunks
return chunks.filter((entryPointName) => {
return compilation.entrypoints.has(entryPointName);
});
};
/**
* Defines the default sorter.
*/
module.exports.auto = module.exports.none;

31
node_modules/html-webpack-plugin/lib/errors.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
// @ts-nocheck
'use strict';
const PrettyError = require('pretty-error');
const prettyError = new PrettyError();
prettyError.withoutColors();
prettyError.skipPackage('html-plugin-evaluation');
prettyError.skipNodeFiles();
prettyError.skip(function (traceLine) {
return traceLine.path === 'html-plugin-evaluation';
});
module.exports = function (err, context) {
return {
toHtml: function () {
return 'Html Webpack Plugin:\n<pre>\n' + this.toString() + '</pre>';
},
toJsonHtml: function () {
return JSON.stringify(this.toHtml());
},
toString: function () {
try {
return prettyError.render(err).replace(/webpack:\/\/\/\./g, context);
} catch (e) {
// This can sometimes fail. We don't know why, but returning the
// original error is better than returning the error thrown by
// pretty-error.
return err;
}
}
};
};

71
node_modules/html-webpack-plugin/lib/file-watcher-api.js generated vendored Normal file
View File

@@ -0,0 +1,71 @@
// @ts-check
/** @typedef {import("webpack/lib/Compilation.js")} WebpackCompilation */
/** @typedef {import("webpack/lib/FileSystemInfo").Snapshot} Snapshot */
'use strict';
/**
*
* @param {{fileDependencies: string[], contextDependencies: string[], missingDependencies: string[]}} fileDependencies
* @param {WebpackCompilation} mainCompilation
* @param {number} startTime
*/
function createSnapshot (fileDependencies, mainCompilation, startTime) {
return new Promise((resolve, reject) => {
mainCompilation.fileSystemInfo.createSnapshot(
startTime,
fileDependencies.fileDependencies,
fileDependencies.contextDependencies,
fileDependencies.missingDependencies,
null,
(err, snapshot) => {
if (err) {
return reject(err);
}
resolve(snapshot);
}
);
});
}
/**
* Returns true if the files inside this snapshot
* have not been changed
*
* @param {Snapshot} snapshot
* @param {WebpackCompilation} mainCompilation
* @returns {Promise<boolean>}
*/
function isSnapShotValid (snapshot, mainCompilation) {
return new Promise((resolve, reject) => {
mainCompilation.fileSystemInfo.checkSnapshotValid(
snapshot,
(err, isValid) => {
if (err) {
reject(err);
}
resolve(isValid);
}
);
});
}
/**
* Ensure that the files keep watched for changes
* and will trigger a recompile
*
* @param {WebpackCompilation} mainCompilation
* @param {{fileDependencies: string[], contextDependencies: string[], missingDependencies: string[]}} fileDependencies
*/
function watchFiles (mainCompilation, fileDependencies) {
Object.keys(fileDependencies).forEach((depencyTypes) => {
fileDependencies[depencyTypes].forEach(fileDependency => {
mainCompilation[depencyTypes].add(fileDependency);
});
});
}
module.exports = {
createSnapshot,
isSnapShotValid,
watchFiles
};

108
node_modules/html-webpack-plugin/lib/hooks.js generated vendored Normal file
View File

@@ -0,0 +1,108 @@
// @ts-check
/** @typedef {import("../typings").Hooks} HtmlWebpackPluginHooks */
'use strict';
/**
* This file provides access to all public htmlWebpackPlugin hooks
*/
/** @typedef {import("webpack/lib/Compilation.js")} WebpackCompilation */
/** @typedef {import("../index.js")} HtmlWebpackPlugin */
const AsyncSeriesWaterfallHook = require('tapable').AsyncSeriesWaterfallHook;
// The following is the API definition for all available hooks
// For the TypeScript definition, see the Hooks type in typings.d.ts
/**
beforeAssetTagGeneration:
AsyncSeriesWaterfallHook<{
assets: {
publicPath: string,
js: Array<string>,
css: Array<string>,
favicon?: string | undefined,
manifest?: string | undefined
},
outputName: string,
plugin: HtmlWebpackPlugin
}>,
alterAssetTags:
AsyncSeriesWaterfallHook<{
assetTags: {
scripts: Array<HtmlTagObject>,
styles: Array<HtmlTagObject>,
meta: Array<HtmlTagObject>,
},
publicPath: string,
outputName: string,
plugin: HtmlWebpackPlugin
}>,
alterAssetTagGroups:
AsyncSeriesWaterfallHook<{
headTags: Array<HtmlTagObject | HtmlTagObject>,
bodyTags: Array<HtmlTagObject | HtmlTagObject>,
publicPath: string,
outputName: string,
plugin: HtmlWebpackPlugin
}>,
afterTemplateExecution:
AsyncSeriesWaterfallHook<{
html: string,
headTags: Array<HtmlTagObject | HtmlTagObject>,
bodyTags: Array<HtmlTagObject | HtmlTagObject>,
outputName: string,
plugin: HtmlWebpackPlugin,
}>,
beforeEmit:
AsyncSeriesWaterfallHook<{
html: string,
outputName: string,
plugin: HtmlWebpackPlugin,
}>,
afterEmit:
AsyncSeriesWaterfallHook<{
outputName: string,
plugin: HtmlWebpackPlugin
}>
*/
/**
* @type {WeakMap<WebpackCompilation, HtmlWebpackPluginHooks>}}
*/
const htmlWebpackPluginHooksMap = new WeakMap();
/**
* Returns all public hooks of the html webpack plugin for the given compilation
*
* @param {WebpackCompilation} compilation
* @returns {HtmlWebpackPluginHooks}
*/
function getHtmlWebpackPluginHooks (compilation) {
let hooks = htmlWebpackPluginHooksMap.get(compilation);
// Setup the hooks only once
if (hooks === undefined) {
hooks = createHtmlWebpackPluginHooks();
htmlWebpackPluginHooksMap.set(compilation, hooks);
}
return hooks;
}
/**
* Add hooks to the webpack compilation object to allow foreign plugins to
* extend the HtmlWebpackPlugin
*
* @returns {HtmlWebpackPluginHooks}
*/
function createHtmlWebpackPluginHooks () {
return {
beforeAssetTagGeneration: new AsyncSeriesWaterfallHook(['pluginArgs']),
alterAssetTags: new AsyncSeriesWaterfallHook(['pluginArgs']),
alterAssetTagGroups: new AsyncSeriesWaterfallHook(['pluginArgs']),
afterTemplateExecution: new AsyncSeriesWaterfallHook(['pluginArgs']),
beforeEmit: new AsyncSeriesWaterfallHook(['pluginArgs']),
afterEmit: new AsyncSeriesWaterfallHook(['pluginArgs'])
};
}
module.exports = {
getHtmlWebpackPluginHooks
};

99
node_modules/html-webpack-plugin/lib/html-tags.js generated vendored Normal file
View File

@@ -0,0 +1,99 @@
// @ts-check
/** @typedef {import("../typings").HtmlTagObject} HtmlTagObject */
/**
* @file
* This file provides to helper to create html as a object representation as
* those objects are easier to modify than pure string representations
*
* Usage:
* ```
* const element = createHtmlTagObject('h1', {class: 'demo'}, 'Hello World');
* const html = htmlTagObjectToString(element);
* console.log(html) // -> <h1 class="demo">Hello World</h1>
* ```
*/
/**
* All html tag elements which must not contain innerHTML
* @see https://www.w3.org/TR/html5/syntax.html#void-elements
*/
const voidTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
/**
* Turn a tag definition into a html string
* @param {HtmlTagObject} tagDefinition
* A tag element according to the htmlWebpackPlugin object notation
*
* @param xhtml {boolean}
* Whether the generated html should add closing slashes to be xhtml compliant
*/
function htmlTagObjectToString (tagDefinition, xhtml) {
const attributes = Object.keys(tagDefinition.attributes || {})
.filter(function (attributeName) {
return tagDefinition.attributes[attributeName] === '' || tagDefinition.attributes[attributeName];
})
.map(function (attributeName) {
if (tagDefinition.attributes[attributeName] === true) {
return xhtml ? attributeName + '="' + attributeName + '"' : attributeName;
}
return attributeName + '="' + tagDefinition.attributes[attributeName] + '"';
});
return '<' + [tagDefinition.tagName].concat(attributes).join(' ') + (tagDefinition.voidTag && xhtml ? '/' : '') + '>' +
(tagDefinition.innerHTML || '') +
(tagDefinition.voidTag ? '' : '</' + tagDefinition.tagName + '>');
}
/**
* Static helper to create a tag object to be get injected into the dom
*
* @param {string} tagName
* the name of the tag e.g. 'div'
*
* @param {{[attributeName: string]: string|boolean|null|undefined}} [attributes]
* tag attributes e.g. `{ 'class': 'example', disabled: true }`
*
* @param {string} [innerHTML]
*
* @param {{[attributeName: string]: string|boolean|null|undefined}} [meta]
* meta information about the tag e.g. `{ 'plugin': 'html-webpack-plugin' }`
*
* @returns {HtmlTagObject}
*/
function createHtmlTagObject (tagName, attributes, innerHTML, meta) {
return {
tagName: tagName,
voidTag: voidTags.indexOf(tagName) !== -1,
attributes: attributes || {},
meta: meta || {},
innerHTML: innerHTML
};
}
/**
* The `HtmlTagArray Array with a custom `.toString()` method.
*
* This allows the following:
* ```
* const tags = HtmlTagArray.from([tag1, tag2]);
* const scriptTags = tags.filter((tag) => tag.tagName === 'script');
* const html = scriptTags.toString();
* ```
*
* Or inside a string literal:
* ```
* const tags = HtmlTagArray.from([tag1, tag2]);
* const html = `<html><body>${tags.filter((tag) => tag.tagName === 'script')}</body></html>`;
* ```
*
*/
class HtmlTagArray extends Array {
toString () {
return this.join('');
}
}
module.exports = {
HtmlTagArray: HtmlTagArray,
createHtmlTagObject: createHtmlTagObject,
htmlTagObjectToString: htmlTagObjectToString
};

40
node_modules/html-webpack-plugin/lib/loader.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
/* This loader renders the template with underscore if no other loader was found */
// @ts-nocheck
'use strict';
const _ = require('lodash');
module.exports = function (source) {
// Get templating options
const options = this.getOptions();
const force = options.force || false;
const allLoadersButThisOne = this.loaders.filter((loader) => loader.normal !== module.exports);
// This loader shouldn't kick in if there is any other loader (unless it's explicitly enforced)
if (allLoadersButThisOne.length > 0 && !force) {
return source;
}
// Allow only one html-webpack-plugin loader to allow loader options in the webpack config
const htmlWebpackPluginLoaders = this.loaders.filter((loader) => loader.normal === module.exports);
const lastHtmlWebpackPluginLoader = htmlWebpackPluginLoaders[htmlWebpackPluginLoaders.length - 1];
if (this.loaders[this.loaderIndex] !== lastHtmlWebpackPluginLoader) {
return source;
}
// Skip .js files (unless it's explicitly enforced)
if (/\.js$/.test(this.resourcePath) && !force) {
return source;
}
// The following part renders the template with lodash as a minimalistic loader
//
const template = _.template(source, { interpolate: /<%=([\s\S]+?)%>/g, variable: 'data', ...options });
// Use __non_webpack_require__ to enforce using the native nodejs require
// during template execution
return 'var _ = __non_webpack_require__(' + JSON.stringify(require.resolve('lodash')) + ');' +
'module.exports = function (templateParams) { with(templateParams) {' +
// Execute the lodash template
'return (' + template.source + ')();' +
'}}';
};

88
node_modules/html-webpack-plugin/package.json generated vendored Normal file
View File

@@ -0,0 +1,88 @@
{
"name": "html-webpack-plugin",
"version": "5.5.0",
"license": "MIT",
"description": "Simplifies creation of HTML files to serve your webpack bundles",
"author": "Jan Nicklas <j.nicklas@me.com> (https://github.com/jantimon)",
"main": "index.js",
"types": "typings.d.ts",
"files": [
"lib/",
"index.js",
"default_index.ejs",
"typings.d.ts"
],
"scripts": {
"pretest": "semistandard",
"posttest": "tsc",
"commit": "git-cz",
"build-examples": "node examples/build-examples.js",
"test": "jest --runInBand --verbose --coverage",
"test-watch": "jest --runInBand --watch",
"puml": "npx puml generate flow.puml -o flow.png",
"release": "standard-version"
},
"semistandard": {
"ignore": [
"examples/*/dist/**/*.*"
]
},
"devDependencies": {
"@types/node": "11.13.9",
"commitizen": "^4.2.4",
"css-loader": "5.0.1",
"cz-conventional-changelog": "2.1.0",
"dir-compare": "^3.3.0",
"html-loader": "2.1.1",
"jest": "^27.2.5",
"mini-css-extract-plugin": "^1.6.0",
"pug": "3.0.2",
"pug-loader": "2.4.0",
"raw-loader": "4.0.2",
"rimraf": "2.6.3",
"semistandard": "^13.0.1",
"standard-version": "^9.3.0",
"style-loader": "2.0.0",
"typescript": "4.1.3",
"webpack": "5.24.3",
"webpack-cli": "4.5.0",
"webpack-recompilation-simulator": "3.2.0"
},
"dependencies": {
"@types/html-minifier-terser": "^6.0.0",
"html-minifier-terser": "^6.0.2",
"lodash": "^4.17.21",
"pretty-error": "^4.0.0",
"tapable": "^2.0.0"
},
"peerDependencies": {
"webpack": "^5.20.0"
},
"keywords": [
"webpack",
"plugin",
"html",
"html-webpack-plugin"
],
"bugs": "https://github.com/jantimon/html-webpack-plugin/issues",
"homepage": "https://github.com/jantimon/html-webpack-plugin",
"repository": "https://github.com/jantimon/html-webpack-plugin.git",
"engines": {
"node": ">=10.13.0"
},
"config": {
"commitizen": {
"path": "./node_modules/cz-conventional-changelog"
}
},
"jest": {
"watchPathIgnorePatterns": [
"<rootDir>/dist"
],
"testEnvironment": "node"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/html-webpack-plugin"
}
}

290
node_modules/html-webpack-plugin/typings.d.ts generated vendored Normal file
View File

@@ -0,0 +1,290 @@
import { AsyncSeriesWaterfallHook } from "tapable";
import { Compiler, Compilation } from "webpack";
import { Options as HtmlMinifierOptions } from "html-minifier-terser";
export = HtmlWebpackPlugin;
declare class HtmlWebpackPlugin {
constructor(options?: HtmlWebpackPlugin.Options);
userOptions: HtmlWebpackPlugin.Options;
/** Current HtmlWebpackPlugin Major */
version: number;
/**
* Options after html-webpack-plugin has been initialized with defaults
*/
options?: HtmlWebpackPlugin.ProcessedOptions;
apply(compiler: Compiler): void;
static getHooks(compilation: Compilation): HtmlWebpackPlugin.Hooks;
/**
* Static helper to create a tag object to be get injected into the dom
*/
static createHtmlTagObject(
tagName: string,
attributes?: { [attributeName: string]: string | boolean },
innerHTML?: string
): HtmlWebpackPlugin.HtmlTagObject;
static readonly version: number;
}
declare namespace HtmlWebpackPlugin {
type MinifyOptions = HtmlMinifierOptions;
interface Options {
/**
* Emit the file only if it was changed.
* @default true
*/
cache?: boolean;
/**
* List all entries which should be injected
*/
chunks?: "all" | string[];
/**
* Allows to control how chunks should be sorted before they are included to the html.
* @default 'auto'
*/
chunksSortMode?:
| "auto"
| "manual"
| ((entryNameA: string, entryNameB: string) => number);
/**
* List all entries which should not be injected
*/
excludeChunks?: string[];
/**
* Path to the favicon icon
*/
favicon?: false | string;
/**
* The file to write the HTML to.
* Supports subdirectories eg: `assets/admin.html`
* [name] will be replaced by the entry name
* Supports a function to generate the name
*
* @default 'index.html'
*/
filename?: string | ((entryName: string) => string);
/**
* By default the public path is set to `auto` - that way the html-webpack-plugin will try
* to set the publicPath according to the current filename and the webpack publicPath setting
*/
publicPath?: string | "auto";
/**
* If `true` then append a unique `webpack` compilation hash to all included scripts and CSS files.
* This is useful for cache busting
*/
hash?: boolean;
/**
* Inject all assets into the given `template` or `templateContent`.
*/
inject?:
| false // Don't inject scripts
| true // Inject scripts into body
| "body" // Inject scripts into body
| "head"; // Inject scripts into head
/**
* Set up script loading
* blocking will result in <script src="..."></script>
* defer will result in <script defer src="..."></script>
*
* @default 'defer'
*/
scriptLoading?: "blocking" | "defer" | "module";
/**
* Inject meta tags
*/
meta?:
| false // Disable injection
| {
[name: string]:
| string
| false // name content pair e.g. {viewport: 'width=device-width, initial-scale=1, shrink-to-fit=no'}`
| { [attributeName: string]: string | boolean }; // custom properties e.g. { name:"viewport" content:"width=500, initial-scale=1" }
};
/**
* HTML Minification options accepts the following values:
* - Set to `false` to disable minifcation
* - Set to `'auto'` to enable minifcation only for production mode
* - Set to custom minification according to
* {@link https://github.com/kangax/html-minifier#options-quick-reference}
*/
minify?: "auto" | boolean | MinifyOptions;
/**
* Render errors into the HTML page
*/
showErrors?: boolean;
/**
* The `webpack` require path to the template.
* @see https://github.com/jantimon/html-webpack-plugin/blob/master/docs/template-option.md
*/
template?: string;
/**
* Allow to use a html string instead of reading from a file
*/
templateContent?:
| false // Use the template option instead to load a file
| string
| ((templateParameters: {
[option: string]: any;
}) => string | Promise<string>)
| Promise<string>;
/**
* Allows to overwrite the parameters used in the template
*/
templateParameters?:
| false // Pass an empty object to the template function
| ((
compilation: any,
assets: {
publicPath: string;
js: Array<string>;
css: Array<string>;
manifest?: string;
favicon?: string;
},
assetTags: {
headTags: HtmlTagObject[];
bodyTags: HtmlTagObject[];
},
options: ProcessedOptions
) => { [option: string]: any } | Promise<{ [option: string]: any }>)
| { [option: string]: any };
/**
* The title to use for the generated HTML document
*/
title?: string;
/**
* Enforce self closing tags e.g. <link />
*/
xhtml?: boolean;
/**
* In addition to the options actually used by this plugin, you can use this hash to pass arbitrary data through
* to your template.
*/
[option: string]: any;
}
/**
* The plugin options after adding default values
*/
interface ProcessedOptions extends Required<Options> {
filename: string;
}
/**
* The values which are available during template execution
*
* Please keep in mind that the `templateParameter` options allows to change them
*/
interface TemplateParameter {
compilation: any;
htmlWebpackPlugin: {
tags: {
headTags: HtmlTagObject[];
bodyTags: HtmlTagObject[];
};
files: {
publicPath: string;
js: Array<string>;
css: Array<string>;
manifest?: string;
favicon?: string;
};
options: Options;
};
webpackConfig: any;
}
interface Hooks {
alterAssetTags: AsyncSeriesWaterfallHook<{
assetTags: {
scripts: HtmlTagObject[];
styles: HtmlTagObject[];
meta: HtmlTagObject[];
};
publicPath: string,
outputName: string;
plugin: HtmlWebpackPlugin;
}>;
alterAssetTagGroups: AsyncSeriesWaterfallHook<{
headTags: HtmlTagObject[];
bodyTags: HtmlTagObject[];
outputName: string;
publicPath: string,
plugin: HtmlWebpackPlugin;
}>;
afterTemplateExecution: AsyncSeriesWaterfallHook<{
html: string;
headTags: HtmlTagObject[];
bodyTags: HtmlTagObject[];
outputName: string;
plugin: HtmlWebpackPlugin;
}>;
beforeAssetTagGeneration: AsyncSeriesWaterfallHook<{
assets: {
publicPath: string;
js: Array<string>;
css: Array<string>;
favicon?: string;
manifest?: string;
};
outputName: string;
plugin: HtmlWebpackPlugin;
}>;
beforeEmit: AsyncSeriesWaterfallHook<{
html: string;
outputName: string;
plugin: HtmlWebpackPlugin;
}>;
afterEmit: AsyncSeriesWaterfallHook<{
outputName: string;
plugin: HtmlWebpackPlugin;
}>;
}
/**
* A tag element according to the htmlWebpackPlugin object notation
*/
interface HtmlTagObject {
/**
* Attributes of the html tag
* E.g. `{'disabled': true, 'value': 'demo'}`
*/
attributes: {
[attributeName: string]: string | boolean | null | undefined;
};
/**
* The tag name e.g. `'div'`
*/
tagName: string;
/**
* The inner HTML
*/
innerHTML?: string;
/**
* Whether this html must not contain innerHTML
* @see https://www.w3.org/TR/html5/syntax.html#void-elements
*/
voidTag: boolean;
/**
* Meta information about the tag
* E.g. `{'plugin': 'html-webpack-plugin'}`
*/
meta: {
plugin?: string,
[metaAttributeName: string]: any;
};
}
}