const serial = require('../util/serial');
|
const relateContext = require('../util/relate-context');
|
|
const LocalModule = require('webpack/lib/dependencies/LocalModule');
|
|
function flattenPrototype(obj) {
|
if (typeof obj === 'string') {
|
return obj;
|
}
|
const copy = {};
|
for (const key in obj) {
|
copy[key] = obj[key];
|
}
|
return copy;
|
}
|
|
const assignTruthful = {
|
freeze(arg, dependency) {
|
return arg;
|
},
|
thaw(arg, frozen) {
|
return arg;
|
},
|
};
|
|
const assignDefined = {
|
freeze(arg, dependency) {
|
if (typeof arg !== 'undefined') {
|
return arg;
|
}
|
},
|
thaw(arg, frozen) {
|
if (typeof arg !== 'undefined') {
|
return arg;
|
}
|
},
|
}
|
|
const optional = serial.assigned({
|
prepend: assignTruthful,
|
replaces: assignTruthful,
|
critical: assignTruthful,
|
namespaceObjectAsContext: assignDefined,
|
callArgs: assignDefined,
|
call: assignDefined,
|
directImport: assignDefined,
|
shorthand: assignDefined,
|
optional: assignTruthful,
|
loc: {
|
freeze(arg, dependency) {
|
return flattenPrototype(dependency.loc);
|
},
|
thaw(arg, frozen) {
|
return arg;
|
},
|
},
|
});
|
|
const localModuleAssigned = {
|
freeze(_, dependency) {
|
if (
|
typeof dependency.localModule === 'object' &&
|
dependency.localModule !== null
|
) {
|
return {
|
name: dependency.localModule.name,
|
idx: dependency.localModule.idx,
|
used: dependency.localModule.used,
|
};
|
}
|
},
|
thaw(thawed, localModule, extra) {
|
const state = extra.state;
|
if (
|
typeof localModule === 'object' &&
|
localModule !== null
|
) {
|
if (!state.localModules) {
|
state.localModules = [];
|
}
|
if (!state.localModules[localModule.idx]) {
|
state.localModules[localModule.idx] = new LocalModule(
|
extra.module,
|
localModule.name,
|
localModule.idx,
|
);
|
state.localModules[localModule.idx].used =
|
localModule.used;
|
}
|
thawed.localModule = state.localModules[localModule.idx];
|
}
|
return thawed;
|
},
|
};
|
|
const warnings = {
|
freeze(frozen, dependency) {
|
if (frozen && dependency.getWarnings) {
|
const warnings = dependency.getWarnings();
|
if (warnings && warnings.length) {
|
return warnings.map(
|
({ stack }) =>
|
stack.includes('\n at Object.freeze')
|
? stack.split('\n at Object.freeze')[0]
|
: stack.includes('\n at pluginCompat.tap')
|
? stack.split('\n at pluginCompat.tap')[0]
|
: stack.split('\n at Compiler.pluginCompat.tap')[0],
|
);
|
}
|
}
|
},
|
thaw(dependency, warnings) {
|
if (dependency && warnings && dependency.getWarnings) {
|
const frozenWarnings = warnings;
|
const _getWarnings = dependency.getWarnings;
|
dependency.getWarnings = function() {
|
const warnings = _getWarnings.call(this);
|
if (warnings && warnings.length) {
|
return warnings.map((warning, i) => {
|
const stack = warning.stack.split(
|
'\n at Compilation.reportDependencyErrorsAndWarnings',
|
)[1];
|
warning.stack = `${
|
frozenWarnings[i]
|
}\n at Compilation.reportDependencyErrorsAndWarnings${stack}`;
|
return warning;
|
});
|
}
|
return warnings;
|
};
|
}
|
return dependency;
|
},
|
};
|
const AMDDefineDependency = require('webpack/lib/dependencies/AMDDefineDependency');
|
const AMDDefineDependencySerial = serial.serial('AMDDefineDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
range: dependency.range,
|
arrayRange: dependency.arrayRange,
|
functionRange: dependency.functionRange,
|
objectRange: dependency.objectRange,
|
namedModule: dependency.namedModule,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new AMDDefineDependency(
|
frozen.range,
|
frozen.arrayRange,
|
frozen.functionRange,
|
frozen.objectRange,
|
frozen.namedModule,
|
);
|
},
|
},
|
|
optional,
|
|
localModuleAssigned,
|
|
warnings,
|
});
|
|
const AMDRequireArrayDependency = require('webpack/lib/dependencies/AMDRequireArrayDependency');
|
const AMDRequireArrayDependencySerial = serial.serial('AMDRequireArrayDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
depsArray: methods.mapFreeze('Dependency', null, dependency.depsArray, extra),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new AMDRequireArrayDependency(
|
methods.mapThaw('Dependency', null, frozen.depsArray, extra),
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const AMDRequireContextDependency = require('webpack/lib/dependencies/AMDRequireContextDependency');
|
const AMDRequireContextDependencySerial = serial.serial('AMDRequireContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
range: dependency.range,
|
valueRange: dependency.valueRange,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new AMDRequireContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
frozen.range,
|
frozen.valueRange,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const AMDRequireDependency = require('webpack/lib/dependencies/AMDRequireDependency');
|
const AMDRequireDependencySerial = serial.serial('AMDRequireDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
block: !dependency.block.dependencies.includes(dependency) ?
|
methods.freeze('DependencyBlock', null, dependency.block, extra) :
|
undefined,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new AMDRequireDependency(
|
!frozen.block ? extra.parent : methods.thaw('DependencyBlock', null, frozen.block, extra),
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const AMDRequireItemDependency = require('webpack/lib/dependencies/AMDRequireItemDependency');
|
const AMDRequireItemDependencySerial = serial.serial('AMDRequireItemDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new AMDRequireItemDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const CommonJsRequireContextDependency = require('webpack/lib/dependencies/CommonJsRequireContextDependency');
|
const CommonJsRequireContextDependencySerial = serial.serial('CommonJsRequireContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
range: dependency.range,
|
valueRange: dependency.valueRange,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new CommonJsRequireContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
frozen.range,
|
frozen.valueRange,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const CommonJsRequireDependency = require('webpack/lib/dependencies/CommonJsRequireDependency');
|
const CommonJsRequireDependencySerial = serial.serial('CommonJsRequireDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new CommonJsRequireDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ConstDependency = require('webpack/lib/dependencies/ConstDependency');
|
const ConstDependencySerial = serial.serial('ConstDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
expression: dependency.expression,
|
range: dependency.range,
|
requireWebpackRequire: dependency.requireWebpackRequire,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ConstDependency(
|
frozen.expression,
|
frozen.range,
|
frozen.requireWebpackRequire,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ContextDependency = require('webpack/lib/dependencies/ContextDependency');
|
const ContextDependencySerial = serial.serial('ContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ContextElementDependency = require('webpack/lib/dependencies/ContextElementDependency');
|
const ContextElementDependencySerial = serial.serial('ContextElementDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
userRequest: relateContext.relateAbsoluteRequest(extra.module.context, dependency.userRequest),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ContextElementDependency(
|
frozen.request,
|
frozen.userRequest,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const CriticalDependencyWarning = require('webpack/lib/dependencies/CriticalDependencyWarning');
|
const CriticalDependencyWarningSerial = serial.serial('CriticalDependencyWarning', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
message: dependency.message,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new CriticalDependencyWarning(
|
frozen.message,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const DelegatedExportsDependency = require('webpack/lib/dependencies/DelegatedExportsDependency');
|
const DelegatedExportsDependencySerial = serial.serial('DelegatedExportsDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
originModule: null,
|
exports: dependency.exports,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new DelegatedExportsDependency(
|
extra.module,
|
frozen.exports,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const DelegatedSourceDependency = require('webpack/lib/dependencies/DelegatedSourceDependency');
|
const DelegatedSourceDependencySerial = serial.serial('DelegatedSourceDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new DelegatedSourceDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const DllEntryDependency = require('webpack/lib/dependencies/DllEntryDependency');
|
const DllEntryDependencySerial = serial.serial('DllEntryDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
dependencies: methods.mapFreeze('Dependency', null, dependency.dependencies, extra),
|
name: dependency.name,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new DllEntryDependency(
|
methods.mapThaw('Dependency', null, frozen.dependencies, extra),
|
frozen.name,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyAcceptDependency = require('webpack/lib/dependencies/HarmonyAcceptDependency');
|
const HarmonyAcceptDependencySerial = serial.serial('HarmonyAcceptDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
range: dependency.range,
|
dependencies: methods.mapFreeze('Dependency', null, dependency.dependencies, extra),
|
hasCallback: dependency.hasCallback,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyAcceptDependency(
|
frozen.range,
|
methods.mapThaw('Dependency', null, frozen.dependencies, extra),
|
frozen.hasCallback,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyAcceptImportDependency = require('webpack/lib/dependencies/HarmonyAcceptImportDependency');
|
const HarmonyAcceptImportDependencySerial = serial.serial('HarmonyAcceptImportDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
parserScope: null,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
extra.state.harmonyParserScope = extra.state.harmonyParserScope || {};
|
return new HarmonyAcceptImportDependency(
|
frozen.request,
|
extra.module,
|
extra.state.harmonyParserScope,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyCompatibilityDependency = require('webpack/lib/dependencies/HarmonyCompatibilityDependency');
|
const HarmonyCompatibilityDependencySerial = serial.serial('HarmonyCompatibilityDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
originModule: null,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyCompatibilityDependency(
|
extra.module,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyExportExpressionDependency = require('webpack/lib/dependencies/HarmonyExportExpressionDependency');
|
const HarmonyExportExpressionDependencySerial = serial.serial('HarmonyExportExpressionDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
originModule: null,
|
range: dependency.range,
|
rangeStatement: dependency.rangeStatement,
|
prefix: dependency.prefix,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyExportExpressionDependency(
|
extra.module,
|
frozen.range,
|
frozen.rangeStatement,
|
frozen.prefix,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyExportHeaderDependency = require('webpack/lib/dependencies/HarmonyExportHeaderDependency');
|
const HarmonyExportHeaderDependencySerial = serial.serial('HarmonyExportHeaderDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
range: dependency.range,
|
rangeStatement: dependency.rangeStatement,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyExportHeaderDependency(
|
frozen.range,
|
frozen.rangeStatement,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyExportImportedSpecifierDependency = require('webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency');
|
const HarmonyExportImportedSpecifierDependencySerial = serial.serial('HarmonyExportImportedSpecifierDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
sourceOrder: dependency.sourceOrder,
|
parserScope: null,
|
id: dependency.id,
|
name: dependency.name,
|
activeExports: null,
|
otherStarExports: dependency.otherStarExports ? 'star' : null,
|
strictExportPresence: dependency.strictExportPresence,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
extra.state.harmonyParserScope = extra.state.harmonyParserScope || {};
|
extra.state.activeExports = extra.state.activeExports || new Set();
|
if (frozen.name) {
|
extra.state.activeExports.add(frozen.name);
|
}
|
return new HarmonyExportImportedSpecifierDependency(
|
frozen.request,
|
extra.module,
|
frozen.sourceOrder,
|
extra.state.harmonyParserScope,
|
frozen.id,
|
frozen.name,
|
extra.state.activeExports,
|
frozen.otherStarExports === 'star' ?
|
(extra.state.otherStarExports || []) :
|
null,
|
frozen.strictExportPresence,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
|
exportImportedDependency: {
|
freeze(frozen) {},
|
thaw(thawed, frozen, extra) {
|
if (thawed.otherStarExports) {
|
extra.state.otherStarExports = (
|
extra.state.otherStarExports || []
|
).concat(thawed);
|
}
|
return thawed;
|
},
|
},
|
});
|
|
const HarmonyExportSpecifierDependency = require('webpack/lib/dependencies/HarmonyExportSpecifierDependency');
|
const HarmonyExportSpecifierDependencySerial = serial.serial('HarmonyExportSpecifierDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
originModule: null,
|
id: dependency.id,
|
name: dependency.name,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyExportSpecifierDependency(
|
extra.module,
|
frozen.id,
|
frozen.name,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyImportDependency = require('webpack/lib/dependencies/HarmonyImportDependency');
|
const HarmonyImportDependencySerial = serial.serial('HarmonyImportDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
sourceOrder: dependency.sourceOrder,
|
parserScope: null,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
extra.state.harmonyParserScope = extra.state.harmonyParserScope || {};
|
return new HarmonyImportDependency(
|
frozen.request,
|
extra.module,
|
frozen.sourceOrder,
|
extra.state.harmonyParserScope,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
|
importDependency: {
|
freeze(frozen) {
|
return frozen;
|
},
|
thaw(thawed, frozen, extra) {
|
const state = extra.state;
|
const ref = frozen.range.toString();
|
if (state.imports[ref]) {
|
return state.imports[ref];
|
}
|
state.imports[ref] = thawed;
|
return thawed;
|
},
|
},
|
});
|
|
const HarmonyImportSideEffectDependency = require('webpack/lib/dependencies/HarmonyImportSideEffectDependency');
|
const HarmonyImportSideEffectDependencySerial = serial.serial('HarmonyImportSideEffectDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
sourceOrder: dependency.sourceOrder,
|
parserScope: null,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
extra.state.harmonyParserScope = extra.state.harmonyParserScope || {};
|
return new HarmonyImportSideEffectDependency(
|
frozen.request,
|
extra.module,
|
frozen.sourceOrder,
|
extra.state.harmonyParserScope,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyImportSpecifierDependency = require('webpack/lib/dependencies/HarmonyImportSpecifierDependency');
|
const HarmonyImportSpecifierDependencySerial = serial.serial('HarmonyImportSpecifierDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
sourceOrder: dependency.sourceOrder,
|
parserScope: null,
|
id: dependency.id,
|
name: dependency.name,
|
range: dependency.range,
|
strictExportPresence: dependency.strictExportPresence,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
extra.state.harmonyParserScope = extra.state.harmonyParserScope || {};
|
return new HarmonyImportSpecifierDependency(
|
frozen.request,
|
extra.module,
|
frozen.sourceOrder,
|
extra.state.harmonyParserScope,
|
frozen.id,
|
frozen.name,
|
frozen.range,
|
frozen.strictExportPresence,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const HarmonyInitDependency = require('webpack/lib/dependencies/HarmonyInitDependency');
|
const HarmonyInitDependencySerial = serial.serial('HarmonyInitDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
originModule: null,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new HarmonyInitDependency(
|
extra.module,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ImportContextDependency = require('webpack/lib/dependencies/ImportContextDependency');
|
const ImportContextDependencySerial = serial.serial('ImportContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
range: dependency.range,
|
valueRange: dependency.valueRange,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ImportContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
frozen.range,
|
frozen.valueRange,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ImportDependency = require('webpack/lib/dependencies/ImportDependency');
|
const ImportDependencySerial = serial.serial('ImportDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
block: !dependency.block.dependencies.includes(dependency) ?
|
methods.freeze('DependencyBlock', null, dependency.block, extra) :
|
undefined,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ImportDependency(
|
frozen.request,
|
extra.module,
|
!frozen.block ? extra.parent : methods.thaw('DependencyBlock', null, frozen.block, extra),
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ImportEagerDependency = require('webpack/lib/dependencies/ImportEagerDependency');
|
const ImportEagerDependencySerial = serial.serial('ImportEagerDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ImportEagerDependency(
|
frozen.request,
|
extra.module,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ImportWeakDependency = require('webpack/lib/dependencies/ImportWeakDependency');
|
const ImportWeakDependencySerial = serial.serial('ImportWeakDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
originModule: null,
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ImportWeakDependency(
|
frozen.request,
|
extra.module,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const JsonExportsDependency = require('webpack/lib/dependencies/JsonExportsDependency');
|
const JsonExportsDependencySerial = serial.serial('JsonExportsDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
exports: dependency.exports,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new JsonExportsDependency(
|
frozen.exports,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const LoaderDependency = require('webpack/lib/dependencies/LoaderDependency');
|
const LoaderDependencySerial = serial.serial('LoaderDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new LoaderDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const LocalModuleDependency = require('webpack/lib/dependencies/LocalModuleDependency');
|
const LocalModuleDependencySerial = serial.serial('LocalModuleDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
localModule: {
|
name: dependency.localModule.name,
|
name: dependency.localModule.idx,
|
},
|
range: dependency.range,
|
callNew: dependency.callNew,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
if (!extra.state.localModules) {
|
extra.state.localModules = [];
|
}
|
if (!extra.state.localModules[frozen.localModule.idx]) {
|
extra.state.localModules[frozen.localModule.idx] = new LocalModule(extra.module, frozen.localModule.name, frozen.localModule.idx);
|
extra.state.localModules[frozen.localModule.idx].used = frozen.localModule.used;
|
}
|
return new LocalModuleDependency(
|
extra.state.localModules[frozen.localModule.idx],
|
frozen.range,
|
frozen.callNew,
|
);
|
},
|
},
|
|
optional,
|
|
localModuleAssigned,
|
|
warnings,
|
});
|
|
const ModuleDependency = require('webpack/lib/dependencies/ModuleDependency');
|
const ModuleDependencySerial = serial.serial('ModuleDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ModuleDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ModuleHotAcceptDependency = require('webpack/lib/dependencies/ModuleHotAcceptDependency');
|
const ModuleHotAcceptDependencySerial = serial.serial('ModuleHotAcceptDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ModuleHotAcceptDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const ModuleHotDeclineDependency = require('webpack/lib/dependencies/ModuleHotDeclineDependency');
|
const ModuleHotDeclineDependencySerial = serial.serial('ModuleHotDeclineDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new ModuleHotDeclineDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const MultiEntryDependency = require('webpack/lib/dependencies/MultiEntryDependency');
|
const MultiEntryDependencySerial = serial.serial('MultiEntryDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
dependencies: methods.mapFreeze('Dependency', null, dependency.dependencies, extra),
|
name: dependency.name,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new MultiEntryDependency(
|
methods.mapThaw('Dependency', null, frozen.dependencies, extra),
|
frozen.name,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const NullDependency = require('webpack/lib/dependencies/NullDependency');
|
const NullDependencySerial = serial.serial('NullDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new NullDependency(
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const PrefetchDependency = require('webpack/lib/dependencies/PrefetchDependency');
|
const PrefetchDependencySerial = serial.serial('PrefetchDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new PrefetchDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireContextDependency = require('webpack/lib/dependencies/RequireContextDependency');
|
const RequireContextDependencySerial = serial.serial('RequireContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireEnsureDependency = require('webpack/lib/dependencies/RequireEnsureDependency');
|
const RequireEnsureDependencySerial = serial.serial('RequireEnsureDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
block: !dependency.block.dependencies.includes(dependency) ?
|
methods.freeze('DependencyBlock', null, dependency.block, extra) :
|
undefined,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireEnsureDependency(
|
!frozen.block ? extra.parent : methods.thaw('DependencyBlock', null, frozen.block, extra),
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireEnsureItemDependency = require('webpack/lib/dependencies/RequireEnsureItemDependency');
|
const RequireEnsureItemDependencySerial = serial.serial('RequireEnsureItemDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireEnsureItemDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireHeaderDependency = require('webpack/lib/dependencies/RequireHeaderDependency');
|
const RequireHeaderDependencySerial = serial.serial('RequireHeaderDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireHeaderDependency(
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireIncludeDependency = require('webpack/lib/dependencies/RequireIncludeDependency');
|
const RequireIncludeDependencySerial = serial.serial('RequireIncludeDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireIncludeDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireResolveContextDependency = require('webpack/lib/dependencies/RequireResolveContextDependency');
|
const RequireResolveContextDependencySerial = serial.serial('RequireResolveContextDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
options: dependency.options.regExp ?
|
Object.assign({}, dependency.options, {
|
regExp: dependency.options.regExp.source,
|
}) :
|
dependency.options,
|
range: dependency.range,
|
valueRange: dependency.valueRange,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireResolveContextDependency(
|
frozen.options.regExp ?
|
Object.assign({}, frozen.options, {
|
regExp: new RegExp(frozen.options.regExp),
|
}) :
|
frozen.options,
|
frozen.range,
|
frozen.valueRange,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireResolveDependency = require('webpack/lib/dependencies/RequireResolveDependency');
|
const RequireResolveDependencySerial = serial.serial('RequireResolveDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireResolveDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const RequireResolveHeaderDependency = require('webpack/lib/dependencies/RequireResolveHeaderDependency');
|
const RequireResolveHeaderDependencySerial = serial.serial('RequireResolveHeaderDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new RequireResolveHeaderDependency(
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const SingleEntryDependency = require('webpack/lib/dependencies/SingleEntryDependency');
|
const SingleEntryDependencySerial = serial.serial('SingleEntryDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new SingleEntryDependency(
|
frozen.request,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const UnsupportedDependency = require('webpack/lib/dependencies/UnsupportedDependency');
|
const UnsupportedDependencySerial = serial.serial('UnsupportedDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
range: dependency.range,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new UnsupportedDependency(
|
frozen.request,
|
frozen.range,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
const WebAssemblyImportDependency = require('webpack/lib/dependencies/WebAssemblyImportDependency');
|
const WebAssemblyImportDependencySerial = serial.serial('WebAssemblyImportDependency', {
|
constructor: {
|
freeze(_, dependency, extra, methods) {
|
return {
|
request: relateContext.relateAbsoluteRequest(extra.module.context, dependency.request),
|
name: dependency.name,
|
description: dependency.description,
|
onlyDirectImport: dependency.onlyDirectImport,
|
};
|
},
|
thaw(thawed, frozen, extra, methods) {
|
return new WebAssemblyImportDependency(
|
frozen.request,
|
frozen.name,
|
frozen.description,
|
frozen.onlyDirectImport,
|
);
|
},
|
},
|
|
optional,
|
|
warnings,
|
});
|
|
exports.map = new Map();
|
exports.AMDDefineDependency = AMDDefineDependencySerial;
|
exports.map.set(AMDDefineDependency, AMDDefineDependencySerial);
|
exports.AMDRequireArrayDependency = AMDRequireArrayDependencySerial;
|
exports.map.set(AMDRequireArrayDependency, AMDRequireArrayDependencySerial);
|
exports.AMDRequireContextDependency = AMDRequireContextDependencySerial;
|
exports.map.set(AMDRequireContextDependency, AMDRequireContextDependencySerial);
|
exports.AMDRequireDependency = AMDRequireDependencySerial;
|
exports.map.set(AMDRequireDependency, AMDRequireDependencySerial);
|
exports.AMDRequireItemDependency = AMDRequireItemDependencySerial;
|
exports.map.set(AMDRequireItemDependency, AMDRequireItemDependencySerial);
|
exports.CommonJsRequireContextDependency = CommonJsRequireContextDependencySerial;
|
exports.map.set(CommonJsRequireContextDependency, CommonJsRequireContextDependencySerial);
|
exports.CommonJsRequireDependency = CommonJsRequireDependencySerial;
|
exports.map.set(CommonJsRequireDependency, CommonJsRequireDependencySerial);
|
exports.ConstDependency = ConstDependencySerial;
|
exports.map.set(ConstDependency, ConstDependencySerial);
|
exports.ContextDependency = ContextDependencySerial;
|
exports.map.set(ContextDependency, ContextDependencySerial);
|
exports.ContextElementDependency = ContextElementDependencySerial;
|
exports.map.set(ContextElementDependency, ContextElementDependencySerial);
|
exports.CriticalDependencyWarning = CriticalDependencyWarningSerial;
|
exports.map.set(CriticalDependencyWarning, CriticalDependencyWarningSerial);
|
exports.DelegatedExportsDependency = DelegatedExportsDependencySerial;
|
exports.map.set(DelegatedExportsDependency, DelegatedExportsDependencySerial);
|
exports.DelegatedSourceDependency = DelegatedSourceDependencySerial;
|
exports.map.set(DelegatedSourceDependency, DelegatedSourceDependencySerial);
|
exports.DllEntryDependency = DllEntryDependencySerial;
|
exports.map.set(DllEntryDependency, DllEntryDependencySerial);
|
exports.HarmonyAcceptDependency = HarmonyAcceptDependencySerial;
|
exports.map.set(HarmonyAcceptDependency, HarmonyAcceptDependencySerial);
|
exports.HarmonyAcceptImportDependency = HarmonyAcceptImportDependencySerial;
|
exports.map.set(HarmonyAcceptImportDependency, HarmonyAcceptImportDependencySerial);
|
exports.HarmonyCompatibilityDependency = HarmonyCompatibilityDependencySerial;
|
exports.map.set(HarmonyCompatibilityDependency, HarmonyCompatibilityDependencySerial);
|
exports.HarmonyExportExpressionDependency = HarmonyExportExpressionDependencySerial;
|
exports.map.set(HarmonyExportExpressionDependency, HarmonyExportExpressionDependencySerial);
|
exports.HarmonyExportHeaderDependency = HarmonyExportHeaderDependencySerial;
|
exports.map.set(HarmonyExportHeaderDependency, HarmonyExportHeaderDependencySerial);
|
exports.HarmonyExportImportedSpecifierDependency = HarmonyExportImportedSpecifierDependencySerial;
|
exports.map.set(HarmonyExportImportedSpecifierDependency, HarmonyExportImportedSpecifierDependencySerial);
|
exports.HarmonyExportSpecifierDependency = HarmonyExportSpecifierDependencySerial;
|
exports.map.set(HarmonyExportSpecifierDependency, HarmonyExportSpecifierDependencySerial);
|
exports.HarmonyImportDependency = HarmonyImportDependencySerial;
|
exports.map.set(HarmonyImportDependency, HarmonyImportDependencySerial);
|
exports.HarmonyImportSideEffectDependency = HarmonyImportSideEffectDependencySerial;
|
exports.map.set(HarmonyImportSideEffectDependency, HarmonyImportSideEffectDependencySerial);
|
exports.HarmonyImportSpecifierDependency = HarmonyImportSpecifierDependencySerial;
|
exports.map.set(HarmonyImportSpecifierDependency, HarmonyImportSpecifierDependencySerial);
|
exports.HarmonyInitDependency = HarmonyInitDependencySerial;
|
exports.map.set(HarmonyInitDependency, HarmonyInitDependencySerial);
|
exports.ImportContextDependency = ImportContextDependencySerial;
|
exports.map.set(ImportContextDependency, ImportContextDependencySerial);
|
exports.ImportDependency = ImportDependencySerial;
|
exports.map.set(ImportDependency, ImportDependencySerial);
|
exports.ImportEagerDependency = ImportEagerDependencySerial;
|
exports.map.set(ImportEagerDependency, ImportEagerDependencySerial);
|
exports.ImportWeakDependency = ImportWeakDependencySerial;
|
exports.map.set(ImportWeakDependency, ImportWeakDependencySerial);
|
exports.JsonExportsDependency = JsonExportsDependencySerial;
|
exports.map.set(JsonExportsDependency, JsonExportsDependencySerial);
|
exports.LoaderDependency = LoaderDependencySerial;
|
exports.map.set(LoaderDependency, LoaderDependencySerial);
|
exports.LocalModuleDependency = LocalModuleDependencySerial;
|
exports.map.set(LocalModuleDependency, LocalModuleDependencySerial);
|
exports.ModuleDependency = ModuleDependencySerial;
|
exports.map.set(ModuleDependency, ModuleDependencySerial);
|
exports.ModuleHotAcceptDependency = ModuleHotAcceptDependencySerial;
|
exports.map.set(ModuleHotAcceptDependency, ModuleHotAcceptDependencySerial);
|
exports.ModuleHotDeclineDependency = ModuleHotDeclineDependencySerial;
|
exports.map.set(ModuleHotDeclineDependency, ModuleHotDeclineDependencySerial);
|
exports.MultiEntryDependency = MultiEntryDependencySerial;
|
exports.map.set(MultiEntryDependency, MultiEntryDependencySerial);
|
exports.NullDependency = NullDependencySerial;
|
exports.map.set(NullDependency, NullDependencySerial);
|
exports.PrefetchDependency = PrefetchDependencySerial;
|
exports.map.set(PrefetchDependency, PrefetchDependencySerial);
|
exports.RequireContextDependency = RequireContextDependencySerial;
|
exports.map.set(RequireContextDependency, RequireContextDependencySerial);
|
exports.RequireEnsureDependency = RequireEnsureDependencySerial;
|
exports.map.set(RequireEnsureDependency, RequireEnsureDependencySerial);
|
exports.RequireEnsureItemDependency = RequireEnsureItemDependencySerial;
|
exports.map.set(RequireEnsureItemDependency, RequireEnsureItemDependencySerial);
|
exports.RequireHeaderDependency = RequireHeaderDependencySerial;
|
exports.map.set(RequireHeaderDependency, RequireHeaderDependencySerial);
|
exports.RequireIncludeDependency = RequireIncludeDependencySerial;
|
exports.map.set(RequireIncludeDependency, RequireIncludeDependencySerial);
|
exports.RequireResolveContextDependency = RequireResolveContextDependencySerial;
|
exports.map.set(RequireResolveContextDependency, RequireResolveContextDependencySerial);
|
exports.RequireResolveDependency = RequireResolveDependencySerial;
|
exports.map.set(RequireResolveDependency, RequireResolveDependencySerial);
|
exports.RequireResolveHeaderDependency = RequireResolveHeaderDependencySerial;
|
exports.map.set(RequireResolveHeaderDependency, RequireResolveHeaderDependencySerial);
|
exports.SingleEntryDependency = SingleEntryDependencySerial;
|
exports.map.set(SingleEntryDependency, SingleEntryDependencySerial);
|
exports.UnsupportedDependency = UnsupportedDependencySerial;
|
exports.map.set(UnsupportedDependency, UnsupportedDependencySerial);
|
exports.WebAssemblyImportDependency = WebAssemblyImportDependencySerial;
|
exports.map.set(WebAssemblyImportDependency, WebAssemblyImportDependencySerial);
|
