Source: node-core-js
Version: 3.22.5-1
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: lu...@debian.org
Usertags: ftbfs-20220525 ftbfs-bookworm
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> zx scripts/generate-indexes.mjs
> indexes generated
> zx scripts/clean-and-copy.mjs
> old copies removed
> created /features/ entries
> copied 3109 files
> zx scripts/build-compat-data.mjs
> compat data rebuilt
> zx scripts/build-compat-entries.mjs
> entries data rebuilt
> zx scripts/build-compat-modules-by-versions.mjs
> modules-by-versions data rebuilt
> ln -s ../packages/core-js node_modules/core-js || true
> zx scripts/bundle.mjs
> /usr/share/nodejs/schema-utils/dist/validate.js:105
> throw new _ValidationError.default(errors, schema, configuration);
> ^
>
> ValidationError: Invalid configuration object. Webpack has been initialized
> using a configuration object that does not match the API schema.
> - configuration.node should be one of these:
> false | object { __dirname?, __filename?, global? }
> -> Include polyfills or mocks for various node stuff.
> Details:
> * configuration.node has an unknown property 'process'. These properties
> are valid:
> object { __dirname?, __filename?, global? }
> -> Options object for node compatibility features.
> * configuration.node has an unknown property 'setImmediate'. These
> properties are valid:
> object { __dirname?, __filename?, global? }
> -> Options object for node compatibility features.
> at validate (/usr/share/nodejs/schema-utils/dist/validate.js:105:11)
> at validateSchema (/usr/share/nodejs/webpack/lib/validateSchema.js:78:2)
> at create (/usr/share/nodejs/webpack/lib/webpack.js:111:24)
> at webpack (/usr/share/nodejs/webpack/lib/webpack.js:142:47)
> at f (/usr/share/nodejs/webpack/lib/index.js:58:16)
> at node:internal/util:360:7
> at new Promise (<anonymous>)
> at f (node:internal/util:346:12)
> at module.exports
> (/<<PKGBUILDDIR>>/packages/core-js-builder/index.js:47:11)
> at bundle (file:///<<PKGBUILDDIR>>/scripts/bundle.mjs:13:24) {
> errors: [
> {
> keyword: 'anyOf',
> dataPath: '.node',
> schemaPath: '#/anyOf',
> params: {},
> message: 'should match some schema in anyOf',
> schema: [ { enum: [ false ] }, { '$ref': '#/definitions/NodeOptions' }
> ],
> parentSchema: {
> description: 'Include polyfills or mocks for various node stuff.',
> anyOf: [ { enum: [Array] }, { '$ref': '#/definitions/NodeOptions' } ]
> },
> data: { global: false, process: false, setImmediate: false },
> children: [
> {
> keyword: 'enum',
> dataPath: '.node',
> schemaPath: '#/anyOf/0/enum',
> params: { allowedValues: [Array] },
> message: 'should be equal to one of the allowed values',
> schema: [ false ],
> parentSchema: { enum: [Array] },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> },
> {
> keyword: 'additionalProperties',
> dataPath: '.node',
> schemaPath: '#/definitions/NodeOptions/additionalProperties',
> params: { additionalProperty: 'process' },
> message: 'should NOT have additional properties',
> schema: false,
> parentSchema: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> },
> {
> keyword: 'additionalProperties',
> dataPath: '.node',
> schemaPath: '#/definitions/NodeOptions/additionalProperties',
> params: { additionalProperty: 'setImmediate' },
> message: 'should NOT have additional properties',
> schema: false,
> parentSchema: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> }
> ]
> }
> ],
> schema: {
> definitions: {
> Amd: {
> description: 'Set the value of `require.amd` and `define.amd`. Or
> disable AMD support.',
> anyOf: [
> {
> description: 'You can pass `false` to disable AMD support.',
> enum: [Array]
> },
> {
> description: 'You can pass an object to set the value of
> `require.amd` and `define.amd`.',
> type: 'object'
> }
> ]
> },
> AssetFilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: "((name: string, asset:
> import('../lib/stats/DefaultStatsFactoryPlugin').StatsAsset) => boolean)"
> }
> ]
> },
> AssetFilterTypes: {
> description: 'Filtering modules.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/AssetFilterItemTypes' }
> ]
> },
> AssetGeneratorDataUrl: {
> description: 'The options for data url generator.',
> anyOf: [
> { '$ref': '#/definitions/AssetGeneratorDataUrlOptions' },
> { '$ref': '#/definitions/AssetGeneratorDataUrlFunction' }
> ]
> },
> AssetGeneratorDataUrlFunction: {
> description: 'Function that executes for module and should return an
> DataUrl string.',
> instanceof: 'Function',
> tsType: "((source: string | Buffer, context: { filename: string,
> module: import('../lib/Module') }) => string)"
> },
> AssetGeneratorDataUrlOptions: {
> description: 'Options object for data url generation.',
> type: 'object',
> additionalProperties: false,
> properties: {
> encoding: {
> description: 'Asset encoding (defaults to base64).',
> enum: [Array]
> },
> mimetype: {
> description: 'Asset mimetype (getting from file extension by
> default).',
> type: 'string'
> }
> }
> },
> AssetGeneratorOptions: {
> description: 'Generator options for asset modules.',
> type: 'object',
> implements: [
> '#/definitions/AssetInlineGeneratorOptions',
> '#/definitions/AssetResourceGeneratorOptions'
> ],
> additionalProperties: false,
> properties: {
> dataUrl: { '$ref': '#/definitions/AssetGeneratorDataUrl' },
> emit: {
> description: "Emit an output asset from this asset module. This
> can be set to 'false' to omit emitting e. g. for SSR.",
> type: 'boolean'
> },
> filename: { '$ref': '#/definitions/FilenameTemplate' },
> publicPath: { '$ref': '#/definitions/RawPublicPath' }
> }
> },
> AssetInlineGeneratorOptions: {
> description: 'Generator options for asset/inline modules.',
> type: 'object',
> additionalProperties: false,
> properties: { dataUrl: { '$ref':
> '#/definitions/AssetGeneratorDataUrl' } }
> },
> AssetModuleFilename: {
> description: "The filename of asset modules as relative path inside
> the 'output.path' directory.",
> anyOf: [
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData,
> assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> AssetParserDataUrlFunction: {
> description: 'Function that executes for module and should return
> whenever asset should be inlined as DataUrl.',
> instanceof: 'Function',
> tsType: "((source: string | Buffer, context: { filename: string,
> module: import('../lib/Module') }) => boolean)"
> },
> AssetParserDataUrlOptions: {
> description: 'Options object for DataUrl condition.',
> type: 'object',
> additionalProperties: false,
> properties: {
> maxSize: {
> description: 'Maximum size of asset that should be inline as
> modules. Default: 8kb.',
> type: 'number'
> }
> }
> },
> AssetParserOptions: {
> description: 'Parser options for asset modules.',
> type: 'object',
> additionalProperties: false,
> properties: {
> dataUrlCondition: {
> description: 'The condition for inlining the asset as DataUrl.',
> anyOf: [Array]
> }
> }
> },
> AssetResourceGeneratorOptions: {
> description: 'Generator options for asset/resource modules.',
> type: 'object',
> additionalProperties: false,
> properties: {
> emit: {
> description: "Emit an output asset from this asset module. This
> can be set to 'false' to omit emitting e. g. for SSR.",
> type: 'boolean'
> },
> filename: { '$ref': '#/definitions/FilenameTemplate' },
> publicPath: { '$ref': '#/definitions/RawPublicPath' }
> }
> },
> AuxiliaryComment: {
> description: 'Add a comment in the UMD wrapper.',
> anyOf: [
> {
> description: 'Append the same comment above each import style.',
> type: 'string'
> },
> { '$ref': '#/definitions/LibraryCustomUmdCommentObject' }
> ]
> },
> Bail: {
> description: 'Report the first error as a hard error instead of
> tolerating it.',
> type: 'boolean'
> },
> CacheOptions: {
> description: 'Cache generated modules and chunks to improve
> performance for multiple incremental builds.',
> anyOf: [
> { description: 'Enable in memory caching.', enum: [Array] },
> { '$ref': '#/definitions/CacheOptionsNormalized' }
> ]
> },
> CacheOptionsNormalized: {
> description: 'Cache generated modules and chunks to improve
> performance for multiple incremental builds.',
> anyOf: [
> { description: 'Disable caching.', enum: [Array] },
> { '$ref': '#/definitions/MemoryCacheOptions' },
> { '$ref': '#/definitions/FileCacheOptions' }
> ]
> },
> Charset: {
> description: 'Add charset attribute for script tag.',
> type: 'boolean'
> },
> ChunkFilename: {
> description: "Specifies the filename template of output files of
> non-initial chunks on disk. You must **not** specify an absolute path here,
> but the path may contain folders separated by '/'! The specified path is
> joined with the value of the 'output.path' option to determine the location
> on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> ChunkFormat: {
> description: "The format of chunks (formats included by default are
> 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but
> others might be added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> ChunkLoadTimeout: {
> description: 'Number of milliseconds before chunk request expires.',
> type: 'number'
> },
> ChunkLoading: {
> description: "The method of loading chunks (methods included by
> default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker),
> 'require' (sync node.js), 'async-node' (async node.js), but others might be
> added by plugins).",
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/ChunkLoadingType' }
> ]
> },
> ChunkLoadingGlobal: {
> description: 'The global variable used by webpack for loading of
> chunks.',
> type: 'string'
> },
> ChunkLoadingType: {
> description: "The method of loading chunks (methods included by
> default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker),
> 'require' (sync node.js), 'async-node' (async node.js), but others might be
> added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> Clean: {
> description: 'Clean the output directory before emit.',
> anyOf: [
> { type: 'boolean' },
> { '$ref': '#/definitions/CleanOptions' }
> ]
> },
> CleanOptions: {
> description: 'Advanced options for cleaning assets.',
> type: 'object',
> additionalProperties: false,
> properties: {
> dry: {
> description: 'Log the assets that should be removed instead of
> deleting them.',
> type: 'boolean'
> },
> keep: { description: 'Keep these assets.', anyOf: [Array] }
> }
> },
> CompareBeforeEmit: {
> description: 'Check if to be emitted file already exists and have the
> same content before writing to output filesystem.',
> type: 'boolean'
> },
> Context: {
> description: 'The base directory (absolute path!) for resolving the
> `entry` option. If `output.pathinfo` is set, the included pathinfo is
> shortened to this directory.',
> type: 'string',
> absolutePath: true
> },
> CrossOriginLoading: {
> description: 'This option enables cross-origin loading of chunks.',
> enum: [ false, 'anonymous', 'use-credentials' ]
> },
> Dependencies: {
> description: 'References to other configurations to depend on.',
> type: 'array',
> items: {
> description: 'References to another configuration to depend on.',
> type: 'string'
> }
> },
> DevServer: {
> description: 'Options for the webpack-dev-server.',
> type: 'object'
> },
> DevTool: {
> description: 'A developer tool to enhance debugging (false | eval |
> [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).',
> anyOf: [
> { enum: [Array] },
> {
> type: 'string',
> pattern:
> '^(inline-|hidden-|eval-)?(nosources-)?(cheap-(module-)?)?source-map$'
> }
> ]
> },
> DevtoolFallbackModuleFilenameTemplate: {
> description: 'Similar to `output.devtoolModuleFilenameTemplate`, but
> used in the case of duplicate module identifiers.',
> anyOf: [
> { type: 'string' },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> DevtoolModuleFilenameTemplate: {
> description: 'Filename template string of function for the sources
> array in a generated SourceMap.',
> anyOf: [
> { type: 'string' },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> DevtoolNamespace: {
> description: "Module namespace to use when interpolating filename
> template string for the sources array in a generated SourceMap. Defaults to
> `output.library` if not set. It's useful for avoiding runtime collisions in
> sourcemaps from multiple webpack projects built as libraries.",
> type: 'string'
> },
> EmptyGeneratorOptions: {
> description: 'No generator options are supported for this module
> type.',
> type: 'object',
> additionalProperties: false
> },
> EmptyParserOptions: {
> description: 'No parser options are supported for this module type.',
> type: 'object',
> additionalProperties: false
> },
> EnabledChunkLoadingTypes: {
> description: 'List of chunk loading types enabled for use by entry
> points.',
> type: 'array',
> items: { '$ref': '#/definitions/ChunkLoadingType' }
> },
> EnabledLibraryTypes: {
> description: 'List of library types enabled for use by entry points.',
> type: 'array',
> items: { '$ref': '#/definitions/LibraryType' }
> },
> EnabledWasmLoadingTypes: {
> description: 'List of wasm loading types enabled for use by entry
> points.',
> type: 'array',
> items: { '$ref': '#/definitions/WasmLoadingType' }
> },
> Entry: {
> description: 'The entry point(s) of the compilation.',
> anyOf: [
> { '$ref': '#/definitions/EntryDynamic' },
> { '$ref': '#/definitions/EntryStatic' }
> ]
> },
> EntryDescription: {
> description: 'An object with entry point description.',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are
> loaded on demand.',
> type: 'boolean'
> },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> dependOn: {
> description: 'The entrypoints that the current entrypoint depend
> on. They must be loaded when this entrypoint is loaded.',
> anyOf: [Array]
> },
> filename: { '$ref': '#/definitions/EntryFilename' },
> import: { '$ref': '#/definitions/EntryItem' },
> layer: { '$ref': '#/definitions/Layer' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> runtime: { '$ref': '#/definitions/EntryRuntime' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' }
> },
> required: [ 'import' ]
> },
> EntryDescriptionNormalized: {
> description: 'An object with entry point description.',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are
> loaded on demand.',
> type: 'boolean'
> },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> dependOn: {
> description: 'The entrypoints that the current entrypoint depend
> on. They must be loaded when this entrypoint is loaded.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> filename: { '$ref': '#/definitions/Filename' },
> import: {
> description: 'Module(s) that are loaded upon startup. The last
> one is exported.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> layer: { '$ref': '#/definitions/Layer' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> runtime: { '$ref': '#/definitions/EntryRuntime' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> EntryDynamic: {
> description: 'A Function returning an entry object, an entry string,
> an entry array or a promise to these things.',
> instanceof: 'Function',
> tsType: '(() => EntryStatic | Promise<EntryStatic>)'
> },
> EntryDynamicNormalized: {
> description: 'A Function returning a Promise resolving to a
> normalized entry.',
> instanceof: 'Function',
> tsType: '(() => Promise<EntryStaticNormalized>)'
> },
> EntryFilename: {
> description: "Specifies the filename of the output file on disk. You
> must **not** specify an absolute path here, but the path may contain folders
> separated by '/'! The specified path is joined with the value of the
> 'output.path' option to determine the location on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> EntryItem: {
> description: 'Module(s) that are loaded upon startup.',
> anyOf: [
> {
> description: 'All modules are loaded upon startup. The last one
> is exported.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> {
> description: 'The string is resolved to a module which is loaded
> upon startup.',
> type: 'string',
> minLength: 1
> }
> ]
> },
> EntryNormalized: {
> description: 'The entry point(s) of the compilation.',
> anyOf: [
> { '$ref': '#/definitions/EntryDynamicNormalized' },
> { '$ref': '#/definitions/EntryStaticNormalized' }
> ]
> },
> EntryObject: {
> description: 'Multiple entry bundles are created. The key is the
> entry name. The value can be a string, an array or an entry description
> object.',
> type: 'object',
> additionalProperties: {
> description: 'An entry point with name.',
> anyOf: [ [Object], [Object] ]
> }
> },
> EntryRuntime: {
> description: 'The name of the runtime chunk. If set a runtime chunk
> with this name is created or an existing entrypoint is used as runtime.',
> anyOf: [ { enum: [Array] }, { type: 'string', minLength: 1 } ]
> },
> EntryStatic: {
> description: 'A static entry description.',
> anyOf: [
> { '$ref': '#/definitions/EntryObject' },
> { '$ref': '#/definitions/EntryUnnamed' }
> ]
> },
> EntryStaticNormalized: {
> description: 'Multiple entry bundles are created. The key is the
> entry name. The value is an entry description object.',
> type: 'object',
> additionalProperties: {
> description: 'An object with entry point description.',
> oneOf: [ [Object] ]
> }
> },
> EntryUnnamed: {
> description: 'An entry point without name.',
> oneOf: [ { '$ref': '#/definitions/EntryItem' } ]
> },
> Environment: {
> description: 'The abilities of the environment where the webpack
> generated code should run.',
> type: 'object',
> additionalProperties: false,
> properties: {
> arrowFunction: {
> description: "The environment supports arrow functions ('() => {
> ... }').",
> type: 'boolean'
> },
> bigIntLiteral: {
> description: 'The environment supports BigInt as literal (123n).',
> type: 'boolean'
> },
> const: {
> description: 'The environment supports const and let for variable
> declarations.',
> type: 'boolean'
> },
> destructuring: {
> description: "The environment supports destructuring ('{ a, b } =
> obj').",
> type: 'boolean'
> },
> dynamicImport: {
> description: 'The environment supports an async import() function
> to import EcmaScript modules.',
> type: 'boolean'
> },
> forOf: {
> description: "The environment supports 'for of' iteration ('for
> (const x of array) { ... }').",
> type: 'boolean'
> },
> module: {
> description: "The environment supports EcmaScript Module syntax
> to import EcmaScript modules (import ... from '...').",
> type: 'boolean'
> },
> optionalChaining: {
> description: "The environment supports optional chaining
> ('obj?.a' or 'obj?.()').",
> type: 'boolean'
> },
> templateLiteral: {
> description: 'The environment supports template literals.',
> type: 'boolean'
> }
> }
> },
> Experiments: {
> description: 'Enables/Disables experiments (experimental features
> with relax SemVer compatibility).',
> type: 'object',
> implements: [ '#/definitions/ExperimentsCommon' ],
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript
> Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation
> warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> buildHttp: {
> description: 'Build http(s): urls using a lockfile and resource
> content cache.',
> anyOf: [Array]
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that
> are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> lazyCompilation: {
> description: 'Compile entrypoints and import()s only when they
> are accessed.',
> anyOf: [Array]
> },
> outputModule: {
> description: 'Allow output javascript files as module source
> type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript
> Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExperimentsCommon: {
> description: 'Enables/Disables experiments (experimental features
> with relax SemVer compatibility).',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript
> Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation
> warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that
> are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> outputModule: {
> description: 'Allow output javascript files as module source
> type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript
> Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExperimentsNormalized: {
> description: 'Enables/Disables experiments (experimental features
> with relax SemVer compatibility).',
> type: 'object',
> implements: [ '#/definitions/ExperimentsCommon' ],
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript
> Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation
> warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> buildHttp: {
> description: 'Build http(s): urls using a lockfile and resource
> content cache.',
> oneOf: [Array]
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that
> are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> lazyCompilation: {
> description: 'Compile entrypoints and import()s only when they
> are accessed.',
> oneOf: [Array]
> },
> outputModule: {
> description: 'Allow output javascript files as module source
> type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript
> Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExternalItem: {
> description: "Specify dependency that shouldn't be resolved by
> webpack, but should become dependencies of the resulting bundle. The kind of
> the dependency depends on `output.libraryTarget`.",
> anyOf: [
> {
> description: 'Every matched dependency becomes external.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> },
> {
> description: 'An exact matched dependency becomes external. The
> same string is used as external dependency.',
> type: 'string'
> },
> {
> description: 'If an dependency matches exactly a property of the
> object, the property value is used as dependency.',
> type: 'object',
> additionalProperties: [Object],
> properties: [Object]
> },
> {
> description: 'The function is called on each dependency
> (`function(context, request, callback(err, result))`).',
> instanceof: 'Function',
> tsType: '(((data: ExternalItemFunctionData, callback: (err?:
> Error, result?: ExternalItemValue) => void) => void) | ((data:
> ExternalItemFunctionData) => Promise<ExternalItemValue>))'
> }
> ]
> },
> ExternalItemFunctionData: {
> description: "Data object passed as argument when a function is set
> for 'externals'.",
> type: 'object',
> additionalProperties: false,
> properties: {
> context: {
> description: 'The directory in which the request is placed.',
> type: 'string'
> },
> contextInfo: {
> description: 'Contextual information.',
> type: 'object',
> tsType:
> "import('../lib/ModuleFactory').ModuleFactoryCreateDataContextInfo"
> },
> dependencyType: {
> description: 'The category of the referencing dependencies.',
> type: 'string'
> },
> getResolve: {
> description: 'Get a resolve function with the current resolver
> options.',
> instanceof: 'Function',
> tsType: '((options?: ResolveOptions) => ((context: string,
> request: string, callback: (err?: Error, result?: string) => void) => void) |
> ((context: string, request: string) => Promise<string>))'
> },
> request: {
> description: 'The request as written by the user in the
> require/import expression/statement.',
> type: 'string'
> }
> }
> },
> ExternalItemValue: {
> description: 'The dependency used for the external.',
> anyOf: [
> { type: 'array', items: [Object] },
> {
> description: '`true`: The dependency name is used as target of
> the external.',
> type: 'boolean'
> },
> {
> description: 'The target of the external.',
> type: 'string'
> },
> { type: 'object' }
> ]
> },
> Externals: {
> description: "Specify dependencies that shouldn't be resolved by
> webpack, but should become dependencies of the resulting bundle. The kind of
> the dependency depends on `output.libraryTarget`.",
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/ExternalItem' }
> ]
> },
> ExternalsPresets: {
> description: 'Enable presets of externals for specific targets.',
> type: 'object',
> additionalProperties: false,
> properties: {
> electron: {
> description: "Treat common electron built-in modules in main and
> preload context like 'electron', 'ipc' or 'shell' as external and load them
> via require() when used.",
> type: 'boolean'
> },
> electronMain: {
> description: "Treat electron built-in modules in the main context
> like 'app', 'ipc-main' or 'shell' as external and load them via require()
> when used.",
> type: 'boolean'
> },
> electronPreload: {
> description: "Treat electron built-in modules in the preload
> context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them
> via require() when used.",
> type: 'boolean'
> },
> electronRenderer: {
> description: "Treat electron built-in modules in the renderer
> context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them
> via require() when used.",
> type: 'boolean'
> },
> node: {
> description: 'Treat node.js built-in modules like fs, path or vm
> as external and load them via require() when used.',
> type: 'boolean'
> },
> nwjs: {
> description: 'Treat NW.js legacy nw.gui module as external and
> load it via require() when used.',
> type: 'boolean'
> },
> web: {
> description: "Treat references to 'http(s)://...' and 'std:...'
> as external and load them via import when used (Note that this changes
> execution order as externals are executed before any other code in the
> chunk).",
> type: 'boolean'
> },
> webAsync: {
> description: "Treat references to 'http(s)://...' and 'std:...'
> as external and load them via async import() when used (Note that this
> external type is an async module, which has various effects on the
> execution).",
> type: 'boolean'
> }
> }
> },
> ExternalsType: {
> description: "Specifies the default type of externals ('amd*',
> 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same
> value).",
> enum: [
> 'var', 'module',
> 'assign', 'this',
> 'window', 'self',
> 'global', 'commonjs',
> 'commonjs2', 'commonjs-module',
> 'amd', 'amd-require',
> 'umd', 'umd2',
> 'jsonp', 'system',
> 'promise', 'import',
> 'script', 'node-commonjs'
> ]
> },
> FileCacheOptions: {
> description: 'Options object for persistent file-based caching.',
> type: 'object',
> additionalProperties: false,
> properties: {
> allowCollectingMemory: {
> description: 'Allows to collect unused memory allocated during
> deserialization. This requires copying data into smaller buffers and has a
> performance cost.',
> type: 'boolean'
> },
> buildDependencies: {
> description: "Dependencies the build depends on (in multiple
> categories, default categories: 'defaultWebpack').",
> type: 'object',
> additionalProperties: [Object]
> },
> cacheDirectory: {
> description: 'Base directory for the cache (defaults to
> node_modules/.cache/webpack).',
> type: 'string',
> absolutePath: true
> },
> cacheLocation: {
> description: 'Locations for the cache (defaults to cacheDirectory
> / name).',
> type: 'string',
> absolutePath: true
> },
> compression: {
> description: 'Compression type used for the cache files.',
> enum: [Array]
> },
> hashAlgorithm: {
> description: 'Algorithm used for generation the hash (see node.js
> crypto package).',
> type: 'string'
> },
> idleTimeout: {
> description: 'Time in ms after which idle period the cache
> storing should happen.',
> type: 'number',
> minimum: 0
> },
> idleTimeoutAfterLargeChanges: {
> description: 'Time in ms after which idle period the cache
> storing should happen when larger changes has been detected (cumulative build
> time > 2 x avg cache store time).',
> type: 'number',
> minimum: 0
> },
> idleTimeoutForInitialStore: {
> description: 'Time in ms after which idle period the initial
> cache storing should happen.',
> type: 'number',
> minimum: 0
> },
> immutablePaths: {
> description: 'List of paths that are managed by a package manager
> and contain a version or hash in its path so all files are immutable.',
> type: 'array',
> items: [Object]
> },
> managedPaths: {
> description: 'List of paths that are managed by a package manager
> and can be trusted to not be modified otherwise.',
> type: 'array',
> items: [Object]
> },
> maxAge: {
> description: 'Time for which unused cache entries stay in the
> filesystem cache at minimum (in milliseconds).',
> type: 'number',
> minimum: 0
> },
> maxMemoryGenerations: {
> description: 'Number of generations unused cache entries stay in
> memory cache at minimum (0 = no memory cache used, 1 = may be removed after
> unused for a single compilation, ..., Infinity: kept forever). Cache entries
> will be deserialized from disk when removed from memory cache.',
> type: 'number',
> minimum: 0
> },
> memoryCacheUnaffected: {
> description: 'Additionally cache computation of modules that are
> unchanged and reference only unchanged modules in memory.',
> type: 'boolean'
> },
> name: {
> description: 'Name for the cache. Different names will lead to
> different coexisting caches.',
> type: 'string'
> },
> profile: {
> description: 'Track and log detailed timing information for
> individual cache items.',
> type: 'boolean'
> },
> store: {
> description: 'When to store data to the filesystem. (pack: Store
> data when compiler is idle in a single file).',
> enum: [Array]
> },
> type: { description: 'Filesystem caching.', enum: [Array] },
> version: {
> description: "Version of the cache data. Different versions won't
> allow to reuse the cache and override existing content. Update the version
> when config changed in a way which doesn't allow to reuse cache. This will
> invalidate the cache.",
> type: 'string'
> }
> },
> required: [ 'type' ]
> },
> Filename: {
> description: "Specifies the filename of output files on disk. You
> must **not** specify an absolute path here, but the path may contain folders
> separated by '/'! The specified path is joined with the value of the
> 'output.path' option to determine the location on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> FilenameTemplate: {
> description: "Specifies the filename template of output files on
> disk. You must **not** specify an absolute path here, but the path may
> contain folders separated by '/'! The specified path is joined with the value
> of the 'output.path' option to determine the location on disk.",
> anyOf: [
> { type: 'string', absolutePath: false, minLength: 1 },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData,
> assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> FilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> }
> ]
> },
> FilterTypes: {
> description: 'Filtering values.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/FilterItemTypes' }
> ]
> },
> GeneratorOptionsByModuleType: {
> description: 'Specify options for each generator.',
> type: 'object',
> additionalProperties: {
> description: 'Options for generating.',
> type: 'object',
> additionalProperties: true
> },
> properties: {
> asset: { '$ref': '#/definitions/AssetGeneratorOptions' },
> 'asset/inline': { '$ref':
> '#/definitions/AssetInlineGeneratorOptions' },
> 'asset/resource': { '$ref':
> '#/definitions/AssetResourceGeneratorOptions' },
> javascript: { '$ref': '#/definitions/EmptyGeneratorOptions' },
> 'javascript/auto': { '$ref': '#/definitions/EmptyGeneratorOptions'
> },
> 'javascript/dynamic': { '$ref':
> '#/definitions/EmptyGeneratorOptions' },
> 'javascript/esm': { '$ref': '#/definitions/EmptyGeneratorOptions' }
> }
> },
> GlobalObject: {
> description: 'An expression which is used to address the global
> object/scope in runtime code.',
> type: 'string',
> minLength: 1
> },
> HashDigest: { description: 'Digest type used for the hash.', type:
> 'string' },
> HashDigestLength: {
> description: 'Number of chars which are used for the hash.',
> type: 'number',
> minimum: 1
> },
> HashFunction: {
> description: 'Algorithm used for generation the hash (see node.js
> crypto package).',
> anyOf: [
> { type: 'string', minLength: 1 },
> {
> instanceof: 'Function',
> tsType: "typeof import('../lib/util/Hash')"
> }
> ]
> },
> HashSalt: {
> description: 'Any string which is added to the hash to salt it.',
> type: 'string',
> minLength: 1
> },
> HotUpdateChunkFilename: {
> description: 'The filename of the Hot Update Chunks. They are inside
> the output.path directory.',
> type: 'string',
> absolutePath: false
> },
> HotUpdateGlobal: {
> description: 'The global variable used by webpack for loading of hot
> update chunks.',
> type: 'string'
> },
> HotUpdateMainFilename: {
> description: "The filename of the Hot Update Main File. It is inside
> the 'output.path' directory.",
> type: 'string',
> absolutePath: false
> },
> HttpUriAllowedUris: {
> description: 'List of allowed URIs for building http resources.',
> cli: { exclude: true },
> oneOf: [ { '$ref': '#/definitions/HttpUriOptionsAllowedUris' } ]
> },
> HttpUriOptions: {
> description: 'Options for building http resources.',
> type: 'object',
> additionalProperties: false,
> properties: {
> allowedUris: { '$ref': '#/definitions/HttpUriOptionsAllowedUris' },
> cacheLocation: {
> description: "Location where resource content is stored for
> lockfile entries. It's also possible to disable storing by passing false.",
> anyOf: [Array]
> },
> frozen: {
> description: 'When set, anything that would lead to a
> modification of the lockfile or any resource content, will result in an
> error.',
> type: 'boolean'
> },
> lockfileLocation: {
> description: 'Location of the lockfile.',
> type: 'string',
> absolutePath: true
> },
> upgrade: {
> description: 'When set, resources of existing lockfile entries
> will be fetched and entries will be upgraded when resource content has
> changed.',
> type: 'boolean'
> }
> },
> required: [ 'allowedUris' ]
> },
> HttpUriOptionsAllowedUris: {
> description: 'List of allowed URIs (resp. the beginning of them).',
> type: 'array',
> items: {
> description: 'List of allowed URIs (resp. the beginning of them).',
> anyOf: [ [Object], [Object], [Object] ]
> }
> },
> IgnoreWarnings: {
> description: 'Ignore specific warnings.',
> type: 'array',
> items: {
> description: 'Ignore specific warnings.',
> anyOf: [ [Object], [Object], [Object] ]
> }
> },
> IgnoreWarningsNormalized: {
> description: 'Ignore specific warnings.',
> type: 'array',
> items: {
> description: 'A function to select warnings based on the raw
> warning instance.',
> instanceof: 'Function',
> tsType: "((warning: import('../lib/WebpackError'), compilation:
> import('../lib/Compilation')) => boolean)"
> }
> },
> Iife: {
> description: "Wrap javascript code into IIFE's to avoid leaking into
> global scope.",
> type: 'boolean'
> },
> ImportFunctionName: {
> description: 'The name of the native import() function (can be
> exchanged for a polyfill).',
> type: 'string'
> },
> ImportMetaName: {
> description: 'The name of the native import.meta object (can be
> exchanged for a polyfill).',
> type: 'string'
> },
> InfrastructureLogging: {
> description: 'Options for infrastructure level logging.',
> type: 'object',
> additionalProperties: false,
> properties: {
> appendOnly: {
> description: 'Only appends lines to the output. Avoids updating
> existing output e. g. for status messages. This option is only used when no
> custom console is provided.',
> type: 'boolean'
> },
> colors: {
> description: 'Enables/Disables colorful output. This option is
> only used when no custom console is provided.',
> type: 'boolean'
> },
> console: {
> description: 'Custom console used for logging.',
> tsType: 'Console'
> },
> debug: {
> description: 'Enable debug logging for specific loggers.',
> anyOf: [Array]
> },
> level: { description: 'Log level.', enum: [Array] },
> stream: {
> description: 'Stream used for logging output. Defaults to
> process.stderr. This option is only used when no custom console is provided.',
> tsType: 'NodeJS.WritableStream'
> }
> }
> },
> JavascriptParserOptions: {
> description: 'Parser options for javascript modules.',
> type: 'object',
> additionalProperties: true,
> properties: {
> amd: { '$ref': '#/definitions/Amd' },
> browserify: {
> description: 'Enable/disable special handling for browserify
> bundles.',
> type: 'boolean'
> },
> commonjs: {
> description: 'Enable/disable parsing of CommonJs syntax.',
> type: 'boolean'
> },
> commonjsMagicComments: {
> description: 'Enable/disable parsing of magic comments in
> CommonJs syntax.',
> type: 'boolean'
> },
> exportsPresence: {
> description: 'Specifies the behavior of invalid export names in
> "import ... from ..." and "export ... from ...".',
> enum: [Array]
> },
> exprContextCritical: {
> description: 'Enable warnings for full dynamic dependencies.',
> type: 'boolean'
> },
> exprContextRecursive: {
> description: 'Enable recursive directory lookup for full dynamic
> dependencies.',
> type: 'boolean'
> },
> exprContextRegExp: {
> description: 'Sets the default regular expression for full
> dynamic dependencies.',
> anyOf: [Array]
> },
> exprContextRequest: {
> description: 'Set the default request for full dynamic
> dependencies.',
> type: 'string'
> },
> harmony: {
> description: 'Enable/disable parsing of EcmaScript Modules
> syntax.',
> type: 'boolean'
> },
> import: {
> description: 'Enable/disable parsing of import() syntax.',
> type: 'boolean'
> },
> importExportsPresence: {
> description: 'Specifies the behavior of invalid export names in
> "import ... from ...".',
> enum: [Array]
> },
> node: { '$ref': '#/definitions/Node' },
> reexportExportsPresence: {
> description: 'Specifies the behavior of invalid export names in
> "export ... from ...". This might be useful to disable during the migration
> from "export ... from ..." to "export type ... from ..." when reexporting
> types in TypeScript.',
> enum: [Array]
> },
> requireContext: {
> description: 'Enable/disable parsing of require.context syntax.',
> type: 'boolean'
> },
> requireEnsure: {
> description: 'Enable/disable parsing of require.ensure syntax.',
> type: 'boolean'
> },
> requireInclude: {
> description: 'Enable/disable parsing of require.include syntax.',
> type: 'boolean'
> },
> requireJs: {
> description: 'Enable/disable parsing of require.js special syntax
> like require.config, requirejs.config, require.version and
> requirejs.onError.',
> type: 'boolean'
> },
> strictExportPresence: {
> description: `Deprecated in favor of "exportsPresence". Emit
> errors instead of warnings when imported names don't exist in imported
> module.`,
> type: 'boolean'
> },
> strictThisContextOnImports: {
> description: 'Handle the this context correctly according to the
> spec for namespace objects.',
> type: 'boolean'
> },
> system: {
> description: 'Enable/disable parsing of System.js special syntax
> like System.import, System.get, System.set and System.register.',
> type: 'boolean'
> },
> unknownContextCritical: {
> description: 'Enable warnings when using the require function in
> a not statically analyse-able way.',
> type: 'boolean'
> },
> unknownContextRecursive: {
> description: 'Enable recursive directory lookup when using the
> require function in a not statically analyse-able way.',
> type: 'boolean'
> },
> unknownContextRegExp: {
> description: 'Sets the regular expression when using the require
> function in a not statically analyse-able way.',
> anyOf: [Array]
> },
> unknownContextRequest: {
> description: 'Sets the request when using the require function in
> a not statically analyse-able way.',
> type: 'string'
> },
> url: {
> description: 'Enable/disable parsing of new URL() syntax.',
> anyOf: [Array]
> },
> worker: {
> description: 'Disable or configure parsing of WebWorker syntax
> like new Worker() or navigator.serviceWorker.register().',
> anyOf: [Array]
> },
> wrappedContextCritical: {
> description: 'Enable warnings for partial dynamic dependencies.',
> type: 'boolean'
> },
> wrappedContextRecursive: {
> description: 'Enable recursive directory lookup for partial
> dynamic dependencies.',
> type: 'boolean'
> },
> wrappedContextRegExp: {
> description: 'Set the inner regular expression for partial
> dynamic dependencies.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> }
> }
> },
> Layer: {
> description: 'Specifies the layer in which modules of this entrypoint
> are placed.',
> anyOf: [ { enum: [Array] }, { type: 'string', minLength: 1 } ]
> },
> LazyCompilationDefaultBackendOptions: {
> description: 'Options for the default backend.',
> type: 'object',
> additionalProperties: false,
> properties: {
> client: { description: 'A custom client.', type: 'string' },
> listen: {
> description: 'Specifies where to listen to from the server.',
> anyOf: [Array]
> },
> protocol: {
> description: 'Specifies the protocol the client should use to
> connect to the server.',
> enum: [Array]
> },
> server: {
> description: 'Specifies how to create the server handling the
> EventSource requests.',
> anyOf: [Array]
> }
> }
> },
> LazyCompilationOptions: {
> description: 'Options for compiling entrypoints and import()s only
> when they are accessed.',
> type: 'object',
> additionalProperties: false,
> properties: {
> backend: {
> description: 'Specifies the backend that should be used for
> handling client keep alive.',
> anyOf: [Array]
> },
> entries: {
> description: 'Enable/disable lazy compilation for entries.',
> type: 'boolean'
> },
> imports: {
> description: 'Enable/disable lazy compilation for import()
> modules.',
> type: 'boolean'
> },
> test: {
> description: 'Specify which entrypoints or import()ed modules
> should be lazily compiled. This is matched with the imported module and not
> the entrypoint name.',
> anyOf: [Array]
> }
> }
> },
> Library: {
> description: 'Make the output files a library, exporting the exports
> of the entry point.',
> anyOf: [
> { '$ref': '#/definitions/LibraryName' },
> { '$ref': '#/definitions/LibraryOptions' }
> ]
> },
> LibraryCustomUmdCommentObject: {
> description: 'Set explicit comments for `commonjs`, `commonjs2`,
> `amd`, and `root`.',
> type: 'object',
> additionalProperties: false,
> properties: {
> amd: {
> description: 'Set comment for `amd` section in UMD.',
> type: 'string'
> },
> commonjs: {
> description: 'Set comment for `commonjs` (exports) section in
> UMD.',
> type: 'string'
> },
> commonjs2: {
> description: 'Set comment for `commonjs2` (module.exports)
> section in UMD.',
> type: 'string'
> },
> root: {
> description: 'Set comment for `root` (global variable) section in
> UMD.',
> type: 'string'
> }
> }
> },
> LibraryCustomUmdObject: {
> description: 'Description object for all UMD variants of the library
> name.',
> type: 'object',
> additionalProperties: false,
> properties: {
> amd: {
> description: 'Name of the exposed AMD library in the UMD.',
> type: 'string',
> minLength: 1
> },
> commonjs: {
> description: 'Name of the exposed commonjs export in the UMD.',
> type: 'string',
> minLength: 1
> },
> root: {
> description: 'Name of the property exposed globally by a UMD
> library.',
> anyOf: [Array]
> }
> }
> },
> LibraryExport: {
> description: 'Specify which export should be exposed as library.',
> anyOf: [
> { type: 'array', items: [Object] },
> { type: 'string', minLength: 1 }
> ]
> },
> LibraryName: {
> description: 'The name of the library (some types allow unnamed
> libraries too).',
> anyOf: [
> { type: 'array', items: [Object], minItems: 1 },
> { type: 'string', minLength: 1 },
> { '$ref': '#/definitions/LibraryCustomUmdObject' }
> ]
> },
> LibraryOptions: {
> description: 'Options for library.',
> type: 'object',
> additionalProperties: false,
> properties: {
> auxiliaryComment: { '$ref': '#/definitions/AuxiliaryComment' },
> export: { '$ref': '#/definitions/LibraryExport' },
> name: { '$ref': '#/definitions/LibraryName' },
> type: { '$ref': '#/definitions/LibraryType' },
> umdNamedDefine: { '$ref': '#/definitions/UmdNamedDefine' }
> },
> required: [ 'type' ]
> },
> LibraryType: {
> description: "Type of library (types included by default are 'var',
> 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global',
> 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd',
> 'umd2', 'jsonp', 'system', but others might be added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> Loader: {
> description: 'Custom values available in the loader context.',
> type: 'object'
> },
> MemoryCacheOptions: {
> description: 'Options object for in-memory caching.',
> type: 'object',
> additionalProperties: false,
> properties: {
> cacheUnaffected: {
> description: 'Additionally cache computation of modules that are
> unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> maxGenerations: {
> description: 'Number of generations unused cache entries stay in
> memory cache at minimum (1 = may be removed after unused for a single
> compilation, ..., Infinity: kept forever).',
> type: 'number',
> minimum: 1
> },
> type: { description: 'In memory caching.', enum: [Array] }
> },
> required: [ 'type' ]
> },
> Mode: {
> description: 'Enable production optimizations or development hints.',
> enum: [ 'development', 'production', 'none' ]
> },
> ModuleFilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: "((name: string, module:
> import('../lib/stats/DefaultStatsFactoryPlugin').StatsModule, type: 'module'
> | 'chunk' | 'root-of-chunk' | 'nested') => boolean)"
> }
> ]
> },
> ModuleFilterTypes: {
> description: 'Filtering modules.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/ModuleFilterItemTypes' }
> ]
> },
> ModuleOptions: {
> description: 'Options affecting the normal modules
> (`NormalModuleFactory`).',
> type: 'object',
> additionalProperties: false,
> properties: {
> defaultRules: {
> description: 'An array of rules applied by default for modules.',
> cli: [Object],
> oneOf: [Array]
> },
> exprContextCritical: {
> description: 'Enable warnings for full dynamic dependencies.',
> type: 'boolean'
> },
> exprContextRecursive: {
> description: "Enable recursive directory lookup for full dynamic
> dependencies. Deprecated: This option has moved to
> 'module.parser.javascript.exprContextRecursive'.",
> type: 'boolean'
> },
> exprContextRegExp: {
> description: "Sets the default regular expression for full
> dynamic dependencies. Deprecated: This option has moved to
> 'module.parser.javascript.exprContextRegExp'.",
> anyOf: [Array]
> },
> exprContextRequest: {
> description: "Set the default request for full dynamic
> dependencies. Deprecated: This option has moved to
> 'module.parser.javascript.exprContextRequest'.",
> type: 'string'
> },
> generator: { '$ref': '#/definitions/GeneratorOptionsByModuleType' },
> noParse: { '$ref': '#/definitions/NoParse' },
> parser: { '$ref': '#/definitions/ParserOptionsByModuleType' },
> rules: {
> description: 'An array of rules applied for modules.',
> oneOf: [Array]
> },
> strictExportPresence: {
> description: "Emit errors instead of warnings when imported names
> don't exist in imported module. Deprecated: This option has moved to
> 'module.parser.javascript.strictExportPresence'.",
> type: 'boolean'
> },
> strictThisContextOnImports: {
> description: "Handle the this context correctly according to the
> spec for namespace objects. Deprecated: This option has moved to
> 'module.parser.javascript.strictThisContextOnImports'.",
> type: 'boolean'
> },
> unknownContextCritical: {
> description: "Enable warnings when using the require function in
> a not statically analyse-able way. Deprecated: This option has moved to
> 'module.parser.javascript.unknownContextCritical'.",
> type: 'boolean'
> },
> unknownContextRecursive: {
> description: "Enable recursive directory lookup when using the
> require function in a not statically analyse-able way. Deprecated: This
> option has moved to 'module.parser.javascript.unknownContextRecursive'.",
> type: 'boolean'
> },
> unknownContextRegExp: {
> description: "Sets the regular expression when using the require
> function in a not statically analyse-able way. Deprecated: This option has
> moved to 'module.parser.javascript.unknownContextRegExp'.",
> anyOf: [Array]
> },
> unknownContextRequest: {
> description: "Sets the request when using the require function in
> a not statically analyse-able way. Deprecated: This option has moved to
> 'module.parser.javascript.unknownContextRequest'.",
> type: 'string'
> },
> unsafeCache: {
> description: 'Cache the resolving of module requests.',
> anyOf: [Array]
> },
> wrappedContextCritical: {
> description: "Enable warnings for partial dynamic dependencies.
> Deprecated: This option has moved to
> 'module.parser.javascript.wrappedContextCritical'.",
> type: 'boolean'
> },
> wrappedContextRecursive: {
> description: "Enable recursive directory lookup for partial
> dynamic dependencies. Deprecated: This option has moved to
> 'module.parser.javascript.wrappedContextRecursive'.",
> type: 'boolean'
> },
> wrappedContextRegExp: {
> description: "Set the inner regular expression for partial
> dynamic dependencies. Deprecated: This option has moved to
> 'module.parser.javascript.wrappedContextRegExp'.",
> instanceof: 'RegExp',
> tsType: 'RegExp'
> }
> }
> },
> ModuleOptionsNormalized: {
> description: 'Options affecting the normal modules
> (`NormalModuleFactory`).',
> type: 'object',
> additionalProperties: false,
> properties: {
> defaultRules: {
> description: 'An array of rules applied by default for modules.',
> cli: [Object],
> oneOf: [Array]
> },
> generator: { '$ref': '#/definitions/GeneratorOptionsByModuleType' },
> noParse: { '$ref': '#/definitions/NoParse' },
> parser: { '$ref': '#/definitions/ParserOptionsByModuleType' },
> rules: {
> description: 'An array of rules applied for modules.',
> oneOf: [Array]
> },
> unsafeCache: {
> description: 'Cache the resolving of module requests.',
> anyOf: [Array]
> }
> },
> required: [ 'defaultRules', 'generator', 'parser', 'rules' ]
> },
> Name: {
> description: 'Name of the configuration. Used when loading multiple
> configurations.',
> type: 'string'
> },
> NoParse: {
> description: "Don't parse files matching. It's matched against the
> full resolved request.",
> anyOf: [
> { type: 'array', items: [Object], minItems: 1 },
> {
> description: 'A regular expression, when matched the module is
> not parsed.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> },
> {
> description: 'An absolute path, when the module starts with this
> path it is not parsed.',
> type: 'string',
> absolutePath: true
> },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> Node: {
> description: 'Include polyfills or mocks for various node stuff.',
> anyOf: [ { enum: [Array] }, { '$ref': '#/definitions/NodeOptions' } ]
> },
> NodeOptions: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: {
> __dirname: {
> description: "Include a polyfill for the '__dirname' variable.",
> enum: [Array]
> },
> __filename: {
> description: "Include a polyfill for the '__filename' variable.",
> enum: [Array]
> },
> global: {
> description: "Include a polyfill for the 'global' variable.",
> enum: [Array]
> }
> }
> },
> Optimization: {
> description: 'Enables/Disables integrated optimizations.',
> type: 'object',
> additionalProperties: false,
> properties: {
> checkWasmTypes: {
> description: 'Check for incompatible wasm types when
> importing/exporting from/to ESM.',
> type: 'boolean'
> },
> chunkIds: {
> description: 'Define the algorithm to choose chunk ids (named:
> readable ids for better debugging, deterministic: numeric hash ids for better
> long term caching, size: numeric ids focused on minimal initial download
> size, total-size: numeric ids focused on minimal total download size, false:
> no algorithm used, as custom one can be provided via plugin).',
> enum: [Array]
> },
> concatenateModules: {
> description: 'Concatenate modules when possible to generate less
> modules, more efficient code and enable more optimizations by the minimizer.',
> type: 'boolean'
> },
> emitOnErrors: {
> description: 'Emit assets even when errors occur. Critical errors
> are emitted into the generated code and will cause errors at runtime.',
> type: 'boolean'
> },
> flagIncludedChunks: {
> description: 'Also flag chunks as loaded which contain a subset
> of the modules.',
> type: 'boolean'
> },
> innerGraph: {
> description: 'Creates a module-internal dependency graph for top
> level symbols, exports and imports, to improve unused exports detection.',
> type: 'boolean'
> },
> mangleExports: {
> description: 'Rename exports when possible to generate shorter
> code (depends on optimization.usedExports and optimization.providedExports,
> true/"deterministic": generate short deterministic names optimized for
> caching, "size": generate the shortest possible names).',
> anyOf: [Array]
> },
> mangleWasmImports: {
> description: 'Reduce size of WASM by changing imports to shorter
> strings.',
> type: 'boolean'
> },
> mergeDuplicateChunks: {
> description: 'Merge chunks which contain the same modules.',
> type: 'boolean'
> },
> minimize: {
> description: 'Enable minimizing the output. Uses
> optimization.minimizer.',
> type: 'boolean'
> },
> minimizer: {
> description: 'Minimizer(s) to use for minimizing the output.',
> type: 'array',
> cli: [Object],
> items: [Object]
> },
> moduleIds: {
> description: 'Define the algorithm to choose module ids (natural:
> numeric ids in order of usage, named: readable ids for better debugging,
> hashed: (deprecated) short hashes as ids for better long term caching,
> deterministic: numeric hash ids for better long term caching, size: numeric
> ids focused on minimal initial download size, false: no algorithm used, as
> custom one can be provided via plugin).',
> enum: [Array]
> },
> noEmitOnErrors: {
> description: "Avoid emitting assets when errors occur
> (deprecated: use 'emitOnErrors' instead).",
> type: 'boolean',
> cli: [Object]
> },
> nodeEnv: {
> description: 'Set process.env.NODE_ENV to a specific value.',
> anyOf: [Array]
> },
> portableRecords: {
> description: 'Generate records with relative paths to be able to
> move the context folder.',
> type: 'boolean'
> },
> providedExports: {
> description: 'Figure out which exports are provided by modules to
> generate more efficient code.',
> type: 'boolean'
> },
> realContentHash: {
> description: 'Use real [contenthash] based on final content of
> the assets.',
> type: 'boolean'
> },
> removeAvailableModules: {
> description: 'Removes modules from chunks when these modules are
> already included in all parents.',
> type: 'boolean'
> },
> removeEmptyChunks: {
> description: 'Remove chunks which are empty.',
> type: 'boolean'
> },
> runtimeChunk: { '$ref': '#/definitions/OptimizationRuntimeChunk' },
> sideEffects: {
> description: "Skip over modules which contain no side effects
> when exports are not used (false: disabled, 'flag': only use manually placed
> side effects flag, true: also analyse source code for side effects).",
> anyOf: [Array]
> },
> splitChunks: {
> description: 'Optimize duplication and caching by splitting
> chunks by shared modules and cache group.',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Figure out which exports are used by modules to
> mangle export names, omit unused exports and generate more efficient code
> (true: analyse used exports for each runtime, "global": analyse exports
> globally for all runtimes combined).',
> anyOf: [Array]
> }
> }
> },
> OptimizationRuntimeChunk: {
> description: 'Create an additional chunk which contains only the
> webpack runtime and chunk hash maps.',
> anyOf: [
> { enum: [Array] },
> { type: 'boolean' },
> {
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> }
> ]
> },
> OptimizationRuntimeChunkNormalized: {
> description: 'Create an additional chunk which contains only the
> webpack runtime and chunk hash maps.',
> anyOf: [
> { enum: [Array] },
> {
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> }
> ]
> },
> OptimizationSplitChunksCacheGroup: {
> description: 'Options object for describing behavior of a cache group
> selecting modules that should be cached together.',
> type: 'object',
> additionalProperties: false,
> properties: {
> automaticNameDelimiter: {
> description: 'Sets the name delimiter for created chunks.',
> type: 'string',
> minLength: 1
> },
> chunks: {
> description: 'Select chunks for determining cache group content
> (defaults to "initial", "initial" and "all" requires adding these chunks to
> the HTML).',
> anyOf: [Array]
> },
> enforce: {
> description: 'Ignore minimum size, minimum chunks and maximum
> requests and always create chunks for this cache group.',
> type: 'boolean'
> },
> enforceSizeThreshold: {
> description: 'Size threshold at which splitting is enforced and
> other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests)
> are ignored.',
> oneOf: [Array]
> },
> filename: {
> description: 'Sets the template for the filename for created
> chunks.',
> anyOf: [Array]
> },
> idHint: {
> description: 'Sets the hint for chunk id.',
> type: 'string'
> },
> layer: {
> description: 'Assign modules to a cache group by module layer.',
> anyOf: [Array]
> },
> maxAsyncRequests: {
> description: 'Maximum number of requests which are accepted for
> on-demand loading.',
> type: 'number',
> minimum: 1
> },
> maxAsyncSize: {
> description: 'Maximal size hint for the on-demand chunks.',
> oneOf: [Array]
> },
> maxInitialRequests: {
> description: 'Maximum number of initial chunks which are accepted
> for an entry point.',
> type: 'number',
> minimum: 1
> },
> maxInitialSize: {
> description: 'Maximal size hint for the initial chunks.',
> oneOf: [Array]
> },
> maxSize: {
> description: 'Maximal size hint for the created chunks.',
> oneOf: [Array]
> },
> minChunks: {
> description: "Minimum number of times a module has to be
> duplicated until it's considered for splitting.",
> type: 'number',
> minimum: 1
> },
> minRemainingSize: {
> description: 'Minimal size for the chunks the stay after moving
> the modules to a new chunk.',
> oneOf: [Array]
> },
> minSize: {
> description: 'Minimal size for the created chunk.',
> oneOf: [Array]
> },
> minSizeReduction: {
> description: 'Minimum size reduction due to the created chunk.',
> oneOf: [Array]
> },
> name: {
> description: 'Give chunks for this cache group a name (chunks
> with equal name are merged).',
> anyOf: [Array]
> },
> priority: {
> description: 'Priority of this cache group.',
> type: 'number'
> },
> reuseExistingChunk: {
> description: 'Try to reuse existing chunk (with name) when it has
> matching modules.',
> type: 'boolean'
> },
> test: {
> description: 'Assign modules to a cache group by module name.',
> anyOf: [Array]
> },
> type: {
> description: 'Assign modules to a cache group by module type.',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Compare used exports when checking common modules.
> Modules will only be put in the same chunk when exports are equal.',
> type: 'boolean'
> }
> }
> },
> OptimizationSplitChunksGetCacheGroups: {
> description: 'A function returning cache groups.',
> instanceof: 'Function',
> tsType: "((module: import('../lib/Module')) =>
> OptimizationSplitChunksCacheGroup | OptimizationSplitChunksCacheGroup[] |
> void)"
> },
> OptimizationSplitChunksOptions: {
> description: 'Options object for splitting chunks into smaller
> chunks.',
> type: 'object',
> additionalProperties: false,
> properties: {
> automaticNameDelimiter: {
> description: 'Sets the name delimiter for created chunks.',
> type: 'string',
> minLength: 1
> },
> cacheGroups: {
> description: "Assign modules to a cache group (modules from
> different cache groups are tried to keep in separate chunks, default
> categories: 'default', 'defaultVendors').",
> type: 'object',
> additionalProperties: [Object],
> not: [Object]
> },
> chunks: {
> description: 'Select chunks for determining shared modules
> (defaults to "async", "initial" and "all" requires adding these chunks to the
> HTML).',
> anyOf: [Array]
> },
> defaultSizeTypes: {
> description: 'Sets the size types which are used when a number is
> used for sizes.',
> type: 'array',
> items: [Object],
> minItems: 1
> },
> enforceSizeThreshold: {
> description: 'Size threshold at which splitting is enforced and
> other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests)
> are ignored.',
> oneOf: [Array]
> },
> fallbackCacheGroup: {
> description: 'Options for modules not selected by any other cache
> group.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> filename: {
> description: 'Sets the template for the filename for created
> chunks.',
> anyOf: [Array]
> },
> hidePathInfo: {
> description: 'Prevents exposing path info when creating names for
> parts splitted by maxSize.',
> type: 'boolean'
> },
> maxAsyncRequests: {
> description: 'Maximum number of requests which are accepted for
> on-demand loading.',
> type: 'number',
> minimum: 1
> },
> maxAsyncSize: {
> description: 'Maximal size hint for the on-demand chunks.',
> oneOf: [Array]
> },
> maxInitialRequests: {
> description: 'Maximum number of initial chunks which are accepted
> for an entry point.',
> type: 'number',
> minimum: 1
> },
> maxInitialSize: {
> description: 'Maximal size hint for the initial chunks.',
> oneOf: [Array]
> },
> maxSize: {
> description: 'Maximal size hint for the created chunks.',
> oneOf: [Array]
> },
> minChunks: {
> description: "Minimum number of times a module has to be
> duplicated until it's considered for splitting.",
> type: 'number',
> minimum: 1
> },
> minRemainingSize: {
> description: 'Minimal size for the chunks the stay after moving
> the modules to a new chunk.',
> oneOf: [Array]
> },
> minSize: {
> description: 'Minimal size for the created chunks.',
> oneOf: [Array]
> },
> minSizeReduction: {
> description: 'Minimum size reduction due to the created chunk.',
> oneOf: [Array]
> },
> name: {
> description: 'Give chunks created a name (chunks with equal name
> are merged).',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Compare used exports when checking common modules.
> Modules will only be put in the same chunk when exports are equal.',
> type: 'boolean'
> }
> }
> },
> OptimizationSplitChunksSizes: {
> description: 'Size description for limits.',
> anyOf: [
> {
> description: 'Size of the javascript part of the chunk.',
> type: 'number',
> minimum: 0
> },
> {
> description: 'Specify size limits per size type.',
> type: 'object',
> additionalProperties: [Object]
> }
> ]
> },
> Output: {
> description: 'Options affecting the output of the compilation.
> `output` options tell webpack how to write the compiled files to disk.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetModuleFilename: { '$ref': '#/definitions/AssetModuleFilename'
> },
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are
> loaded on demand.',
> type: 'boolean'
> },
> auxiliaryComment: { cli: [Object], oneOf: [Array] },
> charset: { '$ref': '#/definitions/Charset' },
> chunkFilename: { '$ref': '#/definitions/ChunkFilename' },
> chunkFormat: { '$ref': '#/definitions/ChunkFormat' },
> chunkLoadTimeout: { '$ref': '#/definitions/ChunkLoadTimeout' },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> chunkLoadingGlobal: { '$ref': '#/definitions/ChunkLoadingGlobal' },
> clean: { '$ref': '#/definitions/Clean' },
> compareBeforeEmit: { '$ref': '#/definitions/CompareBeforeEmit' },
> crossOriginLoading: { '$ref': '#/definitions/CrossOriginLoading' },
> devtoolFallbackModuleFilenameTemplate: {
> '$ref': '#/definitions/DevtoolFallbackModuleFilenameTemplate'
> },
> devtoolModuleFilenameTemplate: { '$ref':
> '#/definitions/DevtoolModuleFilenameTemplate' },
> devtoolNamespace: { '$ref': '#/definitions/DevtoolNamespace' },
> enabledChunkLoadingTypes: { '$ref':
> '#/definitions/EnabledChunkLoadingTypes' },
> enabledLibraryTypes: { '$ref': '#/definitions/EnabledLibraryTypes'
> },
> enabledWasmLoadingTypes: { '$ref':
> '#/definitions/EnabledWasmLoadingTypes' },
> environment: { '$ref': '#/definitions/Environment' },
> filename: { '$ref': '#/definitions/Filename' },
> globalObject: { '$ref': '#/definitions/GlobalObject' },
> hashDigest: { '$ref': '#/definitions/HashDigest' },
> hashDigestLength: { '$ref': '#/definitions/HashDigestLength' },
> hashFunction: { '$ref': '#/definitions/HashFunction' },
> hashSalt: { '$ref': '#/definitions/HashSalt' },
> hotUpdateChunkFilename: { '$ref':
> '#/definitions/HotUpdateChunkFilename' },
> hotUpdateGlobal: { '$ref': '#/definitions/HotUpdateGlobal' },
> hotUpdateMainFilename: { '$ref':
> '#/definitions/HotUpdateMainFilename' },
> iife: { '$ref': '#/definitions/Iife' },
> importFunctionName: { '$ref': '#/definitions/ImportFunctionName' },
> importMetaName: { '$ref': '#/definitions/ImportMetaName' },
> library: { '$ref': '#/definitions/Library' },
> libraryExport: { cli: [Object], oneOf: [Array] },
> libraryTarget: { cli: [Object], oneOf: [Array] },
> module: { '$ref': '#/definitions/OutputModule' },
> path: { '$ref': '#/definitions/Path' },
> pathinfo: { '$ref': '#/definitions/Pathinfo' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> scriptType: { '$ref': '#/definitions/ScriptType' },
> sourceMapFilename: { '$ref': '#/definitions/SourceMapFilename' },
> sourcePrefix: { '$ref': '#/definitions/SourcePrefix' },
> strictModuleErrorHandling: { '$ref':
> '#/definitions/StrictModuleErrorHandling' },
> strictModuleExceptionHandling: { '$ref':
> '#/definitions/StrictModuleExceptionHandling' },
> trustedTypes: {
> description: "Use a Trusted Types policy to create urls for
> chunks. 'output.uniqueName' is used a default policy name. Passing a string
> sets a custom policy name.",
> anyOf: [Array]
> },
> umdNamedDefine: { cli: [Object], oneOf: [Array] },
> uniqueName: { '$ref': '#/definitions/UniqueName' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' },
> webassemblyModuleFilename: { '$ref':
> '#/definitions/WebassemblyModuleFilename' },
> workerChunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> workerWasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> OutputModule: {
> description: 'Output javascript files as module source type.',
> type: 'boolean'
> },
> OutputNormalized: {
> description: 'Normalized options affecting the output of the
> compilation. `output` options tell webpack how to write the compiled files to
> disk.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetModuleFilename: { '$ref': '#/definitions/AssetModuleFilename'
> },
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are
> loaded on demand.',
> type: 'boolean'
> },
> charset: { '$ref': '#/definitions/Charset' },
> chunkFilename: { '$ref': '#/definitions/ChunkFilename' },
> chunkFormat: { '$ref': '#/definitions/ChunkFormat' },
> chunkLoadTimeout: { '$ref': '#/definitions/ChunkLoadTimeout' },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> chunkLoadingGlobal: { '$ref': '#/definitions/ChunkLoadingGlobal' },
> clean: { '$ref': '#/definitions/Clean' },
> compareBeforeEmit: { '$ref': '#/definitions/CompareBeforeEmit' },
> crossOriginLoading: { '$ref': '#/definitions/CrossOriginLoading' },
> devtoolFallbackModuleFilenameTemplate: {
> '$ref': '#/definitions/DevtoolFallbackModuleFilenameTemplate'
> },
> devtoolModuleFilenameTemplate: { '$ref':
> '#/definitions/DevtoolModuleFilenameTemplate' },
> devtoolNamespace: { '$ref': '#/definitions/DevtoolNamespace' },
> enabledChunkLoadingTypes: { '$ref':
> '#/definitions/EnabledChunkLoadingTypes' },
> enabledLibraryTypes: { '$ref': '#/definitions/EnabledLibraryTypes'
> },
> enabledWasmLoadingTypes: { '$ref':
> '#/definitions/EnabledWasmLoadingTypes' },
> environment: { '$ref': '#/definitions/Environment' },
> filename: { '$ref': '#/definitions/Filename' },
> globalObject: { '$ref': '#/definitions/GlobalObject' },
> hashDigest: { '$ref': '#/definitions/HashDigest' },
> hashDigestLength: { '$ref': '#/definitions/HashDigestLength' },
> hashFunction: { '$ref': '#/definitions/HashFunction' },
> hashSalt: { '$ref': '#/definitions/HashSalt' },
> hotUpdateChunkFilename: { '$ref':
> '#/definitions/HotUpdateChunkFilename' },
> hotUpdateGlobal: { '$ref': '#/definitions/HotUpdateGlobal' },
> hotUpdateMainFilename: { '$ref':
> '#/definitions/HotUpdateMainFilename' },
> iife: { '$ref': '#/definitions/Iife' },
> importFunctionName: { '$ref': '#/definitions/ImportFunctionName' },
> importMetaName: { '$ref': '#/definitions/ImportMetaName' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> module: { '$ref': '#/definitions/OutputModule' },
> path: { '$ref': '#/definitions/Path' },
> pathinfo: { '$ref': '#/definitions/Pathinfo' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> scriptType: { '$ref': '#/definitions/ScriptType' },
> sourceMapFilename: { '$ref': '#/definitions/SourceMapFilename' },
> sourcePrefix: { '$ref': '#/definitions/SourcePrefix' },
> strictModuleErrorHandling: { '$ref':
> '#/definitions/StrictModuleErrorHandling' },
> strictModuleExceptionHandling: { '$ref':
> '#/definitions/StrictModuleExceptionHandling' },
> trustedTypes: { '$ref': '#/definitions/TrustedTypes' },
> uniqueName: { '$ref': '#/definitions/UniqueName' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' },
> webassemblyModuleFilename: { '$ref':
> '#/definitions/WebassemblyModuleFilename' },
> workerChunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> workerWasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> Parallelism: {
> description: 'The number of parallel processed modules in the
> compilation.',
> type: 'number',
> minimum: 1
> },
> ParserOptionsByModuleType: {
> description: 'Specify options for each parser.',
> type: 'object',
> additionalProperties: {
> description: 'Options for parsing.',
> type: 'object',
> additionalProperties: true
> },
> properties: {
> asset: { '$ref': '#/definitions/AssetParserOptions' },
> 'asset/inline': { '$ref': '#/definitions/EmptyParserOptions' },
> 'asset/resource': { '$ref': '#/definitions/EmptyParserOptions' },
> 'asset/source': { '$ref': '#/definitions/EmptyParserOptions' },
> javascript: { '$ref': '#/definitions/JavascriptParserOptions' },
> 'javascript/auto': { '$ref':
> '#/definitions/JavascriptParserOptions' },
> 'javascript/dynamic': { '$ref':
> '#/definitions/JavascriptParserOptions' },
> 'javascript/esm': { '$ref': '#/definitions/JavascriptParserOptions'
> }
> }
> },
> Path: {
> description: 'The output directory as **absolute path** (required).',
> type: 'string',
> absolutePath: true
> },
> Pathinfo: {
> description: 'Include comments with information about the modules.',
> anyOf: [ { enum: [Array] }, { type: 'boolean' } ]
> },
> Performance: {
> description: 'Configuration for web performance recommendations.',
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/PerformanceOptions' }
> ]
> },
> PerformanceOptions: {
> description: 'Configuration object for web performance
> recommendations.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetFilter: {
> description: 'Filter function to select assets that are checked.',
> instanceof: 'Function',
> tsType: 'Function'
> },
> hints: {
> description: 'Sets the format of the hints: warnings, errors or
> nothing at all.',
> enum: [Array]
> },
> maxAssetSize: {
> description: 'File size limit (in bytes) when exceeded, that
> webpack will provide performance hints.',
> type: 'number'
> },
> maxEntrypointSize: {
> description: 'Total size of an entry point (in bytes).',
> type: 'number'
> }
> }
> },
> Plugins: {
> description: 'Add additional plugins to the compiler.',
> type: 'array',
> items: {
> description: 'Plugin of type object or instanceof Function.',
> anyOf: [ [Object], [Object] ]
> }
> },
> Profile: {
> description: 'Capture timing information for each module.',
> type: 'boolean'
> },
> PublicPath: {
> description: "The 'publicPath' specifies the public URL address of
> the output files when referenced in a browser.",
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/RawPublicPath' }
> ]
> },
> RawPublicPath: {
> description: "The 'publicPath' specifies the public URL address of
> the output files when referenced in a browser.",
> anyOf: [
> { type: 'string' },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData,
> assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> RecordsInputPath: {
> description: 'Store compiler state to a json file.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> RecordsOutputPath: {
> description: 'Load compiler state from a json file.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> RecordsPath: {
> description: 'Store/Load compiler state from/to a json file. This
> will result in persistent ids of modules and chunks. An absolute path is
> expected. `recordsPath` is used for `recordsInputPath` and
> `recordsOutputPath` if they left undefined.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> Resolve: {
> description: 'Options for the resolver.',
> oneOf: [ { '$ref': '#/definitions/ResolveOptions' } ]
> },
> ResolveAlias: {
> description: 'Redirect module requests.',
> anyOf: [
> { type: 'array', items: [Object] },
> { type: 'object', additionalProperties: [Object] }
> ]
> },
> ResolveLoader: {
> description: 'Options for the resolver when resolving loaders.',
> oneOf: [ { '$ref': '#/definitions/ResolveOptions' } ]
> },
> ResolveOptions: {
> description: 'Options object for resolving requests.',
> type: 'object',
> additionalProperties: false,
> properties: {
> alias: { '$ref': '#/definitions/ResolveAlias' },
> aliasFields: {
> description: 'Fields in the description file (usually
> package.json) which are used to redirect requests inside the module.',
> type: 'array',
> items: [Object]
> },
> byDependency: {
> description: 'Extra resolve options per dependency category.
> Typical categories are "commonjs", "amd", "esm".',
> type: 'object',
> additionalProperties: [Object]
> },
> cache: {
> description: 'Enable caching of successfully resolved requests
> (cache entries are revalidated).',
> type: 'boolean'
> },
> cachePredicate: {
> description: 'Predicate function to decide which requests should
> be cached.',
> instanceof: 'Function',
> tsType: "((request: import('enhanced-resolve').ResolveRequest) =>
> boolean)"
> },
> cacheWithContext: {
> description: 'Include the context information in the cache
> identifier when caching.',
> type: 'boolean'
> },
> conditionNames: {
> description: 'Condition names for exports field entry point.',
> type: 'array',
> items: [Object]
> },
> descriptionFiles: {
> description: 'Filenames used to find a description file (like a
> package.json).',
> type: 'array',
> items: [Object]
> },
> enforceExtension: {
> description: 'Enforce the resolver to use one of the extensions
> from the extensions option (User must specify requests without extension).',
> type: 'boolean'
> },
> exportsFields: {
> description: 'Field names from the description file (usually
> package.json) which are used to provide entry points of a package.',
> type: 'array',
> items: [Object]
> },
> extensions: {
> description: 'Extensions added to the request when trying to find
> the file.',
> type: 'array',
> items: [Object]
> },
> fallback: {
> description: 'Redirect module requests when normal resolving
> fails.',
> oneOf: [Array]
> },
> fileSystem: {
> description: 'Filesystem for the resolver.',
> tsType: "(import('../lib/util/fs').InputFileSystem)"
> },
> fullySpecified: {
> description: "Treats the request specified by the user as fully
> specified, meaning no extensions are added and the mainFiles in directories
> are not resolved (This doesn't affect requests from mainFields, aliasFields
> or aliases).",
> type: 'boolean'
> },
> importsFields: {
> description: 'Field names from the description file (usually
> package.json) which are used to provide internal request of a package
> (requests starting with # are considered as internal).',
> type: 'array',
> items: [Object]
> },
> mainFields: {
> description: 'Field names from the description file
> (package.json) which are used to find the default entry point.',
> type: 'array',
> items: [Object]
> },
> mainFiles: {
> description: 'Filenames used to find the default entry point if
> there is no description file or main field.',
> type: 'array',
> items: [Object]
> },
> modules: {
> description: 'Folder names or directory paths where to find
> modules.',
> type: 'array',
> items: [Object]
> },
> plugins: {
> description: 'Plugins for the resolver.',
> type: 'array',
> cli: [Object],
> items: [Object]
> },
> preferAbsolute: {
> description: "Prefer to resolve server-relative URLs (starting
> with '/') as absolute paths before falling back to resolve in
> 'resolve.roots'.",
> type: 'boolean'
> },
> preferRelative: {
> description: 'Prefer to resolve module requests as relative
> request and fallback to resolving as module.',
> type: 'boolean'
> },
> resolver: {
> description: 'Custom resolver.',
> tsType: "(import('enhanced-resolve').Resolver)"
> },
> restrictions: {
> description: 'A list of resolve restrictions. Resolve results
> must fulfill all of these restrictions to resolve successfully. Other resolve
> paths are taken when restrictions are not met.',
> type: 'array',
> items: [Object]
> },
> roots: {
> description: "A list of directories in which requests that are
> server-relative URLs (starting with '/') are resolved.",
> type: 'array',
> items: [Object]
> },
> symlinks: {
> description: 'Enable resolving symlinks to the original
> location.',
> type: 'boolean'
> },
> unsafeCache: {
> description: 'Enable caching of successfully resolved requests
> (cache entries are not revalidated).',
> anyOf: [Array]
> },
> useSyncFileSystemCalls: {
> description: 'Use synchronous filesystem calls for the resolver.',
> type: 'boolean'
> }
> }
> },
> ResolvePluginInstance: {
> description: 'Plugin instance.',
> type: 'object',
> additionalProperties: true,
> properties: {
> apply: {
> description: 'The run point of the plugin, required method.',
> instanceof: 'Function',
> tsType: "(resolver: import('enhanced-resolve').Resolver) => void"
> }
> },
> required: [ 'apply' ]
> },
> RuleSetCondition: {
> description: 'A condition matcher.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string' },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> },
> { '$ref': '#/definitions/RuleSetLogicalConditions' },
> { '$ref': '#/definitions/RuleSetConditions' }
> ]
> },
> RuleSetConditionAbsolute: {
> description: 'A condition matcher matching an absolute path.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: true },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> },
> { '$ref': '#/definitions/RuleSetLogicalConditionsAbsolute' },
> { '$ref': '#/definitions/RuleSetConditionsAbsolute' }
> ]
> },
> RuleSetConditiomake[1]: *** [debian/rules:14: override_dh_auto_build]
> Error 1
> make[1]: Leaving directory '/<<PKGBUILDDIR>>'
> make: *** [debian/rules:5: binary] Error 2
The full build log is available from:
http://qa-logs.debian.net/2022/05/25/node-core-js_3.22.5-1_unstable.log
All bugs filed during this archive rebuild are listed at:
https://bugs.debian.org/cgi-bin/pkgreport.cgi?tag=ftbfs-20220525;users=lu...@debian.org
or:
https://udd.debian.org/bugs/?release=na&merged=ign&fnewerval=7&flastmodval=7&fusertag=only&fusertagtag=ftbfs-20220525&fusertaguser=lu...@debian.org&allbugs=1&cseverity=1&ctags=1&caffected=1#results
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
