From de98e0b232509d5f40c135d540a70e415272ff85 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 3 May 2017 15:35:00 +0200 Subject: node_modules --- node_modules/webpack/lib/APIPlugin.js | 45 + node_modules/webpack/lib/AmdMainTemplatePlugin.js | 56 + node_modules/webpack/lib/AsyncDependenciesBlock.js | 53 + .../webpack/lib/AutomaticPrefetchPlugin.js | 36 + node_modules/webpack/lib/BannerPlugin.js | 51 + .../webpack/lib/BasicEvaluatedExpression.js | 181 +++ node_modules/webpack/lib/CachePlugin.js | 79 ++ .../webpack/lib/CaseSensitiveModulesWarning.js | 49 + node_modules/webpack/lib/Chunk.js | 396 ++++++ node_modules/webpack/lib/ChunkRenderError.js | 24 + node_modules/webpack/lib/ChunkTemplate.js | 36 + node_modules/webpack/lib/CompatibilityPlugin.js | 57 + node_modules/webpack/lib/Compilation.js | 1247 ++++++++++++++++++ node_modules/webpack/lib/Compiler.js | 499 +++++++ node_modules/webpack/lib/ConstPlugin.js | 60 + node_modules/webpack/lib/ContextModule.js | 257 ++++ node_modules/webpack/lib/ContextModuleFactory.js | 159 +++ .../webpack/lib/ContextReplacementPlugin.js | 111 ++ node_modules/webpack/lib/DefinePlugin.js | 123 ++ node_modules/webpack/lib/DelegatedModule.js | 84 ++ .../webpack/lib/DelegatedModuleFactoryPlugin.js | 58 + node_modules/webpack/lib/DelegatedPlugin.js | 27 + node_modules/webpack/lib/DependenciesBlock.js | 81 ++ .../webpack/lib/DependenciesBlockVariable.js | 51 + node_modules/webpack/lib/Dependency.js | 54 + node_modules/webpack/lib/DllEntryPlugin.js | 37 + node_modules/webpack/lib/DllModule.js | 58 + node_modules/webpack/lib/DllModuleFactory.js | 20 + node_modules/webpack/lib/DllPlugin.js | 38 + node_modules/webpack/lib/DllReferencePlugin.js | 59 + node_modules/webpack/lib/DynamicEntryPlugin.js | 59 + .../webpack/lib/EntryModuleNotFoundError.js | 22 + node_modules/webpack/lib/EntryOptionPlugin.js | 31 + node_modules/webpack/lib/Entrypoint.js | 43 + node_modules/webpack/lib/EnvironmentPlugin.js | 50 + node_modules/webpack/lib/ErrorHelpers.js | 31 + .../webpack/lib/EvalDevToolModulePlugin.js | 22 + .../webpack/lib/EvalDevToolModuleTemplatePlugin.js | 33 + .../EvalSourceMapDevToolModuleTemplatePlugin.js | 74 ++ .../webpack/lib/EvalSourceMapDevToolPlugin.js | 32 + node_modules/webpack/lib/ExtendedAPIPlugin.js | 47 + node_modules/webpack/lib/ExternalModule.js | 116 ++ .../webpack/lib/ExternalModuleFactoryPlugin.js | 91 ++ node_modules/webpack/lib/ExternalsPlugin.js | 21 + .../webpack/lib/FlagDependencyExportsPlugin.js | 101 ++ .../webpack/lib/FlagDependencyUsagePlugin.js | 81 ++ .../webpack/lib/FlagInitialModulesAsUsedPlugin.js | 24 + node_modules/webpack/lib/FunctionModulePlugin.js | 24 + .../webpack/lib/FunctionModuleTemplatePlugin.js | 51 + node_modules/webpack/lib/HashedModuleIdsPlugin.js | 42 + .../webpack/lib/HotModuleReplacement.runtime.js | 583 ++++++++ .../webpack/lib/HotModuleReplacementPlugin.js | 259 ++++ node_modules/webpack/lib/HotUpdateChunkTemplate.js | 30 + node_modules/webpack/lib/IgnorePlugin.js | 69 + .../webpack/lib/JsonpChunkTemplatePlugin.js | 31 + .../webpack/lib/JsonpExportMainTemplatePlugin.js | 37 + .../lib/JsonpHotUpdateChunkTemplatePlugin.js | 27 + .../webpack/lib/JsonpMainTemplate.runtime.js | 58 + .../webpack/lib/JsonpMainTemplatePlugin.js | 208 +++ node_modules/webpack/lib/JsonpTemplatePlugin.js | 21 + node_modules/webpack/lib/LibManifestPlugin.js | 58 + node_modules/webpack/lib/LibraryTemplatePlugin.js | 87 ++ node_modules/webpack/lib/LoaderOptionsPlugin.js | 36 + node_modules/webpack/lib/LoaderTargetPlugin.js | 19 + node_modules/webpack/lib/MainTemplate.js | 235 ++++ node_modules/webpack/lib/MemoryOutputFileSystem.js | 5 + node_modules/webpack/lib/Module.js | 188 +++ node_modules/webpack/lib/ModuleBuildError.js | 42 + node_modules/webpack/lib/ModuleDependencyError.js | 22 + .../webpack/lib/ModuleDependencyWarning.js | 22 + node_modules/webpack/lib/ModuleError.js | 24 + node_modules/webpack/lib/ModuleFilenameHelpers.js | 162 +++ node_modules/webpack/lib/ModuleNotFoundError.js | 26 + node_modules/webpack/lib/ModuleParseError.js | 34 + node_modules/webpack/lib/ModuleReason.js | 12 + node_modules/webpack/lib/ModuleTemplate.js | 23 + node_modules/webpack/lib/ModuleWarning.js | 24 + .../webpack/lib/MovedToPluginWarningPlugin.js | 21 + node_modules/webpack/lib/MultiCompiler.js | 176 +++ node_modules/webpack/lib/MultiEntryPlugin.js | 39 + node_modules/webpack/lib/MultiModule.js | 75 ++ node_modules/webpack/lib/MultiModuleFactory.js | 19 + node_modules/webpack/lib/MultiStats.js | 79 ++ node_modules/webpack/lib/MultiWatching.js | 32 + node_modules/webpack/lib/NamedChunksPlugin.js | 30 + node_modules/webpack/lib/NamedModulesPlugin.js | 27 + node_modules/webpack/lib/NewWatchingPlugin.js | 15 + node_modules/webpack/lib/NoEmitOnErrorsPlugin.js | 22 + node_modules/webpack/lib/NoErrorsPlugin.js | 29 + node_modules/webpack/lib/NodeStuffPlugin.js | 97 ++ node_modules/webpack/lib/NormalModule.js | 524 ++++++++ node_modules/webpack/lib/NormalModuleFactory.js | 304 +++++ .../webpack/lib/NormalModuleReplacementPlugin.js | 45 + node_modules/webpack/lib/NullFactory.js | 12 + node_modules/webpack/lib/OptionsApply.js | 10 + node_modules/webpack/lib/OptionsDefaulter.js | 71 + node_modules/webpack/lib/Parser.js | 1391 ++++++++++++++++++++ node_modules/webpack/lib/ParserHelpers.js | 76 ++ node_modules/webpack/lib/PrefetchPlugin.js | 31 + node_modules/webpack/lib/ProgressPlugin.js | 190 +++ node_modules/webpack/lib/ProvidePlugin.js | 55 + node_modules/webpack/lib/RawModule.js | 50 + node_modules/webpack/lib/RecordIdsPlugin.js | 117 ++ node_modules/webpack/lib/RequestShortener.js | 56 + node_modules/webpack/lib/RequireJsStuffPlugin.js | 31 + node_modules/webpack/lib/RuleSet.js | 444 +++++++ .../webpack/lib/SetVarMainTemplatePlugin.js | 41 + node_modules/webpack/lib/SingleEntryPlugin.js | 35 + node_modules/webpack/lib/SizeFormatHelpers.js | 18 + .../lib/SourceMapDevToolModuleOptionsPlugin.js | 37 + node_modules/webpack/lib/SourceMapDevToolPlugin.js | 166 +++ node_modules/webpack/lib/Stats.js | 894 +++++++++++++ node_modules/webpack/lib/Template.js | 161 +++ node_modules/webpack/lib/TemplatedPathPlugin.js | 112 ++ node_modules/webpack/lib/UmdMainTemplatePlugin.js | 176 +++ .../webpack/lib/UnsupportedFeatureWarning.js | 21 + node_modules/webpack/lib/UseStrictPlugin.js | 34 + .../webpack/lib/WarnCaseSensitiveModulesPlugin.js | 31 + node_modules/webpack/lib/WatchIgnorePlugin.js | 49 + node_modules/webpack/lib/WebpackError.js | 11 + node_modules/webpack/lib/WebpackOptionsApply.js | 298 +++++ .../webpack/lib/WebpackOptionsDefaulter.js | 105 ++ .../webpack/lib/WebpackOptionsValidationError.js | 196 +++ node_modules/webpack/lib/compareLocations.js | 36 + .../lib/dependencies/AMDDefineDependency.js | 142 ++ .../AMDDefineDependencyParserPlugin.js | 250 ++++ node_modules/webpack/lib/dependencies/AMDPlugin.js | 119 ++ .../lib/dependencies/AMDRequireArrayDependency.js | 56 + .../dependencies/AMDRequireContextDependency.js | 29 + .../dependencies/AMDRequireDependenciesBlock.js | 33 + .../AMDRequireDependenciesBlockParserPlugin.js | 177 +++ .../lib/dependencies/AMDRequireDependency.js | 67 + .../lib/dependencies/AMDRequireItemDependency.js | 22 + .../webpack/lib/dependencies/CommonJsPlugin.js | 88 ++ .../CommonJsRequireContextDependency.js | 34 + .../lib/dependencies/CommonJsRequireDependency.js | 22 + .../CommonJsRequireDependencyParserPlugin.js | 89 ++ .../webpack/lib/dependencies/ConstDependency.js | 32 + .../webpack/lib/dependencies/ContextDependency.js | 29 + .../lib/dependencies/ContextDependencyHelpers.js | 71 + .../dependencies/ContextDependencyTemplateAsId.js | 32 + .../ContextDependencyTemplateAsRequireCall.js | 34 + .../lib/dependencies/ContextElementDependency.js | 21 + .../lib/dependencies/CriticalDependencyWarning.js | 20 + .../lib/dependencies/DelegatedSourceDependency.js | 18 + .../webpack/lib/dependencies/DepBlockHelpers.js | 42 + .../webpack/lib/dependencies/DllEntryDependency.js | 20 + .../lib/dependencies/HarmonyAcceptDependency.js | 42 + .../dependencies/HarmonyAcceptImportDependency.js | 22 + .../dependencies/HarmonyCompatibilityDependency.js | 30 + .../dependencies/HarmonyDetectionParserPlugin.js | 56 + .../HarmonyExportDependencyParserPlugin.js | 75 ++ .../HarmonyExportExpressionDependency.js | 57 + .../dependencies/HarmonyExportHeaderDependency.js | 28 + .../HarmonyExportImportedSpecifierDependency.js | 286 ++++ .../HarmonyExportSpecifierDependency.js | 67 + .../lib/dependencies/HarmonyImportDependency.js | 72 + .../HarmonyImportDependencyParserPlugin.js | 102 ++ .../HarmonyImportSpecifierDependency.js | 125 ++ .../lib/dependencies/HarmonyModulesHelpers.js | 85 ++ .../lib/dependencies/HarmonyModulesPlugin.js | 72 + .../lib/dependencies/ImportContextDependency.js | 36 + .../lib/dependencies/ImportDependenciesBlock.js | 17 + .../webpack/lib/dependencies/ImportDependency.js | 54 + .../webpack/lib/dependencies/ImportParserPlugin.js | 51 + .../webpack/lib/dependencies/ImportPlugin.js | 40 + .../webpack/lib/dependencies/LoaderDependency.js | 18 + .../webpack/lib/dependencies/LoaderPlugin.js | 60 + .../webpack/lib/dependencies/LocalModule.js | 23 + .../lib/dependencies/LocalModuleDependency.js | 24 + .../lib/dependencies/LocalModulesHelpers.js | 46 + .../webpack/lib/dependencies/ModuleDependency.js | 23 + .../dependencies/ModuleDependencyTemplateAsId.js | 21 + .../ModuleDependencyTemplateAsRequireId.js | 21 + .../lib/dependencies/ModuleHotAcceptDependency.js | 23 + .../lib/dependencies/ModuleHotDeclineDependency.js | 23 + .../lib/dependencies/MultiEntryDependency.js | 20 + .../webpack/lib/dependencies/NullDependency.js | 24 + .../webpack/lib/dependencies/PrefetchDependency.js | 18 + .../lib/dependencies/RequireContextDependency.js | 22 + .../RequireContextDependencyParserPlugin.js | 42 + .../lib/dependencies/RequireContextPlugin.js | 77 ++ .../dependencies/RequireEnsureDependenciesBlock.js | 28 + .../RequireEnsureDependenciesBlockParserPlugin.js | 102 ++ .../lib/dependencies/RequireEnsureDependency.js | 38 + .../dependencies/RequireEnsureItemDependency.js | 21 + .../lib/dependencies/RequireEnsurePlugin.js | 40 + .../lib/dependencies/RequireHeaderDependency.js | 26 + .../lib/dependencies/RequireIncludeDependency.js | 33 + .../RequireIncludeDependencyParserPlugin.js | 21 + .../lib/dependencies/RequireIncludePlugin.js | 33 + .../RequireResolveContextDependency.js | 34 + .../lib/dependencies/RequireResolveDependency.js | 22 + .../RequireResolveDependencyParserPlugin.js | 71 + .../dependencies/RequireResolveHeaderDependency.js | 26 + .../lib/dependencies/SingleEntryDependency.js | 18 + .../webpack/lib/dependencies/SystemPlugin.js | 44 + .../lib/dependencies/UnsupportedDependency.js | 23 + .../lib/dependencies/WebpackMissingModule.js | 18 + .../lib/dependencies/getFunctionExpression.js | 44 + node_modules/webpack/lib/formatLocation.js | 37 + .../webpack/lib/node/NodeChunkTemplatePlugin.js | 27 + .../webpack/lib/node/NodeEnvironmentPlugin.js | 25 + .../lib/node/NodeHotUpdateChunkTemplatePlugin.js | 27 + .../webpack/lib/node/NodeMainTemplate.runtime.js | 24 + .../lib/node/NodeMainTemplateAsync.runtime.js | 40 + .../webpack/lib/node/NodeMainTemplatePlugin.js | 191 +++ .../webpack/lib/node/NodeOutputFileSystem.js | 22 + node_modules/webpack/lib/node/NodeSourcePlugin.js | 84 ++ node_modules/webpack/lib/node/NodeTargetPlugin.js | 15 + .../webpack/lib/node/NodeTemplatePlugin.js | 27 + .../webpack/lib/node/NodeWatchFileSystem.js | 72 + .../lib/optimize/AggressiveMergingPlugin.js | 121 ++ .../lib/optimize/AggressiveSplittingPlugin.js | 192 +++ .../lib/optimize/ChunkModuleIdRangePlugin.js | 55 + .../webpack/lib/optimize/CommonsChunkPlugin.js | 362 +++++ node_modules/webpack/lib/optimize/DedupePlugin.js | 15 + .../lib/optimize/EnsureChunkConditionsPlugin.js | 36 + .../lib/optimize/FlagIncludedChunksPlugin.js | 35 + .../webpack/lib/optimize/LimitChunkCountPlugin.js | 59 + .../lib/optimize/MergeDuplicateChunksPlugin.js | 33 + .../webpack/lib/optimize/MinChunkSizePlugin.js | 65 + .../webpack/lib/optimize/OccurrenceOrderPlugin.js | 116 ++ .../lib/optimize/RemoveEmptyChunksPlugin.js | 21 + .../lib/optimize/RemoveParentModulesPlugin.js | 91 ++ .../webpack/lib/optimize/UglifyJsPlugin.js | 236 ++++ .../lib/performance/AssetsOverSizeLimitWarning.js | 23 + .../performance/EntrypointsOverSizeLimitWarning.js | 28 + .../lib/performance/NoAsyncChunksWarning.js | 20 + .../webpack/lib/performance/SizeLimitsPlugin.js | 102 ++ node_modules/webpack/lib/removeAndDo.js | 15 + node_modules/webpack/lib/util/identifier.js | 16 + node_modules/webpack/lib/validateSchema.js | 66 + .../webpack/lib/web/WebEnvironmentPlugin.js | 18 + node_modules/webpack/lib/webpack.js | 120 ++ node_modules/webpack/lib/webpack.web.js | 29 + .../lib/webworker/WebWorkerChunkTemplatePlugin.js | 29 + .../WebWorkerHotUpdateChunkTemplatePlugin.js | 28 + .../lib/webworker/WebWorkerMainTemplate.runtime.js | 57 + .../lib/webworker/WebWorkerMainTemplatePlugin.js | 108 ++ .../lib/webworker/WebWorkerTemplatePlugin.js | 20 + 241 files changed, 20510 insertions(+) create mode 100644 node_modules/webpack/lib/APIPlugin.js create mode 100644 node_modules/webpack/lib/AmdMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/AsyncDependenciesBlock.js create mode 100644 node_modules/webpack/lib/AutomaticPrefetchPlugin.js create mode 100644 node_modules/webpack/lib/BannerPlugin.js create mode 100644 node_modules/webpack/lib/BasicEvaluatedExpression.js create mode 100644 node_modules/webpack/lib/CachePlugin.js create mode 100644 node_modules/webpack/lib/CaseSensitiveModulesWarning.js create mode 100644 node_modules/webpack/lib/Chunk.js create mode 100644 node_modules/webpack/lib/ChunkRenderError.js create mode 100644 node_modules/webpack/lib/ChunkTemplate.js create mode 100644 node_modules/webpack/lib/CompatibilityPlugin.js create mode 100644 node_modules/webpack/lib/Compilation.js create mode 100644 node_modules/webpack/lib/Compiler.js create mode 100644 node_modules/webpack/lib/ConstPlugin.js create mode 100644 node_modules/webpack/lib/ContextModule.js create mode 100644 node_modules/webpack/lib/ContextModuleFactory.js create mode 100644 node_modules/webpack/lib/ContextReplacementPlugin.js create mode 100644 node_modules/webpack/lib/DefinePlugin.js create mode 100644 node_modules/webpack/lib/DelegatedModule.js create mode 100644 node_modules/webpack/lib/DelegatedModuleFactoryPlugin.js create mode 100644 node_modules/webpack/lib/DelegatedPlugin.js create mode 100644 node_modules/webpack/lib/DependenciesBlock.js create mode 100644 node_modules/webpack/lib/DependenciesBlockVariable.js create mode 100644 node_modules/webpack/lib/Dependency.js create mode 100644 node_modules/webpack/lib/DllEntryPlugin.js create mode 100644 node_modules/webpack/lib/DllModule.js create mode 100644 node_modules/webpack/lib/DllModuleFactory.js create mode 100644 node_modules/webpack/lib/DllPlugin.js create mode 100644 node_modules/webpack/lib/DllReferencePlugin.js create mode 100644 node_modules/webpack/lib/DynamicEntryPlugin.js create mode 100644 node_modules/webpack/lib/EntryModuleNotFoundError.js create mode 100644 node_modules/webpack/lib/EntryOptionPlugin.js create mode 100644 node_modules/webpack/lib/Entrypoint.js create mode 100644 node_modules/webpack/lib/EnvironmentPlugin.js create mode 100644 node_modules/webpack/lib/ErrorHelpers.js create mode 100644 node_modules/webpack/lib/EvalDevToolModulePlugin.js create mode 100644 node_modules/webpack/lib/EvalDevToolModuleTemplatePlugin.js create mode 100644 node_modules/webpack/lib/EvalSourceMapDevToolModuleTemplatePlugin.js create mode 100644 node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js create mode 100644 node_modules/webpack/lib/ExtendedAPIPlugin.js create mode 100644 node_modules/webpack/lib/ExternalModule.js create mode 100644 node_modules/webpack/lib/ExternalModuleFactoryPlugin.js create mode 100644 node_modules/webpack/lib/ExternalsPlugin.js create mode 100644 node_modules/webpack/lib/FlagDependencyExportsPlugin.js create mode 100644 node_modules/webpack/lib/FlagDependencyUsagePlugin.js create mode 100644 node_modules/webpack/lib/FlagInitialModulesAsUsedPlugin.js create mode 100644 node_modules/webpack/lib/FunctionModulePlugin.js create mode 100644 node_modules/webpack/lib/FunctionModuleTemplatePlugin.js create mode 100644 node_modules/webpack/lib/HashedModuleIdsPlugin.js create mode 100644 node_modules/webpack/lib/HotModuleReplacement.runtime.js create mode 100644 node_modules/webpack/lib/HotModuleReplacementPlugin.js create mode 100644 node_modules/webpack/lib/HotUpdateChunkTemplate.js create mode 100644 node_modules/webpack/lib/IgnorePlugin.js create mode 100644 node_modules/webpack/lib/JsonpChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/JsonpExportMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/JsonpHotUpdateChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/JsonpMainTemplate.runtime.js create mode 100644 node_modules/webpack/lib/JsonpMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/JsonpTemplatePlugin.js create mode 100644 node_modules/webpack/lib/LibManifestPlugin.js create mode 100644 node_modules/webpack/lib/LibraryTemplatePlugin.js create mode 100644 node_modules/webpack/lib/LoaderOptionsPlugin.js create mode 100644 node_modules/webpack/lib/LoaderTargetPlugin.js create mode 100644 node_modules/webpack/lib/MainTemplate.js create mode 100644 node_modules/webpack/lib/MemoryOutputFileSystem.js create mode 100644 node_modules/webpack/lib/Module.js create mode 100644 node_modules/webpack/lib/ModuleBuildError.js create mode 100644 node_modules/webpack/lib/ModuleDependencyError.js create mode 100644 node_modules/webpack/lib/ModuleDependencyWarning.js create mode 100644 node_modules/webpack/lib/ModuleError.js create mode 100644 node_modules/webpack/lib/ModuleFilenameHelpers.js create mode 100644 node_modules/webpack/lib/ModuleNotFoundError.js create mode 100644 node_modules/webpack/lib/ModuleParseError.js create mode 100644 node_modules/webpack/lib/ModuleReason.js create mode 100644 node_modules/webpack/lib/ModuleTemplate.js create mode 100644 node_modules/webpack/lib/ModuleWarning.js create mode 100644 node_modules/webpack/lib/MovedToPluginWarningPlugin.js create mode 100644 node_modules/webpack/lib/MultiCompiler.js create mode 100644 node_modules/webpack/lib/MultiEntryPlugin.js create mode 100644 node_modules/webpack/lib/MultiModule.js create mode 100644 node_modules/webpack/lib/MultiModuleFactory.js create mode 100644 node_modules/webpack/lib/MultiStats.js create mode 100644 node_modules/webpack/lib/MultiWatching.js create mode 100644 node_modules/webpack/lib/NamedChunksPlugin.js create mode 100644 node_modules/webpack/lib/NamedModulesPlugin.js create mode 100644 node_modules/webpack/lib/NewWatchingPlugin.js create mode 100644 node_modules/webpack/lib/NoEmitOnErrorsPlugin.js create mode 100644 node_modules/webpack/lib/NoErrorsPlugin.js create mode 100644 node_modules/webpack/lib/NodeStuffPlugin.js create mode 100644 node_modules/webpack/lib/NormalModule.js create mode 100644 node_modules/webpack/lib/NormalModuleFactory.js create mode 100644 node_modules/webpack/lib/NormalModuleReplacementPlugin.js create mode 100644 node_modules/webpack/lib/NullFactory.js create mode 100644 node_modules/webpack/lib/OptionsApply.js create mode 100644 node_modules/webpack/lib/OptionsDefaulter.js create mode 100644 node_modules/webpack/lib/Parser.js create mode 100644 node_modules/webpack/lib/ParserHelpers.js create mode 100644 node_modules/webpack/lib/PrefetchPlugin.js create mode 100644 node_modules/webpack/lib/ProgressPlugin.js create mode 100644 node_modules/webpack/lib/ProvidePlugin.js create mode 100644 node_modules/webpack/lib/RawModule.js create mode 100644 node_modules/webpack/lib/RecordIdsPlugin.js create mode 100644 node_modules/webpack/lib/RequestShortener.js create mode 100644 node_modules/webpack/lib/RequireJsStuffPlugin.js create mode 100644 node_modules/webpack/lib/RuleSet.js create mode 100644 node_modules/webpack/lib/SetVarMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/SingleEntryPlugin.js create mode 100644 node_modules/webpack/lib/SizeFormatHelpers.js create mode 100644 node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js create mode 100644 node_modules/webpack/lib/SourceMapDevToolPlugin.js create mode 100644 node_modules/webpack/lib/Stats.js create mode 100644 node_modules/webpack/lib/Template.js create mode 100644 node_modules/webpack/lib/TemplatedPathPlugin.js create mode 100644 node_modules/webpack/lib/UmdMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/UnsupportedFeatureWarning.js create mode 100644 node_modules/webpack/lib/UseStrictPlugin.js create mode 100644 node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js create mode 100644 node_modules/webpack/lib/WatchIgnorePlugin.js create mode 100644 node_modules/webpack/lib/WebpackError.js create mode 100644 node_modules/webpack/lib/WebpackOptionsApply.js create mode 100644 node_modules/webpack/lib/WebpackOptionsDefaulter.js create mode 100644 node_modules/webpack/lib/WebpackOptionsValidationError.js create mode 100644 node_modules/webpack/lib/compareLocations.js create mode 100644 node_modules/webpack/lib/dependencies/AMDDefineDependency.js create mode 100644 node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/AMDPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireDependency.js create mode 100644 node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js create mode 100644 node_modules/webpack/lib/dependencies/CommonJsPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js create mode 100644 node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/ConstDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js create mode 100644 node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js create mode 100644 node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js create mode 100644 node_modules/webpack/lib/dependencies/ContextElementDependency.js create mode 100644 node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js create mode 100644 node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js create mode 100644 node_modules/webpack/lib/dependencies/DepBlockHelpers.js create mode 100644 node_modules/webpack/lib/dependencies/DllEntryDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyImportDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js create mode 100644 node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/ImportContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js create mode 100644 node_modules/webpack/lib/dependencies/ImportDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ImportParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/ImportPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/LoaderDependency.js create mode 100644 node_modules/webpack/lib/dependencies/LoaderPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/LocalModule.js create mode 100644 node_modules/webpack/lib/dependencies/LocalModuleDependency.js create mode 100644 node_modules/webpack/lib/dependencies/LocalModulesHelpers.js create mode 100644 node_modules/webpack/lib/dependencies/ModuleDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js create mode 100644 node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js create mode 100644 node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js create mode 100644 node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js create mode 100644 node_modules/webpack/lib/dependencies/MultiEntryDependency.js create mode 100644 node_modules/webpack/lib/dependencies/NullDependency.js create mode 100644 node_modules/webpack/lib/dependencies/PrefetchDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireContextPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js create mode 100644 node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireEnsureDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireHeaderDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireIncludeDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireIncludePlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireResolveDependency.js create mode 100644 node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js create mode 100644 node_modules/webpack/lib/dependencies/SingleEntryDependency.js create mode 100644 node_modules/webpack/lib/dependencies/SystemPlugin.js create mode 100644 node_modules/webpack/lib/dependencies/UnsupportedDependency.js create mode 100644 node_modules/webpack/lib/dependencies/WebpackMissingModule.js create mode 100644 node_modules/webpack/lib/dependencies/getFunctionExpression.js create mode 100644 node_modules/webpack/lib/formatLocation.js create mode 100644 node_modules/webpack/lib/node/NodeChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/node/NodeEnvironmentPlugin.js create mode 100644 node_modules/webpack/lib/node/NodeHotUpdateChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/node/NodeMainTemplate.runtime.js create mode 100644 node_modules/webpack/lib/node/NodeMainTemplateAsync.runtime.js create mode 100644 node_modules/webpack/lib/node/NodeMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/node/NodeOutputFileSystem.js create mode 100644 node_modules/webpack/lib/node/NodeSourcePlugin.js create mode 100644 node_modules/webpack/lib/node/NodeTargetPlugin.js create mode 100644 node_modules/webpack/lib/node/NodeTemplatePlugin.js create mode 100644 node_modules/webpack/lib/node/NodeWatchFileSystem.js create mode 100644 node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js create mode 100644 node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js create mode 100644 node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js create mode 100644 node_modules/webpack/lib/optimize/CommonsChunkPlugin.js create mode 100644 node_modules/webpack/lib/optimize/DedupePlugin.js create mode 100644 node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js create mode 100644 node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js create mode 100644 node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js create mode 100644 node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js create mode 100644 node_modules/webpack/lib/optimize/MinChunkSizePlugin.js create mode 100644 node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js create mode 100644 node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js create mode 100644 node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js create mode 100644 node_modules/webpack/lib/optimize/UglifyJsPlugin.js create mode 100644 node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js create mode 100644 node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js create mode 100644 node_modules/webpack/lib/performance/NoAsyncChunksWarning.js create mode 100644 node_modules/webpack/lib/performance/SizeLimitsPlugin.js create mode 100644 node_modules/webpack/lib/removeAndDo.js create mode 100644 node_modules/webpack/lib/util/identifier.js create mode 100644 node_modules/webpack/lib/validateSchema.js create mode 100644 node_modules/webpack/lib/web/WebEnvironmentPlugin.js create mode 100644 node_modules/webpack/lib/webpack.js create mode 100644 node_modules/webpack/lib/webpack.web.js create mode 100644 node_modules/webpack/lib/webworker/WebWorkerChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/webworker/WebWorkerHotUpdateChunkTemplatePlugin.js create mode 100644 node_modules/webpack/lib/webworker/WebWorkerMainTemplate.runtime.js create mode 100644 node_modules/webpack/lib/webworker/WebWorkerMainTemplatePlugin.js create mode 100644 node_modules/webpack/lib/webworker/WebWorkerTemplatePlugin.js (limited to 'node_modules/webpack/lib') diff --git a/node_modules/webpack/lib/APIPlugin.js b/node_modules/webpack/lib/APIPlugin.js new file mode 100644 index 000000000..19a5be424 --- /dev/null +++ b/node_modules/webpack/lib/APIPlugin.js @@ -0,0 +1,45 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConstDependency = require("./dependencies/ConstDependency"); +const ParserHelpers = require("./ParserHelpers"); + +const NullFactory = require("./NullFactory"); + +const REPLACEMENTS = { + __webpack_require__: "__webpack_require__", // eslint-disable-line camelcase + __webpack_public_path__: "__webpack_require__.p", // eslint-disable-line camelcase + __webpack_modules__: "__webpack_require__.m", // eslint-disable-line camelcase + __webpack_chunk_load__: "__webpack_require__.e", // eslint-disable-line camelcase + __non_webpack_require__: "require", // eslint-disable-line camelcase + __webpack_nonce__: "__webpack_require__.nc", // eslint-disable-line camelcase + "require.onError": "__webpack_require__.oe" // eslint-disable-line camelcase +}; +const REPLACEMENT_TYPES = { + __webpack_public_path__: "string", // eslint-disable-line camelcase + __webpack_require__: "function", // eslint-disable-line camelcase + __webpack_modules__: "object", // eslint-disable-line camelcase + __webpack_chunk_load__: "function", // eslint-disable-line camelcase + __webpack_nonce__: "string" // eslint-disable-line camelcase +}; + +class APIPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + params.normalModuleFactory.plugin("parser", parser => { + Object.keys(REPLACEMENTS).forEach(key => { + parser.plugin(`expression ${key}`, ParserHelpers.toConstantDependency(REPLACEMENTS[key])); + parser.plugin(`evaluate typeof ${key}`, ParserHelpers.evaluateToString(REPLACEMENT_TYPES[key])); + }); + }); + }); + } +} + +module.exports = APIPlugin; diff --git a/node_modules/webpack/lib/AmdMainTemplatePlugin.js b/node_modules/webpack/lib/AmdMainTemplatePlugin.js new file mode 100644 index 000000000..0ff688167 --- /dev/null +++ b/node_modules/webpack/lib/AmdMainTemplatePlugin.js @@ -0,0 +1,56 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ + +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; +const Template = require("./Template"); + +class AmdMainTemplatePlugin { + constructor(name) { + this.name = name; + } + + apply(compilation) { + const mainTemplate = compilation.mainTemplate; + + compilation.templatesPlugin("render-with-entry", (source, chunk, hash) => { + const externals = chunk.modules.filter((m) => m.external); + const externalsDepsArray = JSON.stringify(externals.map((m) => + typeof m.request === "object" ? m.request.amd : m.request + )); + const externalsArguments = externals.map((m) => + Template.toIdentifier(`__WEBPACK_EXTERNAL_MODULE_${m.id}__`) + ).join(", "); + + if(this.name) { + const name = mainTemplate.applyPluginsWaterfall("asset-path", this.name, { + hash, + chunk + }); + + return new ConcatSource( + `define(${JSON.stringify(name)}, ${externalsDepsArray}, function(${externalsArguments}) { return `, source, "});" + ); + } else if(externalsArguments) { + return new ConcatSource(`define(${externalsDepsArray}, function(${externalsArguments}) { return `, source, "});"); + } else { + return new ConcatSource("define(function() { return ", source, "});"); + } + }); + + mainTemplate.plugin("global-hash-paths", (paths) => { + if(this.name) paths.push(this.name); + return paths; + }); + + mainTemplate.plugin("hash", (hash) => { + hash.update("exports amd"); + hash.update(this.name); + }); + } +} + +module.exports = AmdMainTemplatePlugin; diff --git a/node_modules/webpack/lib/AsyncDependenciesBlock.js b/node_modules/webpack/lib/AsyncDependenciesBlock.js new file mode 100644 index 000000000..0f5603324 --- /dev/null +++ b/node_modules/webpack/lib/AsyncDependenciesBlock.js @@ -0,0 +1,53 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const DependenciesBlock = require("./DependenciesBlock"); + +module.exports = class AsyncDependenciesBlock extends DependenciesBlock { + constructor(name, module, loc) { + super(); + this.chunkName = name; + this.chunks = null; + this.module = module; + this.loc = loc; + } + get chunk() { + throw new Error("`chunk` was been renamed to `chunks` and is now an array"); + } + set chunk(chunk) { + throw new Error("`chunk` was been renamed to `chunks` and is now an array"); + } + updateHash(hash) { + hash.update(this.chunkName || ""); + hash.update(this.chunks && this.chunks.map((chunk) => { + return chunk.id !== null ? chunk.id : ""; + }).join(",") || ""); + super.updateHash(hash); + } + disconnect() { + this.chunks = null; + super.disconnect(); + } + unseal() { + this.chunks = null; + super.unseal(); + } + sortItems() { + super.sortItems(); + if(this.chunks) { + this.chunks.sort((a, b) => { + let i = 0; + while(true) { // eslint-disable-line no-constant-condition + if(!a.modules[i] && !b.modules[i]) return 0; + if(!a.modules[i]) return -1; + if(!b.modules[i]) return 1; + if(a.modules[i].id > b.modules[i].id) return 1; + if(a.modules[i].id < b.modules[i].id) return -1; + i++; + } + }); + } + } +}; diff --git a/node_modules/webpack/lib/AutomaticPrefetchPlugin.js b/node_modules/webpack/lib/AutomaticPrefetchPlugin.js new file mode 100644 index 000000000..8652d1cc8 --- /dev/null +++ b/node_modules/webpack/lib/AutomaticPrefetchPlugin.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const asyncLib = require("async"); +const PrefetchDependency = require("./dependencies/PrefetchDependency"); +const NormalModule = require("./NormalModule"); + +class AutomaticPrefetchPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(PrefetchDependency, normalModuleFactory); + }); + let lastModules = null; + compiler.plugin("after-compile", (compilation, callback) => { + lastModules = compilation.modules + .filter(m => m instanceof NormalModule) + .map(m => ({ + context: m.context, + request: m.request + })); + callback(); + }); + compiler.plugin("make", (compilation, callback) => { + if(!lastModules) return callback(); + asyncLib.forEach(lastModules, (m, callback) => { + compilation.prefetch(m.context || compiler.context, new PrefetchDependency(m.request), callback); + }, callback); + }); + } +} +module.exports = AutomaticPrefetchPlugin; diff --git a/node_modules/webpack/lib/BannerPlugin.js b/node_modules/webpack/lib/BannerPlugin.js new file mode 100644 index 000000000..c37a0d3ca --- /dev/null +++ b/node_modules/webpack/lib/BannerPlugin.js @@ -0,0 +1,51 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ + +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); + +function wrapComment(str) { + if(!str.includes("\n")) return `/*! ${str} */`; + return `/*!\n * ${str.split("\n").join("\n * ")}\n */`; +} + +class BannerPlugin { + constructor(options) { + if(arguments.length > 1) + throw new Error("BannerPlugin only takes one argument (pass an options object)"); + if(typeof options === "string") + options = { + banner: options + }; + this.options = options || {}; + this.banner = this.options.raw ? options.banner : wrapComment(options.banner); + } + + apply(compiler) { + const options = this.options; + const banner = this.banner; + + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunk-assets", (chunks, callback) => { + chunks.forEach((chunk) => { + if(options.entryOnly && !chunk.isInitial()) return; + + chunk.files + .filter(ModuleFilenameHelpers.matchObject.bind(undefined, options)) + .forEach((file) => + compilation.assets[file] = new ConcatSource( + banner, "\n", compilation.assets[file] + ) + ); + }); + callback(); + }); + }); + } +} + +module.exports = BannerPlugin; diff --git a/node_modules/webpack/lib/BasicEvaluatedExpression.js b/node_modules/webpack/lib/BasicEvaluatedExpression.js new file mode 100644 index 000000000..d811cbebe --- /dev/null +++ b/node_modules/webpack/lib/BasicEvaluatedExpression.js @@ -0,0 +1,181 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +class BasicEvaluatedExpression { + + constructor() { + this.range = null; + } + + isNull() { + return !!this.null; + } + + isString() { + return Object.prototype.hasOwnProperty.call(this, "string"); + } + + isNumber() { + return Object.prototype.hasOwnProperty.call(this, "number"); + } + + isBoolean() { + return Object.prototype.hasOwnProperty.call(this, "bool"); + } + + isRegExp() { + return Object.prototype.hasOwnProperty.call(this, "regExp"); + } + + isConditional() { + return Object.prototype.hasOwnProperty.call(this, "options"); + } + + isArray() { + return Object.prototype.hasOwnProperty.call(this, "items"); + } + + isConstArray() { + return Object.prototype.hasOwnProperty.call(this, "array"); + } + + isIdentifier() { + return Object.prototype.hasOwnProperty.call(this, "identifier"); + } + + isWrapped() { + return Object.prototype.hasOwnProperty.call(this, "prefix") || Object.prototype.hasOwnProperty.call(this, "postfix"); + } + + isTemplateString() { + return Object.prototype.hasOwnProperty.call(this, "quasis"); + } + + asBool() { + if(this.isBoolean()) return this.bool; + else if(this.isNull()) return false; + else if(this.isString()) return !!this.string; + else if(this.isNumber()) return !!this.number; + else if(this.isRegExp()) return true; + else if(this.isArray()) return true; + else if(this.isConstArray()) return true; + else if(this.isWrapped()) return this.prefix && this.prefix.asBool() || this.postfix && this.postfix.asBool() ? true : undefined; + else if(this.isTemplateString()) { + if(this.quasis.length === 1) return this.quasis[0].asBool(); + for(let i = 0; i < this.quasis.length; i++) { + if(this.quasis[i].asBool()) return true; + } + // can't tell if string will be empty without executing + } + return undefined; + } + + setString(str) { + if(str === null) + delete this.string; + else + this.string = str; + return this; + } + + setNull() { + this.null = true; + return this; + } + + setNumber(num) { + if(num === null) + delete this.number; + else + this.number = num; + return this; + } + + setBoolean(bool) { + if(bool === null) + delete this.bool; + else + this.bool = bool; + return this; + } + + setRegExp(regExp) { + if(regExp === null) + delete this.regExp; + else + this.regExp = regExp; + return this; + } + + setIdentifier(identifier) { + if(identifier === null) + delete this.identifier; + else + this.identifier = identifier; + return this; + } + + setWrapped(prefix, postfix) { + this.prefix = prefix; + this.postfix = postfix; + return this; + } + + unsetWrapped() { + delete this.prefix; + delete this.postfix; + return this; + } + + setOptions(options) { + if(options === null) + delete this.options; + else + this.options = options; + return this; + } + + setItems(items) { + if(items === null) + delete this.items; + else + this.items = items; + return this; + } + + setArray(array) { + if(array === null) + delete this.array; + else + this.array = array; + return this; + } + + setTemplateString(quasis) { + if(quasis === null) + delete this.quasis; + else + this.quasis = quasis; + return this; + } + + addOptions(options) { + if(!this.options) this.options = []; + options.forEach(item => { + this.options.push(item); + }, this); + return this; + } + + setRange(range) { + this.range = range; + return this; + } + +} + +module.exports = BasicEvaluatedExpression; diff --git a/node_modules/webpack/lib/CachePlugin.js b/node_modules/webpack/lib/CachePlugin.js new file mode 100644 index 000000000..1b8d6a30e --- /dev/null +++ b/node_modules/webpack/lib/CachePlugin.js @@ -0,0 +1,79 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const asyncLib = require("async"); + +class CachePlugin { + constructor(cache) { + this.cache = cache || {}; + this.FS_ACCURENCY = 2000; + } + + apply(compiler) { + if(Array.isArray(compiler.compilers)) { + compiler.compilers.forEach((c, idx) => { + c.apply(new CachePlugin(this.cache[idx] = this.cache[idx] || {})); + }); + } else { + compiler.plugin("compilation", compilation => { + if(!compilation.notCacheable) { + compilation.cache = this.cache; + } else if(this.watching) { + compilation.warnings.push( + new Error(`CachePlugin - Cache cannot be used because of: ${compilation.notCacheable}`) + ); + } + }); + compiler.plugin("watch-run", (compiler, callback) => { + this.watching = true; + callback(); + }); + compiler.plugin("run", (compiler, callback) => { + if(!compiler._lastCompilationFileDependencies) return callback(); + const fs = compiler.inputFileSystem; + const fileTs = compiler.fileTimestamps = {}; + asyncLib.forEach(compiler._lastCompilationFileDependencies, (file, callback) => { + fs.stat(file, (err, stat) => { + if(err) { + if(err.code === "ENOENT") return callback(); + return callback(err); + } + + if(stat.mtime) + this.applyMtime(+stat.mtime); + + fileTs[file] = +stat.mtime || Infinity; + callback(); + }); + }, err => { + if(err) return callback(err); + Object.keys(fileTs).forEach(key => { + fileTs[key] += this.FS_ACCURENCY; + }); + callback(); + }); + }); + compiler.plugin("after-compile", function(compilation, callback) { + compilation.compiler._lastCompilationFileDependencies = compilation.fileDependencies; + compilation.compiler._lastCompilationContextDependencies = compilation.contextDependencies; + callback(); + }); + } + } + + /* istanbul ignore next */ + applyMtime(mtime) { + if(this.FS_ACCURENCY > 1 && mtime % 2 !== 0) + this.FS_ACCURENCY = 1; + else if(this.FS_ACCURENCY > 10 && mtime % 20 !== 0) + this.FS_ACCURENCY = 10; + else if(this.FS_ACCURENCY > 100 && mtime % 200 !== 0) + this.FS_ACCURENCY = 100; + else if(this.FS_ACCURENCY > 1000 && mtime % 2000 !== 0) + this.FS_ACCURENCY = 1000; + } +} +module.exports = CachePlugin; diff --git a/node_modules/webpack/lib/CaseSensitiveModulesWarning.js b/node_modules/webpack/lib/CaseSensitiveModulesWarning.js new file mode 100644 index 000000000..0cba12ca6 --- /dev/null +++ b/node_modules/webpack/lib/CaseSensitiveModulesWarning.js @@ -0,0 +1,49 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +module.exports = class CaseSensitiveModulesWarning extends WebpackError { + constructor(modules) { + super(); + + this.name = "CaseSensitiveModulesWarning"; + const sortedModules = this._sort(modules); + const modulesList = this._moduleMessages(sortedModules); + this.message = "There are multiple modules with names that only differ in casing.\n" + + "This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.\n" + + `Use equal casing. Compare these module identifiers:\n${modulesList}`; + this.origin = this.module = sortedModules[0]; + + Error.captureStackTrace(this, this.constructor); + } + + _sort(modules) { + return modules.slice().sort((a, b) => { + a = a.identifier(); + b = b.identifier(); + /* istanbul ignore next */ + if(a < b) return -1; + /* istanbul ignore next */ + if(a > b) return 1; + /* istanbul ignore next */ + return 0; + }); + } + + _moduleMessages(modules) { + return modules.map((m) => { + let message = `* ${m.identifier()}`; + const validReasons = m.reasons.filter((reason) => reason.module); + + if(validReasons.length > 0) { + message += `\n Used by ${validReasons.length} module(s), i. e.`; + message += `\n ${validReasons[0].module.identifier()}`; + } + return message; + }).join("\n"); + } +}; diff --git a/node_modules/webpack/lib/Chunk.js b/node_modules/webpack/lib/Chunk.js new file mode 100644 index 000000000..6962fd6c7 --- /dev/null +++ b/node_modules/webpack/lib/Chunk.js @@ -0,0 +1,396 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const compareLocations = require("./compareLocations"); +let debugId = 1000; + +const byId = (a, b) => { + if(a.id < b.id) return -1; + if(b.id < a.id) return 1; + return 0; +}; + +class Chunk { + + constructor(name, module, loc) { + this.id = null; + this.ids = null; + this.debugId = debugId++; + this.name = name; + this.modules = []; + this.entrypoints = []; + this.chunks = []; + this.parents = []; + this.blocks = []; + this.origins = []; + this.files = []; + this.rendered = false; + if(module) { + this.origins.push({ + module, + loc, + name + }); + } + } + + get entry() { + throw new Error("Chunk.entry was removed. Use hasRuntime()"); + } + + set entry(data) { + throw new Error("Chunk.entry was removed. Use hasRuntime()"); + } + + get initial() { + throw new Error("Chunk.initial was removed. Use isInitial()"); + } + + set initial(data) { + throw new Error("Chunk.initial was removed. Use isInitial()"); + } + + hasRuntime() { + if(this.entrypoints.length === 0) return false; + return this.entrypoints[0].chunks[0] === this; + } + + isInitial() { + return this.entrypoints.length > 0; + } + + hasEntryModule() { + return !!this.entryModule; + } + + addToCollection(collection, item) { + if(item === this) { + return false; + } + + if(collection.indexOf(item) > -1) { + return false; + } + + collection.push(item); + return true; + } + + addChunk(chunk) { + return this.addToCollection(this.chunks, chunk); + } + + addParent(parentChunk) { + return this.addToCollection(this.parents, parentChunk); + } + + addModule(module) { + return this.addToCollection(this.modules, module); + } + + addBlock(block) { + return this.addToCollection(this.blocks, block); + } + + removeModule(module) { + const idx = this.modules.indexOf(module); + if(idx >= 0) { + this.modules.splice(idx, 1); + module.removeChunk(this); + return true; + } + return false; + } + + removeChunk(chunk) { + const idx = this.chunks.indexOf(chunk); + if(idx >= 0) { + this.chunks.splice(idx, 1); + chunk.removeParent(this); + return true; + } + return false; + } + + removeParent(chunk) { + const idx = this.parents.indexOf(chunk); + if(idx >= 0) { + this.parents.splice(idx, 1); + chunk.removeChunk(this); + return true; + } + return false; + } + + addOrigin(module, loc) { + this.origins.push({ + module, + loc, + name: this.name + }); + } + + remove(reason) { + // cleanup modules + this.modules.slice().forEach(module => { + module.removeChunk(this); + }); + + // cleanup parents + this.parents.forEach(parentChunk => { + // remove this chunk from its parents + const idx = parentChunk.chunks.indexOf(this); + if(idx >= 0) { + parentChunk.chunks.splice(idx, 1); + } + + // cleanup "sub chunks" + this.chunks.forEach(chunk => { + /** + * remove this chunk as "intermediary" and connect + * it "sub chunks" and parents directly + */ + // add parent to each "sub chunk" + chunk.addParent(parentChunk); + // add "sub chunk" to parent + parentChunk.addChunk(chunk); + }); + }); + + /** + * we need to iterate again over the chunks + * to remove this from the chunks parents. + * This can not be done in the above loop + * as it is not garuanteed that `this.parents` contains anything. + */ + this.chunks.forEach(chunk => { + // remove this as parent of every "sub chunk" + const idx = chunk.parents.indexOf(this); + if(idx >= 0) { + chunk.parents.splice(idx, 1); + } + }); + + // cleanup blocks + this.blocks.forEach(block => { + const idx = block.chunks.indexOf(this); + if(idx >= 0) { + block.chunks.splice(idx, 1); + if(block.chunks.length === 0) { + block.chunks = null; + block.chunkReason = reason; + } + } + }); + } + + moveModule(module, otherChunk) { + module.removeChunk(this); + module.addChunk(otherChunk); + otherChunk.addModule(module); + module.rewriteChunkInReasons(this, [otherChunk]); + } + + replaceChunk(oldChunk, newChunk) { + const idx = this.chunks.indexOf(oldChunk); + if(idx >= 0) { + this.chunks.splice(idx, 1); + } + if(this !== newChunk && newChunk.addParent(this)) { + this.addChunk(newChunk); + } + } + + replaceParentChunk(oldParentChunk, newParentChunk) { + const idx = this.parents.indexOf(oldParentChunk); + if(idx >= 0) { + this.parents.splice(idx, 1); + } + if(this !== newParentChunk && newParentChunk.addChunk(this)) { + this.addParent(newParentChunk); + } + } + + integrate(otherChunk, reason) { + if(!this.canBeIntegrated(otherChunk)) { + return false; + } + + const otherChunkModules = otherChunk.modules.slice(); + otherChunkModules.forEach(module => otherChunk.moveModule(module, this)); + otherChunk.modules.length = 0; + + otherChunk.parents.forEach(parentChunk => parentChunk.replaceChunk(otherChunk, this)); + otherChunk.parents.length = 0; + + otherChunk.chunks.forEach(chunk => chunk.replaceParentChunk(otherChunk, this)); + otherChunk.chunks.length = 0; + + otherChunk.blocks.forEach(b => { + b.chunks = b.chunks ? b.chunks.map(c => { + return c === otherChunk ? this : c; + }) : [this]; + b.chunkReason = reason; + this.addBlock(b); + }); + otherChunk.blocks.length = 0; + + otherChunk.origins.forEach(origin => { + this.origins.push(origin); + }); + this.origins.forEach(origin => { + if(!origin.reasons) { + origin.reasons = [reason]; + } else if(origin.reasons[0] !== reason) { + origin.reasons.unshift(reason); + } + }); + this.chunks = this.chunks.filter(chunk => { + return chunk !== otherChunk && chunk !== this; + }); + this.parents = this.parents.filter(parentChunk => { + return parentChunk !== otherChunk && parentChunk !== this; + }); + return true; + } + + split(newChunk) { + this.blocks.forEach(block => { + newChunk.blocks.push(block); + block.chunks.push(newChunk); + }); + this.chunks.forEach(chunk => { + newChunk.chunks.push(chunk); + chunk.parents.push(newChunk); + }); + this.parents.forEach(parentChunk => { + parentChunk.chunks.push(newChunk); + newChunk.parents.push(parentChunk); + }); + this.entrypoints.forEach(entrypoint => { + entrypoint.insertChunk(newChunk, this); + }); + } + + isEmpty() { + return this.modules.length === 0; + } + + updateHash(hash) { + hash.update(`${this.id} `); + hash.update(this.ids ? this.ids.join(",") : ""); + hash.update(`${this.name || ""} `); + this.modules.forEach(m => m.updateHash(hash)); + } + + canBeIntegrated(otherChunk) { + if(otherChunk.isInitial()) { + return false; + } + if(this.isInitial()) { + if(otherChunk.parents.length !== 1 || otherChunk.parents[0] !== this) { + return false; + } + } + return true; + } + + addMultiplierAndOverhead(size, options) { + const overhead = typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000; + const multiplicator = this.isInitial() ? (options.entryChunkMultiplicator || 10) : 1; + + return size * multiplicator + overhead; + } + + modulesSize() { + let count = 0; + for(let i = 0; i < this.modules.length; i++) { + count += this.modules[i].size(); + } + return count; + } + + size(options) { + return this.addMultiplierAndOverhead(this.modulesSize(), options); + } + + integratedSize(otherChunk, options) { + // Chunk if it's possible to integrate this chunk + if(!this.canBeIntegrated(otherChunk)) { + return false; + } + + let integratedModulesSize = this.modulesSize(); + // only count modules that do not exist in this chunk! + for(let i = 0; i < otherChunk.modules.length; i++) { + const otherModule = otherChunk.modules[i]; + if(this.modules.indexOf(otherModule) === -1) { + integratedModulesSize += otherModule.size(); + } + } + + return this.addMultiplierAndOverhead(integratedModulesSize, options); + } + + getChunkMaps(includeEntries, realHash) { + const chunksProcessed = []; + const chunkHashMap = {}; + const chunkNameMap = {}; + (function addChunk(chunk) { + if(chunksProcessed.indexOf(chunk) >= 0) return; + chunksProcessed.push(chunk); + if(!chunk.hasRuntime() || includeEntries) { + chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash; + if(chunk.name) + chunkNameMap[chunk.id] = chunk.name; + } + chunk.chunks.forEach(addChunk); + }(this)); + return { + hash: chunkHashMap, + name: chunkNameMap + }; + } + + sortItems() { + this.modules.sort(byId); + this.origins.sort((a, b) => { + const aIdent = a.module.identifier(); + const bIdent = b.module.identifier(); + if(aIdent < bIdent) return -1; + if(aIdent > bIdent) return 1; + return compareLocations(a.loc, b.loc); + }); + this.origins.forEach(origin => { + if(origin.reasons) + origin.reasons.sort(); + }); + this.parents.sort(byId); + this.chunks.sort(byId); + } + + toString() { + return `Chunk[${this.modules.join()}]`; + } + + checkConstraints() { + const chunk = this; + chunk.chunks.forEach((child, idx) => { + if(chunk.chunks.indexOf(child) !== idx) + throw new Error(`checkConstraints: duplicate child in chunk ${chunk.debugId} ${child.debugId}`); + if(child.parents.indexOf(chunk) < 0) + throw new Error(`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`); + }); + chunk.parents.forEach((parentChunk, idx) => { + if(chunk.parents.indexOf(parentChunk) !== idx) + throw new Error(`checkConstraints: duplicate parent in chunk ${chunk.debugId} ${parentChunk.debugId}`); + if(parentChunk.chunks.indexOf(chunk) < 0) + throw new Error(`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`); + }); + } +} + +module.exports = Chunk; diff --git a/node_modules/webpack/lib/ChunkRenderError.js b/node_modules/webpack/lib/ChunkRenderError.js new file mode 100644 index 000000000..578104b53 --- /dev/null +++ b/node_modules/webpack/lib/ChunkRenderError.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +class ChunkRenderError extends WebpackError { + constructor(chunk, file, error) { + super(); + + this.name = "ChunkRenderError"; + this.error = error; + this.message = error.message; + this.details = error.stack; + this.file = file; + this.chunk = chunk; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ChunkRenderError; diff --git a/node_modules/webpack/lib/ChunkTemplate.js b/node_modules/webpack/lib/ChunkTemplate.js new file mode 100644 index 000000000..6bcb8a883 --- /dev/null +++ b/node_modules/webpack/lib/ChunkTemplate.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; +const Template = require("./Template"); + +module.exports = class ChunkTemplate extends Template { + constructor(outputOptions) { + super(outputOptions); + } + + render(chunk, moduleTemplate, dependencyTemplates) { + const moduleSources = this.renderChunkModules(chunk, moduleTemplate, dependencyTemplates); + const core = this.applyPluginsWaterfall("modules", moduleSources, chunk, moduleTemplate, dependencyTemplates); + let source = this.applyPluginsWaterfall("render", core, chunk, moduleTemplate, dependencyTemplates); + if(chunk.hasEntryModule()) { + source = this.applyPluginsWaterfall("render-with-entry", source, chunk); + } + chunk.rendered = true; + return new ConcatSource(source, ";"); + } + + updateHash(hash) { + hash.update("ChunkTemplate"); + hash.update("2"); + this.applyPlugins("hash", hash); + } + + updateHashForChunk(hash, chunk) { + this.updateHash(hash); + this.applyPlugins("hash-for-chunk", hash, chunk); + } +}; diff --git a/node_modules/webpack/lib/CompatibilityPlugin.js b/node_modules/webpack/lib/CompatibilityPlugin.js new file mode 100644 index 000000000..847611e9f --- /dev/null +++ b/node_modules/webpack/lib/CompatibilityPlugin.js @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConstDependency = require("./dependencies/ConstDependency"); + +const NullFactory = require("./NullFactory"); + +const jsonLoaderPath = require.resolve("json-loader"); +const matchJson = /\.json$/i; + +class CompatibilityPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.browserify !== "undefined" && !parserOptions.browserify) + return; + + parser.plugin("call require", (expr) => { + // support for browserify style require delegator: "require(o, !0)" + if(expr.arguments.length !== 2) return; + const second = parser.evaluateExpression(expr.arguments[1]); + if(!second.isBoolean()) return; + if(second.asBool() !== true) return; + const dep = new ConstDependency("require", expr.callee.range); + dep.loc = expr.loc; + if(parser.state.current.dependencies.length > 1) { + const last = parser.state.current.dependencies[parser.state.current.dependencies.length - 1]; + if(last.critical && last.request === "." && last.userRequest === "." && last.recursive) + parser.state.current.dependencies.pop(); + } + parser.state.current.addDependency(dep); + return true; + }); + }); + + params.normalModuleFactory.plugin("after-resolve", (data, done) => { + // if this is a json file and there are no loaders active, we use the json-loader in order to avoid parse errors + // @see https://github.com/webpack/webpack/issues/3363 + if(matchJson.test(data.request) && data.loaders.length === 0) { + data.loaders.push({ + loader: jsonLoaderPath + }); + } + done(null, data); + }); + }); + } +} +module.exports = CompatibilityPlugin; diff --git a/node_modules/webpack/lib/Compilation.js b/node_modules/webpack/lib/Compilation.js new file mode 100644 index 000000000..233ddd387 --- /dev/null +++ b/node_modules/webpack/lib/Compilation.js @@ -0,0 +1,1247 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const asyncLib = require("async"); +const crypto = require("crypto"); +const Tapable = require("tapable"); +const EntryModuleNotFoundError = require("./EntryModuleNotFoundError"); +const ModuleNotFoundError = require("./ModuleNotFoundError"); +const ModuleDependencyWarning = require("./ModuleDependencyWarning"); +const ModuleDependencyError = require("./ModuleDependencyError"); +const Module = require("./Module"); +const Chunk = require("./Chunk"); +const Entrypoint = require("./Entrypoint"); +const Stats = require("./Stats"); +const MainTemplate = require("./MainTemplate"); +const ChunkTemplate = require("./ChunkTemplate"); +const HotUpdateChunkTemplate = require("./HotUpdateChunkTemplate"); +const ModuleTemplate = require("./ModuleTemplate"); +const Dependency = require("./Dependency"); +const ChunkRenderError = require("./ChunkRenderError"); +const CachedSource = require("webpack-sources").CachedSource; + +function byId(a, b) { + if(a.id < b.id) return -1; + if(a.id > b.id) return 1; + return 0; +} + +function iterationBlockVariable(variables, fn) { + for(let indexVariable = 0; indexVariable < variables.length; indexVariable++) { + let varDep = variables[indexVariable].dependencies; + for(let indexVDep = 0; indexVDep < varDep.length; indexVDep++) { + fn(varDep[indexVDep]); + } + } +} + +function iterationOfArrayCallback(arr, fn) { + for(let index = 0; index < arr.length; index++) { + fn(arr[index]); + } +} + +class Compilation extends Tapable { + constructor(compiler) { + super(); + this.compiler = compiler; + this.resolvers = compiler.resolvers; + this.inputFileSystem = compiler.inputFileSystem; + + const options = this.options = compiler.options; + this.outputOptions = options && options.output; + this.bail = options && options.bail; + this.profile = options && options.profile; + this.performance = options && options.performance; + + this.mainTemplate = new MainTemplate(this.outputOptions); + this.chunkTemplate = new ChunkTemplate(this.outputOptions); + this.hotUpdateChunkTemplate = new HotUpdateChunkTemplate(this.outputOptions); + this.moduleTemplate = new ModuleTemplate(this.outputOptions); + + this.entries = []; + this.preparedChunks = []; + this.entrypoints = {}; + this.chunks = []; + this.namedChunks = {}; + this.modules = []; + this._modules = {}; + this.cache = null; + this.records = null; + this.nextFreeModuleIndex = undefined; + this.nextFreeModuleIndex2 = undefined; + this.additionalChunkAssets = []; + this.assets = {}; + this.errors = []; + this.warnings = []; + this.children = []; + this.dependencyFactories = new Map(); + this.dependencyTemplates = new Map(); + } + + templatesPlugin(name, fn) { + this.mainTemplate.plugin(name, fn); + this.chunkTemplate.plugin(name, fn); + } + + addModule(module, cacheGroup) { + const identifier = module.identifier(); + if(this._modules[identifier]) { + return false; + } + const cacheName = (cacheGroup || "m") + identifier; + if(this.cache && this.cache[cacheName]) { + const cacheModule = this.cache[cacheName]; + + let rebuild = true; + if(!cacheModule.error && cacheModule.cacheable && this.fileTimestamps && this.contextTimestamps) { + rebuild = cacheModule.needRebuild(this.fileTimestamps, this.contextTimestamps); + } + + if(!rebuild) { + cacheModule.disconnect(); + this._modules[identifier] = cacheModule; + this.modules.push(cacheModule); + cacheModule.errors.forEach(err => this.errors.push(err), this); + cacheModule.warnings.forEach(err => this.warnings.push(err), this); + return cacheModule; + } else { + module.lastId = cacheModule.id; + } + } + module.unbuild(); + this._modules[identifier] = module; + if(this.cache) { + this.cache[cacheName] = module; + } + this.modules.push(module); + return true; + } + + getModule(module) { + const identifier = module.identifier(); + return this._modules[identifier]; + } + + findModule(identifier) { + return this._modules[identifier]; + } + + buildModule(module, optional, origin, dependencies, thisCallback) { + this.applyPlugins1("build-module", module); + if(module.building) return module.building.push(thisCallback); + const building = module.building = [thisCallback]; + + function callback(err) { + module.building = undefined; + building.forEach(cb => cb(err)); + } + module.build(this.options, this, this.resolvers.normal, this.inputFileSystem, (error) => { + const errors = module.errors; + for(let indexError = 0; indexError < errors.length; indexError++) { + const err = errors[indexError]; + err.origin = origin; + err.dependencies = dependencies; + if(optional) + this.warnings.push(err); + else + this.errors.push(err); + } + + const warnings = module.warnings; + for(let indexWarning = 0; indexWarning < warnings.length; indexWarning++) { + const war = warnings[indexWarning]; + war.origin = origin; + war.dependencies = dependencies; + this.warnings.push(war); + } + module.dependencies.sort(Dependency.compare); + if(error) { + this.applyPlugins2("failed-module", module, error); + return callback(error); + } + this.applyPlugins1("succeed-module", module); + return callback(); + }); + } + + processModuleDependencies(module, callback) { + const dependencies = []; + + function addDependency(dep) { + for(let i = 0; i < dependencies.length; i++) { + if(dep.isEqualResource(dependencies[i][0])) { + return dependencies[i].push(dep); + } + } + dependencies.push([dep]); + } + + function addDependenciesBlock(block) { + if(block.dependencies) { + iterationOfArrayCallback(block.dependencies, addDependency); + } + if(block.blocks) { + iterationOfArrayCallback(block.blocks, addDependenciesBlock); + } + if(block.variables) { + iterationBlockVariable(block.variables, addDependency); + } + } + addDependenciesBlock(module); + this.addModuleDependencies(module, dependencies, this.bail, null, true, callback); + } + + addModuleDependencies(module, dependencies, bail, cacheGroup, recursive, callback) { + let _this = this; + const start = _this.profile && +new Date(); + + const factories = []; + for(let i = 0; i < dependencies.length; i++) { + const factory = _this.dependencyFactories.get(dependencies[i][0].constructor); + if(!factory) { + return callback(new Error(`No module factory available for dependency type: ${dependencies[i][0].constructor.name}`)); + } + factories[i] = [factory, dependencies[i]]; + } + asyncLib.forEach(factories, function iteratorFactory(item, callback) { + const dependencies = item[1]; + + const errorAndCallback = function errorAndCallback(err) { + err.origin = module; + _this.errors.push(err); + if(bail) { + callback(err); + } else { + callback(); + } + }; + const warningAndCallback = function warningAndCallback(err) { + err.origin = module; + _this.warnings.push(err); + callback(); + }; + + const factory = item[0]; + factory.create({ + contextInfo: { + issuer: module.nameForCondition && module.nameForCondition(), + compiler: _this.compiler.name + }, + context: module.context, + dependencies: dependencies + }, function factoryCallback(err, dependentModule) { + let afterFactory; + + function isOptional() { + return dependencies.filter(d => !d.optional).length === 0; + } + + function errorOrWarningAndCallback(err) { + if(isOptional()) { + return warningAndCallback(err); + } else { + return errorAndCallback(err); + } + } + + function iterationDependencies(depend) { + for(let index = 0; index < depend.length; index++) { + const dep = depend[index]; + dep.module = dependentModule; + dependentModule.addReason(module, dep); + } + } + + if(err) { + return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies)); + } + if(!dependentModule) { + return process.nextTick(callback); + } + if(_this.profile) { + if(!dependentModule.profile) { + dependentModule.profile = {}; + } + afterFactory = +new Date(); + dependentModule.profile.factory = afterFactory - start; + } + + dependentModule.issuer = module; + const newModule = _this.addModule(dependentModule, cacheGroup); + + if(!newModule) { // from cache + dependentModule = _this.getModule(dependentModule); + + if(dependentModule.optional) { + dependentModule.optional = isOptional(); + } + + iterationDependencies(dependencies); + + if(_this.profile) { + if(!module.profile) { + module.profile = {}; + } + const time = +new Date() - start; + if(!module.profile.dependencies || time > module.profile.dependencies) { + module.profile.dependencies = time; + } + } + + return process.nextTick(callback); + } + + if(newModule instanceof Module) { + if(_this.profile) { + newModule.profile = dependentModule.profile; + } + + newModule.optional = isOptional(); + newModule.issuer = dependentModule.issuer; + dependentModule = newModule; + + iterationDependencies(dependencies); + + if(_this.profile) { + const afterBuilding = +new Date(); + module.profile.building = afterBuilding - afterFactory; + } + + if(recursive) { + return process.nextTick(_this.processModuleDependencies.bind(_this, dependentModule, callback)); + } else { + return process.nextTick(callback); + } + } + + dependentModule.optional = isOptional(); + + iterationDependencies(dependencies); + + _this.buildModule(dependentModule, isOptional(), module, dependencies, err => { + if(err) { + return errorOrWarningAndCallback(err); + } + + if(_this.profile) { + const afterBuilding = +new Date(); + dependentModule.profile.building = afterBuilding - afterFactory; + } + + if(recursive) { + _this.processModuleDependencies(dependentModule, callback); + } else { + return callback(); + } + }); + + }); + }, function finalCallbackAddModuleDependencies(err) { + // In V8, the Error objects keep a reference to the functions on the stack. These warnings & + // errors are created inside closures that keep a reference to the Compilation, so errors are + // leaking the Compilation object. Setting _this to null workarounds the following issue in V8. + // https://bugs.chromium.org/p/chromium/issues/detail?id=612191 + _this = null; + + if(err) { + return callback(err); + } + + return process.nextTick(callback); + }); + } + + _addModuleChain(context, dependency, onModule, callback) { + const start = this.profile && +new Date(); + + const errorAndCallback = this.bail ? function errorAndCallback(err) { + callback(err); + } : function errorAndCallback(err) { + err.dependencies = [dependency]; + this.errors.push(err); + callback(); + }.bind(this); + + if(typeof dependency !== "object" || dependency === null || !dependency.constructor) { + throw new Error("Parameter 'dependency' must be a Dependency"); + } + + const moduleFactory = this.dependencyFactories.get(dependency.constructor); + if(!moduleFactory) { + throw new Error(`No dependency factory available for this dependency type: ${dependency.constructor.name}`); + } + + moduleFactory.create({ + contextInfo: { + issuer: "", + compiler: this.compiler.name + }, + context: context, + dependencies: [dependency] + }, (err, module) => { + if(err) { + return errorAndCallback(new EntryModuleNotFoundError(err)); + } + + let afterFactory; + + if(this.profile) { + if(!module.profile) { + module.profile = {}; + } + afterFactory = +new Date(); + module.profile.factory = afterFactory - start; + } + + const result = this.addModule(module); + if(!result) { + module = this.getModule(module); + + onModule(module); + + if(this.profile) { + const afterBuilding = +new Date(); + module.profile.building = afterBuilding - afterFactory; + } + + return callback(null, module); + } + + if(result instanceof Module) { + if(this.profile) { + result.profile = module.profile; + } + + module = result; + + onModule(module); + + moduleReady.call(this); + return; + } + + onModule(module); + + this.buildModule(module, false, null, null, (err) => { + if(err) { + return errorAndCallback(err); + } + + if(this.profile) { + const afterBuilding = +new Date(); + module.profile.building = afterBuilding - afterFactory; + } + + moduleReady.call(this); + }); + + function moduleReady() { + this.processModuleDependencies(module, err => { + if(err) { + return callback(err); + } + + return callback(null, module); + }); + } + }); + } + + addEntry(context, entry, name, callback) { + const slot = { + name: name, + module: null + }; + this.preparedChunks.push(slot); + this._addModuleChain(context, entry, (module) => { + + entry.module = module; + this.entries.push(module); + module.issuer = null; + + }, (err, module) => { + if(err) { + return callback(err); + } + + if(module) { + slot.module = module; + } else { + const idx = this.preparedChunks.indexOf(slot); + this.preparedChunks.splice(idx, 1); + } + return callback(null, module); + }); + } + + prefetch(context, dependency, callback) { + this._addModuleChain(context, dependency, module => { + + module.prefetched = true; + module.issuer = null; + + }, callback); + } + + rebuildModule(module, thisCallback) { + if(module.variables.length || module.blocks.length) + throw new Error("Cannot rebuild a complex module with variables or blocks"); + if(module.rebuilding) { + return module.rebuilding.push(thisCallback); + } + const rebuilding = module.rebuilding = [thisCallback]; + + function callback(err) { + module.rebuilding = undefined; + rebuilding.forEach(cb => cb(err)); + } + const deps = module.dependencies.slice(); + this.buildModule(module, false, module, null, (err) => { + if(err) return callback(err); + + this.processModuleDependencies(module, (err) => { + if(err) return callback(err); + deps.forEach(d => { + if(d.module && d.module.removeReason(module, d)) { + module.chunks.forEach(chunk => { + if(!d.module.hasReasonForChunk(chunk)) { + if(d.module.removeChunk(chunk)) { + this.removeChunkFromDependencies(d.module, chunk); + } + } + }); + } + }); + callback(); + }); + + }); + } + + finish() { + const modules = this.modules; + this.applyPlugins1("finish-modules", modules); + + for(let index = 0; index < modules.length; index++) { + const module = modules[index]; + this.reportDependencyErrorsAndWarnings(module, [module]); + } + } + + unseal() { + this.applyPlugins0("unseal"); + this.chunks.length = 0; + this.namedChunks = {}; + this.additionalChunkAssets.length = 0; + this.assets = {}; + this.modules.forEach(module => module.unseal()); + } + + seal(callback) { + const self = this; + self.applyPlugins0("seal"); + self.nextFreeModuleIndex = 0; + self.nextFreeModuleIndex2 = 0; + self.preparedChunks.forEach(preparedChunk => { + const module = preparedChunk.module; + const chunk = self.addChunk(preparedChunk.name, module); + const entrypoint = self.entrypoints[chunk.name] = new Entrypoint(chunk.name); + entrypoint.unshiftChunk(chunk); + + chunk.addModule(module); + module.addChunk(chunk); + chunk.entryModule = module; + self.assignIndex(module); + self.assignDepth(module); + self.processDependenciesBlockForChunk(module, chunk); + }); + self.sortModules(self.modules); + self.applyPlugins0("optimize"); + + while(self.applyPluginsBailResult1("optimize-modules-basic", self.modules) || + self.applyPluginsBailResult1("optimize-modules", self.modules) || + self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)); // eslint-disable-line no-extra-semi + self.applyPlugins1("after-optimize-modules", self.modules); + + while(self.applyPluginsBailResult1("optimize-chunks-basic", self.chunks) || + self.applyPluginsBailResult1("optimize-chunks", self.chunks) || + self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)); // eslint-disable-line no-extra-semi + self.applyPlugins1("after-optimize-chunks", self.chunks); + + self.applyPluginsAsyncSeries("optimize-tree", self.chunks, self.modules, function sealPart2(err) { + if(err) { + return callback(err); + } + + self.applyPlugins2("after-optimize-tree", self.chunks, self.modules); + + const shouldRecord = self.applyPluginsBailResult("should-record") !== false; + + self.applyPlugins2("revive-modules", self.modules, self.records); + self.applyPlugins1("optimize-module-order", self.modules); + self.applyPlugins1("advanced-optimize-module-order", self.modules); + self.applyPlugins1("before-module-ids", self.modules); + self.applyPlugins1("module-ids", self.modules); + self.applyModuleIds(); + self.applyPlugins1("optimize-module-ids", self.modules); + self.applyPlugins1("after-optimize-module-ids", self.modules); + + self.sortItemsWithModuleIds(); + + self.applyPlugins2("revive-chunks", self.chunks, self.records); + self.applyPlugins1("optimize-chunk-order", self.chunks); + self.applyPlugins1("before-chunk-ids", self.chunks); + self.applyChunkIds(); + self.applyPlugins1("optimize-chunk-ids", self.chunks); + self.applyPlugins1("after-optimize-chunk-ids", self.chunks); + + self.sortItemsWithChunkIds(); + + if(shouldRecord) + self.applyPlugins2("record-modules", self.modules, self.records); + if(shouldRecord) + self.applyPlugins2("record-chunks", self.chunks, self.records); + + self.applyPlugins0("before-hash"); + self.createHash(); + self.applyPlugins0("after-hash"); + + if(shouldRecord) + self.applyPlugins1("record-hash", self.records); + + self.applyPlugins0("before-module-assets"); + self.createModuleAssets(); + if(self.applyPluginsBailResult("should-generate-chunk-assets") !== false) { + self.applyPlugins0("before-chunk-assets"); + self.createChunkAssets(); + } + self.applyPlugins1("additional-chunk-assets", self.chunks); + self.summarizeDependencies(); + if(shouldRecord) + self.applyPlugins2("record", self, self.records); + + self.applyPluginsAsync("additional-assets", err => { + if(err) { + return callback(err); + } + self.applyPluginsAsync("optimize-chunk-assets", self.chunks, err => { + if(err) { + return callback(err); + } + self.applyPlugins1("after-optimize-chunk-assets", self.chunks); + self.applyPluginsAsync("optimize-assets", self.assets, err => { + if(err) { + return callback(err); + } + self.applyPlugins1("after-optimize-assets", self.assets); + if(self.applyPluginsBailResult("need-additional-seal")) { + self.unseal(); + return self.seal(callback); + } + return self.applyPluginsAsync("after-seal", callback); + }); + }); + }); + }); + } + + sortModules(modules) { + modules.sort((a, b) => { + if(a.index < b.index) return -1; + if(a.index > b.index) return 1; + return 0; + }); + } + + reportDependencyErrorsAndWarnings(module, blocks) { + for(let indexBlock = 0; indexBlock < blocks.length; indexBlock++) { + const block = blocks[indexBlock]; + const dependencies = block.dependencies; + + for(let indexDep = 0; indexDep < dependencies.length; indexDep++) { + const d = dependencies[indexDep]; + + const warnings = d.getWarnings(); + if(warnings) { + for(let indexWar = 0; indexWar < warnings.length; indexWar++) { + const w = warnings[indexWar]; + + const warning = new ModuleDependencyWarning(module, w, d.loc); + this.warnings.push(warning); + } + } + const errors = d.getErrors(); + if(errors) { + for(let indexErr = 0; indexErr < errors.length; indexErr++) { + const e = errors[indexErr]; + + const error = new ModuleDependencyError(module, e, d.loc); + this.errors.push(error); + } + } + } + + this.reportDependencyErrorsAndWarnings(module, block.blocks); + } + } + + addChunk(name, module, loc) { + if(name) { + if(Object.prototype.hasOwnProperty.call(this.namedChunks, name)) { + const chunk = this.namedChunks[name]; + if(module) { + chunk.addOrigin(module, loc); + } + return chunk; + } + } + const chunk = new Chunk(name, module, loc); + this.chunks.push(chunk); + if(name) { + this.namedChunks[name] = chunk; + } + return chunk; + } + + assignIndex(module) { + const _this = this; + + const queue = [() => { + assignIndexToModule(module); + }]; + + const iteratorAllDependencies = d => { + queue.push(() => assignIndexToDependency(d)); + }; + + function assignIndexToModule(module) { + // enter module + if(typeof module.index !== "number") { + module.index = _this.nextFreeModuleIndex++; + + // leave module + queue.push(() => module.index2 = _this.nextFreeModuleIndex2++); + + // enter it as block + assignIndexToDependencyBlock(module); + } + } + + function assignIndexToDependency(dependency) { + if(dependency.module) { + queue.push(() => assignIndexToModule(dependency.module)); + } + } + + function assignIndexToDependencyBlock(block) { + let allDependencies = []; + + function iteratorDependency(d) { + allDependencies.push(d); + } + + function iteratorBlock(b) { + queue.push(() => assignIndexToDependencyBlock(b)); + } + + if(block.variables) { + iterationBlockVariable(block.variables, iteratorDependency); + } + + if(block.dependencies) { + iterationOfArrayCallback(block.dependencies, iteratorDependency); + } + if(block.blocks) { + const blocks = block.blocks; + let indexBlock = blocks.length; + while(indexBlock--) { + iteratorBlock(blocks[indexBlock]); + } + } + + let indexAll = allDependencies.length; + while(indexAll--) { + iteratorAllDependencies(allDependencies[indexAll]); + } + } + + while(queue.length) { + queue.pop()(); + } + } + + assignDepth(module) { + function assignDepthToModule(module, depth) { + // enter module + if(typeof module.depth === "number" && module.depth <= depth) return; + module.depth = depth; + + // enter it as block + assignDepthToDependencyBlock(module, depth + 1); + } + + function assignDepthToDependency(dependency, depth) { + if(dependency.module) { + queue.push(() => assignDepthToModule(dependency.module, depth)); + } + } + + function assignDepthToDependencyBlock(block, depth) { + function iteratorDependency(d) { + assignDepthToDependency(d, depth); + } + + function iteratorBlock(b) { + assignDepthToDependencyBlock(b, depth); + } + + if(block.variables) { + iterationBlockVariable(block.variables, iteratorDependency); + } + + if(block.dependencies) { + iterationOfArrayCallback(block.dependencies, iteratorDependency); + } + + if(block.blocks) { + iterationOfArrayCallback(block.blocks, iteratorBlock); + } + } + + const queue = [() => { + assignDepthToModule(module, 0); + }]; + while(queue.length) { + queue.pop()(); + } + } + + processDependenciesBlockForChunk(block, chunk) { + const iteratorBlock = b => { + let c; + if(!b.chunks) { + c = this.addChunk(b.chunkName, b.module, b.loc); + b.chunks = [c]; + c.addBlock(b); + } else { + c = b.chunks[0]; + } + chunk.addChunk(c); + c.addParent(chunk); + queue.push([b, c]); + }; + + const iteratorDependency = d => { + if(!d.module) { + return; + } + if(d.weak) { + return; + } + if(chunk.addModule(d.module)) { + d.module.addChunk(chunk); + queue.push([d.module, chunk]); + } + }; + + const queue = [ + [block, chunk] + ]; + + while(queue.length) { + const queueItem = queue.pop(); + block = queueItem[0]; + chunk = queueItem[1]; + + if(block.variables) { + iterationBlockVariable(block.variables, iteratorDependency); + } + + if(block.dependencies) { + iterationOfArrayCallback(block.dependencies, iteratorDependency); + } + + if(block.blocks) { + iterationOfArrayCallback(block.blocks, iteratorBlock); + } + } + } + + removeChunkFromDependencies(block, chunk) { + const iteratorDependency = d => { + if(!d.module) { + return; + } + if(!d.module.hasReasonForChunk(chunk)) { + if(d.module.removeChunk(chunk)) { + this.removeChunkFromDependencies(d.module, chunk); + } + } + }; + + const blocks = block.blocks; + for(let indexBlock = 0; indexBlock < blocks.length; indexBlock++) { + const chunks = blocks[indexBlock].chunks; + for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) { + const blockChunk = chunks[indexChunk]; + chunk.removeChunk(blockChunk); + blockChunk.removeParent(chunk); + this.removeChunkFromDependencies(chunks, blockChunk); + } + } + + if(block.dependencies) { + iterationOfArrayCallback(block.dependencies, iteratorDependency); + } + + if(block.variables) { + iterationBlockVariable(block.variables, iteratorDependency); + } + } + + applyModuleIds() { + let unusedIds = []; + let nextFreeModuleId = 0; + let usedIds = []; + // TODO consider Map when performance has improved https://gist.github.com/sokra/234c077e1299b7369461f1708519c392 + const usedIdMap = Object.create(null); + if(this.usedModuleIds) { + Object.keys(this.usedModuleIds).forEach(key => { + const id = this.usedModuleIds[key]; + if(!usedIdMap[id]) { + usedIds.push(id); + usedIdMap[id] = true; + } + }); + } + + const modules1 = this.modules; + for(let indexModule1 = 0; indexModule1 < modules1.length; indexModule1++) { + const module1 = modules1[indexModule1]; + if(module1.id && !usedIdMap[module1.id]) { + usedIds.push(module1.id); + usedIdMap[module1.id] = true; + } + } + + if(usedIds.length > 0) { + let usedIdMax = -1; + for(let index = 0; index < usedIds.length; index++) { + const usedIdKey = usedIds[index]; + + if(typeof usedIdKey !== "number") { + continue; + } + + usedIdMax = Math.max(usedIdMax, usedIdKey); + } + + let lengthFreeModules = nextFreeModuleId = usedIdMax + 1; + + while(lengthFreeModules--) { + if(!usedIdMap[lengthFreeModules]) { + unusedIds.push(lengthFreeModules); + } + } + } + + const modules2 = this.modules; + for(let indexModule2 = 0; indexModule2 < modules2.length; indexModule2++) { + const module2 = modules2[indexModule2]; + if(module2.id === null) { + if(unusedIds.length > 0) + module2.id = unusedIds.pop(); + else + module2.id = nextFreeModuleId++; + } + } + } + + applyChunkIds() { + const unusedIds = []; + let nextFreeChunkId = 0; + + function getNextFreeChunkId(usedChunkIds) { + const keyChunks = Object.keys(usedChunkIds); + let result = -1; + + for(let index = 0; index < keyChunks.length; index++) { + const usedIdKey = keyChunks[index]; + const usedIdValue = usedChunkIds[usedIdKey]; + + if(typeof usedIdValue !== "number") { + continue; + } + + result = Math.max(result, usedIdValue); + } + + return result; + } + + if(this.usedChunkIds) { + nextFreeChunkId = getNextFreeChunkId(this.usedChunkIds) + 1; + let index = nextFreeChunkId; + while(index--) { + if(this.usedChunkIds[index] !== index) { + unusedIds.push(index); + } + } + } + + const chunks = this.chunks; + for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) { + const chunk = chunks[indexChunk]; + if(chunk.id === null) { + if(unusedIds.length > 0) + chunk.id = unusedIds.pop(); + else + chunk.id = nextFreeChunkId++; + } + if(!chunk.ids) { + chunk.ids = [chunk.id]; + } + } + } + + sortItemsWithModuleIds() { + this.modules.sort(byId); + + const modules = this.modules; + for(let indexModule = 0; indexModule < modules.length; indexModule++) { + modules[indexModule].sortItems(); + } + + const chunks = this.chunks; + for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) { + chunks[indexChunk].sortItems(); + } + } + + sortItemsWithChunkIds() { + this.chunks.sort(byId); + + const modules = this.modules; + for(let indexModule = 0; indexModule < modules.length; indexModule++) { + modules[indexModule].sortItems(); + } + + const chunks = this.chunks; + for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) { + chunks[indexChunk].sortItems(); + } + } + + summarizeDependencies() { + function filterDups(array) { + const newArray = []; + for(let i = 0; i < array.length; i++) { + if(i === 0 || array[i - 1] !== array[i]) + newArray.push(array[i]); + } + return newArray; + } + this.fileDependencies = (this.compilationDependencies || []).slice(); + this.contextDependencies = []; + this.missingDependencies = []; + + const children = this.children; + for(let indexChildren = 0; indexChildren < children.length; indexChildren++) { + const child = children[indexChildren]; + + this.fileDependencies = this.fileDependencies.concat(child.fileDependencies); + this.contextDependencies = this.contextDependencies.concat(child.contextDependencies); + this.missingDependencies = this.missingDependencies.concat(child.missingDependencies); + } + + const modules = this.modules; + for(let indexModule = 0; indexModule < modules.length; indexModule++) { + const module = modules[indexModule]; + + if(module.fileDependencies) { + const fileDependencies = module.fileDependencies; + for(let indexFileDep = 0; indexFileDep < fileDependencies.length; indexFileDep++) { + this.fileDependencies.push(fileDependencies[indexFileDep]); + } + } + if(module.contextDependencies) { + const contextDependencies = module.contextDependencies; + for(let indexContextDep = 0; indexContextDep < contextDependencies.length; indexContextDep++) { + this.contextDependencies.push(contextDependencies[indexContextDep]); + } + } + } + this.errors.forEach(error => { + if(Array.isArray(error.missing)) { + error.missing.forEach(item => this.missingDependencies.push(item)); + } + }); + this.fileDependencies.sort(); + this.fileDependencies = filterDups(this.fileDependencies); + this.contextDependencies.sort(); + this.contextDependencies = filterDups(this.contextDependencies); + this.missingDependencies.sort(); + this.missingDependencies = filterDups(this.missingDependencies); + } + + createHash() { + const outputOptions = this.outputOptions; + const hashFunction = outputOptions.hashFunction; + const hashDigest = outputOptions.hashDigest; + const hashDigestLength = outputOptions.hashDigestLength; + const hash = crypto.createHash(hashFunction); + if(outputOptions.hashSalt) + hash.update(outputOptions.hashSalt); + this.mainTemplate.updateHash(hash); + this.chunkTemplate.updateHash(hash); + this.moduleTemplate.updateHash(hash); + this.children.forEach(function(child) { + hash.update(child.hash); + }); + // clone needed as sort below is inplace mutation + const chunks = this.chunks.slice(); + /** + * sort here will bring all "falsy" values to the beginning + * this is needed as the "hasRuntime()" chunks are dependent on the + * hashes of the non-runtime chunks. + */ + chunks.sort((a, b) => { + const aEntry = a.hasRuntime(); + const bEntry = b.hasRuntime(); + if(aEntry && !bEntry) return 1; + if(!aEntry && bEntry) return -1; + return 0; + }); + for(let i = 0; i < chunks.length; i++) { + const chunk = chunks[i]; + const chunkHash = crypto.createHash(hashFunction); + if(outputOptions.hashSalt) + chunkHash.update(outputOptions.hashSalt); + chunk.updateHash(chunkHash); + if(chunk.hasRuntime()) { + this.mainTemplate.updateHashForChunk(chunkHash, chunk); + } else { + this.chunkTemplate.updateHashForChunk(chunkHash, chunk); + } + this.applyPlugins2("chunk-hash", chunk, chunkHash); + chunk.hash = chunkHash.digest(hashDigest); + hash.update(chunk.hash); + chunk.renderedHash = chunk.hash.substr(0, hashDigestLength); + } + this.fullHash = hash.digest(hashDigest); + this.hash = this.fullHash.substr(0, hashDigestLength); + } + + modifyHash(update) { + const outputOptions = this.outputOptions; + const hashFunction = outputOptions.hashFunction; + const hashDigest = outputOptions.hashDigest; + const hashDigestLength = outputOptions.hashDigestLength; + const hash = crypto.createHash(hashFunction); + hash.update(this.fullHash); + hash.update(update); + this.fullHash = hash.digest(hashDigest); + this.hash = this.fullHash.substr(0, hashDigestLength); + } + + createModuleAssets() { + for(let i = 0; i < this.modules.length; i++) { + const module = this.modules[i]; + if(module.assets) { + Object.keys(module.assets).forEach((assetName) => { + const fileName = this.getPath(assetName); + this.assets[fileName] = module.assets[assetName]; + this.applyPlugins2("module-asset", module, fileName); + }); + } + } + } + + createChunkAssets() { + const outputOptions = this.outputOptions; + const filename = outputOptions.filename; + const chunkFilename = outputOptions.chunkFilename; + for(let i = 0; i < this.chunks.length; i++) { + const chunk = this.chunks[i]; + chunk.files = []; + const chunkHash = chunk.hash; + let source; + let file; + const filenameTemplate = chunk.filenameTemplate ? chunk.filenameTemplate : + chunk.isInitial() ? filename : + chunkFilename; + try { + const useChunkHash = !chunk.hasRuntime() || (this.mainTemplate.useChunkHash && this.mainTemplate.useChunkHash(chunk)); + const usedHash = useChunkHash ? chunkHash : this.fullHash; + const cacheName = "c" + chunk.id; + if(this.cache && this.cache[cacheName] && this.cache[cacheName].hash === usedHash) { + source = this.cache[cacheName].source; + } else { + if(chunk.hasRuntime()) { + source = this.mainTemplate.render(this.hash, chunk, this.moduleTemplate, this.dependencyTemplates); + } else { + source = this.chunkTemplate.render(chunk, this.moduleTemplate, this.dependencyTemplates); + } + if(this.cache) { + this.cache[cacheName] = { + hash: usedHash, + source: source = (source instanceof CachedSource ? source : new CachedSource(source)) + }; + } + } + file = this.getPath(filenameTemplate, { + noChunkHash: !useChunkHash, + chunk + }); + if(this.assets[file]) + throw new Error(`Conflict: Multiple assets emit to the same filename ${file}`); + this.assets[file] = source; + chunk.files.push(file); + this.applyPlugins2("chunk-asset", chunk, file); + } catch(err) { + this.errors.push(new ChunkRenderError(chunk, file || filenameTemplate, err)); + } + } + } + + getPath(filename, data) { + data = data || {}; + data.hash = data.hash || this.hash; + return this.mainTemplate.applyPluginsWaterfall("asset-path", filename, data); + } + + getStats() { + return new Stats(this); + } + + createChildCompiler(name, outputOptions) { + return this.compiler.createChildCompiler(this, name, outputOptions); + } + + checkConstraints() { + const usedIds = {}; + + const modules = this.modules; + for(let indexModule = 0; indexModule < modules.length; indexModule++) { + const moduleId = modules[indexModule].id; + + if(usedIds[moduleId]) + throw new Error(`checkConstraints: duplicate module id ${moduleId}`); + } + + const chunks = this.chunks; + for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) { + const chunk = chunks[indexChunk]; + + if(chunks.indexOf(chunk) !== indexChunk) + throw new Error(`checkConstraints: duplicate chunk in compilation ${chunk.debugId}`); + chunk.checkConstraints(); + } + } +} + +module.exports = Compilation; diff --git a/node_modules/webpack/lib/Compiler.js b/node_modules/webpack/lib/Compiler.js new file mode 100644 index 000000000..d9fa3d34b --- /dev/null +++ b/node_modules/webpack/lib/Compiler.js @@ -0,0 +1,499 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var path = require("path"); +var Tapable = require("tapable"); + +var Compilation = require("./Compilation"); + +var NormalModuleFactory = require("./NormalModuleFactory"); +var ContextModuleFactory = require("./ContextModuleFactory"); + +function Watching(compiler, watchOptions, handler) { + this.startTime = null; + this.invalid = false; + this.error = null; + this.stats = null; + this.handler = handler; + this.closed = false; + if(typeof watchOptions === "number") { + this.watchOptions = { + aggregateTimeout: watchOptions + }; + } else if(watchOptions && typeof watchOptions === "object") { + this.watchOptions = Object.assign({}, watchOptions); + } else { + this.watchOptions = {}; + } + this.watchOptions.aggregateTimeout = this.watchOptions.aggregateTimeout || 200; + this.compiler = compiler; + this.running = true; + this.compiler.readRecords(function(err) { + if(err) return this._done(err); + + this._go(); + }.bind(this)); +} + +Watching.prototype._go = function() { + var self = this; + self.startTime = new Date().getTime(); + self.running = true; + self.invalid = false; + self.compiler.applyPluginsAsync("watch-run", self, function(err) { + if(err) return self._done(err); + self.compiler.compile(function onCompiled(err, compilation) { + if(err) return self._done(err); + if(self.invalid) return self._done(); + + if(self.compiler.applyPluginsBailResult("should-emit", compilation) === false) { + return self._done(null, compilation); + } + + self.compiler.emitAssets(compilation, function(err) { + if(err) return self._done(err); + if(self.invalid) return self._done(); + + self.compiler.emitRecords(function(err) { + if(err) return self._done(err); + + if(compilation.applyPluginsBailResult("need-additional-pass")) { + compilation.needAdditionalPass = true; + + var stats = compilation.getStats(); + stats.startTime = self.startTime; + stats.endTime = new Date().getTime(); + self.compiler.applyPlugins("done", stats); + + self.compiler.applyPluginsAsync("additional-pass", function(err) { + if(err) return self._done(err); + self.compiler.compile(onCompiled); + }); + return; + } + return self._done(null, compilation); + }); + }); + }); + }); +}; + +Watching.prototype._done = function(err, compilation) { + this.running = false; + if(this.invalid) return this._go(); + this.error = err || null; + this.stats = compilation ? compilation.getStats() : null; + if(this.stats) { + this.stats.startTime = this.startTime; + this.stats.endTime = new Date().getTime(); + } + if(this.stats) + this.compiler.applyPlugins("done", this.stats); + else + this.compiler.applyPlugins("failed", this.error); + this.handler(this.error, this.stats); + if(!this.error && !this.closed) + this.watch(compilation.fileDependencies, compilation.contextDependencies, compilation.missingDependencies); +}; + +Watching.prototype.watch = function(files, dirs, missing) { + this.pausedWatcher = null; + this.watcher = this.compiler.watchFileSystem.watch(files, dirs, missing, this.startTime, this.watchOptions, function(err, filesModified, contextModified, missingModified, fileTimestamps, contextTimestamps) { + this.pausedWatcher = this.watcher; + this.watcher = null; + if(err) return this.handler(err); + + this.compiler.fileTimestamps = fileTimestamps; + this.compiler.contextTimestamps = contextTimestamps; + this.invalidate(); + }.bind(this), function(fileName, changeTime) { + this.compiler.applyPlugins("invalid", fileName, changeTime); + }.bind(this)); +}; + +Watching.prototype.invalidate = function() { + if(this.watcher) { + this.pausedWatcher = this.watcher; + this.watcher.pause(); + this.watcher = null; + } + if(this.running) { + this.invalid = true; + return false; + } else { + this._go(); + } +}; + +Watching.prototype.close = function(callback) { + if(callback === undefined) callback = function() {}; + + this.closed = true; + if(this.watcher) { + this.watcher.close(); + this.watcher = null; + } + if(this.pausedWatcher) { + this.pausedWatcher.close(); + this.pausedWatcher = null; + } + if(this.running) { + this.invalid = true; + this._done = () => { + this.compiler.applyPlugins("watch-close"); + callback(); + }; + } else { + this.compiler.applyPlugins("watch-close"); + callback(); + } +}; + +function Compiler() { + Tapable.call(this); + + this.outputPath = ""; + this.outputFileSystem = null; + this.inputFileSystem = null; + + this.recordsInputPath = null; + this.recordsOutputPath = null; + this.records = {}; + + this.fileTimestamps = {}; + this.contextTimestamps = {}; + + this.resolvers = { + normal: null, + loader: null, + context: null + }; + var deprecationReported = false; + this.parser = { + plugin: function(hook, fn) { + if(!deprecationReported) { + console.warn("webpack: Using compiler.parser is deprecated.\n" + + "Use compiler.plugin(\"compilation\", function(compilation, data) {\n data.normalModuleFactory.plugin(\"parser\", function(parser, options) { parser.plugin(/* ... */); });\n}); instead. " + + "It was called " + new Error().stack.split("\n")[2].trim() + "."); + deprecationReported = true; + } + this.plugin("compilation", function(compilation, data) { + data.normalModuleFactory.plugin("parser", function(parser) { + parser.plugin(hook, fn); + }); + }); + }.bind(this), + apply: function() { + var args = arguments; + if(!deprecationReported) { + console.warn("webpack: Using compiler.parser is deprecated.\n" + + "Use compiler.plugin(\"compilation\", function(compilation, data) {\n data.normalModuleFactory.plugin(\"parser\", function(parser, options) { parser.apply(/* ... */); });\n}); instead. " + + "It was called " + new Error().stack.split("\n")[2].trim() + "."); + deprecationReported = true; + } + this.plugin("compilation", function(compilation, data) { + data.normalModuleFactory.plugin("parser", function(parser) { + parser.apply.apply(parser, args); + }); + }); + }.bind(this) + }; + + this.options = {}; +} +module.exports = Compiler; + +Compiler.prototype = Object.create(Tapable.prototype); +Compiler.prototype.constructor = Compiler; + +Compiler.Watching = Watching; +Compiler.prototype.watch = function(watchOptions, handler) { + this.fileTimestamps = {}; + this.contextTimestamps = {}; + var watching = new Watching(this, watchOptions, handler); + return watching; +}; + +Compiler.prototype.run = function(callback) { + var self = this; + var startTime = new Date().getTime(); + + self.applyPluginsAsync("before-run", self, function(err) { + if(err) return callback(err); + + self.applyPluginsAsync("run", self, function(err) { + if(err) return callback(err); + + self.readRecords(function(err) { + if(err) return callback(err); + + self.compile(function onCompiled(err, compilation) { + if(err) return callback(err); + + if(self.applyPluginsBailResult("should-emit", compilation) === false) { + var stats = compilation.getStats(); + stats.startTime = startTime; + stats.endTime = new Date().getTime(); + self.applyPlugins("done", stats); + return callback(null, stats); + } + + self.emitAssets(compilation, function(err) { + if(err) return callback(err); + + if(compilation.applyPluginsBailResult("need-additional-pass")) { + compilation.needAdditionalPass = true; + + var stats = compilation.getStats(); + stats.startTime = startTime; + stats.endTime = new Date().getTime(); + self.applyPlugins("done", stats); + + self.applyPluginsAsync("additional-pass", function(err) { + if(err) return callback(err); + self.compile(onCompiled); + }); + return; + } + + self.emitRecords(function(err) { + if(err) return callback(err); + + var stats = compilation.getStats(); + stats.startTime = startTime; + stats.endTime = new Date().getTime(); + self.applyPlugins("done", stats); + return callback(null, stats); + }); + }); + }); + }); + }); + }); +}; + +Compiler.prototype.runAsChild = function(callback) { + this.compile(function(err, compilation) { + if(err) return callback(err); + + this.parentCompilation.children.push(compilation); + Object.keys(compilation.assets).forEach(function(name) { + this.parentCompilation.assets[name] = compilation.assets[name]; + }.bind(this)); + + var entries = Object.keys(compilation.entrypoints).map(function(name) { + return compilation.entrypoints[name].chunks; + }).reduce(function(array, chunks) { + return array.concat(chunks); + }, []); + + return callback(null, entries, compilation); + }.bind(this)); +}; + +Compiler.prototype.purgeInputFileSystem = function() { + if(this.inputFileSystem && this.inputFileSystem.purge) + this.inputFileSystem.purge(); +}; + +Compiler.prototype.emitAssets = function(compilation, callback) { + var outputPath; + + this.applyPluginsAsync("emit", compilation, function(err) { + if(err) return callback(err); + outputPath = compilation.getPath(this.outputPath); + this.outputFileSystem.mkdirp(outputPath, emitFiles.bind(this)); + }.bind(this)); + + function emitFiles(err) { + if(err) return callback(err); + + require("async").forEach(Object.keys(compilation.assets), function(file, callback) { + + var targetFile = file; + var queryStringIdx = targetFile.indexOf("?"); + if(queryStringIdx >= 0) { + targetFile = targetFile.substr(0, queryStringIdx); + } + + if(targetFile.match(/\/|\\/)) { + var dir = path.dirname(targetFile); + this.outputFileSystem.mkdirp(this.outputFileSystem.join(outputPath, dir), writeOut.bind(this)); + } else writeOut.call(this); + + function writeOut(err) { + if(err) return callback(err); + var targetPath = this.outputFileSystem.join(outputPath, targetFile); + var source = compilation.assets[file]; + if(source.existsAt === targetPath) { + source.emitted = false; + return callback(); + } + var content = source.source(); + + if(!Buffer.isBuffer(content)) { + content = new Buffer(content, "utf8"); //eslint-disable-line + } + + source.existsAt = targetPath; + source.emitted = true; + this.outputFileSystem.writeFile(targetPath, content, callback); + } + + }.bind(this), function(err) { + if(err) return callback(err); + + afterEmit.call(this); + }.bind(this)); + } + + function afterEmit() { + this.applyPluginsAsyncSeries1("after-emit", compilation, function(err) { + if(err) return callback(err); + + return callback(); + }); + } + +}; + +Compiler.prototype.emitRecords = function emitRecords(callback) { + if(!this.recordsOutputPath) return callback(); + var idx1 = this.recordsOutputPath.lastIndexOf("/"); + var idx2 = this.recordsOutputPath.lastIndexOf("\\"); + var recordsOutputPathDirectory = null; + if(idx1 > idx2) recordsOutputPathDirectory = this.recordsOutputPath.substr(0, idx1); + if(idx1 < idx2) recordsOutputPathDirectory = this.recordsOutputPath.substr(0, idx2); + if(!recordsOutputPathDirectory) return writeFile.call(this); + this.outputFileSystem.mkdirp(recordsOutputPathDirectory, function(err) { + if(err) return callback(err); + writeFile.call(this); + }.bind(this)); + + function writeFile() { + this.outputFileSystem.writeFile(this.recordsOutputPath, JSON.stringify(this.records, undefined, 2), callback); + } +}; + +Compiler.prototype.readRecords = function readRecords(callback) { + var self = this; + if(!self.recordsInputPath) { + self.records = {}; + return callback(); + } + self.inputFileSystem.stat(self.recordsInputPath, function(err) { + // It doesn't exist + // We can ignore self. + if(err) return callback(); + + self.inputFileSystem.readFile(self.recordsInputPath, function(err, content) { + if(err) return callback(err); + + try { + self.records = JSON.parse(content.toString("utf-8")); + } catch(e) { + e.message = "Cannot parse records: " + e.message; + return callback(e); + } + + return callback(); + }); + }); +}; + +Compiler.prototype.createChildCompiler = function(compilation, compilerName, outputOptions, plugins) { + var childCompiler = new Compiler(); + if(Array.isArray(plugins)) { + plugins.forEach(plugin => childCompiler.apply(plugin)); + } + for(var name in this._plugins) { + if(["make", "compile", "emit", "after-emit", "invalid", "done", "this-compilation"].indexOf(name) < 0) + childCompiler._plugins[name] = this._plugins[name].slice(); + } + childCompiler.name = compilerName; + childCompiler.outputPath = this.outputPath; + childCompiler.inputFileSystem = this.inputFileSystem; + childCompiler.outputFileSystem = null; + childCompiler.resolvers = this.resolvers; + childCompiler.fileTimestamps = this.fileTimestamps; + childCompiler.contextTimestamps = this.contextTimestamps; + if(!this.records[compilerName]) this.records[compilerName] = []; + this.records[compilerName].push(childCompiler.records = {}); + childCompiler.options = Object.create(this.options); + childCompiler.options.output = Object.create(childCompiler.options.output); + for(name in outputOptions) { + childCompiler.options.output[name] = outputOptions[name]; + } + childCompiler.parentCompilation = compilation; + return childCompiler; +}; + +Compiler.prototype.isChild = function() { + return !!this.parentCompilation; +}; + +Compiler.prototype.createCompilation = function() { + return new Compilation(this); +}; + +Compiler.prototype.newCompilation = function(params) { + var compilation = this.createCompilation(); + compilation.fileTimestamps = this.fileTimestamps; + compilation.contextTimestamps = this.contextTimestamps; + compilation.name = this.name; + compilation.records = this.records; + compilation.compilationDependencies = params.compilationDependencies; + this.applyPlugins("this-compilation", compilation, params); + this.applyPlugins("compilation", compilation, params); + return compilation; +}; + +Compiler.prototype.createNormalModuleFactory = function() { + var normalModuleFactory = new NormalModuleFactory(this.options.context, this.resolvers, this.options.module || {}); + this.applyPlugins("normal-module-factory", normalModuleFactory); + return normalModuleFactory; +}; + +Compiler.prototype.createContextModuleFactory = function() { + var contextModuleFactory = new ContextModuleFactory(this.resolvers, this.inputFileSystem); + this.applyPlugins("context-module-factory", contextModuleFactory); + return contextModuleFactory; +}; + +Compiler.prototype.newCompilationParams = function() { + var params = { + normalModuleFactory: this.createNormalModuleFactory(), + contextModuleFactory: this.createContextModuleFactory(), + compilationDependencies: [] + }; + return params; +}; + +Compiler.prototype.compile = function(callback) { + var self = this; + var params = self.newCompilationParams(); + self.applyPluginsAsync("before-compile", params, function(err) { + if(err) return callback(err); + + self.applyPlugins("compile", params); + + var compilation = self.newCompilation(params); + + self.applyPluginsParallel("make", compilation, function(err) { + if(err) return callback(err); + + compilation.finish(); + + compilation.seal(function(err) { + if(err) return callback(err); + + self.applyPluginsAsync("after-compile", compilation, function(err) { + if(err) return callback(err); + + return callback(null, compilation); + }); + }); + }); + }); +}; diff --git a/node_modules/webpack/lib/ConstPlugin.js b/node_modules/webpack/lib/ConstPlugin.js new file mode 100644 index 000000000..8534a6fe8 --- /dev/null +++ b/node_modules/webpack/lib/ConstPlugin.js @@ -0,0 +1,60 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ConstDependency = require("./dependencies/ConstDependency"); +const NullFactory = require("./NullFactory"); +const ParserHelpers = require("./ParserHelpers"); + +const getQuery = (request) => { + const i = request.indexOf("?"); + return request.indexOf("?") < 0 ? "" : request.substr(i); +}; + +class ConstPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + params.normalModuleFactory.plugin("parser", parser => { + parser.plugin("statement if", function(statement) { + const param = this.evaluateExpression(statement.test); + const bool = param.asBool(); + if(typeof bool === "boolean") { + if(statement.test.type !== "Literal") { + const dep = new ConstDependency(`${bool}`, param.range); + dep.loc = statement.loc; + this.state.current.addDependency(dep); + } + return bool; + } + }); + parser.plugin("expression ?:", function(expression) { + const param = this.evaluateExpression(expression.test); + const bool = param.asBool(); + if(typeof bool === "boolean") { + if(expression.test.type !== "Literal") { + const dep = new ConstDependency(` ${bool}`, param.range); + dep.loc = expression.loc; + this.state.current.addDependency(dep); + } + return bool; + } + }); + parser.plugin("evaluate Identifier __resourceQuery", function(expr) { + if(!this.state.module) return; + return ParserHelpers.evaluateToString(getQuery(this.state.module.resource))(expr); + }); + parser.plugin("expression __resourceQuery", function() { + if(!this.state.module) return; + this.state.current.addVariable("__resourceQuery", JSON.stringify(getQuery(this.state.module.resource))); + return true; + }); + }); + }); + } +} + +module.exports = ConstPlugin; diff --git a/node_modules/webpack/lib/ContextModule.js b/node_modules/webpack/lib/ContextModule.js new file mode 100644 index 000000000..ee7228bac --- /dev/null +++ b/node_modules/webpack/lib/ContextModule.js @@ -0,0 +1,257 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const path = require("path"); +const Module = require("./Module"); +const OriginalSource = require("webpack-sources").OriginalSource; +const RawSource = require("webpack-sources").RawSource; +const AsyncDependenciesBlock = require("./AsyncDependenciesBlock"); + +class ContextModule extends Module { + constructor(resolveDependencies, context, recursive, regExp, addon, isAsync, chunkName) { + super(); + this.resolveDependencies = resolveDependencies; + this.context = context; + this.recursive = recursive; + this.regExp = regExp; + this.addon = addon; + this.async = !!isAsync; + this.cacheable = true; + this.contextDependencies = [context]; + this.built = false; + this.chunkName = chunkName; + } + + prettyRegExp(regexString) { + // remove the "/" at the front and the beginning + // "/foo/" -> "foo" + return regexString.substring(1, regexString.length - 1); + } + + contextify(context, request) { + return request.split("!").map(subrequest => { + let rp = path.relative(context, subrequest); + if(path.sep === "\\") + rp = rp.replace(/\\/g, "/"); + if(rp.indexOf("../") !== 0) + rp = "./" + rp; + return rp; + }).join("!"); + } + + identifier() { + let identifier = this.context; + if(this.async) + identifier += " async"; + if(!this.recursive) + identifier += " nonrecursive"; + if(this.addon) + identifier += ` ${this.addon}`; + if(this.regExp) + identifier += ` ${this.regExp}`; + + return identifier; + } + + readableIdentifier(requestShortener) { + let identifier = requestShortener.shorten(this.context); + if(this.async) + identifier += " async"; + if(!this.recursive) + identifier += " nonrecursive"; + if(this.addon) + identifier += ` ${requestShortener.shorten(this.addon)}`; + if(this.regExp) + identifier += ` ${this.prettyRegExp(this.regExp + "")}`; + + return identifier; + } + + libIdent(options) { + let identifier = this.contextify(options.context, this.context); + if(this.async) + identifier += " async"; + if(this.recursive) + identifier += " recursive"; + if(this.addon) + identifier += ` ${this.contextify(options.context, this.addon)}`; + if(this.regExp) + identifier += ` ${this.prettyRegExp(this.regExp + "")}`; + + return identifier; + } + + needRebuild(fileTimestamps, contextTimestamps) { + const ts = contextTimestamps[this.context]; + if(!ts) { + return true; + } + + return ts >= this.builtTime; + } + + unbuild() { + this.built = false; + super.unbuild(); + } + + build(options, compilation, resolver, fs, callback) { + this.built = true; + this.builtTime = new Date().getTime(); + this.resolveDependencies(fs, this.context, this.recursive, this.regExp, (err, dependencies) => { + if(err) return callback(err); + + if(!dependencies) { + this.dependencies = []; + callback(); + return; + } + + // enhance dependencies + dependencies.forEach(dep => { + dep.loc = dep.userRequest; + dep.request = this.addon + dep.request; + }); + + // if these we are not a async context + // add dependencies and continue + if(!this.async) { + this.dependencies = dependencies; + callback(); + return; + } + + // if we are async however create a new async dependency block + // and add that block to this context + dependencies.forEach(dep => { + const block = new AsyncDependenciesBlock(this.chunkName, dep.module, dep.loc); + block.addDependency(dep); + this.addBlock(block); + }); + callback(); + }); + } + + getSourceWithDependencies(dependencies, id) { + // if we filter first we get a new array + // therefor we dont need to create a clone of dependencies explicitly + // therefore the order of this is !important! + const map = dependencies + .filter(dependency => dependency.module) + .sort((a, b) => { + if(a.userRequest === b.userRequest) { + return 0; + } + return a.userRequest < b.userRequest ? -1 : 1; + }).reduce(function(map, dep) { + map[dep.userRequest] = dep.module.id; + return map; + }, Object.create(null)); + return `var map = ${JSON.stringify(map, null, "\t")}; +function webpackContext(req) { + return __webpack_require__(webpackContextResolve(req)); +}; +function webpackContextResolve(req) { + var id = map[req]; + if(!(id + 1)) // check for number or string + throw new Error("Cannot find module '" + req + "'."); + return id; +}; +webpackContext.keys = function webpackContextKeys() { + return Object.keys(map); +}; +webpackContext.resolve = webpackContextResolve; +module.exports = webpackContext; +webpackContext.id = ${JSON.stringify(id)};`; + } + + getSourceWithBlocks(blocks, id) { + let hasMultipleOrNoChunks = false; + const map = blocks + .filter(block => block.dependencies[0].module) + .map((block) => ({ + dependency: block.dependencies[0], + block: block, + userRequest: block.dependencies[0].userRequest + })).sort((a, b) => { + if(a.userRequest === b.userRequest) return 0; + return a.userRequest < b.userRequest ? -1 : 1; + }).reduce((map, item) => { + const chunks = item.block.chunks || []; + if(chunks.length !== 1) { + hasMultipleOrNoChunks = true; + } + map[item.userRequest] = [item.dependency.module.id] + .concat(chunks.map(chunk => chunk.id)); + + return map; + }, Object.create(null)); + + const requestPrefix = hasMultipleOrNoChunks ? + "Promise.all(ids.slice(1).map(__webpack_require__.e))" : + "__webpack_require__.e(ids[1])"; + + return `var map = ${JSON.stringify(map, null, "\t")}; +function webpackAsyncContext(req) { + var ids = map[req]; + if(!ids) + return Promise.reject(new Error("Cannot find module '" + req + "'.")); + return ${requestPrefix}.then(function() { + return __webpack_require__(ids[0]); + }); +}; +webpackAsyncContext.keys = function webpackAsyncContextKeys() { + return Object.keys(map); +}; +module.exports = webpackAsyncContext; +webpackAsyncContext.id = ${JSON.stringify(id)};`; + } + + getSourceForEmptyContext(id) { + return `function webpackEmptyContext(req) { + throw new Error("Cannot find module '" + req + "'."); +} +webpackEmptyContext.keys = function() { return []; }; +webpackEmptyContext.resolve = webpackEmptyContext; +module.exports = webpackEmptyContext; +webpackEmptyContext.id = ${JSON.stringify(id)};`; + } + + getSourceString() { + if(this.dependencies && this.dependencies.length > 0) { + return this.getSourceWithDependencies(this.dependencies, this.id); + } + + if(this.blocks && this.blocks.length > 0) { + return this.getSourceWithBlocks(this.blocks, this.id); + } + + return this.getSourceForEmptyContext(this.id); + } + + getSource(sourceString) { + if(this.useSourceMap) { + return new OriginalSource(sourceString, this.identifier()); + } + return new RawSource(sourceString); + } + + source() { + return this.getSource( + this.getSourceString() + ); + } + + size() { + // base penalty + const initialSize = 160; + + // if we dont have dependencies we stop here. + return this.dependencies + .reduce((size, dependency) => size + 5 + dependency.userRequest.length, initialSize); + } +} + +module.exports = ContextModule; diff --git a/node_modules/webpack/lib/ContextModuleFactory.js b/node_modules/webpack/lib/ContextModuleFactory.js new file mode 100644 index 000000000..a2b666fad --- /dev/null +++ b/node_modules/webpack/lib/ContextModuleFactory.js @@ -0,0 +1,159 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var asyncLib = require("async"); +var path = require("path"); + +var Tapable = require("tapable"); +var ContextModule = require("./ContextModule"); +var ContextElementDependency = require("./dependencies/ContextElementDependency"); + +function ContextModuleFactory(resolvers) { + Tapable.call(this); + this.resolvers = resolvers; +} +module.exports = ContextModuleFactory; + +ContextModuleFactory.prototype = Object.create(Tapable.prototype); +ContextModuleFactory.prototype.constructor = ContextModuleFactory; + +ContextModuleFactory.prototype.create = function(data, callback) { + var module = this; + var context = data.context; + var dependencies = data.dependencies; + var dependency = dependencies[0]; + this.applyPluginsAsyncWaterfall("before-resolve", { + context: context, + request: dependency.request, + recursive: dependency.recursive, + regExp: dependency.regExp, + async: dependency.async, + dependencies: dependencies + }, function(err, result) { + if(err) return callback(err); + + // Ignored + if(!result) return callback(); + + var context = result.context; + var request = result.request; + var recursive = result.recursive; + var regExp = result.regExp; + var asyncContext = result.async; + var dependencies = result.dependencies; + + var loaders, resource, loadersPrefix = ""; + var idx = request.lastIndexOf("!"); + if(idx >= 0) { + loaders = request.substr(0, idx + 1); + for(var i = 0; i < loaders.length && loaders[i] === "!"; i++) { + loadersPrefix += "!"; + } + loaders = loaders.substr(i).replace(/!+$/, "").replace(/!!+/g, "!"); + if(loaders === "") loaders = []; + else loaders = loaders.split("!"); + resource = request.substr(idx + 1); + } else { + loaders = []; + resource = request; + } + + var resolvers = module.resolvers; + + asyncLib.parallel([ + function(callback) { + resolvers.context.resolve({}, context, resource, function(err, result) { + if(err) return callback(err); + callback(null, result); + }); + }, + function(callback) { + asyncLib.map(loaders, function(loader, callback) { + resolvers.loader.resolve({}, context, loader, function(err, result) { + if(err) return callback(err); + callback(null, result); + }); + }, callback); + } + ], function(err, result) { + if(err) return callback(err); + + module.applyPluginsAsyncWaterfall("after-resolve", { + loaders: loadersPrefix + result[1].join("!") + (result[1].length > 0 ? "!" : ""), + resource: result[0], + recursive: recursive, + regExp: regExp, + async: asyncContext, + dependencies: dependencies, + resolveDependencies: module.resolveDependencies.bind(module) + }, function(err, result) { + if(err) return callback(err); + + // Ignored + if(!result) return callback(); + + return callback(null, new ContextModule(result.resolveDependencies, result.resource, result.recursive, result.regExp, result.loaders, result.async, dependency.chunkName)); + }); + }); + }); +}; + +ContextModuleFactory.prototype.resolveDependencies = function resolveDependencies(fs, resource, recursive, regExp, callback) { + if(!regExp || !resource) + return callback(null, []); + (function addDirectory(directory, callback) { + fs.readdir(directory, function(err, files) { + if(err) return callback(err); + if(!files || files.length === 0) return callback(null, []); + asyncLib.map(files.filter(function(p) { + return p.indexOf(".") !== 0; + }), function(seqment, callback) { + + var subResource = path.join(directory, seqment); + + fs.stat(subResource, function(err, stat) { + if(err) return callback(err); + + if(stat.isDirectory()) { + + if(!recursive) return callback(); + addDirectory.call(this, subResource, callback); + + } else if(stat.isFile()) { + + var obj = { + context: resource, + request: "." + subResource.substr(resource.length).replace(/\\/g, "/") + }; + + this.applyPluginsAsyncWaterfall("alternatives", [obj], function(err, alternatives) { + if(err) return callback(err); + alternatives = alternatives.filter(function(obj) { + return regExp.test(obj.request); + }).map(function(obj) { + var dep = new ContextElementDependency(obj.request); + dep.optional = true; + return dep; + }); + callback(null, alternatives); + }); + + } else callback(); + + }.bind(this)); + + }.bind(this), function(err, result) { + if(err) return callback(err); + + if(!result) return callback(null, []); + + callback(null, result.filter(function(i) { + return !!i; + }).reduce(function(a, i) { + return a.concat(i); + }, [])); + }); + }.bind(this)); + }.call(this, resource, callback)); +}; diff --git a/node_modules/webpack/lib/ContextReplacementPlugin.js b/node_modules/webpack/lib/ContextReplacementPlugin.js new file mode 100644 index 000000000..29fede826 --- /dev/null +++ b/node_modules/webpack/lib/ContextReplacementPlugin.js @@ -0,0 +1,111 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const ContextElementDependency = require("./dependencies/ContextElementDependency"); + +class ContextReplacementPlugin { + constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) { + this.resourceRegExp = resourceRegExp; + + if(typeof newContentResource === "function") { + this.newContentCallback = newContentResource; + } else if(typeof newContentResource === "string" && typeof newContentRecursive === "object") { + this.newContentResource = newContentResource; + this.newContentCreateContextMap = (fs, callback) => { + callback(null, newContentRecursive); + }; + } else if(typeof newContentResource === "string" && typeof newContentRecursive === "function") { + this.newContentResource = newContentResource; + this.newContentCreateContextMap = newContentRecursive; + } else { + if(typeof newContentResource !== "string") { + newContentRegExp = newContentRecursive; + newContentRecursive = newContentResource; + newContentResource = undefined; + } + if(typeof newContentRecursive !== "boolean") { + newContentRegExp = newContentRecursive; + newContentRecursive = undefined; + } + this.newContentResource = newContentResource; + this.newContentRecursive = newContentRecursive; + this.newContentRegExp = newContentRegExp; + } + } + + apply(compiler) { + const resourceRegExp = this.resourceRegExp; + const newContentCallback = this.newContentCallback; + const newContentResource = this.newContentResource; + const newContentRecursive = this.newContentRecursive; + const newContentRegExp = this.newContentRegExp; + const newContentCreateContextMap = this.newContentCreateContextMap; + + compiler.plugin("context-module-factory", (cmf) => { + cmf.plugin("before-resolve", (result, callback) => { + if(!result) return callback(); + if(resourceRegExp.test(result.request)) { + if(typeof newContentResource !== "undefined") + result.request = newContentResource; + if(typeof newContentRecursive !== "undefined") + result.recursive = newContentRecursive; + if(typeof newContentRegExp !== "undefined") + result.regExp = newContentRegExp; + if(typeof newContentCallback === "function") { + newContentCallback(result); + } else { + result.dependencies.forEach((d) => { + if(d.critical) + d.critical = false; + }); + } + } + return callback(null, result); + }); + cmf.plugin("after-resolve", (result, callback) => { + if(!result) return callback(); + if(resourceRegExp.test(result.resource)) { + if(typeof newContentResource !== "undefined") + result.resource = path.resolve(result.resource, newContentResource); + if(typeof newContentRecursive !== "undefined") + result.recursive = newContentRecursive; + if(typeof newContentRegExp !== "undefined") + result.regExp = newContentRegExp; + if(typeof newContentCreateContextMap === "function") + result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap); + if(typeof newContentCallback === "function") { + const origResource = result.resource; + newContentCallback(result); + if(result.resource !== origResource) { + result.resource = path.resolve(origResource, result.resource); + } + } else { + result.dependencies.forEach((d) => { + if(d.critical) + d.critical = false; + }); + } + } + return callback(null, result); + }); + }); + } +} + +const createResolveDependenciesFromContextMap = (createContextMap) => { + return function resolveDependenciesFromContextMap(fs, resource, recursive, regExp, callback) { + createContextMap(fs, (err, map) => { + if(err) return callback(err); + const dependencies = Object.keys(map).map((key) => { + return new ContextElementDependency(map[key], key); + }); + callback(null, dependencies); + }); + }; +}; + +module.exports = ContextReplacementPlugin; diff --git a/node_modules/webpack/lib/DefinePlugin.js b/node_modules/webpack/lib/DefinePlugin.js new file mode 100644 index 000000000..52bbdfe31 --- /dev/null +++ b/node_modules/webpack/lib/DefinePlugin.js @@ -0,0 +1,123 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConstDependency = require("./dependencies/ConstDependency"); +const BasicEvaluatedExpression = require("./BasicEvaluatedExpression"); +const ParserHelpers = require("./ParserHelpers"); +const NullFactory = require("./NullFactory"); + +class DefinePlugin { + constructor(definitions) { + this.definitions = definitions; + } + + apply(compiler) { + const definitions = this.definitions; + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser) => { + (function walkDefinitions(definitions, prefix) { + Object.keys(definitions).forEach((key) => { + const code = definitions[key]; + if(code && typeof code === "object" && !(code instanceof RegExp)) { + walkDefinitions(code, prefix + key + "."); + applyObjectDefine(prefix + key, code); + return; + } + applyDefineKey(prefix, key); + applyDefine(prefix + key, code); + }); + }(definitions, "")); + + function stringifyObj(obj) { + return "__webpack_require__.i({" + Object.keys(obj).map((key) => { + const code = obj[key]; + return JSON.stringify(key) + ":" + toCode(code); + }).join(",") + "})"; + } + + function toCode(code) { + if(code === null) return "null"; + else if(code === undefined) return "undefined"; + else if(code instanceof RegExp && code.toString) return code.toString(); + else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")"; + else if(typeof code === "object") return stringifyObj(code); + else return code + ""; + } + + function applyDefineKey(prefix, key) { + const splittedKey = key.split("."); + splittedKey.slice(1).forEach((_, i) => { + const fullKey = prefix + splittedKey.slice(0, i + 1).join("."); + parser.plugin("can-rename " + fullKey, ParserHelpers.approve); + }); + } + + function applyDefine(key, code) { + const isTypeof = /^typeof\s+/.test(key); + if(isTypeof) key = key.replace(/^typeof\s+/, ""); + let recurse = false; + let recurseTypeof = false; + code = toCode(code); + if(!isTypeof) { + parser.plugin("can-rename " + key, ParserHelpers.approve); + parser.plugin("evaluate Identifier " + key, (expr) => { + /** + * this is needed in case there is a recursion in the DefinePlugin + * to prevent an endless recursion + * e.g.: new DefinePlugin({ + * "a": "b", + * "b": "a" + * }); + */ + if(recurse) return; + recurse = true; + const res = parser.evaluate(code); + recurse = false; + res.setRange(expr.range); + return res; + }); + parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code)); + } + const typeofCode = isTypeof ? code : "typeof (" + code + ")"; + parser.plugin("evaluate typeof " + key, (expr) => { + /** + * this is needed in case there is a recursion in the DefinePlugin + * to prevent an endless recursion + * e.g.: new DefinePlugin({ + * "typeof a": "tyepof b", + * "typeof b": "typeof a" + * }); + */ + if(recurseTypeof) return; + recurseTypeof = true; + const res = parser.evaluate(typeofCode); + recurseTypeof = false; + res.setRange(expr.range); + return res; + }); + parser.plugin("typeof " + key, (expr) => { + const res = parser.evaluate(typeofCode); + if(!res.isString()) return; + return ParserHelpers.toConstantDependency(JSON.stringify(res.string)).bind(parser)(expr); + }); + } + + function applyObjectDefine(key, obj) { + const code = stringifyObj(obj); + parser.plugin("can-rename " + key, ParserHelpers.approve); + parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setRange(expr.range)); + parser.plugin("evaluate typeof " + key, ParserHelpers.evaluateToString("object")); + parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code)); + parser.plugin("typeof " + key, ParserHelpers.toConstantDependency(JSON.stringify("object"))); + } + }); + }); + } +} +module.exports = DefinePlugin; diff --git a/node_modules/webpack/lib/DelegatedModule.js b/node_modules/webpack/lib/DelegatedModule.js new file mode 100644 index 000000000..6fd4559b7 --- /dev/null +++ b/node_modules/webpack/lib/DelegatedModule.js @@ -0,0 +1,84 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Module = require("./Module"); +const OriginalSource = require("webpack-sources").OriginalSource; +const RawSource = require("webpack-sources").RawSource; +const WebpackMissingModule = require("./dependencies/WebpackMissingModule"); +const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency"); + +class DelegatedModule extends Module { + constructor(sourceRequest, data, type, userRequest) { + super(); + this.sourceRequest = sourceRequest; + this.request = data.id; + this.meta = data.meta; + this.type = type; + this.userRequest = userRequest; + this.built = false; + this.delegated = true; + this.delegateData = data; + } + + identifier() { + return `delegated ${JSON.stringify(this.request)} from ${this.sourceRequest}`; + } + + readableIdentifier() { + return `delegated ${this.userRequest} from ${this.sourceRequest}`; + } + + needRebuild() { + return false; + } + + build(options, compilation, resolver, fs, callback) { + this.built = true; + this.builtTime = new Date().getTime(); + this.usedExports = true; + this.providedExports = this.delegateData.exports || true; + this.dependencies.length = 0; + this.addDependency(new DelegatedSourceDependency(this.sourceRequest)); + callback(); + } + + unbuild() { + this.built = false; + super.unbuild(); + } + + source() { + const sourceModule = this.dependencies[0].module; + let str; + + if(!sourceModule) { + str = WebpackMissingModule.moduleCode(this.sourceRequest); + } else { + str = `module.exports = (__webpack_require__(${sourceModule.id}))`; + + switch(this.type) { + case "require": + str += `(${JSON.stringify(this.request)})`; + break; + case "object": + str += `[${JSON.stringify(this.request)}]`; + break; + } + } + + if(this.useSourceMap) { + return new OriginalSource(str, this.identifier()); + } else { + return new RawSource(str); + } + } + + size() { + return 42; + } +} + +module.exports = DelegatedModule; diff --git a/node_modules/webpack/lib/DelegatedModuleFactoryPlugin.js b/node_modules/webpack/lib/DelegatedModuleFactoryPlugin.js new file mode 100644 index 000000000..501125bd0 --- /dev/null +++ b/node_modules/webpack/lib/DelegatedModuleFactoryPlugin.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const DelegatedModule = require("./DelegatedModule"); + +// options.source +// options.type +// options.context +// options.scope +// options.content +class DelegatedModuleFactoryPlugin { + constructor(options) { + this.options = options; + options.type = options.type || "require"; + options.extensions = options.extensions || ["", ".js"]; + } + + apply(normalModuleFactory) { + const scope = this.options.scope; + if(scope) { + normalModuleFactory.plugin("factory", factory => (data, callback) => { + const dependency = data.dependencies[0]; + const request = dependency.request; + if(request && request.indexOf(scope + "/") === 0) { + const innerRequest = "." + request.substr(scope.length); + let resolved; + if(innerRequest in this.options.content) { + resolved = this.options.content[innerRequest]; + return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, innerRequest)); + } + for(let i = 0; i < this.options.extensions.length; i++) { + const requestPlusExt = innerRequest + this.options.extensions[i]; + if(requestPlusExt in this.options.content) { + resolved = this.options.content[requestPlusExt]; + return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, requestPlusExt)); + } + } + } + return factory(data, callback); + }); + } else { + normalModuleFactory.plugin("module", module => { + if(module.libIdent) { + const request = module.libIdent(this.options); + if(request && request in this.options.content) { + const resolved = this.options.content[request]; + return new DelegatedModule(this.options.source, resolved, this.options.type, request); + } + } + return module; + }); + } + } +} +module.exports = DelegatedModuleFactoryPlugin; diff --git a/node_modules/webpack/lib/DelegatedPlugin.js b/node_modules/webpack/lib/DelegatedPlugin.js new file mode 100644 index 000000000..709ede204 --- /dev/null +++ b/node_modules/webpack/lib/DelegatedPlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin"); +const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency"); + +class DelegatedPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(DelegatedSourceDependency, params.normalModuleFactory); + }); + + compiler.plugin("compile", (params) => { + params.normalModuleFactory.apply(new DelegatedModuleFactoryPlugin(this.options)); + }); + } +} + +module.exports = DelegatedPlugin; diff --git a/node_modules/webpack/lib/DependenciesBlock.js b/node_modules/webpack/lib/DependenciesBlock.js new file mode 100644 index 000000000..d8b07c1db --- /dev/null +++ b/node_modules/webpack/lib/DependenciesBlock.js @@ -0,0 +1,81 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const DependenciesBlockVariable = require("./DependenciesBlockVariable"); + +function disconnect(i) { + i.disconnect(); +} + +function unseal(i) { + i.unseal(); +} + +class DependenciesBlock { + constructor() { + this.dependencies = []; + this.blocks = []; + this.variables = []; + } + + addBlock(block) { + this.blocks.push(block); + block.parent = this; + } + + addVariable(name, expression, dependencies) { + for(let v of this.variables) { + if(v.name === name && v.expression === expression) { + return; + } + } + this.variables.push(new DependenciesBlockVariable(name, expression, dependencies)); + } + + addDependency(dependency) { + this.dependencies.push(dependency); + } + + updateHash(hash) { + function updateHash(i) { + i.updateHash(hash); + } + + this.dependencies.forEach(updateHash); + this.blocks.forEach(updateHash); + this.variables.forEach(updateHash); + } + + disconnect() { + this.dependencies.forEach(disconnect); + this.blocks.forEach(disconnect); + this.variables.forEach(disconnect); + } + + unseal() { + this.blocks.forEach(unseal); + } + + hasDependencies(filter) { + if(filter) { + if(this.dependencies.some(filter)) { + return true; + } + } else { + if(this.dependencies.length > 0) { + return true; + } + } + + return this.blocks.concat(this.variables).some(item => item.hasDependencies(filter)); + } + + sortItems() { + this.blocks.forEach(block => block.sortItems()); + } +} + +module.exports = DependenciesBlock; diff --git a/node_modules/webpack/lib/DependenciesBlockVariable.js b/node_modules/webpack/lib/DependenciesBlockVariable.js new file mode 100644 index 000000000..0da641674 --- /dev/null +++ b/node_modules/webpack/lib/DependenciesBlockVariable.js @@ -0,0 +1,51 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ReplaceSource = require("webpack-sources").ReplaceSource; +const RawSource = require("webpack-sources").RawSource; + +class DependenciesBlockVariable { + constructor(name, expression, dependencies) { + this.name = name; + this.expression = expression; + this.dependencies = dependencies || []; + } + + updateHash(hash) { + hash.update(this.name); + hash.update(this.expression); + this.dependencies.forEach(d => { + d.updateHash(hash); + }); + } + + expressionSource(dependencyTemplates, outputOptions, requestShortener) { + const source = new ReplaceSource(new RawSource(this.expression)); + this.dependencies.forEach(dep => { + const template = dependencyTemplates.get(dep.constructor); + if(!template) throw new Error(`No template for dependency: ${dep.constructor.name}`); + template.apply(dep, source, outputOptions, requestShortener, dependencyTemplates); + }); + return source; + } + + disconnect() { + this.dependencies.forEach(d => { + d.disconnect(); + }); + } + + hasDependencies(filter) { + if(filter) { + if(this.dependencies.some(filter)) return true; + } else { + if(this.dependencies.length > 0) return true; + } + return false; + } +} + +module.exports = DependenciesBlockVariable; diff --git a/node_modules/webpack/lib/Dependency.js b/node_modules/webpack/lib/Dependency.js new file mode 100644 index 000000000..d9ebc287f --- /dev/null +++ b/node_modules/webpack/lib/Dependency.js @@ -0,0 +1,54 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const compareLocations = require("./compareLocations"); + +class Dependency { + constructor() { + this.module = null; + } + + isEqualResource() { + return false; + } + + // Returns the referenced module and export + getReference() { + if(!this.module) return null; + return { + module: this.module, + importedNames: true, // true: full object, false: only sideeffects/no export, array of strings: the exports with this names + }; + } + + // Returns the exported names + getExports() { + return null; + } + + getWarnings() { + return null; + } + + getErrors() { + return null; + } + + updateHash(hash) { + hash.update((this.module && this.module.id) + ""); + } + + disconnect() { + this.module = null; + } + + // TODO: remove in webpack 3 + compare(a, b) { + return compareLocations(a.loc, b.loc); + } +} +Dependency.compare = (a, b) => compareLocations(a.loc, b.loc); + +module.exports = Dependency; diff --git a/node_modules/webpack/lib/DllEntryPlugin.js b/node_modules/webpack/lib/DllEntryPlugin.js new file mode 100644 index 000000000..92b3c92c8 --- /dev/null +++ b/node_modules/webpack/lib/DllEntryPlugin.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const DllEntryDependency = require("./dependencies/DllEntryDependency"); +const SingleEntryDependency = require("./dependencies/SingleEntryDependency"); +const DllModuleFactory = require("./DllModuleFactory"); + +class DllEntryPlugin { + constructor(context, entries, name) { + this.context = context; + this.entries = entries; + this.name = name; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const dllModuleFactory = new DllModuleFactory(); + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(DllEntryDependency, dllModuleFactory); + + compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory); + }); + compiler.plugin("make", (compilation, callback) => { + compilation.addEntry(this.context, new DllEntryDependency(this.entries.map((e, idx) => { + const dep = new SingleEntryDependency(e); + dep.loc = `${this.name}:${idx}`; + return dep; + }), this.name), this.name, callback); + }); + } +} + +module.exports = DllEntryPlugin; diff --git a/node_modules/webpack/lib/DllModule.js b/node_modules/webpack/lib/DllModule.js new file mode 100644 index 000000000..5e83129e9 --- /dev/null +++ b/node_modules/webpack/lib/DllModule.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const Module = require("./Module"); +const RawSource = require("webpack-sources").RawSource; + +class DllModule extends Module { + constructor(context, dependencies, name, type) { + super(); + this.context = context; + this.dependencies = dependencies; + this.name = name; + this.built = false; + this.cacheable = true; + this.type = type; + } + + identifier() { + return `dll ${this.name}`; + } + + readableIdentifier() { + return `dll ${this.name}`; + } + + disconnect() { + this.built = false; + super.disconnect(); + } + + build(options, compilation, resolver, fs, callback) { + this.built = true; + return callback(); + } + + source() { + return new RawSource("module.exports = __webpack_require__;"); + } + + needRebuild() { + return false; + } + + size() { + return 12; + } + + updateHash(hash) { + hash.update("dll module"); + hash.update(this.name || ""); + super.updateHash(hash); + } +} + +module.exports = DllModule; diff --git a/node_modules/webpack/lib/DllModuleFactory.js b/node_modules/webpack/lib/DllModuleFactory.js new file mode 100644 index 000000000..aae5c5747 --- /dev/null +++ b/node_modules/webpack/lib/DllModuleFactory.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +var Tapable = require("tapable"); +var DllModule = require("./DllModule"); + +class DllModuleFactory extends Tapable { + constructor() { + super(); + } + create(data, callback) { + const dependency = data.dependencies[0]; + callback(null, new DllModule(data.context, dependency.dependencies, dependency.name, dependency.type)); + } +} + +module.exports = DllModuleFactory; diff --git a/node_modules/webpack/lib/DllPlugin.js b/node_modules/webpack/lib/DllPlugin.js new file mode 100644 index 000000000..6fd929d6e --- /dev/null +++ b/node_modules/webpack/lib/DllPlugin.js @@ -0,0 +1,38 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const DllEntryPlugin = require("./DllEntryPlugin"); +const LibManifestPlugin = require("./LibManifestPlugin"); +const FlagInitialModulesAsUsedPlugin = require("./FlagInitialModulesAsUsedPlugin"); + +class DllPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("entry-option", (context, entry) => { + function itemToPlugin(item, name) { + if(Array.isArray(item)) + return new DllEntryPlugin(context, item, name); + else + throw new Error("DllPlugin: supply an Array as entry"); + } + if(typeof entry === "object" && !Array.isArray(entry)) { + Object.keys(entry).forEach(name => { + compiler.apply(itemToPlugin(entry[name], name)); + }); + } else { + compiler.apply(itemToPlugin(entry, "main")); + } + return true; + }); + compiler.apply(new LibManifestPlugin(this.options)); + compiler.apply(new FlagInitialModulesAsUsedPlugin()); + } +} + +module.exports = DllPlugin; diff --git a/node_modules/webpack/lib/DllReferencePlugin.js b/node_modules/webpack/lib/DllReferencePlugin.js new file mode 100644 index 000000000..39289db61 --- /dev/null +++ b/node_modules/webpack/lib/DllReferencePlugin.js @@ -0,0 +1,59 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency"); +const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin"); +const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin"); + +class DllReferencePlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + compilation.dependencyFactories.set(DelegatedSourceDependency, normalModuleFactory); + }); + + compiler.plugin("before-compile", (params, callback) => { + const manifest = this.options.manifest; + if(typeof manifest === "string") { + params.compilationDependencies.push(manifest); + compiler.inputFileSystem.readFile(manifest, function(err, result) { + if(err) return callback(err); + params["dll reference " + manifest] = JSON.parse(result.toString("utf-8")); + return callback(); + }); + } else { + return callback(); + } + }); + + compiler.plugin("compile", (params) => { + let manifest = this.options.manifest; + if(typeof manifest === "string") { + manifest = params["dll reference " + manifest]; + } + const name = this.options.name || manifest.name; + const sourceType = this.options.sourceType || "var"; + const externals = {}; + const source = "dll-reference " + name; + externals[source] = name; + params.normalModuleFactory.apply(new ExternalModuleFactoryPlugin(sourceType, externals)); + params.normalModuleFactory.apply(new DelegatedModuleFactoryPlugin({ + source: source, + type: this.options.type, + scope: this.options.scope, + context: this.options.context || compiler.options.context, + content: this.options.content || manifest.content, + extensions: this.options.extensions + })); + }); + } +} + +module.exports = DllReferencePlugin; diff --git a/node_modules/webpack/lib/DynamicEntryPlugin.js b/node_modules/webpack/lib/DynamicEntryPlugin.js new file mode 100644 index 000000000..2079e1276 --- /dev/null +++ b/node_modules/webpack/lib/DynamicEntryPlugin.js @@ -0,0 +1,59 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Naoyuki Kanezawa @nkzawa +*/ +"use strict"; + +const MultiEntryDependency = require("./dependencies/MultiEntryDependency"); +const SingleEntryDependency = require("./dependencies/SingleEntryDependency"); +const MultiModuleFactory = require("./MultiModuleFactory"); +const MultiEntryPlugin = require("./MultiEntryPlugin"); +const SingleEntryPlugin = require("./SingleEntryPlugin"); + +class DynamicEntryPlugin { + constructor(context, entry) { + this.context = context; + this.entry = entry; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const multiModuleFactory = new MultiModuleFactory(); + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(MultiEntryDependency, multiModuleFactory); + compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory); + }); + + compiler.plugin("make", (compilation, callback) => { + const addEntry = (entry, name) => { + const dep = DynamicEntryPlugin.createDependency(entry, name); + return new Promise((resolve, reject) => { + compilation.addEntry(this.context, dep, name, (err) => { + if(err) return reject(err); + resolve(); + }); + }); + }; + + Promise.resolve(this.entry()).then((entry) => { + if(typeof entry === "string" || Array.isArray(entry)) { + addEntry(entry, "main").then(() => callback(), callback); + } else if(typeof entry === "object") { + Promise.all(Object.keys(entry).map((name) => { + return addEntry(entry[name], name); + })).then(() => callback(), callback); + } + }); + }); + } +} + +module.exports = DynamicEntryPlugin; + +DynamicEntryPlugin.createDependency = function(entry, name) { + if(Array.isArray(entry)) + return MultiEntryPlugin.createDependency(entry, name); + else + return SingleEntryPlugin.createDependency(entry, name); +}; diff --git a/node_modules/webpack/lib/EntryModuleNotFoundError.js b/node_modules/webpack/lib/EntryModuleNotFoundError.js new file mode 100644 index 000000000..d7b5d24fb --- /dev/null +++ b/node_modules/webpack/lib/EntryModuleNotFoundError.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +class EntryModuleNotFoundError extends WebpackError { + constructor(err) { + super(); + + this.name = "EntryModuleNotFoundError"; + this.message = "Entry module not found: " + err; + this.details = err.details; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = EntryModuleNotFoundError; diff --git a/node_modules/webpack/lib/EntryOptionPlugin.js b/node_modules/webpack/lib/EntryOptionPlugin.js new file mode 100644 index 000000000..49b1c798a --- /dev/null +++ b/node_modules/webpack/lib/EntryOptionPlugin.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const SingleEntryPlugin = require("./SingleEntryPlugin"); +const MultiEntryPlugin = require("./MultiEntryPlugin"); +const DynamicEntryPlugin = require("./DynamicEntryPlugin"); + +module.exports = class EntryOptionPlugin { + apply(compiler) { + compiler.plugin("entry-option", (context, entry) => { + function itemToPlugin(item, name) { + if(Array.isArray(item)) { + return new MultiEntryPlugin(context, item, name); + } else { + return new SingleEntryPlugin(context, item, name); + } + } + if(typeof entry === "string" || Array.isArray(entry)) { + compiler.apply(itemToPlugin(entry, "main")); + } else if(typeof entry === "object") { + Object.keys(entry).forEach(name => compiler.apply(itemToPlugin(entry[name], name))); + } else if(typeof entry === "function") { + compiler.apply(new DynamicEntryPlugin(context, entry)); + } + return true; + }); + } +}; diff --git a/node_modules/webpack/lib/Entrypoint.js b/node_modules/webpack/lib/Entrypoint.js new file mode 100644 index 000000000..04dc2084b --- /dev/null +++ b/node_modules/webpack/lib/Entrypoint.js @@ -0,0 +1,43 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class Entrypoint { + constructor(name) { + this.name = name; + this.chunks = []; + } + + unshiftChunk(chunk) { + this.chunks.unshift(chunk); + chunk.entrypoints.push(this); + } + + insertChunk(chunk, before) { + const idx = this.chunks.indexOf(before); + if(idx >= 0) { + this.chunks.splice(idx, 0, chunk); + } else { + throw new Error("before chunk not found"); + } + chunk.entrypoints.push(this); + } + + getFiles() { + const files = []; + + for(let chunkIdx = 0; chunkIdx < this.chunks.length; chunkIdx++) { + for(let fileIdx = 0; fileIdx < this.chunks[chunkIdx].files.length; fileIdx++) { + if(files.indexOf(this.chunks[chunkIdx].files[fileIdx]) === -1) { + files.push(this.chunks[chunkIdx].files[fileIdx]); + } + } + } + + return files; + } +} + +module.exports = Entrypoint; diff --git a/node_modules/webpack/lib/EnvironmentPlugin.js b/node_modules/webpack/lib/EnvironmentPlugin.js new file mode 100644 index 000000000..3f03fabdf --- /dev/null +++ b/node_modules/webpack/lib/EnvironmentPlugin.js @@ -0,0 +1,50 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Authors Simen Brekken @simenbrekken, Einar Löve @einarlove +*/ + +"use strict"; + +const DefinePlugin = require("./DefinePlugin"); + +class EnvironmentPlugin { + constructor(keys) { + if(Array.isArray(keys)) { + this.keys = keys; + this.defaultValues = {}; + } else if(keys && typeof keys === "object") { + this.keys = Object.keys(keys); + this.defaultValues = keys; + } else { + this.keys = Array.prototype.slice.call(arguments); + this.defaultValues = {}; + } + } + + apply(compiler) { + const definitions = this.keys.reduce((defs, key) => { + const value = process.env[key] !== undefined ? process.env[key] : this.defaultValues[key]; + + if(value === undefined) { + compiler.plugin("this-compilation", compilation => { + const error = new Error( + `EnvironmentPlugin - ${key} environment variable is undefined.\n\n` + + "You can pass an object with default values to suppress this warning.\n" + + "See https://webpack.js.org/plugins/environment-plugin for example." + ); + + error.name = "EnvVariableNotDefinedError"; + compilation.warnings.push(error); + }); + } + + defs[`process.env.${key}`] = typeof value === "undefined" ? "undefined" : JSON.stringify(value); + + return defs; + }, {}); + + compiler.apply(new DefinePlugin(definitions)); + } +} + +module.exports = EnvironmentPlugin; diff --git a/node_modules/webpack/lib/ErrorHelpers.js b/node_modules/webpack/lib/ErrorHelpers.js new file mode 100644 index 000000000..527e0ed21 --- /dev/null +++ b/node_modules/webpack/lib/ErrorHelpers.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const loaderFlag = "LOADER_EXECUTION"; + +exports.cutOffLoaderExecution = (stack) => { + stack = stack.split("\n"); + for(let i = 0; i < stack.length; i++) + if(stack[i].indexOf(loaderFlag) >= 0) + stack.length = i; + return stack.join("\n"); +}; + +exports.cutOffMessage = (stack, message) => { + const nextLine = stack.indexOf("\n"); + if(nextLine === -1) { + return stack === message ? "" : stack; + } else { + const firstLine = stack.substr(0, nextLine); + return firstLine === message ? stack.substr(nextLine + 1) : stack; + } +}; + +exports.cleanUp = (stack, message) => { + stack = exports.cutOffLoaderExecution(stack); + stack = exports.cutOffMessage(stack, message); + return stack; +}; diff --git a/node_modules/webpack/lib/EvalDevToolModulePlugin.js b/node_modules/webpack/lib/EvalDevToolModulePlugin.js new file mode 100644 index 000000000..69f1e9d85 --- /dev/null +++ b/node_modules/webpack/lib/EvalDevToolModulePlugin.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const EvalDevToolModuleTemplatePlugin = require("./EvalDevToolModuleTemplatePlugin"); + +class EvalDevToolModulePlugin { + constructor(sourceUrlComment, moduleFilenameTemplate) { + this.sourceUrlComment = sourceUrlComment; + this.moduleFilenameTemplate = moduleFilenameTemplate; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.moduleTemplate.apply(new EvalDevToolModuleTemplatePlugin(this.sourceUrlComment, this.moduleFilenameTemplate)); + }); + } +} + +module.exports = EvalDevToolModulePlugin; diff --git a/node_modules/webpack/lib/EvalDevToolModuleTemplatePlugin.js b/node_modules/webpack/lib/EvalDevToolModuleTemplatePlugin.js new file mode 100644 index 000000000..e56970ce9 --- /dev/null +++ b/node_modules/webpack/lib/EvalDevToolModuleTemplatePlugin.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RawSource = require("webpack-sources").RawSource; +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); + +class EvalDevToolModuleTemplatePlugin { + constructor(sourceUrlComment, moduleFilenameTemplate) { + this.sourceUrlComment = sourceUrlComment || "\n//# sourceURL=[url]"; + this.moduleFilenameTemplate = moduleFilenameTemplate || "webpack:///[resourcePath]?[loaders]"; + } + + apply(moduleTemplate) { + moduleTemplate.plugin("module", (source, module) => { + const content = source.source(); + const str = ModuleFilenameHelpers.createFilename(module, this.moduleFilenameTemplate, moduleTemplate.requestShortener); + const footer = ["\n", + ModuleFilenameHelpers.createFooter(module, moduleTemplate.requestShortener), + this.sourceUrlComment.replace(/\[url\]/g, encodeURI(str).replace(/%2F/g, "/").replace(/%20/g, "_").replace(/%5E/g, "^").replace(/%5C/g, "\\").replace(/^\//, "")) + ].join("\n"); + return new RawSource(`eval(${JSON.stringify(content + footer)});`); + }); + moduleTemplate.plugin("hash", hash => { + hash.update("EvalDevToolModuleTemplatePlugin"); + hash.update("2"); + }); + } +} + +module.exports = EvalDevToolModuleTemplatePlugin; diff --git a/node_modules/webpack/lib/EvalSourceMapDevToolModuleTemplatePlugin.js b/node_modules/webpack/lib/EvalSourceMapDevToolModuleTemplatePlugin.js new file mode 100644 index 000000000..31c44492a --- /dev/null +++ b/node_modules/webpack/lib/EvalSourceMapDevToolModuleTemplatePlugin.js @@ -0,0 +1,74 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RawSource = require("webpack-sources").RawSource; +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); + +class EvalSourceMapDevToolModuleTemplatePlugin { + constructor(compilation, options) { + this.compilation = compilation; + this.sourceMapComment = options.append || "//# sourceMappingURL=[url]"; + this.moduleFilenameTemplate = options.moduleFilenameTemplate || "webpack:///[resource-path]?[hash]"; + this.options = options; + } + + apply(moduleTemplate) { + const self = this; + const options = this.options; + moduleTemplate.plugin("module", function(source, module) { + if(source.__EvalSourceMapDevToolData) + return source.__EvalSourceMapDevToolData; + let sourceMap; + let content; + if(source.sourceAndMap) { + const sourceAndMap = source.sourceAndMap(options); + sourceMap = sourceAndMap.map; + content = sourceAndMap.source; + } else { + sourceMap = source.map(options); + content = source.source(); + } + if(!sourceMap) { + return source; + } + + // Clone (flat) the sourcemap to ensure that the mutations below do not persist. + sourceMap = Object.keys(sourceMap).reduce(function(obj, key) { + obj[key] = sourceMap[key]; + return obj; + }, {}); + const modules = sourceMap.sources.map(function(source) { + const module = self.compilation.findModule(source); + return module || source; + }); + let moduleFilenames = modules.map(function(module) { + return ModuleFilenameHelpers.createFilename(module, self.moduleFilenameTemplate, this.requestShortener); + }, this); + moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(moduleFilenames, function(filename, i, n) { + for(let j = 0; j < n; j++) + filename += "*"; + return filename; + }); + sourceMap.sources = moduleFilenames; + if(sourceMap.sourcesContent) { + sourceMap.sourcesContent = sourceMap.sourcesContent.map(function(content, i) { + return `${content}\n\n\n${ModuleFilenameHelpers.createFooter(modules[i], this.requestShortener)}`; + }, this); + } + sourceMap.sourceRoot = options.sourceRoot || ""; + sourceMap.file = `${module.id}.js`; + + const footer = self.sourceMapComment.replace(/\[url\]/g, `data:application/json;charset=utf-8;base64,${new Buffer(JSON.stringify(sourceMap), "utf8").toString("base64")}`); //eslint-disable-line + source.__EvalSourceMapDevToolData = new RawSource(`eval(${JSON.stringify(content + footer)});`); + return source.__EvalSourceMapDevToolData; + }); + moduleTemplate.plugin("hash", function(hash) { + hash.update("eval-source-map"); + hash.update("1"); + }); + } +} +module.exports = EvalSourceMapDevToolModuleTemplatePlugin; diff --git a/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js b/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js new file mode 100644 index 000000000..1a2aed396 --- /dev/null +++ b/node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js @@ -0,0 +1,32 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const EvalSourceMapDevToolModuleTemplatePlugin = require("./EvalSourceMapDevToolModuleTemplatePlugin"); +const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin"); + +class EvalSourceMapDevToolPlugin { + constructor(options) { + if(arguments.length > 1) + throw new Error("EvalSourceMapDevToolPlugin only takes one argument (pass an options object)"); + if(typeof options === "string") { + options = { + append: options + }; + } + if(!options) options = {}; + this.options = options; + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation) => { + new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation); + compilation.moduleTemplate.apply(new EvalSourceMapDevToolModuleTemplatePlugin(compilation, options)); + }); + } +} + +module.exports = EvalSourceMapDevToolPlugin; diff --git a/node_modules/webpack/lib/ExtendedAPIPlugin.js b/node_modules/webpack/lib/ExtendedAPIPlugin.js new file mode 100644 index 000000000..5b0b913d4 --- /dev/null +++ b/node_modules/webpack/lib/ExtendedAPIPlugin.js @@ -0,0 +1,47 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConstDependency = require("./dependencies/ConstDependency"); +const ParserHelpers = require("./ParserHelpers"); +const NullFactory = require("./NullFactory"); + +const REPLACEMENTS = { + __webpack_hash__: "__webpack_require__.h", // eslint-disable-line camelcase + __webpack_chunkname__: "__webpack_require__.cn" // eslint-disable-line camelcase +}; +const REPLACEMENT_TYPES = { + __webpack_hash__: "string", // eslint-disable-line camelcase + __webpack_chunkname__: "string" // eslint-disable-line camelcase +}; + +class ExtendedAPIPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + compilation.mainTemplate.plugin("require-extensions", function(source, chunk, hash) { + const buf = [source]; + buf.push(""); + buf.push("// __webpack_hash__"); + buf.push(`${this.requireFn}.h = ${JSON.stringify(hash)};`); + buf.push(""); + buf.push("// __webpack_chunkname__"); + buf.push(`${this.requireFn}.cn = ${JSON.stringify(chunk.name)};`); + return this.asString(buf); + }); + compilation.mainTemplate.plugin("global-hash", () => true); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + Object.keys(REPLACEMENTS).forEach(key => { + parser.plugin(`expression ${key}`, ParserHelpers.toConstantDependency(REPLACEMENTS[key])); + parser.plugin(`evaluate typeof ${key}`, ParserHelpers.evaluateToString(REPLACEMENT_TYPES[key])); + }); + }); + }); + } +} + +module.exports = ExtendedAPIPlugin; diff --git a/node_modules/webpack/lib/ExternalModule.js b/node_modules/webpack/lib/ExternalModule.js new file mode 100644 index 000000000..225d3c448 --- /dev/null +++ b/node_modules/webpack/lib/ExternalModule.js @@ -0,0 +1,116 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Module = require("./Module"); +const OriginalSource = require("webpack-sources").OriginalSource; +const RawSource = require("webpack-sources").RawSource; +const WebpackMissingModule = require("./dependencies/WebpackMissingModule"); +const Template = require("./Template"); + +class ExternalModule extends Module { + constructor(request, type) { + super(); + this.request = request; + this.type = type; + this.built = false; + this.external = true; + } + + chunkCondition(chunk) { + return chunk.hasEntryModule(); + } + + identifier() { + return "external " + JSON.stringify(this.request); + } + + readableIdentifier() { + return "external " + JSON.stringify(this.request); + } + + needRebuild() { + return false; + } + + build(options, compilation, resolver, fs, callback) { + this.builtTime = new Date().getTime(); + callback(); + } + + getSourceForGlobalVariableExternal(variableName, type) { + if(!Array.isArray(variableName)) { + // make it an array as the look up works the same basically + variableName = [variableName]; + } + + // needed for e.g. window["some"]["thing"] + const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join(""); + return `(function() { module.exports = ${type}${objectLookup}; }());`; + } + + getSourceForCommonJsExternal(moduleAndSpecifiers) { + if(!Array.isArray(moduleAndSpecifiers)) { + return `module.exports = require(${JSON.stringify(moduleAndSpecifiers)});`; + } + + const moduleName = moduleAndSpecifiers[0]; + const objectLookup = moduleAndSpecifiers.slice(1).map(r => `[${JSON.stringify(r)}]`).join(""); + return `module.exports = require(${moduleName})${objectLookup};`; + } + + checkExternalVariable(variableToCheck, request) { + return `if(typeof ${variableToCheck} === 'undefined') {${WebpackMissingModule.moduleCode(request)}}\n`; + } + + getSourceForAmdOrUmdExternal(id, optional, request) { + const externalVariable = Template.toIdentifier(`__WEBPACK_EXTERNAL_MODULE_${id}__`); + const missingModuleError = optional ? this.checkExternalVariable(externalVariable, request) : ""; + return `${missingModuleError}module.exports = ${externalVariable};`; + } + + getSourceForDefaultCase(optional, request) { + const missingModuleError = optional ? this.checkExternalVariable(request, request) : ""; + return `${missingModuleError}module.exports = ${request};`; + } + + getSourceString() { + const request = typeof this.request === "object" ? this.request[this.type] : this.request; + switch(this.type) { + case "this": + case "window": + case "global": + return this.getSourceForGlobalVariableExternal(request, this.type); + case "commonjs": + case "commonjs2": + return this.getSourceForCommonJsExternal(request); + case "amd": + case "umd": + case "umd2": + return this.getSourceForAmdOrUmdExternal(this.id, this.optional, request); + default: + return this.getSourceForDefaultCase(this.optional, request); + } + } + + getSource(sourceString) { + if(this.useSourceMap) { + return new OriginalSource(sourceString, this.identifier()); + } + + return new RawSource(sourceString); + } + + source() { + return this.getSource( + this.getSourceString() + ); + } + + size() { + return 42; + } +} + +module.exports = ExternalModule; diff --git a/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js b/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js new file mode 100644 index 000000000..54cf0a28b --- /dev/null +++ b/node_modules/webpack/lib/ExternalModuleFactoryPlugin.js @@ -0,0 +1,91 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ExternalModule = require("./ExternalModule"); + +class ExternalModuleFactoryPlugin { + constructor(type, externals) { + this.type = type; + this.externals = externals; + } + + apply(normalModuleFactory) { + const globalType = this.type; + normalModuleFactory.plugin("factory", factory => (data, callback) => { + const context = data.context; + const dependency = data.dependencies[0]; + + function handleExternal(value, type, callback) { + if(typeof type === "function") { + callback = type; + type = undefined; + } + if(value === false) return factory(data, callback); + if(value === true) value = dependency.request; + if(typeof type === "undefined" && /^[a-z0-9]+ /.test(value)) { + const idx = value.indexOf(" "); + type = value.substr(0, idx); + value = value.substr(idx + 1); + } + callback(null, new ExternalModule(value, type || globalType)); + return true; + } + (function handleExternals(externals, callback) { + if(typeof externals === "string") { + if(externals === dependency.request) { + return handleExternal(dependency.request, callback); + } + } else if(Array.isArray(externals)) { + let i = 0; + (function next() { + let asyncFlag; + const handleExternalsAndCallback = function handleExternalsAndCallback(err, module) { + if(err) return callback(err); + if(!module) { + if(asyncFlag) { + asyncFlag = false; + return; + } + return next(); + } + callback(null, module); + }; + + do { + asyncFlag = true; + if(i >= externals.length) return callback(); + handleExternals(externals[i++], handleExternalsAndCallback); + } while (!asyncFlag); // eslint-disable-line keyword-spacing + asyncFlag = false; + }()); + return; + } else if(externals instanceof RegExp) { + if(externals.test(dependency.request)) { + return handleExternal(dependency.request, callback); + } + } else if(typeof externals === "function") { + externals.call(null, context, dependency.request, function(err, value, type) { + if(err) return callback(err); + if(typeof value !== "undefined") { + handleExternal(value, type, callback); + } else { + callback(); + } + }); + return; + } else if(typeof externals === "object" && Object.prototype.hasOwnProperty.call(externals, dependency.request)) { + return handleExternal(externals[dependency.request], callback); + } + callback(); + }(this.externals, function(err, module) { + if(err) return callback(err); + if(!module) return handleExternal(false, callback); + return callback(null, module); + })); + }); + } +} +module.exports = ExternalModuleFactoryPlugin; diff --git a/node_modules/webpack/lib/ExternalsPlugin.js b/node_modules/webpack/lib/ExternalsPlugin.js new file mode 100644 index 000000000..751b6e13e --- /dev/null +++ b/node_modules/webpack/lib/ExternalsPlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +var ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin"); + +class ExternalsPlugin { + constructor(type, externals) { + this.type = type; + this.externals = externals; + } + apply(compiler) { + compiler.plugin("compile", (params) => { + params.normalModuleFactory.apply(new ExternalModuleFactoryPlugin(this.type, this.externals)); + }); + } +} + +module.exports = ExternalsPlugin; diff --git a/node_modules/webpack/lib/FlagDependencyExportsPlugin.js b/node_modules/webpack/lib/FlagDependencyExportsPlugin.js new file mode 100644 index 000000000..581c30fa0 --- /dev/null +++ b/node_modules/webpack/lib/FlagDependencyExportsPlugin.js @@ -0,0 +1,101 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class FlagDependencyExportsPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("finish-modules", (modules) => { + const dependencies = Object.create(null); + + let module; + let moduleWithExports; + let moduleProvidedExports; + const queue = modules.filter((m) => !m.providedExports); + for(let i = 0; i < queue.length; i++) { + module = queue[i]; + + if(module.providedExports !== true) { + moduleWithExports = false; + moduleProvidedExports = Array.isArray(module.providedExports) ? new Set(module.providedExports) : new Set(); + processDependenciesBlock(module); + if(!moduleWithExports) { + module.providedExports = true; + notifyDependencies(); + } else if(module.providedExports !== true) { + module.providedExports = Array.from(moduleProvidedExports); + } + } + } + + function processDependenciesBlock(depBlock) { + depBlock.dependencies.forEach((dep) => processDependency(dep)); + depBlock.variables.forEach((variable) => { + variable.dependencies.forEach((dep) => processDependency(dep)); + }); + depBlock.blocks.forEach(processDependenciesBlock); + } + + function processDependency(dep) { + const exportDesc = dep.getExports && dep.getExports(); + if(!exportDesc) return; + moduleWithExports = true; + const exports = exportDesc.exports; + const exportDeps = exportDesc.dependencies; + if(exportDeps) { + exportDeps.forEach((dep) => { + const depIdent = dep.identifier(); + // if this was not yet initialized + // initialize it as an array containing the module and stop + const array = dependencies[depIdent]; + if(!array) { + dependencies[depIdent] = [module]; + return; + } + + // check if this module is known + // if not, add it to the dependencies for this identifier + if(array.indexOf(module) < 0) + array.push(module); + }); + } + let changed = false; + if(module.providedExports !== true) { + if(exports === true) { + module.providedExports = true; + changed = true; + } else if(Array.isArray(exports)) { + changed = addToSet(moduleProvidedExports, exports); + } + } + if(changed) { + notifyDependencies(); + } + } + + function notifyDependencies() { + const deps = dependencies[module.identifier()]; + if(deps) { + deps.forEach((dep) => queue.push(dep)); + } + } + }); + + function addToSet(a, b) { + let changed = false; + b.forEach((item) => { + if(!a.has(item)) { + a.add(item); + changed = true; + } + }); + return changed; + } + }); + } +} + +module.exports = FlagDependencyExportsPlugin; diff --git a/node_modules/webpack/lib/FlagDependencyUsagePlugin.js b/node_modules/webpack/lib/FlagDependencyUsagePlugin.js new file mode 100644 index 000000000..0be9d54b2 --- /dev/null +++ b/node_modules/webpack/lib/FlagDependencyUsagePlugin.js @@ -0,0 +1,81 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class FlagDependencyUsagePlugin { + apply(compiler) { + compiler.plugin("compilation", compilation => { + compilation.plugin("optimize-modules-advanced", modules => { + + modules.forEach(module => module.used = false); + + const queue = []; + compilation.chunks.forEach(chunk => { + if(chunk.entryModule) { + processModule(chunk.entryModule, true); + } + }); + + while(queue.length) { + const queueItem = queue.pop(); + processDependenciesBlock(queueItem[0], queueItem[1]); + } + + function processModule(module, usedExports) { + module.used = true; + if(module.usedExports === true) + return; + else if(usedExports === true) + module.usedExports = true; + else if(Array.isArray(usedExports)) { + var old = module.usedExports ? module.usedExports.length : -1; + module.usedExports = addToSet(module.usedExports || [], usedExports); + if(module.usedExports.length === old) + return; + } else if(Array.isArray(module.usedExports)) + return; + else + module.usedExports = false; + + queue.push([module, module.usedExports]); + } + + function processDependenciesBlock(depBlock, usedExports) { + depBlock.dependencies.forEach(dep => processDependency(dep)); + depBlock.variables.forEach(variable => variable.dependencies.forEach(dep => processDependency(dep))); + depBlock.blocks.forEach(block => queue.push([block, usedExports])); + } + + function processDependency(dep) { + const reference = dep.getReference && dep.getReference(); + if(!reference) return; + const module = reference.module; + const importedNames = reference.importedNames; + const oldUsed = module.used; + const oldUsedExports = module.usedExports; + if(!oldUsed || (importedNames && (!oldUsedExports || !isSubset(oldUsedExports, importedNames)))) { + processModule(module, importedNames); + } + } + + }); + + function addToSet(a, b) { + b.forEach(item => { + if(a.indexOf(item) < 0) + a.push(item); + }); + return a; + } + + function isSubset(biggerSet, subset) { + if(biggerSet === true) return true; + if(subset === true) return false; + return subset.every(item => biggerSet.indexOf(item) >= 0); + } + }); + } +} +module.exports = FlagDependencyUsagePlugin; diff --git a/node_modules/webpack/lib/FlagInitialModulesAsUsedPlugin.js b/node_modules/webpack/lib/FlagInitialModulesAsUsedPlugin.js new file mode 100644 index 000000000..8f68805ed --- /dev/null +++ b/node_modules/webpack/lib/FlagInitialModulesAsUsedPlugin.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class FlagInitialModulesAsUsedPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("after-optimize-chunks", (chunks) => { + chunks.forEach((chunk) => { + if(!chunk.isInitial()) { + return; + } + chunk.modules.forEach((module) => { + module.usedExports = true; + }); + }); + }); + }); + } +} + +module.exports = FlagInitialModulesAsUsedPlugin; diff --git a/node_modules/webpack/lib/FunctionModulePlugin.js b/node_modules/webpack/lib/FunctionModulePlugin.js new file mode 100644 index 000000000..a150a94e3 --- /dev/null +++ b/node_modules/webpack/lib/FunctionModulePlugin.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const FunctionModuleTemplatePlugin = require("./FunctionModuleTemplatePlugin"); +const RequestShortener = require("./RequestShortener"); + +class FunctionModulePlugin { + constructor(options, requestShortener) { + this.options = options; + this.requestShortener = requestShortener; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.moduleTemplate.requestShortener = this.requestShortener || new RequestShortener(compiler.context); + compilation.moduleTemplate.apply(new FunctionModuleTemplatePlugin()); + }); + } +} + +module.exports = FunctionModulePlugin; diff --git a/node_modules/webpack/lib/FunctionModuleTemplatePlugin.js b/node_modules/webpack/lib/FunctionModuleTemplatePlugin.js new file mode 100644 index 000000000..dd20b7867 --- /dev/null +++ b/node_modules/webpack/lib/FunctionModuleTemplatePlugin.js @@ -0,0 +1,51 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class FunctionModuleTemplatePlugin { + apply(moduleTemplate) { + moduleTemplate.plugin("render", function(moduleSource, module) { + const source = new ConcatSource(); + const defaultArguments = [module.moduleArgument || "module", module.exportsArgument || "exports"]; + if((module.arguments && module.arguments.length !== 0) || module.hasDependencies(d => d.requireWebpackRequire !== false)) { + defaultArguments.push("__webpack_require__"); + } + source.add("/***/ (function(" + defaultArguments.concat(module.arguments || []).join(", ") + ") {\n\n"); + if(module.strict) source.add("\"use strict\";\n"); + source.add(moduleSource); + source.add("\n\n/***/ })"); + return source; + }); + + moduleTemplate.plugin("package", function(moduleSource, module) { + if(this.outputOptions.pathinfo) { + const source = new ConcatSource(); + const req = module.readableIdentifier(this.requestShortener); + if(Array.isArray(module.providedExports)) + source.add("/* exports provided: " + module.providedExports.join(", ") + " */\n"); + else if(module.providedExports) + source.add("/* unknown exports provided */\n"); + if(Array.isArray(module.usedExports)) + source.add("/* exports used: " + module.usedExports.join(", ") + " */\n"); + else if(module.usedExports) + source.add("/* all exports used */\n"); + source.add("/*!****" + req.replace(/./g, "*") + "****!*\\\n"); + source.add(" !*** " + req.replace(/\*\//g, "*_/") + " ***!\n"); + source.add(" \\****" + req.replace(/./g, "*") + "****/\n"); + source.add(moduleSource); + return source; + } + return moduleSource; + }); + + moduleTemplate.plugin("hash", function(hash) { + hash.update("FunctionModuleTemplatePlugin"); + hash.update("2"); + }); + } +} +module.exports = FunctionModuleTemplatePlugin; diff --git a/node_modules/webpack/lib/HashedModuleIdsPlugin.js b/node_modules/webpack/lib/HashedModuleIdsPlugin.js new file mode 100644 index 000000000..40a491b07 --- /dev/null +++ b/node_modules/webpack/lib/HashedModuleIdsPlugin.js @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const createHash = require("crypto").createHash; + +class HashedModuleIdsPlugin { + constructor(options) { + this.options = Object.assign({ + hashFunction: "md5", + hashDigest: "base64", + hashDigestLength: 4 + }, options); + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation) => { + const usedIds = new Set(); + compilation.plugin("before-module-ids", (modules) => { + modules.forEach((module) => { + if(module.id === null && module.libIdent) { + const id = module.libIdent({ + context: this.options.context || compiler.options.context + }); + const hash = createHash(options.hashFunction); + hash.update(id); + const hashId = hash.digest(options.hashDigest); + let len = options.hashDigestLength; + while(usedIds.has(hashId.substr(0, len))) + len++; + module.id = hashId.substr(0, len); + usedIds.add(module.id); + } + }); + }); + }); + } +} + +module.exports = HashedModuleIdsPlugin; diff --git a/node_modules/webpack/lib/HotModuleReplacement.runtime.js b/node_modules/webpack/lib/HotModuleReplacement.runtime.js new file mode 100644 index 000000000..bf6f6f8bf --- /dev/null +++ b/node_modules/webpack/lib/HotModuleReplacement.runtime.js @@ -0,0 +1,583 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/*global $hash$ installedModules $require$ hotDownloadManifest hotDownloadUpdateChunk hotDisposeChunk modules */ +module.exports = function() { + + var hotApplyOnUpdate = true; + var hotCurrentHash = $hash$; // eslint-disable-line no-unused-vars + var hotCurrentModuleData = {}; + var hotCurrentChildModule; // eslint-disable-line no-unused-vars + var hotCurrentParents = []; // eslint-disable-line no-unused-vars + var hotCurrentParentsTemp = []; // eslint-disable-line no-unused-vars + + function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars + var me = installedModules[moduleId]; + if(!me) return $require$; + var fn = function(request) { + if(me.hot.active) { + if(installedModules[request]) { + if(installedModules[request].parents.indexOf(moduleId) < 0) + installedModules[request].parents.push(moduleId); + } else { + hotCurrentParents = [moduleId]; + hotCurrentChildModule = request; + } + if(me.children.indexOf(request) < 0) + me.children.push(request); + } else { + console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId); + hotCurrentParents = []; + } + return $require$(request); + }; + var ObjectFactory = function ObjectFactory(name) { + return { + configurable: true, + enumerable: true, + get: function() { + return $require$[name]; + }, + set: function(value) { + $require$[name] = value; + } + }; + }; + for(var name in $require$) { + if(Object.prototype.hasOwnProperty.call($require$, name) && name !== "e") { + Object.defineProperty(fn, name, ObjectFactory(name)); + } + } + fn.e = function(chunkId) { + if(hotStatus === "ready") + hotSetStatus("prepare"); + hotChunksLoading++; + return $require$.e(chunkId).then(finishChunkLoading, function(err) { + finishChunkLoading(); + throw err; + }); + + function finishChunkLoading() { + hotChunksLoading--; + if(hotStatus === "prepare") { + if(!hotWaitingFilesMap[chunkId]) { + hotEnsureUpdateChunk(chunkId); + } + if(hotChunksLoading === 0 && hotWaitingFiles === 0) { + hotUpdateDownloaded(); + } + } + } + }; + return fn; + } + + function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars + var hot = { + // private stuff + _acceptedDependencies: {}, + _declinedDependencies: {}, + _selfAccepted: false, + _selfDeclined: false, + _disposeHandlers: [], + _main: hotCurrentChildModule !== moduleId, + + // Module API + active: true, + accept: function(dep, callback) { + if(typeof dep === "undefined") + hot._selfAccepted = true; + else if(typeof dep === "function") + hot._selfAccepted = dep; + else if(typeof dep === "object") + for(var i = 0; i < dep.length; i++) + hot._acceptedDependencies[dep[i]] = callback || function() {}; + else + hot._acceptedDependencies[dep] = callback || function() {}; + }, + decline: function(dep) { + if(typeof dep === "undefined") + hot._selfDeclined = true; + else if(typeof dep === "object") + for(var i = 0; i < dep.length; i++) + hot._declinedDependencies[dep[i]] = true; + else + hot._declinedDependencies[dep] = true; + }, + dispose: function(callback) { + hot._disposeHandlers.push(callback); + }, + addDisposeHandler: function(callback) { + hot._disposeHandlers.push(callback); + }, + removeDisposeHandler: function(callback) { + var idx = hot._disposeHandlers.indexOf(callback); + if(idx >= 0) hot._disposeHandlers.splice(idx, 1); + }, + + // Management API + check: hotCheck, + apply: hotApply, + status: function(l) { + if(!l) return hotStatus; + hotStatusHandlers.push(l); + }, + addStatusHandler: function(l) { + hotStatusHandlers.push(l); + }, + removeStatusHandler: function(l) { + var idx = hotStatusHandlers.indexOf(l); + if(idx >= 0) hotStatusHandlers.splice(idx, 1); + }, + + //inherit from previous dispose call + data: hotCurrentModuleData[moduleId] + }; + hotCurrentChildModule = undefined; + return hot; + } + + var hotStatusHandlers = []; + var hotStatus = "idle"; + + function hotSetStatus(newStatus) { + hotStatus = newStatus; + for(var i = 0; i < hotStatusHandlers.length; i++) + hotStatusHandlers[i].call(null, newStatus); + } + + // while downloading + var hotWaitingFiles = 0; + var hotChunksLoading = 0; + var hotWaitingFilesMap = {}; + var hotRequestedFilesMap = {}; + var hotAvailableFilesMap = {}; + var hotDeferred; + + // The update info + var hotUpdate, hotUpdateNewHash; + + function toModuleId(id) { + var isNumber = (+id) + "" === id; + return isNumber ? +id : id; + } + + function hotCheck(apply) { + if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status"); + hotApplyOnUpdate = apply; + hotSetStatus("check"); + return hotDownloadManifest().then(function(update) { + if(!update) { + hotSetStatus("idle"); + return null; + } + hotRequestedFilesMap = {}; + hotWaitingFilesMap = {}; + hotAvailableFilesMap = update.c; + hotUpdateNewHash = update.h; + + hotSetStatus("prepare"); + var promise = new Promise(function(resolve, reject) { + hotDeferred = { + resolve: resolve, + reject: reject + }; + }); + hotUpdate = {}; + /*foreachInstalledChunks*/ + { // eslint-disable-line no-lone-blocks + /*globals chunkId */ + hotEnsureUpdateChunk(chunkId); + } + if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) { + hotUpdateDownloaded(); + } + return promise; + }); + } + + function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars + if(!hotAvailableFilesMap[chunkId] || !hotRequestedFilesMap[chunkId]) + return; + hotRequestedFilesMap[chunkId] = false; + for(var moduleId in moreModules) { + if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) { + hotUpdate[moduleId] = moreModules[moduleId]; + } + } + if(--hotWaitingFiles === 0 && hotChunksLoading === 0) { + hotUpdateDownloaded(); + } + } + + function hotEnsureUpdateChunk(chunkId) { + if(!hotAvailableFilesMap[chunkId]) { + hotWaitingFilesMap[chunkId] = true; + } else { + hotRequestedFilesMap[chunkId] = true; + hotWaitingFiles++; + hotDownloadUpdateChunk(chunkId); + } + } + + function hotUpdateDownloaded() { + hotSetStatus("ready"); + var deferred = hotDeferred; + hotDeferred = null; + if(!deferred) return; + if(hotApplyOnUpdate) { + hotApply(hotApplyOnUpdate).then(function(result) { + deferred.resolve(result); + }, function(err) { + deferred.reject(err); + }); + } else { + var outdatedModules = []; + for(var id in hotUpdate) { + if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) { + outdatedModules.push(toModuleId(id)); + } + } + deferred.resolve(outdatedModules); + } + } + + function hotApply(options) { + if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status"); + options = options || {}; + + var cb; + var i; + var j; + var module; + var moduleId; + + function getAffectedStuff(updateModuleId) { + var outdatedModules = [updateModuleId]; + var outdatedDependencies = {}; + + var queue = outdatedModules.slice().map(function(id) { + return { + chain: [id], + id: id + }; + }); + while(queue.length > 0) { + var queueItem = queue.pop(); + var moduleId = queueItem.id; + var chain = queueItem.chain; + module = installedModules[moduleId]; + if(!module || module.hot._selfAccepted) + continue; + if(module.hot._selfDeclined) { + return { + type: "self-declined", + chain: chain, + moduleId: moduleId + }; + } + if(module.hot._main) { + return { + type: "unaccepted", + chain: chain, + moduleId: moduleId + }; + } + for(var i = 0; i < module.parents.length; i++) { + var parentId = module.parents[i]; + var parent = installedModules[parentId]; + if(!parent) continue; + if(parent.hot._declinedDependencies[moduleId]) { + return { + type: "declined", + chain: chain.concat([parentId]), + moduleId: moduleId, + parentId: parentId + }; + } + if(outdatedModules.indexOf(parentId) >= 0) continue; + if(parent.hot._acceptedDependencies[moduleId]) { + if(!outdatedDependencies[parentId]) + outdatedDependencies[parentId] = []; + addAllToSet(outdatedDependencies[parentId], [moduleId]); + continue; + } + delete outdatedDependencies[parentId]; + outdatedModules.push(parentId); + queue.push({ + chain: chain.concat([parentId]), + id: parentId + }); + } + } + + return { + type: "accepted", + moduleId: updateModuleId, + outdatedModules: outdatedModules, + outdatedDependencies: outdatedDependencies + }; + } + + function addAllToSet(a, b) { + for(var i = 0; i < b.length; i++) { + var item = b[i]; + if(a.indexOf(item) < 0) + a.push(item); + } + } + + // at begin all updates modules are outdated + // the "outdated" status can propagate to parents if they don't accept the children + var outdatedDependencies = {}; + var outdatedModules = []; + var appliedUpdate = {}; + + var warnUnexpectedRequire = function warnUnexpectedRequire() { + console.warn("[HMR] unexpected require(" + result.moduleId + ") to disposed module"); + }; + + for(var id in hotUpdate) { + if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) { + moduleId = toModuleId(id); + var result; + if(hotUpdate[id]) { + result = getAffectedStuff(moduleId); + } else { + result = { + type: "disposed", + moduleId: id + }; + } + var abortError = false; + var doApply = false; + var doDispose = false; + var chainInfo = ""; + if(result.chain) { + chainInfo = "\nUpdate propagation: " + result.chain.join(" -> "); + } + switch(result.type) { + case "self-declined": + if(options.onDeclined) + options.onDeclined(result); + if(!options.ignoreDeclined) + abortError = new Error("Aborted because of self decline: " + result.moduleId + chainInfo); + break; + case "declined": + if(options.onDeclined) + options.onDeclined(result); + if(!options.ignoreDeclined) + abortError = new Error("Aborted because of declined dependency: " + result.moduleId + " in " + result.parentId + chainInfo); + break; + case "unaccepted": + if(options.onUnaccepted) + options.onUnaccepted(result); + if(!options.ignoreUnaccepted) + abortError = new Error("Aborted because " + moduleId + " is not accepted" + chainInfo); + break; + case "accepted": + if(options.onAccepted) + options.onAccepted(result); + doApply = true; + break; + case "disposed": + if(options.onDisposed) + options.onDisposed(result); + doDispose = true; + break; + default: + throw new Error("Unexception type " + result.type); + } + if(abortError) { + hotSetStatus("abort"); + return Promise.reject(abortError); + } + if(doApply) { + appliedUpdate[moduleId] = hotUpdate[moduleId]; + addAllToSet(outdatedModules, result.outdatedModules); + for(moduleId in result.outdatedDependencies) { + if(Object.prototype.hasOwnProperty.call(result.outdatedDependencies, moduleId)) { + if(!outdatedDependencies[moduleId]) + outdatedDependencies[moduleId] = []; + addAllToSet(outdatedDependencies[moduleId], result.outdatedDependencies[moduleId]); + } + } + } + if(doDispose) { + addAllToSet(outdatedModules, [result.moduleId]); + appliedUpdate[moduleId] = warnUnexpectedRequire; + } + } + } + + // Store self accepted outdated modules to require them later by the module system + var outdatedSelfAcceptedModules = []; + for(i = 0; i < outdatedModules.length; i++) { + moduleId = outdatedModules[i]; + if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted) + outdatedSelfAcceptedModules.push({ + module: moduleId, + errorHandler: installedModules[moduleId].hot._selfAccepted + }); + } + + // Now in "dispose" phase + hotSetStatus("dispose"); + Object.keys(hotAvailableFilesMap).forEach(function(chunkId) { + if(hotAvailableFilesMap[chunkId] === false) { + hotDisposeChunk(chunkId); + } + }); + + var idx; + var queue = outdatedModules.slice(); + while(queue.length > 0) { + moduleId = queue.pop(); + module = installedModules[moduleId]; + if(!module) continue; + + var data = {}; + + // Call dispose handlers + var disposeHandlers = module.hot._disposeHandlers; + for(j = 0; j < disposeHandlers.length; j++) { + cb = disposeHandlers[j]; + cb(data); + } + hotCurrentModuleData[moduleId] = data; + + // disable module (this disables requires from this module) + module.hot.active = false; + + // remove module from cache + delete installedModules[moduleId]; + + // remove "parents" references from all children + for(j = 0; j < module.children.length; j++) { + var child = installedModules[module.children[j]]; + if(!child) continue; + idx = child.parents.indexOf(moduleId); + if(idx >= 0) { + child.parents.splice(idx, 1); + } + } + } + + // remove outdated dependency from module children + var dependency; + var moduleOutdatedDependencies; + for(moduleId in outdatedDependencies) { + if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) { + module = installedModules[moduleId]; + if(module) { + moduleOutdatedDependencies = outdatedDependencies[moduleId]; + for(j = 0; j < moduleOutdatedDependencies.length; j++) { + dependency = moduleOutdatedDependencies[j]; + idx = module.children.indexOf(dependency); + if(idx >= 0) module.children.splice(idx, 1); + } + } + } + } + + // Not in "apply" phase + hotSetStatus("apply"); + + hotCurrentHash = hotUpdateNewHash; + + // insert new code + for(moduleId in appliedUpdate) { + if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) { + modules[moduleId] = appliedUpdate[moduleId]; + } + } + + // call accept handlers + var error = null; + for(moduleId in outdatedDependencies) { + if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) { + module = installedModules[moduleId]; + moduleOutdatedDependencies = outdatedDependencies[moduleId]; + var callbacks = []; + for(i = 0; i < moduleOutdatedDependencies.length; i++) { + dependency = moduleOutdatedDependencies[i]; + cb = module.hot._acceptedDependencies[dependency]; + if(callbacks.indexOf(cb) >= 0) continue; + callbacks.push(cb); + } + for(i = 0; i < callbacks.length; i++) { + cb = callbacks[i]; + try { + cb(moduleOutdatedDependencies); + } catch(err) { + if(options.onErrored) { + options.onErrored({ + type: "accept-errored", + moduleId: moduleId, + dependencyId: moduleOutdatedDependencies[i], + error: err + }); + } + if(!options.ignoreErrored) { + if(!error) + error = err; + } + } + } + } + } + + // Load self accepted modules + for(i = 0; i < outdatedSelfAcceptedModules.length; i++) { + var item = outdatedSelfAcceptedModules[i]; + moduleId = item.module; + hotCurrentParents = [moduleId]; + try { + $require$(moduleId); + } catch(err) { + if(typeof item.errorHandler === "function") { + try { + item.errorHandler(err); + } catch(err2) { + if(options.onErrored) { + options.onErrored({ + type: "self-accept-error-handler-errored", + moduleId: moduleId, + error: err2, + orginalError: err + }); + } + if(!options.ignoreErrored) { + if(!error) + error = err2; + } + if(!error) + error = err; + } + } else { + if(options.onErrored) { + options.onErrored({ + type: "self-accept-errored", + moduleId: moduleId, + error: err + }); + } + if(!options.ignoreErrored) { + if(!error) + error = err; + } + } + } + } + + // handle errors in accept handlers and self accepted module load + if(error) { + hotSetStatus("fail"); + return Promise.reject(error); + } + + hotSetStatus("idle"); + return Promise.resolve(outdatedModules); + } +}; diff --git a/node_modules/webpack/lib/HotModuleReplacementPlugin.js b/node_modules/webpack/lib/HotModuleReplacementPlugin.js new file mode 100644 index 000000000..640e05e9d --- /dev/null +++ b/node_modules/webpack/lib/HotModuleReplacementPlugin.js @@ -0,0 +1,259 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +var Template = require("./Template"); +var ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDependency"); +var ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency"); +var RawSource = require("webpack-sources").RawSource; +var ConstDependency = require("./dependencies/ConstDependency"); +var NullFactory = require("./NullFactory"); +const ParserHelpers = require("./ParserHelpers"); + +function HotModuleReplacementPlugin(options) { + options = options || {}; + this.multiStep = options.multiStep; + this.fullBuildTimeout = options.fullBuildTimeout || 200; +} +module.exports = HotModuleReplacementPlugin; + +HotModuleReplacementPlugin.prototype.apply = function(compiler) { + var multiStep = this.multiStep; + var fullBuildTimeout = this.fullBuildTimeout; + var hotUpdateChunkFilename = compiler.options.output.hotUpdateChunkFilename; + var hotUpdateMainFilename = compiler.options.output.hotUpdateMainFilename; + compiler.plugin("compilation", function(compilation, params) { + var hotUpdateChunkTemplate = compilation.hotUpdateChunkTemplate; + if(!hotUpdateChunkTemplate) return; + + var normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + compilation.dependencyFactories.set(ModuleHotAcceptDependency, normalModuleFactory); + compilation.dependencyTemplates.set(ModuleHotAcceptDependency, new ModuleHotAcceptDependency.Template()); + + compilation.dependencyFactories.set(ModuleHotDeclineDependency, normalModuleFactory); + compilation.dependencyTemplates.set(ModuleHotDeclineDependency, new ModuleHotDeclineDependency.Template()); + + compilation.plugin("record", function(compilation, records) { + if(records.hash === this.hash) return; + records.hash = compilation.hash; + records.moduleHashs = {}; + this.modules.forEach(function(module) { + var identifier = module.identifier(); + var hash = require("crypto").createHash("md5"); + module.updateHash(hash); + records.moduleHashs[identifier] = hash.digest("hex"); + }); + records.chunkHashs = {}; + this.chunks.forEach(function(chunk) { + records.chunkHashs[chunk.id] = chunk.hash; + }); + records.chunkModuleIds = {}; + this.chunks.forEach(function(chunk) { + records.chunkModuleIds[chunk.id] = chunk.modules.map(function(m) { + return m.id; + }); + }); + }); + var initialPass = false; + var recompilation = false; + compilation.plugin("after-hash", function() { + var records = this.records; + if(!records) { + initialPass = true; + return; + } + if(!records.hash) + initialPass = true; + var preHash = records.preHash || "x"; + var prepreHash = records.prepreHash || "x"; + if(preHash === this.hash) { + recompilation = true; + this.modifyHash(prepreHash); + return; + } + records.prepreHash = records.hash || "x"; + records.preHash = this.hash; + this.modifyHash(records.prepreHash); + }); + compilation.plugin("should-generate-chunk-assets", function() { + if(multiStep && !recompilation && !initialPass) + return false; + }); + compilation.plugin("need-additional-pass", function() { + if(multiStep && !recompilation && !initialPass) + return true; + }); + compiler.plugin("additional-pass", function(callback) { + if(multiStep) + return setTimeout(callback, fullBuildTimeout); + return callback(); + }); + compilation.plugin("additional-chunk-assets", function() { + var records = this.records; + if(records.hash === this.hash) return; + if(!records.moduleHashs || !records.chunkHashs || !records.chunkModuleIds) return; + this.modules.forEach(function(module) { + var identifier = module.identifier(); + var hash = require("crypto").createHash("md5"); + module.updateHash(hash); + hash = hash.digest("hex"); + module.hotUpdate = records.moduleHashs[identifier] !== hash; + }); + var hotUpdateMainContent = { + h: this.hash, + c: {} + }; + Object.keys(records.chunkHashs).forEach(function(chunkId) { + chunkId = isNaN(+chunkId) ? chunkId : +chunkId; + var currentChunk = this.chunks.find(chunk => chunk.id === chunkId); + if(currentChunk) { + var newModules = currentChunk.modules.filter(function(module) { + return module.hotUpdate; + }); + var allModules = {}; + currentChunk.modules.forEach(function(module) { + allModules[module.id] = true; + }); + var removedModules = records.chunkModuleIds[chunkId].filter(function(id) { + return !allModules[id]; + }); + if(newModules.length > 0 || removedModules.length > 0) { + var source = hotUpdateChunkTemplate.render(chunkId, newModules, removedModules, this.hash, this.moduleTemplate, this.dependencyTemplates); + var filename = this.getPath(hotUpdateChunkFilename, { + hash: records.hash, + chunk: currentChunk + }); + this.additionalChunkAssets.push(filename); + this.assets[filename] = source; + hotUpdateMainContent.c[chunkId] = true; + currentChunk.files.push(filename); + this.applyPlugins("chunk-asset", currentChunk, filename); + } + } else { + hotUpdateMainContent.c[chunkId] = false; + } + }, this); + var source = new RawSource(JSON.stringify(hotUpdateMainContent)); + var filename = this.getPath(hotUpdateMainFilename, { + hash: records.hash + }); + this.assets[filename] = source; + }); + + compilation.mainTemplate.plugin("hash", function(hash) { + hash.update("HotMainTemplateDecorator"); + }); + + compilation.mainTemplate.plugin("module-require", function(_, chunk, hash, varModuleId) { + return "hotCreateRequire(" + varModuleId + ")"; + }); + + compilation.mainTemplate.plugin("require-extensions", function(source) { + var buf = [source]; + buf.push(""); + buf.push("// __webpack_hash__"); + buf.push(this.requireFn + ".h = function() { return hotCurrentHash; };"); + return this.asString(buf); + }); + + compilation.mainTemplate.plugin("bootstrap", function(source, chunk, hash) { + source = this.applyPluginsWaterfall("hot-bootstrap", source, chunk, hash); + return this.asString([ + source, + "", + hotInitCode + .replace(/\$require\$/g, this.requireFn) + .replace(/\$hash\$/g, JSON.stringify(hash)) + .replace(/\/\*foreachInstalledChunks\*\//g, chunk.chunks.length > 0 ? "for(var chunkId in installedChunks)" : "var chunkId = " + JSON.stringify(chunk.id) + ";") + ]); + }); + + compilation.mainTemplate.plugin("global-hash", function() { + return true; + }); + + compilation.mainTemplate.plugin("current-hash", function(_, length) { + if(isFinite(length)) + return "hotCurrentHash.substr(0, " + length + ")"; + else + return "hotCurrentHash"; + }); + + compilation.mainTemplate.plugin("module-obj", function(source, chunk, hash, varModuleId) { + return this.asString([ + source + ",", + "hot: hotCreateModule(" + varModuleId + "),", + "parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),", + "children: []" + ]); + }); + + params.normalModuleFactory.plugin("parser", function(parser, parserOptions) { + parser.plugin("expression __webpack_hash__", ParserHelpers.toConstantDependency("__webpack_require__.h()")); + parser.plugin("evaluate typeof __webpack_hash__", ParserHelpers.evaluateToString("string")); + parser.plugin("evaluate Identifier module.hot", function(expr) { + return ParserHelpers.evaluateToBoolean(!!this.state.compilation.hotUpdateChunkTemplate)(expr); + }); + parser.plugin("call module.hot.accept", function(expr) { + if(!this.state.compilation.hotUpdateChunkTemplate) return false; + if(expr.arguments.length >= 1) { + var arg = this.evaluateExpression(expr.arguments[0]); + var params = [], + requests = []; + if(arg.isString()) { + params = [arg]; + } else if(arg.isArray()) { + params = arg.items.filter(function(param) { + return param.isString(); + }); + } + if(params.length > 0) { + params.forEach(function(param, idx) { + var request = param.string; + var dep = new ModuleHotAcceptDependency(request, param.range); + dep.optional = true; + dep.loc = Object.create(expr.loc); + dep.loc.index = idx; + this.state.module.addDependency(dep); + requests.push(request); + }.bind(this)); + if(expr.arguments.length > 1) + this.applyPluginsBailResult("hot accept callback", expr.arguments[1], requests); + else + this.applyPluginsBailResult("hot accept without callback", expr, requests); + } + } + }); + parser.plugin("call module.hot.decline", function(expr) { + if(!this.state.compilation.hotUpdateChunkTemplate) return false; + if(expr.arguments.length === 1) { + var arg = this.evaluateExpression(expr.arguments[0]); + var params = []; + if(arg.isString()) { + params = [arg]; + } else if(arg.isArray()) { + params = arg.items.filter(function(param) { + return param.isString(); + }); + } + params.forEach(function(param, idx) { + var dep = new ModuleHotDeclineDependency(param.string, param.range); + dep.optional = true; + dep.loc = Object.create(expr.loc); + dep.loc.index = idx; + this.state.module.addDependency(dep); + }.bind(this)); + } + }); + parser.plugin("expression module.hot", ParserHelpers.skipTraversal); + }); + }); + +}; + +var hotInitCode = Template.getFunctionContent(require("./HotModuleReplacement.runtime.js")); diff --git a/node_modules/webpack/lib/HotUpdateChunkTemplate.js b/node_modules/webpack/lib/HotUpdateChunkTemplate.js new file mode 100644 index 000000000..89cda0b69 --- /dev/null +++ b/node_modules/webpack/lib/HotUpdateChunkTemplate.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Template = require("./Template"); + +module.exports = class HotUpdateChunkTemplate extends Template { + constructor(outputOptions) { + super(outputOptions); + } + + render(id, modules, removedModules, hash, moduleTemplate, dependencyTemplates) { + const modulesSource = this.renderChunkModules({ + id: id, + modules: modules, + removedModules: removedModules + }, moduleTemplate, dependencyTemplates); + const core = this.applyPluginsWaterfall("modules", modulesSource, modules, removedModules, moduleTemplate, dependencyTemplates); + const source = this.applyPluginsWaterfall("render", core, modules, removedModules, hash, id, moduleTemplate, dependencyTemplates); + return source; + } + + updateHash(hash) { + hash.update("HotUpdateChunkTemplate"); + hash.update("1"); + this.applyPlugins("hash", hash); + } +}; diff --git a/node_modules/webpack/lib/IgnorePlugin.js b/node_modules/webpack/lib/IgnorePlugin.js new file mode 100644 index 000000000..9464f5746 --- /dev/null +++ b/node_modules/webpack/lib/IgnorePlugin.js @@ -0,0 +1,69 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class IgnorePlugin { + constructor(resourceRegExp, contextRegExp) { + this.resourceRegExp = resourceRegExp; + this.contextRegExp = contextRegExp; + + this.checkIgnore = this.checkIgnore.bind(this); + } + + /* + * Only returns true if a "resourceRegExp" exists + * and the resource given matches the regexp. + */ + checkResouce(resource) { + if(!this.resourceRegExp) { + return false; + } + return this.resourceRegExp.test(resource); + } + + /* + * Returns true if contextRegExp does not exist + * or if context matches the given regexp. + */ + checkContext(context) { + if(!this.contextRegExp) { + return true; + } + return this.contextRegExp.test(context); + } + + /* + * Returns true if result should be ignored. + * false if it shouldn't. + * + * Not that if "contextRegExp" is given, both the "resourceRegExp" + * and "contextRegExp" have to match. + */ + checkResult(result) { + if(!result) { + return true; + } + return this.checkResouce(result.request) && this.checkContext(result.context); + } + + checkIgnore(result, callback) { + // check if result is ignored + if(this.checkResult(result)) { + return callback(); + } + return callback(null, result); + } + + apply(compiler) { + compiler.plugin("normal-module-factory", (nmf) => { + nmf.plugin("before-resolve", this.checkIgnore); + }); + compiler.plugin("context-module-factory", (cmf) => { + cmf.plugin("before-resolve", this.checkIgnore); + }); + } +} + +module.exports = IgnorePlugin; diff --git a/node_modules/webpack/lib/JsonpChunkTemplatePlugin.js b/node_modules/webpack/lib/JsonpChunkTemplatePlugin.js new file mode 100644 index 000000000..ceeb95406 --- /dev/null +++ b/node_modules/webpack/lib/JsonpChunkTemplatePlugin.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class JsonpChunkTemplatePlugin { + apply(chunkTemplate) { + chunkTemplate.plugin("render", function(modules, chunk) { + const jsonpFunction = this.outputOptions.jsonpFunction; + const source = new ConcatSource(); + source.add(`${jsonpFunction}(${JSON.stringify(chunk.ids)},`); + source.add(modules); + const entries = [chunk.entryModule].filter(Boolean).map(m => m.id); + if(entries.length > 0) { + source.add(`,${JSON.stringify(entries)}`); + } + source.add(")"); + return source; + }); + chunkTemplate.plugin("hash", function(hash) { + hash.update("JsonpChunkTemplatePlugin"); + hash.update("3"); + hash.update(`${this.outputOptions.jsonpFunction}`); + hash.update(`${this.outputOptions.library}`); + }); + } +} +module.exports = JsonpChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/JsonpExportMainTemplatePlugin.js b/node_modules/webpack/lib/JsonpExportMainTemplatePlugin.js new file mode 100644 index 000000000..8bbab2e04 --- /dev/null +++ b/node_modules/webpack/lib/JsonpExportMainTemplatePlugin.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class JsonpExportMainTemplatePlugin { + constructor(name) { + this.name = name; + } + + apply(compilation) { + const mainTemplate = compilation.mainTemplate; + + compilation.templatesPlugin("render-with-entry", (source, chunk, hash) => { + const name = mainTemplate.applyPluginsWaterfall("asset-path", this.name || "", { + hash: hash, + chunk: chunk + }); + return new ConcatSource(`${name}(`, source, ");"); + }); + + mainTemplate.plugin("global-hash-paths", paths => { + if(this.name) paths.push(this.name); + return paths; + }); + + mainTemplate.plugin("hash", hash => { + hash.update("jsonp export"); + hash.update(`${this.name}`); + }); + } +} + +module.exports = JsonpExportMainTemplatePlugin; diff --git a/node_modules/webpack/lib/JsonpHotUpdateChunkTemplatePlugin.js b/node_modules/webpack/lib/JsonpHotUpdateChunkTemplatePlugin.js new file mode 100644 index 000000000..407110e93 --- /dev/null +++ b/node_modules/webpack/lib/JsonpHotUpdateChunkTemplatePlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class JsonpHotUpdateChunkTemplatePlugin { + apply(hotUpdateChunkTemplate) { + hotUpdateChunkTemplate.plugin("render", function(modulesSource, modules, removedModules, hash, id) { + const source = new ConcatSource(); + source.add(`${this.outputOptions.hotUpdateFunction}(${JSON.stringify(id)},`); + source.add(modulesSource); + source.add(")"); + return source; + }); + hotUpdateChunkTemplate.plugin("hash", function(hash) { + hash.update("JsonpHotUpdateChunkTemplatePlugin"); + hash.update("3"); + hash.update(`${this.outputOptions.hotUpdateFunction}`); + hash.update(`${this.outputOptions.library}`); + }); + } +} + +module.exports = JsonpHotUpdateChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/JsonpMainTemplate.runtime.js b/node_modules/webpack/lib/JsonpMainTemplate.runtime.js new file mode 100644 index 000000000..dc177376e --- /dev/null +++ b/node_modules/webpack/lib/JsonpMainTemplate.runtime.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/*globals hotAddUpdateChunk parentHotUpdateCallback document XMLHttpRequest $require$ $hotChunkFilename$ $hotMainFilename$ */ +module.exports = function() { + function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars + hotAddUpdateChunk(chunkId, moreModules); + if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules); + } //$semicolon + + function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars + var head = document.getElementsByTagName("head")[0]; + var script = document.createElement("script"); + script.type = "text/javascript"; + script.charset = "utf-8"; + script.src = $require$.p + $hotChunkFilename$; + head.appendChild(script); + } + + function hotDownloadManifest() { // eslint-disable-line no-unused-vars + return new Promise(function(resolve, reject) { + if(typeof XMLHttpRequest === "undefined") + return reject(new Error("No browser support")); + try { + var request = new XMLHttpRequest(); + var requestPath = $require$.p + $hotMainFilename$; + request.open("GET", requestPath, true); + request.timeout = 10000; + request.send(null); + } catch(err) { + return reject(err); + } + request.onreadystatechange = function() { + if(request.readyState !== 4) return; + if(request.status === 0) { + // timeout + reject(new Error("Manifest request to " + requestPath + " timed out.")); + } else if(request.status === 404) { + // no update available + resolve(); + } else if(request.status !== 200 && request.status !== 304) { + // other failure + reject(new Error("Manifest request to " + requestPath + " failed.")); + } else { + // success + try { + var update = JSON.parse(request.responseText); + } catch(e) { + reject(e); + return; + } + resolve(update); + } + }; + }); + } +}; diff --git a/node_modules/webpack/lib/JsonpMainTemplatePlugin.js b/node_modules/webpack/lib/JsonpMainTemplatePlugin.js new file mode 100644 index 000000000..8034ca5d5 --- /dev/null +++ b/node_modules/webpack/lib/JsonpMainTemplatePlugin.js @@ -0,0 +1,208 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Template = require("./Template"); + +class JsonpMainTemplatePlugin { + + apply(mainTemplate) { + mainTemplate.plugin("local-vars", function(source, chunk) { + if(chunk.chunks.length > 0) { + return this.asString([ + source, + "", + "// objects to store loaded and loading chunks", + "var installedChunks = {", + this.indent( + chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(",\n") + ), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("jsonp-script", function(_, chunk, hash) { + const chunkFilename = this.outputOptions.chunkFilename; + const chunkMaps = chunk.getChunkMaps(); + const crossOriginLoading = this.outputOptions.crossOriginLoading; + const chunkLoadTimeout = this.outputOptions.chunkLoadTimeout || 120000; + const scriptSrcPath = this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), { + hash: `" + ${this.renderCurrentHashCode(hash)} + "`, + hashWithLength: length => `" + ${this.renderCurrentHashCode(hash, length)} + "`, + chunk: { + id: "\" + chunkId + \"", + hash: `" + ${JSON.stringify(chunkMaps.hash)}[chunkId] + "`, + hashWithLength(length) { + const shortChunkHashMap = Object.create(null); + Object.keys(chunkMaps.hash).forEach(chunkId => { + if(typeof chunkMaps.hash[chunkId] === "string") + shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(0, length); + }); + return `" + ${JSON.stringify(shortChunkHashMap)}[chunkId] + "`; + }, + name: `" + (${JSON.stringify(chunkMaps.name)}[chunkId]||chunkId) + "` + } + }); + return this.asString([ + "var script = document.createElement('script');", + "script.type = 'text/javascript';", + "script.charset = 'utf-8';", + "script.async = true;", + `script.timeout = ${chunkLoadTimeout};`, + crossOriginLoading ? `script.crossOrigin = ${JSON.stringify(crossOriginLoading)};` : "", + `if (${this.requireFn}.nc) {`, + this.indent(`script.setAttribute("nonce", ${this.requireFn}.nc);`), + "}", + `script.src = ${this.requireFn}.p + ${scriptSrcPath};`, + `var timeout = setTimeout(onScriptComplete, ${chunkLoadTimeout});`, + "script.onerror = script.onload = onScriptComplete;", + "function onScriptComplete() {", + this.indent([ + "// avoid mem leaks in IE.", + "script.onerror = script.onload = null;", + "clearTimeout(timeout);", + "var chunk = installedChunks[chunkId];", + "if(chunk !== 0) {", + this.indent([ + "if(chunk) {", + this.indent("chunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));"), + "}", + "installedChunks[chunkId] = undefined;" + ]), + "}" + ]), + "};", + ]); + }); + mainTemplate.plugin("require-ensure", function(_, chunk, hash) { + return this.asString([ + "if(installedChunks[chunkId] === 0) {", + this.indent([ + "return Promise.resolve();" + ]), + "}", + "", + "// a Promise means \"currently loading\".", + "if(installedChunks[chunkId]) {", + this.indent([ + "return installedChunks[chunkId][2];" + ]), + "}", + "", + "// setup Promise in chunk cache", + "var promise = new Promise(function(resolve, reject) {", + this.indent([ + "installedChunks[chunkId] = [resolve, reject];" + ]), + "});", + "installedChunks[chunkId][2] = promise;", + "", + "// start chunk loading", + "var head = document.getElementsByTagName('head')[0];", + this.applyPluginsWaterfall("jsonp-script", "", chunk, hash), + "head.appendChild(script);", + "", + "return promise;" + ]); + }); + mainTemplate.plugin("require-extensions", function(source, chunk) { + if(chunk.chunks.length === 0) return source; + + return this.asString([ + source, + "", + "// on error function for async loading", + `${this.requireFn}.oe = function(err) { console.error(err); throw err; };` + ]); + }); + mainTemplate.plugin("bootstrap", function(source, chunk, hash) { + if(chunk.chunks.length > 0) { + var jsonpFunction = this.outputOptions.jsonpFunction; + return this.asString([ + source, + "", + "// install a JSONP callback for chunk loading", + `var parentJsonpFunction = window[${JSON.stringify(jsonpFunction)}];`, + `window[${JSON.stringify(jsonpFunction)}] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {`, + this.indent([ + "// add \"moreModules\" to the modules object,", + "// then flag all \"chunkIds\" as loaded and fire callback", + "var moduleId, chunkId, i = 0, resolves = [], result;", + "for(;i < chunkIds.length; i++) {", + this.indent([ + "chunkId = chunkIds[i];", + "if(installedChunks[chunkId]) {", + this.indent("resolves.push(installedChunks[chunkId][0]);"), + "}", + "installedChunks[chunkId] = 0;" + ]), + "}", + "for(moduleId in moreModules) {", + this.indent([ + "if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {", + this.indent(this.renderAddModule(hash, chunk, "moduleId", "moreModules[moduleId]")), + "}" + ]), + "}", + "if(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);", + "while(resolves.length) {", + this.indent("resolves.shift()();"), + "}", + this.entryPointInChildren(chunk) ? [ + "if(executeModules) {", + this.indent([ + "for(i=0; i < executeModules.length; i++) {", + this.indent(`result = ${this.requireFn}(${this.requireFn}.s = executeModules[i]);`), + "}" + ]), + "}", + "return result;", + ] : "" + ]), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("hot-bootstrap", function(source, chunk, hash) { + const hotUpdateChunkFilename = this.outputOptions.hotUpdateChunkFilename; + const hotUpdateMainFilename = this.outputOptions.hotUpdateMainFilename; + const hotUpdateFunction = this.outputOptions.hotUpdateFunction; + const currentHotUpdateChunkFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateChunkFilename), { + hash: `" + ${this.renderCurrentHashCode(hash)} + "`, + hashWithLength: length => `" + ${this.renderCurrentHashCode(hash, length)} + "`, + chunk: { + id: "\" + chunkId + \"" + } + }); + const currentHotUpdateMainFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateMainFilename), { + hash: `" + ${this.renderCurrentHashCode(hash)} + "`, + hashWithLength: length => `" + ${this.renderCurrentHashCode(hash, length)} + "` + }); + const runtimeSource = Template.getFunctionContent(require("./JsonpMainTemplate.runtime.js")) + .replace(/\/\/\$semicolon/g, ";") + .replace(/\$require\$/g, this.requireFn) + .replace(/\$hotMainFilename\$/g, currentHotUpdateMainFilename) + .replace(/\$hotChunkFilename\$/g, currentHotUpdateChunkFilename) + .replace(/\$hash\$/g, JSON.stringify(hash)); + return `${source} +function hotDisposeChunk(chunkId) { + delete installedChunks[chunkId]; +} +var parentHotUpdateCallback = this[${JSON.stringify(hotUpdateFunction)}]; +this[${JSON.stringify(hotUpdateFunction)}] = ${runtimeSource}`; + }); + mainTemplate.plugin("hash", function(hash) { + hash.update("jsonp"); + hash.update("4"); + hash.update(`${this.outputOptions.filename}`); + hash.update(`${this.outputOptions.chunkFilename}`); + hash.update(`${this.outputOptions.jsonpFunction}`); + hash.update(`${this.outputOptions.hotUpdateFunction}`); + }); + } +} +module.exports = JsonpMainTemplatePlugin; diff --git a/node_modules/webpack/lib/JsonpTemplatePlugin.js b/node_modules/webpack/lib/JsonpTemplatePlugin.js new file mode 100644 index 000000000..a141891f7 --- /dev/null +++ b/node_modules/webpack/lib/JsonpTemplatePlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const JsonpMainTemplatePlugin = require("./JsonpMainTemplatePlugin"); +const JsonpChunkTemplatePlugin = require("./JsonpChunkTemplatePlugin"); +const JsonpHotUpdateChunkTemplatePlugin = require("./JsonpHotUpdateChunkTemplatePlugin"); + +class JsonpTemplatePlugin { + apply(compiler) { + compiler.plugin("this-compilation", (compilation) => { + compilation.mainTemplate.apply(new JsonpMainTemplatePlugin()); + compilation.chunkTemplate.apply(new JsonpChunkTemplatePlugin()); + compilation.hotUpdateChunkTemplate.apply(new JsonpHotUpdateChunkTemplatePlugin()); + }); + } +} + +module.exports = JsonpTemplatePlugin; diff --git a/node_modules/webpack/lib/LibManifestPlugin.js b/node_modules/webpack/lib/LibManifestPlugin.js new file mode 100644 index 000000000..ba6b6d426 --- /dev/null +++ b/node_modules/webpack/lib/LibManifestPlugin.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const asyncLib = require("async"); + +class LibManifestPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("emit", (compilation, callback) => { + asyncLib.forEach(compilation.chunks, (chunk, callback) => { + if(!chunk.isInitial()) { + callback(); + return; + } + const targetPath = compilation.getPath(this.options.path, { + hash: compilation.hash, + chunk + }); + const name = this.options.name && compilation.getPath(this.options.name, { + hash: compilation.hash, + chunk + }); + const manifest = { + name, + type: this.options.type, + content: chunk.modules.reduce((obj, module) => { + if(module.libIdent) { + const ident = module.libIdent({ + context: this.options.context || compiler.options.context + }); + if(ident) { + obj[ident] = { + id: module.id, + meta: module.meta, + exports: Array.isArray(module.providedExports) ? module.providedExports : undefined + }; + } + } + return obj; + }, {}) + }; + const content = new Buffer(JSON.stringify(manifest, null, 2), "utf8"); //eslint-disable-line + compiler.outputFileSystem.mkdirp(path.dirname(targetPath), err => { + if(err) return callback(err); + compiler.outputFileSystem.writeFile(targetPath, content, callback); + }); + }, callback); + }); + } +} +module.exports = LibManifestPlugin; diff --git a/node_modules/webpack/lib/LibraryTemplatePlugin.js b/node_modules/webpack/lib/LibraryTemplatePlugin.js new file mode 100644 index 000000000..6e389053d --- /dev/null +++ b/node_modules/webpack/lib/LibraryTemplatePlugin.js @@ -0,0 +1,87 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const SetVarMainTemplatePlugin = require("./SetVarMainTemplatePlugin"); + +function accessorToObjectAccess(accessor) { + return accessor.map((a) => { + return `[${JSON.stringify(a)}]`; + }).join(""); +} + +function accessorAccess(base, accessor, joinWith) { + accessor = [].concat(accessor); + return accessor.map((a, idx) => { + a = base ? + base + accessorToObjectAccess(accessor.slice(0, idx + 1)) : + accessor[0] + accessorToObjectAccess(accessor.slice(1, idx + 1)); + if(idx === accessor.length - 1) return a; + if(idx === 0 && typeof base === "undefined") return `${a} = typeof ${a} === "object" ? ${a} : {}`; + return `${a} = ${a} || {}`; + }).join(joinWith || "; "); +} + +class LibraryTemplatePlugin { + + constructor(name, target, umdNamedDefine, auxiliaryComment) { + this.name = name; + this.target = target; + this.umdNamedDefine = umdNamedDefine; + this.auxiliaryComment = auxiliaryComment; + } + + apply(compiler) { + compiler.plugin("this-compilation", (compilation) => { + switch(this.target) { + case "var": + compilation.apply(new SetVarMainTemplatePlugin(`var ${accessorAccess(false, this.name)}`)); + break; + case "assign": + compilation.apply(new SetVarMainTemplatePlugin(accessorAccess(undefined, this.name))); + break; + case "this": + case "window": + case "global": + if(this.name) + compilation.apply(new SetVarMainTemplatePlugin(accessorAccess(this.target, this.name))); + else + compilation.apply(new SetVarMainTemplatePlugin(this.target, true)); + break; + case "commonjs": + if(this.name) + compilation.apply(new SetVarMainTemplatePlugin(accessorAccess("exports", this.name))); + else + compilation.apply(new SetVarMainTemplatePlugin("exports", true)); + break; + case "commonjs2": + case "commonjs-module": + compilation.apply(new SetVarMainTemplatePlugin("module.exports")); + break; + case "amd": + var AmdMainTemplatePlugin = require("./AmdMainTemplatePlugin"); + compilation.apply(new AmdMainTemplatePlugin(this.name)); + break; + case "umd": + case "umd2": + var UmdMainTemplatePlugin = require("./UmdMainTemplatePlugin"); + compilation.apply(new UmdMainTemplatePlugin(this.name, { + optionalAmdExternalAsGlobal: this.target === "umd2", + namedDefine: this.umdNamedDefine, + auxiliaryComment: this.auxiliaryComment + })); + break; + case "jsonp": + var JsonpExportMainTemplatePlugin = require("./JsonpExportMainTemplatePlugin"); + compilation.apply(new JsonpExportMainTemplatePlugin(this.name)); + break; + default: + throw new Error(`${this.target} is not a valid Library target`); + } + }); + } +} + +module.exports = LibraryTemplatePlugin; diff --git a/node_modules/webpack/lib/LoaderOptionsPlugin.js b/node_modules/webpack/lib/LoaderOptionsPlugin.js new file mode 100644 index 000000000..b3d3ef7f4 --- /dev/null +++ b/node_modules/webpack/lib/LoaderOptionsPlugin.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); + +class LoaderOptionsPlugin { + constructor(options) { + if(typeof options !== "object") options = {}; + if(!options.test) options.test = { + test: () => true + }; + this.options = options; + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation) => { + compilation.plugin("normal-module-loader", (context, module) => { + const resource = module.resource; + if(!resource) return; + const i = resource.indexOf("?"); + if(ModuleFilenameHelpers.matchObject(options, i < 0 ? resource : resource.substr(0, i))) { + const filterSet = new Set(["include", "exclude", "test"]); + Object.keys(options) + .filter((key) => !filterSet.has(key)) + .forEach((key) => context[key] = options[key]); + } + }); + }); + } +} + +module.exports = LoaderOptionsPlugin; diff --git a/node_modules/webpack/lib/LoaderTargetPlugin.js b/node_modules/webpack/lib/LoaderTargetPlugin.js new file mode 100644 index 000000000..c7f5f59b4 --- /dev/null +++ b/node_modules/webpack/lib/LoaderTargetPlugin.js @@ -0,0 +1,19 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class LoaderTargetPlugin { + constructor(target) { + this.target = target; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("normal-module-loader", (loaderContext) => loaderContext.target = this.target); + }); + } +} + +module.exports = LoaderTargetPlugin; diff --git a/node_modules/webpack/lib/MainTemplate.js b/node_modules/webpack/lib/MainTemplate.js new file mode 100644 index 000000000..d14883d15 --- /dev/null +++ b/node_modules/webpack/lib/MainTemplate.js @@ -0,0 +1,235 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; +const OriginalSource = require("webpack-sources").OriginalSource; +const PrefixSource = require("webpack-sources").PrefixSource; +const Template = require("./Template"); + +// require function shortcuts: +// __webpack_require__.s = the module id of the entry point +// __webpack_require__.c = the module cache +// __webpack_require__.m = the module functions +// __webpack_require__.p = the bundle public path +// __webpack_require__.i = the identity function used for harmony imports +// __webpack_require__.e = the chunk ensure function +// __webpack_require__.d = the exported propery define getter function +// __webpack_require__.o = Object.prototype.hasOwnProperty.call +// __webpack_require__.n = compatibility get default export +// __webpack_require__.h = the webpack hash +// __webpack_require__.oe = the uncatched error handler for the webpack runtime +// __webpack_require__.nc = the script nonce + +module.exports = class MainTemplate extends Template { + constructor(outputOptions) { + super(outputOptions); + this.plugin("startup", (source, chunk, hash) => { + const buf = []; + if(chunk.entryModule) { + buf.push("// Load entry module and return exports"); + buf.push(`return ${this.renderRequireFunctionForModule(hash, chunk, JSON.stringify(chunk.entryModule.id))}(${this.requireFn}.s = ${JSON.stringify(chunk.entryModule.id)});`); + } + return this.asString(buf); + }); + this.plugin("render", (bootstrapSource, chunk, hash, moduleTemplate, dependencyTemplates) => { + const source = new ConcatSource(); + source.add("/******/ (function(modules) { // webpackBootstrap\n"); + source.add(new PrefixSource("/******/", bootstrapSource)); + source.add("/******/ })\n"); + source.add("/************************************************************************/\n"); + source.add("/******/ ("); + const modules = this.renderChunkModules(chunk, moduleTemplate, dependencyTemplates, "/******/ "); + source.add(this.applyPluginsWaterfall("modules", modules, chunk, hash, moduleTemplate, dependencyTemplates)); + source.add(")"); + return source; + }); + this.plugin("local-vars", (source, chunk, hash) => { + return this.asString([ + source, + "// The module cache", + "var installedModules = {};" + ]); + }); + this.plugin("require", (source, chunk, hash) => { + return this.asString([ + source, + "// Check if module is in cache", + "if(installedModules[moduleId]) {", + this.indent("return installedModules[moduleId].exports;"), + "}", + "// Create a new module (and put it into the cache)", + "var module = installedModules[moduleId] = {", + this.indent(this.applyPluginsWaterfall("module-obj", "", chunk, hash, "moduleId")), + "};", + "", + this.asString(outputOptions.strictModuleExceptionHandling ? [ + "// Execute the module function", + "var threw = true;", + "try {", + this.indent([ + `modules[moduleId].call(module.exports, module, module.exports, ${this.renderRequireFunctionForModule(hash, chunk, "moduleId")});`, + "threw = false;" + ]), + "} finally {", + this.indent([ + "if(threw) delete installedModules[moduleId];" + ]), + "}" + ] : [ + "// Execute the module function", + `modules[moduleId].call(module.exports, module, module.exports, ${this.renderRequireFunctionForModule(hash, chunk, "moduleId")});`, + ]), + "", + "// Flag the module as loaded", + "module.l = true;", + "", + "// Return the exports of the module", + "return module.exports;" + ]); + }); + this.plugin("module-obj", (source, chunk, hash, varModuleId) => { + return this.asString([ + "i: moduleId,", + "l: false,", + "exports: {}" + ]); + }); + this.plugin("require-extensions", (source, chunk, hash) => { + const buf = []; + if(chunk.chunks.length > 0) { + buf.push("// This file contains only the entry chunk."); + buf.push("// The chunk loading function for additional chunks"); + buf.push(`${this.requireFn}.e = function requireEnsure(chunkId) {`); + buf.push(this.indent(this.applyPluginsWaterfall("require-ensure", "throw new Error('Not chunk loading available');", chunk, hash, "chunkId"))); + buf.push("};"); + } + buf.push(""); + buf.push("// expose the modules object (__webpack_modules__)"); + buf.push(`${this.requireFn}.m = modules;`); + + buf.push(""); + buf.push("// expose the module cache"); + buf.push(`${this.requireFn}.c = installedModules;`); + + buf.push(""); + buf.push("// identity function for calling harmony imports with the correct context"); + buf.push(`${this.requireFn}.i = function(value) { return value; };`); + + buf.push(""); + buf.push("// define getter function for harmony exports"); + buf.push(`${this.requireFn}.d = function(exports, name, getter) {`); + buf.push(this.indent([ + `if(!${this.requireFn}.o(exports, name)) {`, + this.indent([ + "Object.defineProperty(exports, name, {", + this.indent([ + "configurable: false,", + "enumerable: true,", + "get: getter" + ]), + "});" + ]), + "}" + ])); + buf.push("};"); + + buf.push(""); + buf.push("// getDefaultExport function for compatibility with non-harmony modules"); + buf.push(this.requireFn + ".n = function(module) {"); + buf.push(this.indent([ + "var getter = module && module.__esModule ?", + this.indent([ + "function getDefault() { return module['default']; } :", + "function getModuleExports() { return module; };" + ]), + `${this.requireFn}.d(getter, 'a', getter);`, + "return getter;" + ])); + buf.push("};"); + + buf.push(""); + buf.push("// Object.prototype.hasOwnProperty.call"); + buf.push(`${this.requireFn}.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };`); + + const publicPath = this.getPublicPath({ + hash: hash + }); + buf.push(""); + buf.push("// __webpack_public_path__"); + buf.push(`${this.requireFn}.p = ${JSON.stringify(publicPath)};`); + return this.asString(buf); + }); + + this.requireFn = "__webpack_require__"; + } + + render(hash, chunk, moduleTemplate, dependencyTemplates) { + const buf = []; + buf.push(this.applyPluginsWaterfall("bootstrap", "", chunk, hash, moduleTemplate, dependencyTemplates)); + buf.push(this.applyPluginsWaterfall("local-vars", "", chunk, hash)); + buf.push(""); + buf.push("// The require function"); + buf.push(`function ${this.requireFn}(moduleId) {`); + buf.push(this.indent(this.applyPluginsWaterfall("require", "", chunk, hash))); + buf.push("}"); + buf.push(""); + buf.push(this.asString(this.applyPluginsWaterfall("require-extensions", "", chunk, hash))); + buf.push(""); + buf.push(this.asString(this.applyPluginsWaterfall("startup", "", chunk, hash))); + let source = this.applyPluginsWaterfall("render", new OriginalSource(this.prefix(buf, " \t") + "\n", `webpack/bootstrap ${hash}`), chunk, hash, moduleTemplate, dependencyTemplates); + if(chunk.hasEntryModule()) { + source = this.applyPluginsWaterfall("render-with-entry", source, chunk, hash); + } + if(!source) throw new Error("Compiler error: MainTemplate plugin 'render' should return something"); + chunk.rendered = true; + return new ConcatSource(source, ";"); + } + + renderRequireFunctionForModule(hash, chunk, varModuleId) { + return this.applyPluginsWaterfall("module-require", this.requireFn, chunk, hash, varModuleId); + } + + renderAddModule(hash, chunk, varModuleId, varModule) { + return this.applyPluginsWaterfall("add-module", `modules[${varModuleId}] = ${varModule};`, chunk, hash, varModuleId, varModule); + } + + renderCurrentHashCode(hash, length) { + length = length || Infinity; + return this.applyPluginsWaterfall("current-hash", JSON.stringify(hash.substr(0, length)), length); + } + + entryPointInChildren(chunk) { + const checkChildren = (chunk, alreadyCheckedChunks) => { + return chunk.chunks.some((child) => { + if(alreadyCheckedChunks.indexOf(child) >= 0) return; + alreadyCheckedChunks.push(child); + return child.hasEntryModule() || checkChildren(child, alreadyCheckedChunks); + }); + }; + return checkChildren(chunk, []); + } + + getPublicPath(options) { + return this.applyPluginsWaterfall("asset-path", this.outputOptions.publicPath || "", options); + } + + updateHash(hash) { + hash.update("maintemplate"); + hash.update("3"); + hash.update(this.outputOptions.publicPath + ""); + this.applyPlugins("hash", hash); + } + + updateHashForChunk(hash, chunk) { + this.updateHash(hash); + this.applyPlugins("hash-for-chunk", hash, chunk); + } + + useChunkHash(chunk) { + const paths = this.applyPluginsWaterfall("global-hash-paths", []); + return !this.applyPluginsBailResult("global-hash", chunk, paths); + } +}; diff --git a/node_modules/webpack/lib/MemoryOutputFileSystem.js b/node_modules/webpack/lib/MemoryOutputFileSystem.js new file mode 100644 index 000000000..bc0769369 --- /dev/null +++ b/node_modules/webpack/lib/MemoryOutputFileSystem.js @@ -0,0 +1,5 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = require("memory-fs"); diff --git a/node_modules/webpack/lib/Module.js b/node_modules/webpack/lib/Module.js new file mode 100644 index 000000000..8ce9c85ad --- /dev/null +++ b/node_modules/webpack/lib/Module.js @@ -0,0 +1,188 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const DependenciesBlock = require("./DependenciesBlock"); +const ModuleReason = require("./ModuleReason"); +const Template = require("./Template"); + +function addToSet(set, items) { + for(let item of items) { + if(set.indexOf(item) < 0) + set.push(item); + } +} + +function byId(a, b) { + return a.id - b.id; +} + +let debugId = 1000; + +class Module extends DependenciesBlock { + constructor() { + super(); + this.context = null; + this.reasons = []; + this.debugId = debugId++; + this.lastId = -1; + this.id = null; + this.portableId = null; + this.index = null; + this.index2 = null; + this.depth = null; + this.used = null; + this.usedExports = null; + this.providedExports = null; + this.chunks = []; + this.warnings = []; + this.dependenciesWarnings = []; + this.errors = []; + this.dependenciesErrors = []; + this.strict = false; + this.meta = {}; + } + + disconnect() { + this.reasons.length = 0; + this.lastId = this.id; + this.id = null; + this.index = null; + this.index2 = null; + this.depth = null; + this.used = null; + this.usedExports = null; + this.providedExports = null; + this.chunks.length = 0; + super.disconnect(); + } + + unseal() { + this.lastId = this.id; + this.id = null; + this.index = null; + this.index2 = null; + this.depth = null; + this.chunks.length = 0; + super.unseal(); + } + + addChunk(chunk) { + let idx = this.chunks.indexOf(chunk); + if(idx < 0) + this.chunks.push(chunk); + } + + removeChunk(chunk) { + let idx = this.chunks.indexOf(chunk); + if(idx >= 0) { + this.chunks.splice(idx, 1); + chunk.removeModule(this); + return true; + } + return false; + } + + addReason(module, dependency) { + this.reasons.push(new ModuleReason(module, dependency)); + } + + removeReason(module, dependency) { + for(let i = 0; i < this.reasons.length; i++) { + let r = this.reasons[i]; + if(r.module === module && r.dependency === dependency) { + this.reasons.splice(i, 1); + return true; + } + } + return false; + } + + hasReasonForChunk(chunk) { + for(let r of this.reasons) { + if(r.chunks) { + if(r.chunks.indexOf(chunk) >= 0) + return true; + } else if(r.module.chunks.indexOf(chunk) >= 0) + return true; + } + return false; + } + + rewriteChunkInReasons(oldChunk, newChunks) { + this.reasons.forEach(r => { + if(!r.chunks) { + if(r.module.chunks.indexOf(oldChunk) < 0) + return; + r.chunks = r.module.chunks; + } + r.chunks = r.chunks.reduce((arr, c) => { + addToSet(arr, c !== oldChunk ? [c] : newChunks); + return arr; + }, []); + }); + } + + isUsed(exportName) { + if(this.used === null) return exportName; + if(!exportName) return !!this.used; + if(!this.used) return false; + if(!this.usedExports) return false; + if(this.usedExports === true) return exportName; + let idx = this.usedExports.indexOf(exportName); + if(idx < 0) return false; + if(this.isProvided(exportName)) + return Template.numberToIdentifer(idx); + return exportName; + } + + isProvided(exportName) { + if(!Array.isArray(this.providedExports)) + return null; + return this.providedExports.indexOf(exportName) >= 0; + } + + toString() { + return `Module[${this.id || this.debugId}]`; + } + + needRebuild(fileTimestamps, contextTimestamps) { + return true; + } + + updateHash(hash) { + hash.update(this.id + "" + this.used); + hash.update(JSON.stringify(this.usedExports)); + super.updateHash(hash); + } + + sortItems() { + super.sortItems(); + this.chunks.sort(byId); + this.reasons.sort((a, b) => byId(a.module, b.module)); + } + + unbuild() { + this.disconnect(); + } +} + +Object.defineProperty(Module.prototype, "entry", { + configurable: false, + get() { + throw new Error("Module.entry was removed. Use Chunk.entryModule"); + }, + set() { + throw new Error("Module.entry was removed. Use Chunk.entryModule"); + } +}); +Module.prototype.identifier = null; +Module.prototype.readableIdentifier = null; +Module.prototype.build = null; +Module.prototype.source = null; +Module.prototype.size = null; +Module.prototype.nameForCondition = null; + +module.exports = Module; diff --git a/node_modules/webpack/lib/ModuleBuildError.js b/node_modules/webpack/lib/ModuleBuildError.js new file mode 100644 index 000000000..09158f697 --- /dev/null +++ b/node_modules/webpack/lib/ModuleBuildError.js @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const cutOffLoaderExecution = require("./ErrorHelpers").cutOffLoaderExecution; + +class ModuleBuildError extends WebpackError { + constructor(module, err) { + super(); + + this.name = "ModuleBuildError"; + this.message = "Module build failed: "; + if(err !== null && typeof err === "object") { + if(typeof err.stack === "string" && err.stack) { + var stack = cutOffLoaderExecution(err.stack); + if(!err.hideStack) { + this.message += stack; + } else { + this.details = stack; + if(typeof err.message === "string" && err.message) { + this.message += err.message; + } else { + this.message += err; + } + } + } else if(typeof err.message === "string" && err.message) { + this.message += err.message; + } else { + this.message += err; + } + } + this.module = module; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ModuleBuildError; diff --git a/node_modules/webpack/lib/ModuleDependencyError.js b/node_modules/webpack/lib/ModuleDependencyError.js new file mode 100644 index 000000000..582b6b2ab --- /dev/null +++ b/node_modules/webpack/lib/ModuleDependencyError.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const formatLocation = require("./formatLocation"); + +module.exports = class ModuleDependencyError extends WebpackError { + constructor(module, err, loc) { + super(); + + this.name = "ModuleDependencyError"; + this.message = `${formatLocation(loc)} ${err.message}`; + this.details = err.stack.split("\n").slice(1).join("\n"); + this.origin = this.module = module; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +}; diff --git a/node_modules/webpack/lib/ModuleDependencyWarning.js b/node_modules/webpack/lib/ModuleDependencyWarning.js new file mode 100644 index 000000000..235fa1bb2 --- /dev/null +++ b/node_modules/webpack/lib/ModuleDependencyWarning.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const formatLocation = require("./formatLocation"); + +module.exports = class ModuleDependencyWarning extends WebpackError { + constructor(module, err, loc) { + super(); + + this.name = "ModuleDependencyWarning"; + this.message = `${formatLocation(loc)} ${err.message}`; + this.details = err.stack.split("\n").slice(1).join("\n"); + this.origin = this.module = module; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +}; diff --git a/node_modules/webpack/lib/ModuleError.js b/node_modules/webpack/lib/ModuleError.js new file mode 100644 index 000000000..9e9be7683 --- /dev/null +++ b/node_modules/webpack/lib/ModuleError.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const cleanUp = require("./ErrorHelpers").cleanUp; + +class ModuleError extends WebpackError { + constructor(module, err) { + super(); + + this.name = "ModuleError"; + this.module = module; + this.message = err && typeof err === "object" && err.message ? err.message : err; + this.error = err; + this.details = err && typeof err === "object" && err.stack ? cleanUp(err.stack, this.message) : undefined; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ModuleError; diff --git a/node_modules/webpack/lib/ModuleFilenameHelpers.js b/node_modules/webpack/lib/ModuleFilenameHelpers.js new file mode 100644 index 000000000..5deda6e17 --- /dev/null +++ b/node_modules/webpack/lib/ModuleFilenameHelpers.js @@ -0,0 +1,162 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ModuleFilenameHelpers = exports; + +ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]"; +ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE = /\[all-?loaders\]\[resource\]/gi; +ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]"; +ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi; +ModuleFilenameHelpers.RESOURCE = "[resource]"; +ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi; +ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]"; +ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH = /\[abs(olute)?-?resource-?path\]/gi; +ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]"; +ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi; +ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]"; +ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi; +ModuleFilenameHelpers.LOADERS = "[loaders]"; +ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi; +ModuleFilenameHelpers.QUERY = "[query]"; +ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi; +ModuleFilenameHelpers.ID = "[id]"; +ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi; +ModuleFilenameHelpers.HASH = "[hash]"; +ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi; + +function getAfter(str, token) { + const idx = str.indexOf(token); + return idx < 0 ? "" : str.substr(idx); +} + +function getBefore(str, token) { + const idx = str.lastIndexOf(token); + return idx < 0 ? "" : str.substr(0, idx); +} + +function getHash(str) { + const hash = require("crypto").createHash("md5"); + hash.update(str); + return hash.digest("hex").substr(0, 4); +} + +function asRegExp(test) { + if(typeof test === "string") test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")); + return test; +} + +ModuleFilenameHelpers.createFilename = function createFilename(module, moduleFilenameTemplate, requestShortener) { + let absoluteResourcePath; + let hash; + let identifier; + let moduleId; + let shortIdentifier; + if(module === undefined) module = ""; + if(typeof module === "string") { + shortIdentifier = requestShortener.shorten(module); + identifier = shortIdentifier; + moduleId = ""; + absoluteResourcePath = module.split("!").pop(); + hash = getHash(identifier); + } else { + shortIdentifier = module.readableIdentifier(requestShortener); + identifier = requestShortener.shorten(module.identifier()); + moduleId = module.id; + absoluteResourcePath = module.identifier().split("!").pop(); + hash = getHash(identifier); + } + const resource = shortIdentifier.split("!").pop(); + const loaders = getBefore(shortIdentifier, "!"); + const allLoaders = getBefore(identifier, "!"); + const query = getAfter(resource, "?"); + const resourcePath = resource.substr(0, resource.length - query.length); + if(typeof moduleFilenameTemplate === "function") { + return moduleFilenameTemplate({ + identifier: identifier, + shortIdentifier: shortIdentifier, + resource: resource, + resourcePath: resourcePath, + absoluteResourcePath: absoluteResourcePath, + allLoaders: allLoaders, + query: query, + moduleId: moduleId, + hash: hash + }); + } + return moduleFilenameTemplate + .replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, identifier) + .replace(ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE, shortIdentifier) + .replace(ModuleFilenameHelpers.REGEXP_RESOURCE, resource) + .replace(ModuleFilenameHelpers.REGEXP_RESOURCE_PATH, resourcePath) + .replace(ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH, absoluteResourcePath) + .replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS, allLoaders) + .replace(ModuleFilenameHelpers.REGEXP_LOADERS, loaders) + .replace(ModuleFilenameHelpers.REGEXP_QUERY, query) + .replace(ModuleFilenameHelpers.REGEXP_ID, moduleId) + .replace(ModuleFilenameHelpers.REGEXP_HASH, hash); +}; + +ModuleFilenameHelpers.createFooter = function createFooter(module, requestShortener) { + if(!module) module = ""; + if(typeof module === "string") { + return [ + "// WEBPACK FOOTER //", + `// ${requestShortener.shorten(module)}` + ].join("\n"); + } else { + return [ + "//////////////////", + "// WEBPACK FOOTER", + `// ${module.readableIdentifier(requestShortener)}`, + `// module id = ${module.id}`, + `// module chunks = ${module.chunks.map(c => c.id).join(" ")}` + ].join("\n"); + } +}; + +ModuleFilenameHelpers.replaceDuplicates = function replaceDuplicates(array, fn, comparator) { + const countMap = Object.create(null); + const posMap = Object.create(null); + array.forEach((item, idx) => { + countMap[item] = (countMap[item] || []); + countMap[item].push(idx); + posMap[item] = 0; + }); + if(comparator) { + Object.keys(countMap).forEach(item => { + countMap[item].sort(comparator); + }); + } + return array.map((item, i) => { + if(countMap[item].length > 1) { + if(comparator && countMap[item][0] === i) + return item; + return fn(item, i, posMap[item]++); + } else return item; + }); +}; + +ModuleFilenameHelpers.matchPart = function matchPart(str, test) { + if(!test) return true; + test = asRegExp(test); + if(Array.isArray(test)) { + return test.map(asRegExp).filter(function(regExp) { + return regExp.test(str); + }).length > 0; + } else { + return test.test(str); + } +}; + +ModuleFilenameHelpers.matchObject = function matchObject(obj, str) { + if(obj.test) + if(!ModuleFilenameHelpers.matchPart(str, obj.test)) return false; + if(obj.include) + if(!ModuleFilenameHelpers.matchPart(str, obj.include)) return false; + if(obj.exclude) + if(ModuleFilenameHelpers.matchPart(str, obj.exclude)) return false; + return true; +}; diff --git a/node_modules/webpack/lib/ModuleNotFoundError.js b/node_modules/webpack/lib/ModuleNotFoundError.js new file mode 100644 index 000000000..454cd48bf --- /dev/null +++ b/node_modules/webpack/lib/ModuleNotFoundError.js @@ -0,0 +1,26 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +class ModuleNotFoundError extends WebpackError { + constructor(module, err, dependencies) { + super(); + + this.name = "ModuleNotFoundError"; + this.message = "Module not found: " + err; + this.details = err.details; + this.missing = err.missing; + this.module = module; + this.origin = module; + this.dependencies = dependencies; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ModuleNotFoundError; diff --git a/node_modules/webpack/lib/ModuleParseError.js b/node_modules/webpack/lib/ModuleParseError.js new file mode 100644 index 000000000..3b17889ea --- /dev/null +++ b/node_modules/webpack/lib/ModuleParseError.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +class ModuleParseError extends WebpackError { + constructor(module, source, err) { + super(); + + this.name = "ModuleParseError"; + this.message = "Module parse failed: " + module.request + " " + err.message; + this.message += "\nYou may need an appropriate loader to handle this file type."; + if(err.loc && typeof err.loc === "object" && typeof err.loc.line === "number") { + var lineNumber = err.loc.line; + if(/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)) { // binary file + this.message += "\n(Source code omitted for this binary file)"; + } else { + source = source.split("\n"); + this.message += "\n| " + source.slice(Math.max(0, lineNumber - 3), lineNumber + 2).join("\n| "); + } + } else { + this.message += "\n" + err.stack; + } + this.module = module; + this.error = err; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ModuleParseError; diff --git a/node_modules/webpack/lib/ModuleReason.js b/node_modules/webpack/lib/ModuleReason.js new file mode 100644 index 000000000..999952069 --- /dev/null +++ b/node_modules/webpack/lib/ModuleReason.js @@ -0,0 +1,12 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +module.exports = class ModuleReason { + constructor(module, dependency) { + this.module = module; + this.dependency = dependency; + } +}; diff --git a/node_modules/webpack/lib/ModuleTemplate.js b/node_modules/webpack/lib/ModuleTemplate.js new file mode 100644 index 000000000..69834df48 --- /dev/null +++ b/node_modules/webpack/lib/ModuleTemplate.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Template = require("./Template"); + +module.exports = class ModuleTemplate extends Template { + constructor(outputOptions) { + super(outputOptions); + } + render(module, dependencyTemplates, chunk) { + const moduleSource = module.source(dependencyTemplates, this.outputOptions, this.requestShortener); + const moduleSourcePostModule = this.applyPluginsWaterfall("module", moduleSource, module, chunk, dependencyTemplates); + const moduleSourcePostRender = this.applyPluginsWaterfall("render", moduleSourcePostModule, module, chunk, dependencyTemplates); + return this.applyPluginsWaterfall("package", moduleSourcePostRender, module, chunk, dependencyTemplates); + } + updateHash(hash) { + hash.update("1"); + this.applyPlugins("hash", hash); + } +}; diff --git a/node_modules/webpack/lib/ModuleWarning.js b/node_modules/webpack/lib/ModuleWarning.js new file mode 100644 index 000000000..2bda197a6 --- /dev/null +++ b/node_modules/webpack/lib/ModuleWarning.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const cleanUp = require("./ErrorHelpers").cleanUp; + +class ModuleWarning extends WebpackError { + constructor(module, warning) { + super(); + + this.name = "ModuleWarning"; + this.module = module; + this.message = warning && typeof warning === "object" && warning.message ? warning.message : warning; + this.warning = warning; + this.details = warning && typeof warning === "object" && warning.stack ? cleanUp(warning.stack, this.message) : undefined; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = ModuleWarning; diff --git a/node_modules/webpack/lib/MovedToPluginWarningPlugin.js b/node_modules/webpack/lib/MovedToPluginWarningPlugin.js new file mode 100644 index 000000000..e4198d1ca --- /dev/null +++ b/node_modules/webpack/lib/MovedToPluginWarningPlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +module.exports = class MovedToPluginWarningPlugin { + constructor(optionName, pluginName) { + this.optionName = optionName; + this.pluginName = pluginName; + } + apply(compiler) { + const optionName = this.optionName; + const pluginName = this.pluginName; + compiler.plugin("compilation", (compilation) => { + compilation.warnings.push(new Error `webpack options: + DEPRECATED option ${optionName} will be moved to the ${pluginName}. + Use this instead. + For more info about the usage of the ${pluginName} see https://webpack.js.org/plugins/`); + }); + } +}; diff --git a/node_modules/webpack/lib/MultiCompiler.js b/node_modules/webpack/lib/MultiCompiler.js new file mode 100644 index 000000000..d04ef778f --- /dev/null +++ b/node_modules/webpack/lib/MultiCompiler.js @@ -0,0 +1,176 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Tapable = require("tapable"); +var asyncLib = require("async"); +var MultiWatching = require("./MultiWatching"); +var MultiStats = require("./MultiStats"); + +function MultiCompiler(compilers) { + Tapable.call(this); + if(!Array.isArray(compilers)) { + compilers = Object.keys(compilers).map(function(name) { + compilers[name].name = name; + return compilers[name]; + }); + } + this.compilers = compilers; + + function delegateProperty(name) { + Object.defineProperty(this, name, { + configurable: false, + get: function() { + throw new Error("Cannot read " + name + " of a MultiCompiler"); + }, + set: function(value) { + this.compilers.forEach(function(compiler) { + compiler[name] = value; + }); + }.bind(this) + }); + } + delegateProperty.call(this, "outputFileSystem"); + delegateProperty.call(this, "inputFileSystem"); + + Object.defineProperty(this, "outputPath", { + configurable: false, + get: function() { + var commonPath = compilers[0].outputPath; + for(var i = 1; i < compilers.length; i++) { + while(compilers[i].outputPath.indexOf(commonPath) !== 0 && /[\/\\]/.test(commonPath)) { + commonPath = commonPath.replace(/[\/\\][^\/\\]*$/, ""); + } + } + if(!commonPath && compilers[0].outputPath[0] === "/") return "/"; + return commonPath; + } + }); + + var doneCompilers = 0; + var compilerStats = []; + this.compilers.forEach(function(compiler, idx) { + var compilerDone = false; + compiler.plugin("done", function(stats) { + if(!compilerDone) { + compilerDone = true; + doneCompilers++; + } + compilerStats[idx] = stats; + if(doneCompilers === this.compilers.length) { + this.applyPlugins("done", new MultiStats(compilerStats)); + } + }.bind(this)); + compiler.plugin("invalid", function() { + if(compilerDone) { + compilerDone = false; + doneCompilers--; + } + this.applyPlugins("invalid"); + }.bind(this)); + }, this); +} +module.exports = MultiCompiler; + +MultiCompiler.prototype = Object.create(Tapable.prototype); +MultiCompiler.prototype.constructor = MultiCompiler; + +function runWithDependencies(compilers, fn, callback) { + var fulfilledNames = {}; + var remainingCompilers = compilers; + + function isDependencyFulfilled(d) { + return fulfilledNames[d]; + } + + function getReadyCompilers() { + var readyCompilers = []; + var list = remainingCompilers; + remainingCompilers = []; + for(var i = 0; i < list.length; i++) { + var c = list[i]; + var ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled); + if(ready) + readyCompilers.push(c); + else + remainingCompilers.push(c); + } + return readyCompilers; + } + + function runCompilers(callback) { + if(remainingCompilers.length === 0) return callback(); + asyncLib.map(getReadyCompilers(), function(compiler, callback) { + fn(compiler, function(err) { + if(err) return callback(err); + fulfilledNames[compiler.name] = true; + runCompilers(callback); + }); + }, callback); + } + runCompilers(callback); +} + +MultiCompiler.prototype.watch = function(watchOptions, handler) { + var watchings = []; + var allStats = this.compilers.map(function() { + return null; + }); + var compilerStatus = this.compilers.map(function() { + return false; + }); + runWithDependencies(this.compilers, function(compiler, callback) { + var compilerIdx = this.compilers.indexOf(compiler); + var firstRun = true; + var watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[compilerIdx] : watchOptions, function(err, stats) { + if(err) + handler(err); + if(stats) { + allStats[compilerIdx] = stats; + compilerStatus[compilerIdx] = "new"; + if(compilerStatus.every(Boolean)) { + var freshStats = allStats.filter(function(s, idx) { + return compilerStatus[idx] === "new"; + }); + compilerStatus.fill(true); + var multiStats = new MultiStats(freshStats); + handler(null, multiStats); + } + } + if(firstRun && !err) { + firstRun = false; + callback(); + } + }); + watchings.push(watching); + }.bind(this), function() { + // ignore + }); + + return new MultiWatching(watchings, this); +}; + +MultiCompiler.prototype.run = function(callback) { + var allStats = this.compilers.map(function() { + return null; + }); + + runWithDependencies(this.compilers, function(compiler, callback) { + var compilerIdx = this.compilers.indexOf(compiler); + compiler.run(function(err, stats) { + if(err) return callback(err); + allStats[compilerIdx] = stats; + callback(); + }); + }.bind(this), function(err) { + if(err) return callback(err); + callback(null, new MultiStats(allStats)); + }); +}; + +MultiCompiler.prototype.purgeInputFileSystem = function() { + this.compilers.forEach(function(compiler) { + if(compiler.inputFileSystem && compiler.inputFileSystem.purge) + compiler.inputFileSystem.purge(); + }); +}; diff --git a/node_modules/webpack/lib/MultiEntryPlugin.js b/node_modules/webpack/lib/MultiEntryPlugin.js new file mode 100644 index 000000000..e7ca65189 --- /dev/null +++ b/node_modules/webpack/lib/MultiEntryPlugin.js @@ -0,0 +1,39 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const MultiEntryDependency = require("./dependencies/MultiEntryDependency"); +const SingleEntryDependency = require("./dependencies/SingleEntryDependency"); +const MultiModuleFactory = require("./MultiModuleFactory"); + +module.exports = class MultiEntryPlugin { + constructor(context, entries, name) { + this.context = context; + this.entries = entries; + this.name = name; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const multiModuleFactory = new MultiModuleFactory(); + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(MultiEntryDependency, multiModuleFactory); + compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory); + }); + compiler.plugin("make", (compilation, callback) => { + const dep = MultiEntryPlugin.createDependency(this.entries, this.name); + compilation.addEntry(this.context, dep, this.name, callback); + }); + } + + static createDependency(entries, name) { + return new MultiEntryDependency(entries.map((e, idx) => { + const dep = new SingleEntryDependency(e); + dep.loc = name + ":" + (100000 + idx); + return dep; + }), name); + } +}; diff --git a/node_modules/webpack/lib/MultiModule.js b/node_modules/webpack/lib/MultiModule.js new file mode 100644 index 000000000..b6a91e34f --- /dev/null +++ b/node_modules/webpack/lib/MultiModule.js @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Module = require("./Module"); +const RawSource = require("webpack-sources").RawSource; + +class MultiModule extends Module { + + constructor(context, dependencies, name) { + super(); + this.context = context; + this.dependencies = dependencies; + this.name = name; + this.built = false; + this.cacheable = true; + } + + identifier() { + return `multi ${this.dependencies.map((d) => d.request).join(" ")}`; + } + + readableIdentifier(requestShortener) { + return `multi ${this.dependencies.map((d) => requestShortener.shorten(d.request)).join(" ")}`; + } + + disconnect() { + this.built = false; + super.disconnect(); + } + + build(options, compilation, resolver, fs, callback) { + this.built = true; + return callback(); + } + + needRebuild() { + return false; + } + + size() { + return 16 + this.dependencies.length * 12; + } + + updateHash(hash) { + hash.update("multi module"); + hash.update(this.name || ""); + super.updateHash(hash); + } + + source(dependencyTemplates, outputOptions) { + const str = []; + this.dependencies.forEach(function(dep, idx) { + if(dep.module) { + if(idx === this.dependencies.length - 1) + str.push("module.exports = "); + str.push("__webpack_require__("); + if(outputOptions.pathinfo) + str.push(`/*! ${dep.request} */`); + str.push(`${JSON.stringify(dep.module.id)}`); + str.push(")"); + } else { + str.push("(function webpackMissingModule() { throw new Error("); + str.push(JSON.stringify(`Cannot find module "${dep.request}"`)); + str.push("); }())"); + } + str.push(";\n"); + }, this); + return new RawSource(str.join("")); + } +} + +module.exports = MultiModule; diff --git a/node_modules/webpack/lib/MultiModuleFactory.js b/node_modules/webpack/lib/MultiModuleFactory.js new file mode 100644 index 000000000..d28bfb551 --- /dev/null +++ b/node_modules/webpack/lib/MultiModuleFactory.js @@ -0,0 +1,19 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Tapable = require("tapable"); +const MultiModule = require("./MultiModule"); + +module.exports = class MultiModuleFactory extends Tapable { + constructor() { + super(); + } + + create(data, callback) { + const dependency = data.dependencies[0]; + callback(null, new MultiModule(data.context, dependency.dependencies, dependency.name)); + } +}; diff --git a/node_modules/webpack/lib/MultiStats.js b/node_modules/webpack/lib/MultiStats.js new file mode 100644 index 000000000..3401c9d30 --- /dev/null +++ b/node_modules/webpack/lib/MultiStats.js @@ -0,0 +1,79 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Stats = require("./Stats"); + +const optionOrFallback = (optionValue, fallbackValue) => optionValue !== undefined ? optionValue : fallbackValue; + +class MultiStats { + constructor(stats) { + this.stats = stats; + this.hash = stats.map(stat => stat.hash).join(""); + } + + hasErrors() { + return this.stats.map((stat) => stat.hasErrors()).reduce((a, b) => a || b, false); + } + + hasWarnings() { + return this.stats.map((stat) => stat.hasWarnings()).reduce((a, b) => a || b, false); + } + + toJson(options, forToString) { + if(typeof options === "boolean" || typeof options === "string") { + options = Stats.presetToOptions(options); + } else if(!options) { + options = {}; + } + const jsons = this.stats.map((stat, idx) => { + const childOptions = Stats.getChildOptions(options, idx); + const obj = stat.toJson(childOptions, forToString); + obj.name = stat.compilation && stat.compilation.name; + return obj; + }); + const showVersion = typeof options.version === "undefined" ? jsons.every(j => j.version) : options.version !== false; + const showHash = typeof options.hash === "undefined" ? jsons.every(j => j.hash) : options.hash !== false; + jsons.forEach(j => { + if(showVersion) + delete j.version; + }); + const obj = { + errors: jsons.reduce((arr, j) => { + return arr.concat(j.errors.map(msg => { + return `(${j.name}) ${msg}`; + })); + }, []), + warnings: jsons.reduce((arr, j) => { + return arr.concat(j.warnings.map(msg => { + return `(${j.name}) ${msg}`; + })); + }, []) + }; + if(showVersion) + obj.version = require("../package.json").version; + if(showHash) + obj.hash = this.hash; + if(options.children !== false) + obj.children = jsons; + return obj; + } + + toString(options) { + if(typeof options === "boolean" || typeof options === "string") { + options = Stats.presetToOptions(options); + } else if(!options) { + options = {}; + } + + const useColors = optionOrFallback(options.colors, false); + + const obj = this.toJson(options, true); + + return Stats.jsonToString(obj, useColors); + } +} + +module.exports = MultiStats; diff --git a/node_modules/webpack/lib/MultiWatching.js b/node_modules/webpack/lib/MultiWatching.js new file mode 100644 index 000000000..95fd4075f --- /dev/null +++ b/node_modules/webpack/lib/MultiWatching.js @@ -0,0 +1,32 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const asyncLib = require("async"); + +class MultiWatching { + constructor(watchings, compiler) { + this.watchings = watchings; + this.compiler = compiler; + } + + invalidate() { + this.watchings.forEach((watching) => watching.invalidate()); + } + + close(callback) { + if(callback === undefined) callback = () => { /*do nothing*/ }; + + asyncLib.forEach(this.watchings, (watching, finishedCallback) => { + watching.close(finishedCallback); + }, err => { + this.compiler.applyPlugins("watch-close"); + callback(err); + }); + + } +} + +module.exports = MultiWatching; diff --git a/node_modules/webpack/lib/NamedChunksPlugin.js b/node_modules/webpack/lib/NamedChunksPlugin.js new file mode 100644 index 000000000..10f99530f --- /dev/null +++ b/node_modules/webpack/lib/NamedChunksPlugin.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class NamedChunksPlugin { + + static defaultNameResolver(chunk) { + return chunk.name || null; + } + + constructor(nameResolver) { + this.nameResolver = nameResolver || NamedChunksPlugin.defaultNameResolver; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("before-chunk-ids", (chunks) => { + chunks.forEach((chunk) => { + if(chunk.id === null) { + chunk.id = this.nameResolver(chunk); + } + }); + }); + }); + } +} + +module.exports = NamedChunksPlugin; diff --git a/node_modules/webpack/lib/NamedModulesPlugin.js b/node_modules/webpack/lib/NamedModulesPlugin.js new file mode 100644 index 000000000..37c12a9cf --- /dev/null +++ b/node_modules/webpack/lib/NamedModulesPlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class NamedModulesPlugin { + constructor(options) { + this.options = options || {}; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("before-module-ids", (modules) => { + modules.forEach((module) => { + if(module.id === null && module.libIdent) { + module.id = module.libIdent({ + context: this.options.context || compiler.options.context + }); + } + }); + }); + }); + } +} + +module.exports = NamedModulesPlugin; diff --git a/node_modules/webpack/lib/NewWatchingPlugin.js b/node_modules/webpack/lib/NewWatchingPlugin.js new file mode 100644 index 000000000..29e2fa326 --- /dev/null +++ b/node_modules/webpack/lib/NewWatchingPlugin.js @@ -0,0 +1,15 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class NewWatchingPlugin { + apply(compiler) { + compiler.plugin("compilation", function(compilation) { + compilation.warnings.push(new Error("The 'NewWatchingPlugin' is no longer necessary (now default)")); + }); + } +} + +module.exports = NewWatchingPlugin; diff --git a/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js b/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js new file mode 100644 index 000000000..c650253e5 --- /dev/null +++ b/node_modules/webpack/lib/NoEmitOnErrorsPlugin.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class NoEmitOnErrorsPlugin { + apply(compiler) { + compiler.plugin("should-emit", (compilation) => { + if(compilation.errors.length > 0) + return false; + }); + compiler.plugin("compilation", (compilation) => { + compilation.plugin("should-record", () => { + if(compilation.errors.length > 0) + return false; + }); + }); + } +} + +module.exports = NoEmitOnErrorsPlugin; diff --git a/node_modules/webpack/lib/NoErrorsPlugin.js b/node_modules/webpack/lib/NoErrorsPlugin.js new file mode 100644 index 000000000..0922f72f9 --- /dev/null +++ b/node_modules/webpack/lib/NoErrorsPlugin.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +let deprecationReported = false; + +class NoErrorsPlugin { + apply(compiler) { + compiler.plugin("should-emit", (compilation) => { + if(!deprecationReported) { + compilation.warnings.push("webpack: Using NoErrorsPlugin is deprecated.\n" + + "Use NoEmitOnErrorsPlugin instead.\n"); + deprecationReported = true; + } + if(compilation.errors.length > 0) + return false; + }); + compiler.plugin("compilation", (compilation) => { + compilation.plugin("should-record", () => { + if(compilation.errors.length > 0) + return false; + }); + }); + } +} + +module.exports = NoErrorsPlugin; diff --git a/node_modules/webpack/lib/NodeStuffPlugin.js b/node_modules/webpack/lib/NodeStuffPlugin.js new file mode 100644 index 000000000..07a63d1cc --- /dev/null +++ b/node_modules/webpack/lib/NodeStuffPlugin.js @@ -0,0 +1,97 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const ParserHelpers = require("./ParserHelpers"); +const ConstDependency = require("./dependencies/ConstDependency"); + +const NullFactory = require("./NullFactory"); + +class NodeStuffPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(parserOptions.node === false) + return; + + let localOptions = options; + if(parserOptions.node) + localOptions = Object.assign({}, localOptions, parserOptions.node); + + function setConstant(expressionName, value) { + parser.plugin(`expression ${expressionName}`, function() { + this.state.current.addVariable(expressionName, JSON.stringify(value)); + return true; + }); + } + + function setModuleConstant(expressionName, fn) { + parser.plugin(`expression ${expressionName}`, function() { + this.state.current.addVariable(expressionName, JSON.stringify(fn(this.state.module))); + return true; + }); + } + const context = compiler.context; + if(localOptions.__filename === "mock") { + setConstant("__filename", "/index.js"); + } else if(localOptions.__filename) { + setModuleConstant("__filename", module => path.relative(context, module.resource)); + } + parser.plugin("evaluate Identifier __filename", function(expr) { + if(!this.state.module) return; + const resource = this.state.module.resource; + const i = resource.indexOf("?"); + return ParserHelpers.evaluateToString(i < 0 ? resource : resource.substr(0, i))(expr); + }); + if(localOptions.__dirname === "mock") { + setConstant("__dirname", "/"); + } else if(localOptions.__dirname) { + setModuleConstant("__dirname", module => path.relative(context, module.context)); + } + parser.plugin("evaluate Identifier __dirname", function(expr) { + if(!this.state.module) return; + return ParserHelpers.evaluateToString(this.state.module.context)(expr); + }); + parser.plugin("expression require.main", ParserHelpers.toConstantDependency("__webpack_require__.c[__webpack_require__.s]")); + parser.plugin( + "expression require.extensions", + ParserHelpers.expressionIsUnsupported("require.extensions is not supported by webpack. Use a loader instead.") + ); + parser.plugin("expression module.loaded", ParserHelpers.toConstantDependency("module.l")); + parser.plugin("expression module.id", ParserHelpers.toConstantDependency("module.i")); + parser.plugin("expression module.exports", function() { + const module = this.state.module; + const isHarmony = module.meta && module.meta.harmonyModule; + if(!isHarmony) + return true; + }); + parser.plugin("evaluate Identifier module.hot", ParserHelpers.evaluateToBoolean(false)); + parser.plugin("expression module", function() { + const module = this.state.module; + const isHarmony = module.meta && module.meta.harmonyModule; + let moduleJsPath = path.join(__dirname, "..", "buildin", isHarmony ? "harmony-module.js" : "module.js"); + if(module.context) { + moduleJsPath = path.relative(this.state.module.context, moduleJsPath); + if(!/^[A-Z]:/i.test(moduleJsPath)) { + moduleJsPath = `./${moduleJsPath.replace(/\\/g, "/")}`; + } + } + return ParserHelpers.addParsedVariableToModule(this, "module", `require(${JSON.stringify(moduleJsPath)})(module)`); + }); + }); + }); + } +} +module.exports = NodeStuffPlugin; diff --git a/node_modules/webpack/lib/NormalModule.js b/node_modules/webpack/lib/NormalModule.js new file mode 100644 index 000000000..949bfef87 --- /dev/null +++ b/node_modules/webpack/lib/NormalModule.js @@ -0,0 +1,524 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const NativeModule = require("module"); +const crypto = require("crypto"); + +const SourceMapSource = require("webpack-sources").SourceMapSource; +const OriginalSource = require("webpack-sources").OriginalSource; +const RawSource = require("webpack-sources").RawSource; +const ReplaceSource = require("webpack-sources").ReplaceSource; +const CachedSource = require("webpack-sources").CachedSource; +const LineToLineMappedSource = require("webpack-sources").LineToLineMappedSource; + +const WebpackError = require("./WebpackError"); +const Module = require("./Module"); +const ModuleParseError = require("./ModuleParseError"); +const ModuleBuildError = require("./ModuleBuildError"); +const ModuleError = require("./ModuleError"); +const ModuleWarning = require("./ModuleWarning"); + +const runLoaders = require("loader-runner").runLoaders; +const getContext = require("loader-runner").getContext; + +function asString(buf) { + if(Buffer.isBuffer(buf)) { + return buf.toString("utf-8"); + } + return buf; +} + +function contextify(context, request) { + return request.split("!").map(function(r) { + let rp = path.relative(context, r); + if(path.sep === "\\") + rp = rp.replace(/\\/g, "/"); + if(rp.indexOf("../") !== 0) + rp = "./" + rp; + return rp; + }).join("!"); +} + +class NonErrorEmittedError extends WebpackError { + constructor(error) { + super(); + + this.name = "NonErrorEmittedError"; + this.message = "(Emitted value instead of an instance of Error) " + error; + + Error.captureStackTrace(this, this.constructor); + } +} + +class NormalModule extends Module { + + constructor(request, userRequest, rawRequest, loaders, resource, parser) { + super(); + this.request = request; + this.userRequest = userRequest; + this.rawRequest = rawRequest; + this.parser = parser; + this.resource = resource; + this.context = getContext(resource); + this.loaders = loaders; + this.fileDependencies = []; + this.contextDependencies = []; + this.warnings = []; + this.errors = []; + this.error = null; + this._source = null; + this.assets = {}; + this.built = false; + this._cachedSource = null; + } + + identifier() { + return this.request; + } + + readableIdentifier(requestShortener) { + return requestShortener.shorten(this.userRequest); + } + + libIdent(options) { + return contextify(options.context, this.userRequest); + } + + nameForCondition() { + const idx = this.resource.indexOf("?"); + if(idx >= 0) return this.resource.substr(0, idx); + return this.resource; + } + + createSourceForAsset(name, content, sourceMap) { + if(!sourceMap) { + return new RawSource(content); + } + + if(typeof sourceMap === "string") { + return new OriginalSource(content, sourceMap); + } + + return new SourceMapSource(content, name, sourceMap); + } + + createLoaderContext(resolver, options, compilation, fs) { + const loaderContext = { + version: 2, + emitWarning: (warning) => { + if(!(warning instanceof Error)) + warning = new NonErrorEmittedError(warning); + this.warnings.push(new ModuleWarning(this, warning)); + }, + emitError: (error) => { + if(!(error instanceof Error)) + error = new NonErrorEmittedError(error); + this.errors.push(new ModuleError(this, error)); + }, + exec: (code, filename) => { + const module = new NativeModule(filename, this); + module.paths = NativeModule._nodeModulePaths(this.context); + module.filename = filename; + module._compile(code, filename); + return module.exports; + }, + resolve(context, request, callback) { + resolver.resolve({}, context, request, callback); + }, + resolveSync(context, request) { + return resolver.resolveSync({}, context, request); + }, + emitFile: (name, content, sourceMap) => { + this.assets[name] = this.createSourceForAsset(name, content, sourceMap); + }, + options: options, + webpack: true, + sourceMap: !!this.useSourceMap, + _module: this, + _compilation: compilation, + _compiler: compilation.compiler, + fs: fs, + }; + + compilation.applyPlugins("normal-module-loader", loaderContext, this); + if(options.loader) + Object.assign(loaderContext, options.loader); + + return loaderContext; + } + + createSource(source, resourceBuffer, sourceMap) { + // if there is no identifier return raw source + if(!this.identifier) { + return new RawSource(source); + } + + // from here on we assume we have an identifier + const identifier = this.identifier(); + + if(this.lineToLine && resourceBuffer) { + return new LineToLineMappedSource( + source, identifier, asString(resourceBuffer)); + } + + if(this.useSourceMap && sourceMap) { + return new SourceMapSource(source, identifier, sourceMap); + } + + return new OriginalSource(source, identifier); + } + + doBuild(options, compilation, resolver, fs, callback) { + this.cacheable = false; + const loaderContext = this.createLoaderContext(resolver, options, compilation, fs); + + runLoaders({ + resource: this.resource, + loaders: this.loaders, + context: loaderContext, + readResource: fs.readFile.bind(fs) + }, (err, result) => { + if(result) { + this.cacheable = result.cacheable; + this.fileDependencies = result.fileDependencies; + this.contextDependencies = result.contextDependencies; + } + + if(err) { + const error = new ModuleBuildError(this, err); + return callback(error); + } + + const resourceBuffer = result.resourceBuffer; + const source = result.result[0]; + const sourceMap = result.result[1]; + + if(!Buffer.isBuffer(source) && typeof source !== "string") { + const error = new ModuleBuildError(this, new Error("Final loader didn't return a Buffer or String")); + return callback(error); + } + + this._source = this.createSource(asString(source), resourceBuffer, sourceMap); + return callback(); + }); + } + + disconnect() { + this.built = false; + super.disconnect(); + } + + markModuleAsErrored(error) { + this.meta = null; + this.error = error; + this.errors.push(this.error); + this._source = new RawSource("throw new Error(" + JSON.stringify(this.error.message) + ");"); + } + + applyNoParseRule(rule, content) { + // must start with "rule" if rule is a string + if(typeof rule === "string") { + return content.indexOf(rule) === 0; + } + // we assume rule is a regexp + return rule.test(content); + } + + // check if module should not be parsed + // returns "true" if the module should !not! be parsed + // returns "false" if the module !must! be parsed + shouldPreventParsing(noParseRule, request) { + // if no noParseRule exists, return false + // the module !must! be parsed. + if(!noParseRule) { + return false; + } + + // we only have one rule to check + if(!Array.isArray(noParseRule)) { + // returns "true" if the module is !not! to be parsed + return this.applyNoParseRule(noParseRule, request); + } + + for(let i = 0; i < noParseRule.length; i++) { + const rule = noParseRule[i]; + // early exit on first truthy match + // this module is !not! to be parsed + if(this.applyNoParseRule(rule, request)) { + return true; + } + } + // no match found, so this module !should! be parsed + return false; + } + + build(options, compilation, resolver, fs, callback) { + this.buildTimestamp = new Date().getTime(); + this.built = true; + this._source = null; + this.error = null; + this.errors.length = 0; + this.warnings.length = 0; + this.meta = {}; + + return this.doBuild(options, compilation, resolver, fs, (err) => { + this.dependencies.length = 0; + this.variables.length = 0; + this.blocks.length = 0; + this._cachedSource = null; + + // if we have an error mark module as failed and exit + if(err) { + this.markModuleAsErrored(err); + return callback(); + } + + // check if this module should !not! be parsed. + // if so, exit here; + const noParseRule = options.module && options.module.noParse; + if(this.shouldPreventParsing(noParseRule, this.request)) { + return callback(); + } + + try { + this.parser.parse(this._source.source(), { + current: this, + module: this, + compilation: compilation, + options: options + }); + } catch(e) { + const source = this._source.source(); + const error = new ModuleParseError(this, source, e); + this.markModuleAsErrored(error); + return callback(); + } + return callback(); + }); + } + + getHashDigest() { + const hash = crypto.createHash("md5"); + this.updateHash(hash); + return hash.digest("hex"); + } + + sourceDependency(dependency, dependencyTemplates, source, outputOptions, requestShortener) { + const template = dependencyTemplates.get(dependency.constructor); + if(!template) throw new Error("No template for dependency: " + dependency.constructor.name); + template.apply(dependency, source, outputOptions, requestShortener, dependencyTemplates); + } + + sourceVariables(variable, availableVars, dependencyTemplates, outputOptions, requestShortener) { + const name = variable.name; + const expr = variable.expressionSource(dependencyTemplates, outputOptions, requestShortener); + + if(availableVars.some(v => v.name === name && v.expression.source() === expr.source())) { + return; + } + return { + name: name, + expression: expr + }; + } + + /* + * creates the start part of a IIFE around the module to inject a variable name + * (function(...){ <- this part + * }.call(...)) + */ + variableInjectionFunctionWrapperStartCode(varNames) { + const args = varNames.join(", "); + return `/* WEBPACK VAR INJECTION */(function(${args}) {`; + } + + contextArgument(block) { + if(this === block) { + return this.exportsArgument || "exports"; + } + return "this"; + } + + /* + * creates the end part of a IIFE around the module to inject a variable name + * (function(...){ + * }.call(...)) <- this part + */ + variableInjectionFunctionWrapperEndCode(varExpressions, block) { + const firstParam = this.contextArgument(block); + const furtherParams = varExpressions.map(e => e.source()).join(", "); + return `}.call(${firstParam}, ${furtherParams}))`; + } + + splitVariablesInUniqueNamedChunks(vars) { + const startState = [ + [] + ]; + return vars.reduce((chunks, variable) => { + const current = chunks[chunks.length - 1]; + // check if variable with same name exists already + // if so create a new chunk of variables. + const variableNameAlreadyExists = current.some(v => v.name === variable.name); + + if(variableNameAlreadyExists) { + // start new chunk with current variable + chunks.push([variable]); + } else { + // else add it to current chunk + current.push(variable); + } + return chunks; + }, startState); + } + + sourceBlock(block, availableVars, dependencyTemplates, source, outputOptions, requestShortener) { + block.dependencies.forEach((dependency) => this.sourceDependency( + dependency, dependencyTemplates, source, outputOptions, requestShortener)); + + /** + * Get the variables of all blocks that we need to inject. + * These will contain the variable name and its expression. + * The name will be added as a paramter in a IIFE the expression as its value. + */ + const vars = block.variables.map((variable) => this.sourceVariables( + variable, availableVars, dependencyTemplates, outputOptions, requestShortener)) + .filter(Boolean); + + /** + * if we actually have variables + * this is important as how #splitVariablesInUniqueNamedChunks works + * it will always return an array in an array which would lead to a IIFE wrapper around + * a module if we do this with an empty vars array. + */ + if(vars.length > 0) { + /** + * Split all variables up into chunks of unique names. + * e.g. imagine you have the following variable names that need to be injected: + * [foo, bar, baz, foo, some, more] + * we can not inject "foo" twice, therefore we just make two IIFEs like so: + * (function(foo, bar, baz){ + * (function(foo, some, more){ + * ... + * }(...)); + * }(...)); + * + * "splitVariablesInUniqueNamedChunks" splits the variables shown above up to this: + * [[foo, bar, baz], [foo, some, more]] + */ + const injectionVariableChunks = this.splitVariablesInUniqueNamedChunks(vars); + + // create all the beginnings of IIFEs + const functionWrapperStarts = injectionVariableChunks.map((variableChunk) => variableChunk.map(variable => variable.name)) + .map(names => this.variableInjectionFunctionWrapperStartCode(names)); + + // and all the ends + const functionWrapperEnds = injectionVariableChunks.map((variableChunk) => variableChunk.map(variable => variable.expression)) + .map(expressions => this.variableInjectionFunctionWrapperEndCode(expressions, block)); + + // join them to one big string + const varStartCode = functionWrapperStarts.join(""); + // reverse the ends first before joining them, as the last added must be the inner most + const varEndCode = functionWrapperEnds.reverse().join(""); + + // if we have anything, add it to the source + if(varStartCode && varEndCode) { + const start = block.range ? block.range[0] : -10; + const end = block.range ? block.range[1] : (this._source.size() + 1); + source.insert(start + 0.5, varStartCode); + source.insert(end + 0.5, "\n/* WEBPACK VAR INJECTION */" + varEndCode); + } + } + block.blocks.forEach((block) => this.sourceBlock( + block, availableVars.concat(vars), dependencyTemplates, source, outputOptions, requestShortener)); + } + + source(dependencyTemplates, outputOptions, requestShortener) { + const hashDigest = this.getHashDigest(); + if(this._cachedSource && this._cachedSource.hash === hashDigest) { + return this._cachedSource.source; + } + + if(!this._source) { + return new RawSource("throw new Error('No source available');"); + } + + const source = new ReplaceSource(this._source); + this._cachedSource = { + source: source, + hash: hashDigest + }; + + this.sourceBlock(this, [], dependencyTemplates, source, outputOptions, requestShortener); + return new CachedSource(source); + } + + originalSource() { + return this._source; + } + + getHighestTimestamp(keys, timestampsByKey) { + let highestTimestamp = 0; + for(let i = 0; i < keys.length; i++) { + const key = keys[i]; + const timestamp = timestampsByKey[key]; + // if there is no timestamp yet, early return with Infinity + if(!timestamp) return Infinity; + highestTimestamp = Math.max(highestTimestamp, timestamp); + } + return highestTimestamp; + } + + needRebuild(fileTimestamps, contextTimestamps) { + const highestFileDepTimestamp = this.getHighestTimestamp( + this.fileDependencies, fileTimestamps); + // if the hightest is Infinity, we need a rebuild + // exit early here. + if(highestFileDepTimestamp === Infinity) { + return true; + } + + const highestContextDepTimestamp = this.getHighestTimestamp( + this.contextDependencies, contextTimestamps); + + // Again if the hightest is Infinity, we need a rebuild + // exit early here. + if(highestContextDepTimestamp === Infinity) { + return true; + } + + // else take the highest of file and context timestamps and compare + // to last build timestamp + return Math.max(highestContextDepTimestamp, highestFileDepTimestamp) >= this.buildTimestamp; + } + + size() { + return this._source ? this._source.size() : -1; + } + + updateHashWithSource(hash) { + if(!this._source) { + hash.update("null"); + return; + } + hash.update("source"); + this._source.updateHash(hash); + } + + updateHashWithMeta(hash) { + hash.update("meta"); + hash.update(JSON.stringify(this.meta)); + } + + updateHash(hash) { + this.updateHashWithSource(hash); + this.updateHashWithMeta(hash); + super.updateHash(hash); + } + +} + +module.exports = NormalModule; diff --git a/node_modules/webpack/lib/NormalModuleFactory.js b/node_modules/webpack/lib/NormalModuleFactory.js new file mode 100644 index 000000000..170afb1c3 --- /dev/null +++ b/node_modules/webpack/lib/NormalModuleFactory.js @@ -0,0 +1,304 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra + */ +"use strict"; + +const asyncLib = require("async"); +const Tapable = require("tapable"); +const NormalModule = require("./NormalModule"); +const RawModule = require("./RawModule"); +const Parser = require("./Parser"); +const RuleSet = require("./RuleSet"); + +function loaderToIdent(data) { + if(!data.options) + return data.loader; + if(typeof data.options === "string") + return data.loader + "?" + data.options; + if(typeof data.options !== "object") + throw new Error("loader options must be string or object"); + if(data.ident) + return data.loader + "??" + data.ident; + return data.loader + "?" + JSON.stringify(data.options); +} + +function identToLoaderRequest(resultString) { + const idx = resultString.indexOf("?"); + let options; + + if(idx >= 0) { + options = resultString.substr(idx + 1); + resultString = resultString.substr(0, idx); + + return { + loader: resultString, + options + }; + } else { + return { + loader: resultString + }; + } +} + +class NormalModuleFactory extends Tapable { + constructor(context, resolvers, options) { + super(); + this.resolvers = resolvers; + this.ruleSet = new RuleSet(options.rules || options.loaders); + this.cachePredicate = typeof options.unsafeCache === "function" ? options.unsafeCache : Boolean.bind(null, options.unsafeCache); + this.context = context || ""; + this.parserCache = {}; + this.plugin("factory", function() { + /* beautify preserve:start */ + // js-beautify consider to concat "return" and "(" + // but it сontradicts eslint rule (keyword-spacing) + return (result, callback) => { + /* beautify preserve:end */ + let resolver = this.applyPluginsWaterfall0("resolver", null); + + // Ignored + if(!resolver) return callback(); + + resolver(result, (err, data) => { + if(err) return callback(err); + + // Ignored + if(!data) return callback(); + + // direct module + if(typeof data.source === "function") + return callback(null, data); + + this.applyPluginsAsyncWaterfall("after-resolve", data, (err, result) => { + if(err) return callback(err); + + // Ignored + if(!result) return callback(); + + let createdModule = this.applyPluginsBailResult("create-module", result); + if(!createdModule) { + + if(!result.request) { + return callback(new Error("Empty dependency (no request)")); + } + + createdModule = new NormalModule( + result.request, + result.userRequest, + result.rawRequest, + result.loaders, + result.resource, + result.parser + ); + } + + createdModule = this.applyPluginsWaterfall0("module", createdModule); + + return callback(null, createdModule); + }); + }); + }; + }); + this.plugin("resolver", function() { + /* beautify preserve:start */ + // js-beautify consider to concat "return" and "(" + // but it сontradicts eslint rule (keyword-spacing) + return (data, callback) => { + /* beautify preserve:end */ + const contextInfo = data.contextInfo; + const context = data.context; + const request = data.request; + + const noAutoLoaders = /^-?!/.test(request); + const noPrePostAutoLoaders = /^!!/.test(request); + const noPostAutoLoaders = /^-!/.test(request); + let elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!"); + let resource = elements.pop(); + elements = elements.map(identToLoaderRequest); + + asyncLib.parallel([ + callback => this.resolveRequestArray(contextInfo, context, elements, this.resolvers.loader, callback), + callback => { + if(resource === "" || resource[0] === "?") + return callback(null, { + resource + }); + + this.resolvers.normal.resolve(contextInfo, context, resource, (err, resource, resourceResolveData) => { + if(err) return callback(err); + callback(null, { + resourceResolveData, + resource + }); + }); + } + ], (err, results) => { + if(err) return callback(err); + let loaders = results[0]; + const resourceResolveData = results[1].resourceResolveData; + resource = results[1].resource; + + // translate option idents + try { + loaders.forEach(item => { + if(typeof item.options === "string" && /^\?/.test(item.options)) { + item.options = this.ruleSet.findOptionsByIdent(item.options.substr(1)); + } + }); + } catch(e) { + return callback(e); + } + + if(resource === false) { + // ignored + return callback(null, + new RawModule( + "/* (ignored) */", + `ignored ${context} ${request}`, + `${request} (ignored)` + ) + ); + } + + const userRequest = loaders.map(loaderToIdent).concat([resource]).join("!"); + + let resourcePath = resource; + let resourceQuery = ""; + const queryIndex = resourcePath.indexOf("?"); + if(queryIndex >= 0) { + resourceQuery = resourcePath.substr(queryIndex); + resourcePath = resourcePath.substr(0, queryIndex); + } + + const result = this.ruleSet.exec({ + resource: resourcePath, + resourceQuery, + issuer: contextInfo.issuer, + compiler: contextInfo.compiler + }); + const settings = {}; + const useLoadersPost = []; + const useLoaders = []; + const useLoadersPre = []; + result.forEach(r => { + if(r.type === "use") { + if(r.enforce === "post" && !noPostAutoLoaders && !noPrePostAutoLoaders) + useLoadersPost.push(r.value); + else if(r.enforce === "pre" && !noPrePostAutoLoaders) + useLoadersPre.push(r.value); + else if(!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders) + useLoaders.push(r.value); + } else { + settings[r.type] = r.value; + } + }); + asyncLib.parallel([ + this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPost, this.resolvers.loader), + this.resolveRequestArray.bind(this, contextInfo, this.context, useLoaders, this.resolvers.loader), + this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPre, this.resolvers.loader) + ], (err, results) => { + if(err) return callback(err); + loaders = results[0].concat(loaders, results[1], results[2]); + process.nextTick(() => { + callback(null, { + context: context, + request: loaders.map(loaderToIdent).concat([resource]).join("!"), + dependencies: data.dependencies, + userRequest, + rawRequest: request, + loaders, + resource, + resourceResolveData, + parser: this.getParser(settings.parser) + }); + }); + }); + }); + }; + }); + } + + create(data, callback) { + const dependencies = data.dependencies; + const cacheEntry = dependencies[0].__NormalModuleFactoryCache; + if(cacheEntry) return callback(null, cacheEntry); + const context = data.context || this.context; + const request = dependencies[0].request; + const contextInfo = data.contextInfo || {}; + this.applyPluginsAsyncWaterfall("before-resolve", { + contextInfo, + context, + request, + dependencies + }, (err, result) => { + if(err) return callback(err); + + // Ignored + if(!result) return callback(); + + const factory = this.applyPluginsWaterfall0("factory", null); + + // Ignored + if(!factory) return callback(); + + factory(result, (err, module) => { + if(err) return callback(err); + + if(module && this.cachePredicate(module)) { + dependencies.forEach(d => d.__NormalModuleFactoryCache = module); + } + + callback(null, module); + }); + }); + } + + resolveRequestArray(contextInfo, context, array, resolver, callback) { + if(array.length === 0) return callback(null, []); + asyncLib.map(array, (item, callback) => { + resolver.resolve(contextInfo, context, item.loader, (err, result) => { + if(err && /^[^/]*$/.test(item.loader) && !/-loader$/.test(item.loader)) { + return resolver.resolve(contextInfo, context, item.loader + "-loader", err2 => { + if(!err2) { + err.message = err.message + "\n" + + "BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" + + ` You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` + + " see https://webpack.js.org/guides/migrating/#automatic-loader-module-name-extension-removed"; + } + callback(err); + }); + } + if(err) return callback(err); + + const optionsOnly = item.options ? { + options: item.options + } : undefined; + return callback(null, Object.assign({}, item, identToLoaderRequest(result), optionsOnly)); + }); + }, callback); + } + + getParser(parserOptions) { + let ident = "null"; + if(parserOptions) { + if(parserOptions.ident) + ident = parserOptions.ident; + else + ident = JSON.stringify(parserOptions); + } + const parser = this.parserCache[ident]; + if(parser) + return parser; + return this.parserCache[ident] = this.createParser(parserOptions); + } + + createParser(parserOptions) { + const parser = new Parser(); + this.applyPlugins2("parser", parser, parserOptions || {}); + return parser; + } +} + +module.exports = NormalModuleFactory; diff --git a/node_modules/webpack/lib/NormalModuleReplacementPlugin.js b/node_modules/webpack/lib/NormalModuleReplacementPlugin.js new file mode 100644 index 000000000..46a662d68 --- /dev/null +++ b/node_modules/webpack/lib/NormalModuleReplacementPlugin.js @@ -0,0 +1,45 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); + +class NormalModuleReplacementPlugin { + constructor(resourceRegExp, newResource) { + this.resourceRegExp = resourceRegExp; + this.newResource = newResource; + } + + apply(compiler) { + const resourceRegExp = this.resourceRegExp; + const newResource = this.newResource; + compiler.plugin("normal-module-factory", (nmf) => { + nmf.plugin("before-resolve", (result, callback) => { + if(!result) return callback(); + if(resourceRegExp.test(result.request)) { + if(typeof newResource === "function") { + newResource(result); + } else { + result.request = newResource; + } + } + return callback(null, result); + }); + nmf.plugin("after-resolve", (result, callback) => { + if(!result) return callback(); + if(resourceRegExp.test(result.resource)) { + if(typeof newResource === "function") { + newResource(result); + } else { + result.resource = path.resolve(path.dirname(result.resource), newResource); + } + } + return callback(null, result); + }); + }); + } +} + +module.exports = NormalModuleReplacementPlugin; diff --git a/node_modules/webpack/lib/NullFactory.js b/node_modules/webpack/lib/NullFactory.js new file mode 100644 index 000000000..9ff4cb58e --- /dev/null +++ b/node_modules/webpack/lib/NullFactory.js @@ -0,0 +1,12 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class NullFactory { + create(data, callback) { + return callback(); + } +} +module.exports = NullFactory; diff --git a/node_modules/webpack/lib/OptionsApply.js b/node_modules/webpack/lib/OptionsApply.js new file mode 100644 index 000000000..022506360 --- /dev/null +++ b/node_modules/webpack/lib/OptionsApply.js @@ -0,0 +1,10 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class OptionsApply { + process(options, compiler) {} +} +module.exports = OptionsApply; diff --git a/node_modules/webpack/lib/OptionsDefaulter.js b/node_modules/webpack/lib/OptionsDefaulter.js new file mode 100644 index 000000000..f9bd0c00b --- /dev/null +++ b/node_modules/webpack/lib/OptionsDefaulter.js @@ -0,0 +1,71 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +function getProperty(obj, name) { + name = name.split("."); + for(var i = 0; i < name.length - 1; i++) { + obj = obj[name[i]]; + if(typeof obj !== "object" || !obj) return; + } + return obj[name.pop()]; +} + +function setProperty(obj, name, value) { + name = name.split("."); + for(var i = 0; i < name.length - 1; i++) { + if(typeof obj[name[i]] !== "object" && typeof obj[name[i]] !== "undefined") return; + if(!obj[name[i]]) obj[name[i]] = {}; + obj = obj[name[i]]; + } + obj[name.pop()] = value; +} + +class OptionsDefaulter { + constructor() { + this.defaults = {}; + this.config = {}; + } + + process(options) { + for(let name in this.defaults) { + switch(this.config[name]) { + case undefined: + if(getProperty(options, name) === undefined) + setProperty(options, name, this.defaults[name]); + break; + case "call": + setProperty(options, name, this.defaults[name].call(this, getProperty(options, name), options), options); + break; + case "make": + if(getProperty(options, name) === undefined) + setProperty(options, name, this.defaults[name].call(this, options), options); + break; + case "append": + { + let oldValue = getProperty(options, name); + if(!Array.isArray(oldValue)) oldValue = []; + oldValue.push.apply(oldValue, this.defaults[name]); + setProperty(options, name, oldValue); + break; + } + default: + throw new Error("OptionsDefaulter cannot process " + this.config[name]); + } + } + } + + set(name, config, def) { + if(arguments.length === 3) { + this.defaults[name] = def; + this.config[name] = config; + } else { + this.defaults[name] = config; + delete this.config[name]; + } + } +} + +module.exports = OptionsDefaulter; diff --git a/node_modules/webpack/lib/Parser.js b/node_modules/webpack/lib/Parser.js new file mode 100644 index 000000000..02db5c562 --- /dev/null +++ b/node_modules/webpack/lib/Parser.js @@ -0,0 +1,1391 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API + +const acorn = require("acorn-dynamic-import").default; +const Tapable = require("tapable"); +const json5 = require("json5"); +const BasicEvaluatedExpression = require("./BasicEvaluatedExpression"); + +function joinRanges(startRange, endRange) { + if(!endRange) return startRange; + if(!startRange) return endRange; + return [startRange[0], endRange[1]]; +} + +const POSSIBLE_AST_OPTIONS = [{ + ranges: true, + locations: true, + ecmaVersion: 2017, + sourceType: "module", + plugins: { + dynamicImport: true + } +}, { + ranges: true, + locations: true, + ecmaVersion: 2017, + sourceType: "script", + plugins: { + dynamicImport: true + } +}]; + +class Parser extends Tapable { + constructor(options) { + super(); + this.options = options; + this.scope = undefined; + this.state = undefined; + this.comments = undefined; + this.initializeEvaluating(); + } + + initializeEvaluating() { + this.plugin("evaluate Literal", expr => { + switch(typeof expr.value) { + case "number": + return new BasicEvaluatedExpression().setNumber(expr.value).setRange(expr.range); + case "string": + return new BasicEvaluatedExpression().setString(expr.value).setRange(expr.range); + case "boolean": + return new BasicEvaluatedExpression().setBoolean(expr.value).setRange(expr.range); + } + if(expr.value === null) + return new BasicEvaluatedExpression().setNull().setRange(expr.range); + if(expr.value instanceof RegExp) + return new BasicEvaluatedExpression().setRegExp(expr.value).setRange(expr.range); + }); + this.plugin("evaluate LogicalExpression", function(expr) { + let left; + let leftAsBool; + let right; + if(expr.operator === "&&") { + left = this.evaluateExpression(expr.left); + leftAsBool = left && left.asBool(); + if(leftAsBool === false) return left.setRange(expr.range); + if(leftAsBool !== true) return; + right = this.evaluateExpression(expr.right); + return right.setRange(expr.range); + } else if(expr.operator === "||") { + left = this.evaluateExpression(expr.left); + leftAsBool = left && left.asBool(); + if(leftAsBool === true) return left.setRange(expr.range); + if(leftAsBool !== false) return; + right = this.evaluateExpression(expr.right); + return right.setRange(expr.range); + } + }); + this.plugin("evaluate BinaryExpression", function(expr) { + let left; + let right; + let res; + if(expr.operator === "+") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + res = new BasicEvaluatedExpression(); + if(left.isString()) { + if(right.isString()) { + res.setString(left.string + right.string); + } else if(right.isNumber()) { + res.setString(left.string + right.number); + } else if(right.isWrapped() && right.prefix && right.prefix.isString()) { + res.setWrapped( + new BasicEvaluatedExpression() + .setString(left.string + right.prefix.string) + .setRange(joinRanges(left.range, right.prefix.range)), + right.postfix); + } else if(right.isWrapped()) { + res.setWrapped( + new BasicEvaluatedExpression() + .setString(left.string) + .setRange(left.range), + right.postfix); + } else { + res.setWrapped(left, null); + } + } else if(left.isNumber()) { + if(right.isString()) { + res.setString(left.number + right.string); + } else if(right.isNumber()) { + res.setNumber(left.number + right.number); + } + } else if(left.isWrapped()) { + if(left.postfix && left.postfix.isString() && right.isString()) { + res.setWrapped(left.prefix, + new BasicEvaluatedExpression() + .setString(left.postfix.string + right.string) + .setRange(joinRanges(left.postfix.range, right.range)) + ); + } else if(left.postfix && left.postfix.isString() && right.isNumber()) { + res.setWrapped(left.prefix, + new BasicEvaluatedExpression() + .setString(left.postfix.string + right.number) + .setRange(joinRanges(left.postfix.range, right.range)) + ); + } else if(right.isString()) { + res.setWrapped(left.prefix, right); + } else if(right.isNumber()) { + res.setWrapped(left.prefix, + new BasicEvaluatedExpression() + .setString(right.number + "") + .setRange(right.range)); + } else { + res.setWrapped(left.prefix, new BasicEvaluatedExpression()); + } + } else { + if(right.isString()) { + res.setWrapped(null, right); + } + } + res.setRange(expr.range); + return res; + } else if(expr.operator === "-") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + if(!left.isNumber() || !right.isNumber()) return; + res = new BasicEvaluatedExpression(); + res.setNumber(left.number - right.number); + res.setRange(expr.range); + return res; + } else if(expr.operator === "*") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + if(!left.isNumber() || !right.isNumber()) return; + res = new BasicEvaluatedExpression(); + res.setNumber(left.number * right.number); + res.setRange(expr.range); + return res; + } else if(expr.operator === "/") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + if(!left.isNumber() || !right.isNumber()) return; + res = new BasicEvaluatedExpression(); + res.setNumber(left.number / right.number); + res.setRange(expr.range); + return res; + } else if(expr.operator === "==" || expr.operator === "===") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + res = new BasicEvaluatedExpression(); + res.setRange(expr.range); + if(left.isString() && right.isString()) { + return res.setBoolean(left.string === right.string); + } else if(left.isNumber() && right.isNumber()) { + return res.setBoolean(left.number === right.number); + } else if(left.isBoolean() && right.isBoolean()) { + return res.setBoolean(left.bool === right.bool); + } + } else if(expr.operator === "!=" || expr.operator === "!==") { + left = this.evaluateExpression(expr.left); + right = this.evaluateExpression(expr.right); + if(!left || !right) return; + res = new BasicEvaluatedExpression(); + res.setRange(expr.range); + if(left.isString() && right.isString()) { + return res.setBoolean(left.string !== right.string); + } else if(left.isNumber() && right.isNumber()) { + return res.setBoolean(left.number !== right.number); + } else if(left.isBoolean() && right.isBoolean()) { + return res.setBoolean(left.bool !== right.bool); + } + } + }); + this.plugin("evaluate UnaryExpression", function(expr) { + if(expr.operator === "typeof") { + let res; + let name; + if(expr.argument.type === "Identifier") { + name = this.scope.renames["$" + expr.argument.name] || expr.argument.name; + if(this.scope.definitions.indexOf(name) === -1) { + res = this.applyPluginsBailResult1("evaluate typeof " + name, expr); + if(res !== undefined) return res; + } + } + if(expr.argument.type === "MemberExpression") { + let expression = expr.argument; + let exprName = []; + while(expression.type === "MemberExpression" && !expression.computed) { + exprName.unshift(this.scope.renames["$" + expression.property.name] || expression.property.name); + expression = expression.object; + } + if(expression.type === "Identifier") { + exprName.unshift(this.scope.renames["$" + expression.name] || expression.name); + if(this.scope.definitions.indexOf(name) === -1) { + exprName = exprName.join("."); + res = this.applyPluginsBailResult1("evaluate typeof " + exprName, expr); + if(res !== undefined) return res; + } + } + } + if(expr.argument.type === "FunctionExpression") { + return new BasicEvaluatedExpression().setString("function").setRange(expr.range); + } + const arg = this.evaluateExpression(expr.argument); + if(arg.isString() || arg.isWrapped()) return new BasicEvaluatedExpression().setString("string").setRange(expr.range); + else if(arg.isNumber()) return new BasicEvaluatedExpression().setString("number").setRange(expr.range); + else if(arg.isBoolean()) return new BasicEvaluatedExpression().setString("boolean").setRange(expr.range); + else if(arg.isArray() || arg.isConstArray() || arg.isRegExp()) return new BasicEvaluatedExpression().setString("object").setRange(expr.range); + } else if(expr.operator === "!") { + const argument = this.evaluateExpression(expr.argument); + if(!argument) return; + if(argument.isBoolean()) { + return new BasicEvaluatedExpression().setBoolean(!argument.bool).setRange(expr.range); + } else if(argument.isString()) { + return new BasicEvaluatedExpression().setBoolean(!argument.string).setRange(expr.range); + } else if(argument.isNumber()) { + return new BasicEvaluatedExpression().setBoolean(!argument.number).setRange(expr.range); + } + } + }); + this.plugin("evaluate typeof undefined", function(expr) { + return new BasicEvaluatedExpression().setString("undefined").setRange(expr.range); + }); + this.plugin("evaluate Identifier", function(expr) { + const name = this.scope.renames["$" + expr.name] || expr.name; + if(this.scope.definitions.indexOf(expr.name) === -1) { + const result = this.applyPluginsBailResult1("evaluate Identifier " + name, expr); + if(result) return result; + return new BasicEvaluatedExpression().setIdentifier(name).setRange(expr.range); + } else { + return this.applyPluginsBailResult1("evaluate defined Identifier " + name, expr); + } + }); + this.plugin("evaluate MemberExpression", function(expression) { + let expr = expression; + let exprName = []; + while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) { + exprName.unshift(expr.property.name || expr.property.value); + expr = expr.object; + } + if(expr.type === "Identifier") { + const name = this.scope.renames["$" + expr.name] || expr.name; + if(this.scope.definitions.indexOf(name) === -1) { + exprName.unshift(name); + exprName = exprName.join("."); + if(this.scope.definitions.indexOf(expr.name) === -1) { + const result = this.applyPluginsBailResult1("evaluate Identifier " + exprName, expression); + if(result) return result; + return new BasicEvaluatedExpression().setIdentifier(exprName).setRange(expression.range); + } else { + return this.applyPluginsBailResult1("evaluate defined Identifier " + exprName, expression); + } + } + } + }); + this.plugin("evaluate CallExpression", function(expr) { + if(expr.callee.type !== "MemberExpression") return; + if(expr.callee.property.type !== (expr.callee.computed ? "Literal" : "Identifier")) return; + const param = this.evaluateExpression(expr.callee.object); + if(!param) return; + const property = expr.callee.property.name || expr.callee.property.value; + return this.applyPluginsBailResult("evaluate CallExpression ." + property, expr, param); + }); + this.plugin("evaluate CallExpression .replace", function(expr, param) { + if(!param.isString()) return; + if(expr.arguments.length !== 2) return; + let arg1 = this.evaluateExpression(expr.arguments[0]); + let arg2 = this.evaluateExpression(expr.arguments[1]); + if(!arg1.isString() && !arg1.isRegExp()) return; + arg1 = arg1.regExp || arg1.string; + if(!arg2.isString()) return; + arg2 = arg2.string; + return new BasicEvaluatedExpression().setString(param.string.replace(arg1, arg2)).setRange(expr.range); + }); + ["substr", "substring"].forEach(fn => { + this.plugin("evaluate CallExpression ." + fn, function(expr, param) { + if(!param.isString()) return; + let arg1; + let result, str = param.string; + switch(expr.arguments.length) { + case 1: + arg1 = this.evaluateExpression(expr.arguments[0]); + if(!arg1.isNumber()) return; + result = str[fn](arg1.number); + break; + case 2: + { + arg1 = this.evaluateExpression(expr.arguments[0]); + const arg2 = this.evaluateExpression(expr.arguments[1]); + if(!arg1.isNumber()) return; + if(!arg2.isNumber()) return; + result = str[fn](arg1.number, arg2.number); + break; + } + default: + return; + } + return new BasicEvaluatedExpression().setString(result).setRange(expr.range); + }); + + /** + * @param {string} kind "cooked" | "raw" + * @param {any[]} quasis quasis + * @param {any[]} expressions expressions + * @return {BasicEvaluatedExpression[]} Simplified template + */ + function getSimplifiedTemplateResult(kind, quasis, expressions) { + const parts = []; + + for(let i = 0; i < quasis.length; i++) { + parts.push(new BasicEvaluatedExpression().setString(quasis[i].value[kind]).setRange(quasis[i].range)); + + if(i > 0) { + const prevExpr = parts[parts.length - 2], + lastExpr = parts[parts.length - 1]; + const expr = this.evaluateExpression(expressions[i - 1]); + if(!(expr.isString() || expr.isNumber())) continue; + + prevExpr.setString(prevExpr.string + (expr.isString() ? expr.string : expr.number) + lastExpr.string); + prevExpr.setRange([prevExpr.range[0], lastExpr.range[1]]); + parts.pop(); + } + } + return parts; + } + + this.plugin("evaluate TemplateLiteral", function(node) { + const parts = getSimplifiedTemplateResult.call(this, "cooked", node.quasis, node.expressions); + if(parts.length === 1) { + return parts[0].setRange(node.range); + } + return new BasicEvaluatedExpression().setTemplateString(parts).setRange(node.range); + }); + this.plugin("evaluate TaggedTemplateExpression", function(node) { + if(this.evaluateExpression(node.tag).identifier !== "String.raw") return; + const parts = getSimplifiedTemplateResult.call(this, "raw", node.quasi.quasis, node.quasi.expressions); + return new BasicEvaluatedExpression().setTemplateString(parts).setRange(node.range); + }); + }); + this.plugin("evaluate CallExpression .split", function(expr, param) { + if(!param.isString()) return; + if(expr.arguments.length !== 1) return; + let result; + const arg = this.evaluateExpression(expr.arguments[0]); + if(arg.isString()) { + result = param.string.split(arg.string); + } else if(arg.isRegExp()) { + result = param.string.split(arg.regExp); + } else return; + return new BasicEvaluatedExpression().setArray(result).setRange(expr.range); + }); + this.plugin("evaluate ConditionalExpression", function(expr) { + const condition = this.evaluateExpression(expr.test); + const conditionValue = condition.asBool(); + let res; + if(conditionValue === undefined) { + const consequent = this.evaluateExpression(expr.consequent); + const alternate = this.evaluateExpression(expr.alternate); + if(!consequent || !alternate) return; + res = new BasicEvaluatedExpression(); + if(consequent.isConditional()) + res.setOptions(consequent.options); + else + res.setOptions([consequent]); + if(alternate.isConditional()) + res.addOptions(alternate.options); + else + res.addOptions([alternate]); + } else { + res = this.evaluateExpression(conditionValue ? expr.consequent : expr.alternate); + } + res.setRange(expr.range); + return res; + }); + this.plugin("evaluate ArrayExpression", function(expr) { + const items = expr.elements.map(function(element) { + return element !== null && this.evaluateExpression(element); + }, this); + if(!items.every(Boolean)) return; + return new BasicEvaluatedExpression().setItems(items).setRange(expr.range); + }); + } + + getRenameIdentifier(expr) { + const result = this.evaluateExpression(expr); + if(!result) return; + if(result.isIdentifier()) return result.identifier; + return; + } + + walkClass(classy) { + if(classy.superClass) + this.walkExpression(classy.superClass); + if(classy.body && classy.body.type === "ClassBody") { + classy.body.body.forEach(methodDefinition => { + if(methodDefinition.type === "MethodDefinition") + this.walkMethodDefinition(methodDefinition); + }); + } + } + + walkMethodDefinition(methodDefinition) { + if(methodDefinition.computed && methodDefinition.key) + this.walkExpression(methodDefinition.key); + if(methodDefinition.value) + this.walkExpression(methodDefinition.value); + } + + // Prewalking iterates the scope for variable declarations + prewalkStatements(statements) { + for(let index = 0, len = statements.length; index < len; index++) { + const statement = statements[index]; + this.prewalkStatement(statement); + } + } + + // Walking iterates the statements and expressions and processes them + walkStatements(statements) { + for(let index = 0, len = statements.length; index < len; index++) { + const statement = statements[index]; + this.walkStatement(statement); + } + } + + prewalkStatement(statement) { + const handler = this["prewalk" + statement.type]; + if(handler) + handler.call(this, statement); + } + + walkStatement(statement) { + if(this.applyPluginsBailResult1("statement", statement) !== undefined) return; + const handler = this["walk" + statement.type]; + if(handler) + handler.call(this, statement); + } + + // Real Statements + prewalkBlockStatement(statement) { + this.prewalkStatements(statement.body); + } + + walkBlockStatement(statement) { + this.walkStatements(statement.body); + } + + walkExpressionStatement(statement) { + this.walkExpression(statement.expression); + } + + prewalkIfStatement(statement) { + this.prewalkStatement(statement.consequent); + if(statement.alternate) + this.prewalkStatement(statement.alternate); + } + + walkIfStatement(statement) { + const result = this.applyPluginsBailResult1("statement if", statement); + if(result === undefined) { + this.walkExpression(statement.test); + this.walkStatement(statement.consequent); + if(statement.alternate) + this.walkStatement(statement.alternate); + } else { + if(result) + this.walkStatement(statement.consequent); + else if(statement.alternate) + this.walkStatement(statement.alternate); + } + } + + prewalkLabeledStatement(statement) { + this.prewalkStatement(statement.body); + } + + walkLabeledStatement(statement) { + const result = this.applyPluginsBailResult1("label " + statement.label.name, statement); + if(result !== true) + this.walkStatement(statement.body); + } + + prewalkWithStatement(statement) { + this.prewalkStatement(statement.body); + } + + walkWithStatement(statement) { + this.walkExpression(statement.object); + this.walkStatement(statement.body); + } + + prewalkSwitchStatement(statement) { + this.prewalkSwitchCases(statement.cases); + } + + walkSwitchStatement(statement) { + this.walkExpression(statement.discriminant); + this.walkSwitchCases(statement.cases); + } + + walkTerminatingStatement(statement) { + if(statement.argument) + this.walkExpression(statement.argument); + } + + walkReturnStatement(statement) { + this.walkTerminatingStatement(statement); + } + + walkThrowStatement(statement) { + this.walkTerminatingStatement(statement); + } + + prewalkTryStatement(statement) { + this.prewalkStatement(statement.block); + } + + walkTryStatement(statement) { + if(this.scope.inTry) { + this.walkStatement(statement.block); + } else { + this.scope.inTry = true; + this.walkStatement(statement.block); + this.scope.inTry = false; + } + if(statement.handler) + this.walkCatchClause(statement.handler); + if(statement.finalizer) + this.walkStatement(statement.finalizer); + } + + prewalkWhileStatement(statement) { + this.prewalkStatement(statement.body); + } + + walkWhileStatement(statement) { + this.walkExpression(statement.test); + this.walkStatement(statement.body); + } + + prewalkDoWhileStatement(statement) { + this.prewalkStatement(statement.body); + } + + walkDoWhileStatement(statement) { + this.walkStatement(statement.body); + this.walkExpression(statement.test); + } + + prewalkForStatement(statement) { + if(statement.init) { + if(statement.init.type === "VariableDeclaration") + this.prewalkStatement(statement.init); + } + this.prewalkStatement(statement.body); + } + + walkForStatement(statement) { + if(statement.init) { + if(statement.init.type === "VariableDeclaration") + this.walkStatement(statement.init); + else + this.walkExpression(statement.init); + } + if(statement.test) + this.walkExpression(statement.test); + if(statement.update) + this.walkExpression(statement.update); + this.walkStatement(statement.body); + } + + prewalkForInStatement(statement) { + if(statement.left.type === "VariableDeclaration") + this.prewalkStatement(statement.left); + this.prewalkStatement(statement.body); + } + + walkForInStatement(statement) { + if(statement.left.type === "VariableDeclaration") + this.walkStatement(statement.left); + else + this.walkExpression(statement.left); + this.walkExpression(statement.right); + this.walkStatement(statement.body); + } + + prewalkForOfStatement(statement) { + if(statement.left.type === "VariableDeclaration") + this.prewalkStatement(statement.left); + this.prewalkStatement(statement.body); + } + + walkForOfStatement(statement) { + if(statement.left.type === "VariableDeclaration") + this.walkStatement(statement.left); + else + this.walkExpression(statement.left); + this.walkExpression(statement.right); + this.walkStatement(statement.body); + } + + // Declarations + prewalkFunctionDeclaration(statement) { + if(statement.id) { + this.scope.renames["$" + statement.id.name] = undefined; + this.scope.definitions.push(statement.id.name); + } + } + + walkFunctionDeclaration(statement) { + this.inScope(statement.params, function() { + if(statement.body.type === "BlockStatement") { + this.prewalkStatement(statement.body); + this.walkStatement(statement.body); + } else { + this.walkExpression(statement.body); + } + }.bind(this)); + } + + prewalkImportDeclaration(statement) { + const source = statement.source.value; + this.applyPluginsBailResult("import", statement, source); + statement.specifiers.forEach(function(specifier) { + const name = specifier.local.name; + this.scope.renames["$" + name] = undefined; + this.scope.definitions.push(name); + switch(specifier.type) { + case "ImportDefaultSpecifier": + this.applyPluginsBailResult("import specifier", statement, source, "default", name); + break; + case "ImportSpecifier": + this.applyPluginsBailResult("import specifier", statement, source, specifier.imported.name, name); + break; + case "ImportNamespaceSpecifier": + this.applyPluginsBailResult("import specifier", statement, source, null, name); + break; + } + }, this); + } + + prewalkExportNamedDeclaration(statement) { + let source; + if(statement.source) { + source = statement.source.value; + this.applyPluginsBailResult("export import", statement, source); + } else { + this.applyPluginsBailResult1("export", statement); + } + if(statement.declaration) { + if(/Expression$/.test(statement.declaration.type)) { + throw new Error("Doesn't occur?"); + } else { + if(!this.applyPluginsBailResult("export declaration", statement, statement.declaration)) { + const pos = this.scope.definitions.length; + this.prewalkStatement(statement.declaration); + const newDefs = this.scope.definitions.slice(pos); + for(let index = newDefs.length - 1; index >= 0; index--) { + const def = newDefs[index]; + this.applyPluginsBailResult("export specifier", statement, def, def, index); + } + } + } + } + if(statement.specifiers) { + for(let specifierIndex = 0; specifierIndex < statement.specifiers.length; specifierIndex++) { + const specifier = statement.specifiers[specifierIndex]; + switch(specifier.type) { + case "ExportSpecifier": + { + const name = specifier.exported.name; + if(source) + this.applyPluginsBailResult("export import specifier", statement, source, specifier.local.name, name, specifierIndex); + else + this.applyPluginsBailResult("export specifier", statement, specifier.local.name, name, specifierIndex); + break; + } + } + } + } + } + + walkExportNamedDeclaration(statement) { + if(statement.declaration) { + this.walkStatement(statement.declaration); + } + } + + prewalkExportDefaultDeclaration(statement) { + if(/Declaration$/.test(statement.declaration.type)) { + const pos = this.scope.definitions.length; + this.prewalkStatement(statement.declaration); + const newDefs = this.scope.definitions.slice(pos); + for(let index = 0, len = newDefs.length; index < len; index++) { + const def = newDefs[index]; + this.applyPluginsBailResult("export specifier", statement, def, "default"); + } + } + } + + walkExportDefaultDeclaration(statement) { + this.applyPluginsBailResult1("export", statement); + if(/Declaration$/.test(statement.declaration.type)) { + if(!this.applyPluginsBailResult("export declaration", statement, statement.declaration)) { + this.walkStatement(statement.declaration); + } + } else { + this.walkExpression(statement.declaration); + if(!this.applyPluginsBailResult("export expression", statement, statement.declaration)) { + this.applyPluginsBailResult("export specifier", statement, statement.declaration, "default"); + } + } + } + + prewalkExportAllDeclaration(statement) { + const source = statement.source.value; + this.applyPluginsBailResult("export import", statement, source); + this.applyPluginsBailResult("export import specifier", statement, source, null, null, 0); + } + + prewalkVariableDeclaration(statement) { + if(statement.declarations) + this.prewalkVariableDeclarators(statement.declarations); + } + + walkVariableDeclaration(statement) { + if(statement.declarations) + this.walkVariableDeclarators(statement.declarations); + } + + prewalkClassDeclaration(statement) { + if(statement.id) { + this.scope.renames["$" + statement.id.name] = undefined; + this.scope.definitions.push(statement.id.name); + } + } + + walkClassDeclaration(statement) { + this.walkClass(statement); + } + + prewalkSwitchCases(switchCases) { + for(let index = 0, len = switchCases.length; index < len; index++) { + const switchCase = switchCases[index]; + this.prewalkStatements(switchCase.consequent); + } + } + + walkSwitchCases(switchCases) { + for(let index = 0, len = switchCases.length; index < len; index++) { + const switchCase = switchCases[index]; + + if(switchCase.test) { + this.walkExpression(switchCase.test); + } + this.walkStatements(switchCase.consequent); + } + } + + walkCatchClause(catchClause) { + this.inScope([catchClause.param], function() { + this.prewalkStatement(catchClause.body); + this.walkStatement(catchClause.body); + }.bind(this)); + } + + prewalkVariableDeclarators(declarators) { + declarators.forEach(declarator => { + switch(declarator.type) { + case "VariableDeclarator": + { + const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init); + if(renameIdentifier && declarator.id.type === "Identifier" && this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) { + // renaming with "var a = b;" + if(!this.applyPluginsBailResult1("rename " + renameIdentifier, declarator.init)) { + this.scope.renames["$" + declarator.id.name] = this.scope.renames["$" + renameIdentifier] || renameIdentifier; + const idx = this.scope.definitions.indexOf(declarator.id.name); + if(idx >= 0) this.scope.definitions.splice(idx, 1); + } + } else { + this.enterPattern(declarator.id, (name, decl) => { + if(!this.applyPluginsBailResult1("var-" + declarator.kind + " " + name, decl)) { + if(!this.applyPluginsBailResult1("var " + name, decl)) { + this.scope.renames["$" + name] = undefined; + this.scope.definitions.push(name); + } + } + }); + } + break; + } + } + }); + } + + walkVariableDeclarators(declarators) { + declarators.forEach(declarator => { + switch(declarator.type) { + case "VariableDeclarator": + { + const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init); + if(!renameIdentifier || declarator.id.type !== "Identifier" || !this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) { + this.walkPattern(declarator.id); + if(declarator.init) + this.walkExpression(declarator.init); + } + break; + } + } + }); + } + + walkPattern(pattern) { + if(pattern.type === "Identifier") + return; + if(this["walk" + pattern.type]) + this["walk" + pattern.type](pattern); + } + + walkObjectPattern(pattern) { + for(let i = 0, len = pattern.properties.length; i < len; i++) { + const prop = pattern.properties[i]; + if(prop) { + if(prop.computed) + this.walkExpression(prop.key); + if(prop.value) + this.walkPattern(prop.value); + } + } + } + + walkArrayPattern(pattern) { + for(let i = 0, len = pattern.elements.length; i < len; i++) { + const element = pattern.elements[i]; + if(element) + this.walkPattern(element); + } + } + + walkRestElement(pattern) { + this.walkPattern(pattern.argument); + } + + walkExpressions(expressions) { + for(let expressionsIndex = 0, len = expressions.length; expressionsIndex < len; expressionsIndex++) { + const expression = expressions[expressionsIndex]; + if(expression) + this.walkExpression(expression); + } + } + + walkExpression(expression) { + if(this["walk" + expression.type]) + return this["walk" + expression.type](expression); + } + + walkAwaitExpression(expression) { + const argument = expression.argument; + if(this["walk" + argument.type]) + return this["walk" + argument.type](argument); + } + + walkArrayExpression(expression) { + if(expression.elements) + this.walkExpressions(expression.elements); + } + + walkSpreadElement(expression) { + if(expression.argument) + this.walkExpression(expression.argument); + } + + walkObjectExpression(expression) { + for(let propIndex = 0, len = expression.properties.length; propIndex < len; propIndex++) { + const prop = expression.properties[propIndex]; + if(prop.computed) + this.walkExpression(prop.key); + if(prop.shorthand) + this.scope.inShorthand = true; + this.walkExpression(prop.value); + if(prop.shorthand) + this.scope.inShorthand = false; + } + } + + walkFunctionExpression(expression) { + this.inScope(expression.params, function() { + if(expression.body.type === "BlockStatement") { + this.prewalkStatement(expression.body); + this.walkStatement(expression.body); + } else { + this.walkExpression(expression.body); + } + }.bind(this)); + } + + walkArrowFunctionExpression(expression) { + this.inScope(expression.params, function() { + if(expression.body.type === "BlockStatement") { + this.prewalkStatement(expression.body); + this.walkStatement(expression.body); + } else { + this.walkExpression(expression.body); + } + }.bind(this)); + } + + walkSequenceExpression(expression) { + if(expression.expressions) + this.walkExpressions(expression.expressions); + } + + walkUpdateExpression(expression) { + this.walkExpression(expression.argument); + } + + walkUnaryExpression(expression) { + if(expression.operator === "typeof") { + let expr = expression.argument; + let exprName = []; + while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) { + exprName.unshift(expr.property.name || expr.property.value); + expr = expr.object; + } + if(expr.type === "Identifier" && this.scope.definitions.indexOf(expr.name) === -1) { + exprName.unshift(this.scope.renames["$" + expr.name] || expr.name); + exprName = exprName.join("."); + const result = this.applyPluginsBailResult1("typeof " + exprName, expression); + if(result === true) + return; + } + } + this.walkExpression(expression.argument); + } + + walkLeftRightExpression(expression) { + this.walkExpression(expression.left); + this.walkExpression(expression.right); + } + + walkBinaryExpression(expression) { + this.walkLeftRightExpression(expression); + } + + walkLogicalExpression(expression) { + this.walkLeftRightExpression(expression); + } + + walkAssignmentExpression(expression) { + const renameIdentifier = this.getRenameIdentifier(expression.right); + if(expression.left.type === "Identifier" && renameIdentifier && this.applyPluginsBailResult1("can-rename " + renameIdentifier, expression.right)) { + // renaming "a = b;" + if(!this.applyPluginsBailResult1("rename " + renameIdentifier, expression.right)) { + this.scope.renames["$" + expression.left.name] = renameIdentifier; + const idx = this.scope.definitions.indexOf(expression.left.name); + if(idx >= 0) this.scope.definitions.splice(idx, 1); + } + } else if(expression.left.type === "Identifier") { + if(!this.applyPluginsBailResult1("assigned " + expression.left.name, expression)) { + this.walkExpression(expression.right); + } + this.scope.renames["$" + expression.left.name] = undefined; + if(!this.applyPluginsBailResult1("assign " + expression.left.name, expression)) { + this.walkExpression(expression.left); + } + } else { + this.walkExpression(expression.right); + this.scope.renames["$" + expression.left.name] = undefined; + this.walkExpression(expression.left); + } + } + + walkConditionalExpression(expression) { + const result = this.applyPluginsBailResult1("expression ?:", expression); + if(result === undefined) { + this.walkExpression(expression.test); + this.walkExpression(expression.consequent); + if(expression.alternate) + this.walkExpression(expression.alternate); + } else { + if(result) + this.walkExpression(expression.consequent); + else if(expression.alternate) + this.walkExpression(expression.alternate); + } + } + + walkNewExpression(expression) { + this.walkExpression(expression.callee); + if(expression.arguments) + this.walkExpressions(expression.arguments); + } + + walkYieldExpression(expression) { + if(expression.argument) + this.walkExpression(expression.argument); + } + + walkTemplateLiteral(expression) { + if(expression.expressions) + this.walkExpressions(expression.expressions); + } + + walkTaggedTemplateExpression(expression) { + if(expression.tag) + this.walkExpression(expression.tag); + if(expression.quasi && expression.quasi.expressions) + this.walkExpressions(expression.quasi.expressions); + } + + walkClassExpression(expression) { + this.walkClass(expression); + } + + walkCallExpression(expression) { + let result; + + function walkIIFE(functionExpression, options) { + const params = functionExpression.params; + const args = options.map(function(arg) { + const renameIdentifier = this.getRenameIdentifier(arg); + if(renameIdentifier && this.applyPluginsBailResult1("can-rename " + renameIdentifier, arg)) { + if(!this.applyPluginsBailResult1("rename " + renameIdentifier, arg)) + return renameIdentifier; + } + this.walkExpression(arg); + }, this); + this.inScope(params.filter(function(identifier, idx) { + return !args[idx]; + }), function() { + for(let i = 0; i < args.length; i++) { + const param = args[i]; + if(!param) continue; + if(!params[i] || params[i].type !== "Identifier") continue; + this.scope.renames["$" + params[i].name] = param; + } + if(functionExpression.body.type === "BlockStatement") { + this.prewalkStatement(functionExpression.body); + this.walkStatement(functionExpression.body); + } else + this.walkExpression(functionExpression.body); + }.bind(this)); + } + if(expression.callee.type === "MemberExpression" && + expression.callee.object.type === "FunctionExpression" && + !expression.callee.computed && + (["call", "bind"]).indexOf(expression.callee.property.name) >= 0 && + expression.arguments && + expression.arguments.length > 1 + ) { + // (function(...) { }.call/bind(?, ...)) + walkIIFE.call(this, expression.callee.object, expression.arguments.slice(1)); + this.walkExpression(expression.arguments[0]); + } else if(expression.callee.type === "FunctionExpression" && expression.arguments) { + // (function(...) { }(...)) + walkIIFE.call(this, expression.callee, expression.arguments); + } else if(expression.callee.type === "Import") { + result = this.applyPluginsBailResult1("import-call", expression); + if(result === true) + return; + + if(expression.arguments) + this.walkExpressions(expression.arguments); + } else { + + const callee = this.evaluateExpression(expression.callee); + if(callee.isIdentifier()) { + result = this.applyPluginsBailResult1("call " + callee.identifier, expression); + if(result === true) + return; + } + + if(expression.callee) + this.walkExpression(expression.callee); + if(expression.arguments) + this.walkExpressions(expression.arguments); + } + } + + walkMemberExpression(expression) { + let expr = expression; + let exprName = []; + while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) { + exprName.unshift(expr.property.name || expr.property.value); + expr = expr.object; + } + if(expr.type === "Identifier" && this.scope.definitions.indexOf(expr.name) === -1) { + exprName.unshift(this.scope.renames["$" + expr.name] || expr.name); + let result = this.applyPluginsBailResult1("expression " + exprName.join("."), expression); + if(result === true) + return; + exprName[exprName.length - 1] = "*"; + result = this.applyPluginsBailResult1("expression " + exprName.join("."), expression); + if(result === true) + return; + } + this.walkExpression(expression.object); + if(expression.computed === true) + this.walkExpression(expression.property); + } + + walkIdentifier(expression) { + if(this.scope.definitions.indexOf(expression.name) === -1) { + const result = this.applyPluginsBailResult1("expression " + (this.scope.renames["$" + expression.name] || expression.name), expression); + if(result === true) + return; + } + } + + inScope(params, fn) { + const oldScope = this.scope; + this.scope = { + inTry: false, + inShorthand: false, + definitions: oldScope.definitions.slice(), + renames: Object.create(oldScope.renames) + }; + + for(let paramIndex = 0, len = params.length; paramIndex < len; paramIndex++) { + const param = params[paramIndex]; + + if(typeof param !== "string") { + this.enterPattern(param, param => { + this.scope.renames["$" + param] = undefined; + this.scope.definitions.push(param); + }); + } else { + this.scope.renames["$" + param] = undefined; + this.scope.definitions.push(param); + } + } + + fn(); + this.scope = oldScope; + } + + enterPattern(pattern, onIdent) { + if(pattern && this["enter" + pattern.type]) + this["enter" + pattern.type](pattern, onIdent); + } + + enterIdentifier(pattern, onIdent) { + onIdent(pattern.name, pattern); + } + + enterObjectPattern(pattern, onIdent) { + for(let propIndex = 0, len = pattern.properties.length; propIndex < len; propIndex++) { + const prop = pattern.properties[propIndex]; + this.enterPattern(prop.value, onIdent); + } + } + + enterArrayPattern(pattern, onIdent) { + for(let elementIndex = 0, len = pattern.elements.length; elementIndex < len; elementIndex++) { + const element = pattern.elements[elementIndex]; + this.enterPattern(element, onIdent); + } + } + + enterRestElement(pattern, onIdent) { + this.enterPattern(pattern.argument, onIdent); + } + + enterAssignmentPattern(pattern, onIdent) { + this.enterPattern(pattern.left, onIdent); + this.walkExpression(pattern.right); + } + + evaluateExpression(expression) { + try { + const result = this.applyPluginsBailResult1("evaluate " + expression.type, expression); + if(result !== undefined) + return result; + } catch(e) { + console.warn(e); + // ignore error + } + return new BasicEvaluatedExpression().setRange(expression.range); + } + + parseString(expression) { + switch(expression.type) { + case "BinaryExpression": + if(expression.operator === "+") + return this.parseString(expression.left) + this.parseString(expression.right); + break; + case "Literal": + return expression.value + ""; + } + throw new Error(expression.type + " is not supported as parameter for require"); + } + + parseCalculatedString(expression) { + switch(expression.type) { + case "BinaryExpression": + if(expression.operator === "+") { + const left = this.parseCalculatedString(expression.left); + const right = this.parseCalculatedString(expression.right); + if(left.code) { + return { + range: left.range, + value: left.value, + code: true + }; + } else if(right.code) { + return { + range: [left.range[0], right.range ? right.range[1] : left.range[1]], + value: left.value + right.value, + code: true + }; + } else { + return { + range: [left.range[0], right.range[1]], + value: left.value + right.value + }; + } + } + break; + case "ConditionalExpression": + { + const consequent = this.parseCalculatedString(expression.consequent); + const alternate = this.parseCalculatedString(expression.alternate); + const items = []; + if(consequent.conditional) + Array.prototype.push.apply(items, consequent.conditional); + else if(!consequent.code) + items.push(consequent); + else break; + if(alternate.conditional) + Array.prototype.push.apply(items, alternate.conditional); + else if(!alternate.code) + items.push(alternate); + else break; + return { + value: "", + code: true, + conditional: items + }; + } + case "Literal": + return { + range: expression.range, + value: expression.value + "" + }; + } + return { + value: "", + code: true + }; + } + + parseStringArray(expression) { + if(expression.type !== "ArrayExpression") { + return [this.parseString(expression)]; + } + + const arr = []; + if(expression.elements) + expression.elements.forEach(function(expr) { + arr.push(this.parseString(expr)); + }, this); + return arr; + } + + parseCalculatedStringArray(expression) { + if(expression.type !== "ArrayExpression") { + return [this.parseCalculatedString(expression)]; + } + + const arr = []; + if(expression.elements) + expression.elements.forEach(function(expr) { + arr.push(this.parseCalculatedString(expr)); + }, this); + return arr; + } + + parse(source, initialState) { + let ast; + const comments = []; + for(let i = 0, len = POSSIBLE_AST_OPTIONS.length; i < len; i++) { + if(!ast) { + try { + comments.length = 0; + POSSIBLE_AST_OPTIONS[i].onComment = comments; + ast = acorn.parse(source, POSSIBLE_AST_OPTIONS[i]); + } catch(e) { + // ignore the error + } + } + } + if(!ast) { + // for the error + ast = acorn.parse(source, { + ranges: true, + locations: true, + ecmaVersion: 2017, + sourceType: "module", + plugins: { + dynamicImport: true + }, + onComment: comments + }); + } + if(!ast || typeof ast !== "object") + throw new Error("Source couldn't be parsed"); + const oldScope = this.scope; + const oldState = this.state; + const oldComments = this.comments; + this.scope = { + inTry: false, + definitions: [], + renames: {} + }; + const state = this.state = initialState || {}; + this.comments = comments; + if(this.applyPluginsBailResult("program", ast, comments) === undefined) { + this.prewalkStatements(ast.body); + this.walkStatements(ast.body); + } + this.scope = oldScope; + this.state = oldState; + this.comments = oldComments; + return state; + } + + evaluate(source) { + const ast = acorn.parse("(" + source + ")", { + ranges: true, + locations: true, + ecmaVersion: 2017, + sourceType: "module", + plugins: { + dynamicImport: true + } + }); + if(!ast || typeof ast !== "object" || ast.type !== "Program") + throw new Error("evaluate: Source couldn't be parsed"); + if(ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") + throw new Error("evaluate: Source is not a expression"); + return this.evaluateExpression(ast.body[0].expression); + } + + getComments(range) { + return this.comments.filter(comment => comment.range[0] >= range[0] && comment.range[1] <= range[1]); + } + + getCommentOptions(range) { + const comments = this.getComments(range); + if(comments.length === 0) return null; + const options = comments.map(comment => { + try { + return json5.parse(`{${comment.value}}`); + } catch(e) { + return {}; + } + }); + return options.reduce((o, i) => Object.assign(o, i), {}); + } + +} + +module.exports = Parser; diff --git a/node_modules/webpack/lib/ParserHelpers.js b/node_modules/webpack/lib/ParserHelpers.js new file mode 100644 index 000000000..944c54820 --- /dev/null +++ b/node_modules/webpack/lib/ParserHelpers.js @@ -0,0 +1,76 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const path = require("path"); + +const BasicEvaluatedExpression = require("./BasicEvaluatedExpression"); +const ConstDependency = require("./dependencies/ConstDependency"); +const UnsupportedFeatureWarning = require("./UnsupportedFeatureWarning"); + +const ParserHelpers = exports; + +ParserHelpers.addParsedVariableToModule = function(parser, name, expression) { + if(!parser.state.current.addVariable) return false; + var deps = []; + parser.parse(expression, { + current: { + addDependency: function(dep) { + dep.userRequest = name; + deps.push(dep); + } + }, + module: parser.state.module + }); + parser.state.current.addVariable(name, expression, deps); + return true; +}; + +ParserHelpers.requireFileAsExpression = function(context, pathToModule) { + var moduleJsPath = path.relative(context, pathToModule); + if(!/^[A-Z]:/i.test(moduleJsPath)) { + moduleJsPath = "./" + moduleJsPath.replace(/\\/g, "/"); + } + return "require(" + JSON.stringify(moduleJsPath) + ")"; +}; + +ParserHelpers.toConstantDependency = function(value) { + return function constDependency(expr) { + var dep = new ConstDependency(value, expr.range); + dep.loc = expr.loc; + this.state.current.addDependency(dep); + return true; + }; +}; + +ParserHelpers.evaluateToString = function(value) { + return function stringExpression(expr) { + return new BasicEvaluatedExpression().setString(value).setRange(expr.range); + }; +}; + +ParserHelpers.evaluateToBoolean = function(value) { + return function booleanExpression(expr) { + return new BasicEvaluatedExpression().setBoolean(value).setRange(expr.range); + }; +}; + +ParserHelpers.expressionIsUnsupported = function(message) { + return function unsupportedExpression(expr) { + var dep = new ConstDependency("(void 0)", expr.range); + dep.loc = expr.loc; + this.state.current.addDependency(dep); + if(!this.state.module) return; + this.state.module.warnings.push(new UnsupportedFeatureWarning(this.state.module, message)); + return true; + }; +}; + +ParserHelpers.skipTraversal = function skipTraversal() { + return true; +}; + +ParserHelpers.approve = function approve() { + return true; +}; diff --git a/node_modules/webpack/lib/PrefetchPlugin.js b/node_modules/webpack/lib/PrefetchPlugin.js new file mode 100644 index 000000000..4f45d33f7 --- /dev/null +++ b/node_modules/webpack/lib/PrefetchPlugin.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const PrefetchDependency = require("./dependencies/PrefetchDependency"); + +class PrefetchPlugin { + + constructor(context, request) { + if(!request) { + this.request = context; + } else { + this.context = context; + this.request = request; + } + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(PrefetchDependency, normalModuleFactory); + }); + compiler.plugin("make", (compilation, callback) => { + compilation.prefetch(this.context || compiler.context, new PrefetchDependency(this.request), callback); + }); + } + +} +module.exports = PrefetchPlugin; diff --git a/node_modules/webpack/lib/ProgressPlugin.js b/node_modules/webpack/lib/ProgressPlugin.js new file mode 100644 index 000000000..44b8c65dd --- /dev/null +++ b/node_modules/webpack/lib/ProgressPlugin.js @@ -0,0 +1,190 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class ProgressPlugin { + + constructor(options) { + if(typeof options === "function") { + options = { + handler: options + }; + } + options = options || {}; + this.profile = options.profile; + this.handler = options.handler; + } + + apply(compiler) { + const handler = this.handler || defaultHandler; + const profile = this.profile; + if(compiler.compilers) { + const states = new Array(compiler.compilers.length); + compiler.compilers.forEach(function(compiler, idx) { + compiler.apply(new ProgressPlugin(function(p, msg) { + states[idx] = Array.prototype.slice.apply(arguments); + handler.apply(null, [ + states.map(state => state && state[0] || 0).reduce((a, b) => a + b) / states.length, + `[${idx}] ${msg}` + ].concat(Array.prototype.slice.call(arguments, 2))); + })); + }); + } else { + let lastModulesCount = 0; + let moduleCount = 500; + let doneModules = 0; + const activeModules = []; + + const update = function update(module) { + handler( + 0.1 + (doneModules / Math.max(lastModulesCount, moduleCount)) * 0.6, + "building modules", + `${doneModules}/${moduleCount} modules`, + `${activeModules.length} active`, + activeModules[activeModules.length - 1] + ); + }; + + const moduleDone = function moduleDone(module) { + doneModules++; + const ident = module.identifier(); + if(ident) { + const idx = activeModules.indexOf(ident); + if(idx >= 0) activeModules.splice(idx, 1); + } + update(); + }; + compiler.plugin("compilation", function(compilation) { + if(compilation.compiler.isChild()) return; + lastModulesCount = moduleCount; + moduleCount = 0; + doneModules = 0; + handler(0, "compiling"); + compilation.plugin("build-module", function(module) { + moduleCount++; + const ident = module.identifier(); + if(ident) { + activeModules.push(ident); + } + update(); + }); + compilation.plugin("failed-module", moduleDone); + compilation.plugin("succeed-module", moduleDone); + const syncHooks = { + "seal": [0.71, "sealing"], + "optimize": [0.72, "optimizing"], + "optimize-modules-basic": [0.73, "basic module optimization"], + "optimize-modules": [0.74, "module optimization"], + "optimize-modules-advanced": [0.75, "advanced module optimization"], + "optimize-chunks-basic": [0.76, "basic chunk optimization"], + "optimize-chunks": [0.77, "chunk optimization"], + "optimize-chunks-advanced": [0.78, "advanced chunk optimization"], + // optimize-tree + "revive-modules": [0.80, "module reviving"], + "optimize-module-order": [0.81, "module order optimization"], + "optimize-module-ids": [0.82, "module id optimization"], + "revive-chunks": [0.83, "chunk reviving"], + "optimize-chunk-order": [0.84, "chunk order optimization"], + "optimize-chunk-ids": [0.85, "chunk id optimization"], + "before-hash": [0.86, "hashing"], + "before-module-assets": [0.87, "module assets processing"], + "before-chunk-assets": [0.88, "chunk assets processing"], + "additional-chunk-assets": [0.89, "additional chunk assets processing"], + "record": [0.90, "recording"] + }; + Object.keys(syncHooks).forEach(name => { + let pass = 0; + const settings = syncHooks[name]; + compilation.plugin(name, () => { + if(pass++ > 0) + handler(settings[0], settings[1], `pass ${pass}`); + else + handler(settings[0], settings[1]); + }); + }); + compilation.plugin("optimize-tree", (chunks, modules, callback) => { + handler(0.79, "module and chunk tree optimization"); + callback(); + }); + compilation.plugin("additional-assets", callback => { + handler(0.91, "additional asset processing"); + callback(); + }); + compilation.plugin("optimize-chunk-assets", (chunks, callback) => { + handler(0.92, "chunk asset optimization"); + callback(); + }); + compilation.plugin("optimize-assets", (assets, callback) => { + handler(0.94, "asset optimization"); + callback(); + }); + }); + compiler.plugin("emit", (compilation, callback) => { + handler(0.95, "emitting"); + callback(); + }); + compiler.plugin("done", () => { + handler(1, ""); + }); + } + + let lineCaretPosition = 0, + lastState, lastStateTime; + + function defaultHandler(percentage, msg) { + let state = msg; + const details = Array.prototype.slice.call(arguments, 2); + if(percentage < 1) { + percentage = Math.floor(percentage * 100); + msg = `${percentage}% ${msg}`; + if(percentage < 100) { + msg = ` ${msg}`; + } + if(percentage < 10) { + msg = ` ${msg}`; + } + details.forEach(detail => { + if(!detail) return; + if(detail.length > 40) { + detail = `...${detail.substr(detail.length - 37)}`; + } + msg += ` ${detail}`; + }); + } + if(profile) { + state = state.replace(/^\d+\/\d+\s+/, ""); + if(percentage === 0) { + lastState = null; + lastStateTime = +new Date(); + } else if(state !== lastState || percentage === 1) { + const now = +new Date(); + if(lastState) { + const stateMsg = `${now - lastStateTime}ms ${lastState}`; + goToLineStart(stateMsg); + process.stderr.write(stateMsg + "\n"); + lineCaretPosition = 0; + } + lastState = state; + lastStateTime = now; + } + } + goToLineStart(msg); + process.stderr.write(msg); + } + + function goToLineStart(nextMessage) { + let str = ""; + for(; lineCaretPosition > nextMessage.length; lineCaretPosition--) { + str += "\b \b"; + } + for(var i = 0; i < lineCaretPosition; i++) { + str += "\b"; + } + lineCaretPosition = nextMessage.length; + if(str) process.stderr.write(str); + } + } +} +module.exports = ProgressPlugin; diff --git a/node_modules/webpack/lib/ProvidePlugin.js b/node_modules/webpack/lib/ProvidePlugin.js new file mode 100644 index 000000000..fff352a4b --- /dev/null +++ b/node_modules/webpack/lib/ProvidePlugin.js @@ -0,0 +1,55 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ParserHelpers = require("./ParserHelpers"); +const ConstDependency = require("./dependencies/ConstDependency"); + +const NullFactory = require("./NullFactory"); + +class ProvidePlugin { + constructor(definitions) { + this.definitions = definitions; + } + + apply(compiler) { + const definitions = this.definitions; + compiler.plugin("compilation", (compilation, params) => { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + Object.keys(definitions).forEach(name => { + var request = [].concat(definitions[name]); + var splittedName = name.split("."); + if(splittedName.length > 0) { + splittedName.slice(1).forEach((_, i) => { + const name = splittedName.slice(0, i + 1).join("."); + parser.plugin(`can-rename ${name}`, ParserHelpers.approve); + }); + } + parser.plugin(`expression ${name}`, function(expr) { + let nameIdentifier = name; + const scopedName = name.indexOf(".") >= 0; + let expression = `require(${JSON.stringify(request[0])})`; + if(scopedName) { + nameIdentifier = `__webpack_provided_${name.replace(/\./g, "_dot_")}`; + } + if(request.length > 1) { + expression += request.slice(1).map(r => `[${JSON.stringify(r)}]`).join(""); + } + if(!ParserHelpers.addParsedVariableToModule(this, nameIdentifier, expression)) { + return false; + } + if(scopedName) { + ParserHelpers.toConstantDependency(nameIdentifier).bind(this)(expr); + } + return true; + }); + }); + }); + }); + } +} +module.exports = ProvidePlugin; diff --git a/node_modules/webpack/lib/RawModule.js b/node_modules/webpack/lib/RawModule.js new file mode 100644 index 000000000..0c828f6b2 --- /dev/null +++ b/node_modules/webpack/lib/RawModule.js @@ -0,0 +1,50 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Module = require("./Module"); +const OriginalSource = require("webpack-sources").OriginalSource; +const RawSource = require("webpack-sources").RawSource; + +module.exports = class RawModule extends Module { + + constructor(source, identifier, readableIdentifier) { + super(); + this.sourceStr = source; + this.identifierStr = identifier || this.sourceStr; + this.readableIdentifierStr = readableIdentifier || this.identifierStr; + this.cacheable = true; + this.built = false; + } + + identifier() { + return this.identifierStr; + } + + size() { + return this.sourceStr.length; + } + + readableIdentifier(requestShortener) { + return requestShortener.shorten(this.readableIdentifierStr); + } + + needRebuild() { + return false; + } + + build(options, compilations, resolver, fs, callback) { + this.builtTime = new Date().getTime(); + callback(); + } + + source() { + if(this.useSourceMap) + return new OriginalSource(this.sourceStr, this.identifier()); + else + return new RawSource(this.sourceStr); + } + +}; diff --git a/node_modules/webpack/lib/RecordIdsPlugin.js b/node_modules/webpack/lib/RecordIdsPlugin.js new file mode 100644 index 000000000..735288f40 --- /dev/null +++ b/node_modules/webpack/lib/RecordIdsPlugin.js @@ -0,0 +1,117 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const identifierUtils = require("./util/identifier"); + +class RecordIdsPlugin { + + apply(compiler) { + compiler.plugin("compilation", compilation => { + compilation.plugin("record-modules", (modules, records) => { + if(!records.modules) records.modules = {}; + if(!records.modules.byIdentifier) records.modules.byIdentifier = {}; + if(!records.modules.usedIds) records.modules.usedIds = {}; + modules.forEach(function(module) { + if(!module.portableId) module.portableId = identifierUtils.makePathsRelative(compiler.context, module.identifier()); + const identifier = module.portableId; + records.modules.byIdentifier[identifier] = module.id; + records.modules.usedIds[module.id] = module.id; + }); + }); + compilation.plugin("revive-modules", (modules, records) => { + if(!records.modules) return; + if(records.modules.byIdentifier) { + const usedIds = {}; + modules.forEach(function(module) { + if(module.id !== null) return; + if(!module.portableId) module.portableId = identifierUtils.makePathsRelative(compiler.context, module.identifier()); + const identifier = module.portableId; + const id = records.modules.byIdentifier[identifier]; + if(id === undefined) return; + if(usedIds[id]) return; + usedIds[id] = true; + module.id = id; + }); + } + compilation.usedModuleIds = records.modules.usedIds; + }); + + function getDepBlockIdent(chunk, block) { + const ident = []; + if(block.chunks.length > 1) + ident.push(block.chunks.indexOf(chunk)); + while(block.parent) { + const p = block.parent; + const idx = p.blocks.indexOf(block); + const l = p.blocks.length - 1; + ident.unshift(`${idx}/${l}`); + block = block.parent; + } + if(!block.identifier) return null; + ident.unshift(identifierUtils.makePathsRelative(compiler.context, block.identifier())); + return ident.join(":"); + } + compilation.plugin("record-chunks", (chunks, records) => { + records.nextFreeChunkId = compilation.nextFreeChunkId; + if(!records.chunks) records.chunks = {}; + if(!records.chunks.byName) records.chunks.byName = {}; + if(!records.chunks.byBlocks) records.chunks.byBlocks = {}; + records.chunks.usedIds = {}; + chunks.forEach(chunk => { + const name = chunk.name; + const blockIdents = chunk.blocks.map(getDepBlockIdent.bind(null, chunk)).filter(Boolean); + if(name) records.chunks.byName[name] = chunk.id; + blockIdents.forEach((blockIdent) => { + records.chunks.byBlocks[blockIdent] = chunk.id; + }); + records.chunks.usedIds[chunk.id] = chunk.id; + }); + }); + compilation.plugin("revive-chunks", (chunks, records) => { + if(!records.chunks) return; + const usedIds = {}; + if(records.chunks.byName) { + chunks.forEach(function(chunk) { + if(chunk.id !== null) return; + if(!chunk.name) return; + const id = records.chunks.byName[chunk.name]; + if(id === undefined) return; + if(usedIds[id]) return; + usedIds[id] = true; + chunk.id = id; + }); + } + if(records.chunks.byBlocks) { + const argumentedChunks = chunks.filter(chunk => chunk.id === null).map(chunk => ({ + chunk, + blockIdents: chunk.blocks.map(getDepBlockIdent.bind(null, chunk)).filter(Boolean) + })).filter(arg => arg.blockIdents.length > 0); + let blockIdentsCount = {}; + argumentedChunks.forEach((arg, idx) => { + arg.blockIdents.forEach(blockIdent => { + const id = records.chunks.byBlocks[blockIdent]; + if(typeof id !== "number") return; + const accessor = `${id}:${idx}`; + blockIdentsCount[accessor] = (blockIdentsCount[accessor] || 0) + 1; + }); + }); + blockIdentsCount = Object.keys(blockIdentsCount).map(accessor => [blockIdentsCount[accessor]].concat(accessor.split(":").map(Number))).sort((a, b) => b[0] - a[0]); + blockIdentsCount.forEach(function(arg) { + const id = arg[1]; + if(usedIds[id]) return; + const idx = arg[2]; + const chunk = argumentedChunks[idx].chunk; + if(chunk.id !== null) return; + usedIds[id] = true; + chunk.id = id; + }); + } + compilation.usedChunkIds = records.chunks.usedIds; + }); + }); + } +} +module.exports = RecordIdsPlugin; diff --git a/node_modules/webpack/lib/RequestShortener.js b/node_modules/webpack/lib/RequestShortener.js new file mode 100644 index 000000000..369e44334 --- /dev/null +++ b/node_modules/webpack/lib/RequestShortener.js @@ -0,0 +1,56 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); + +class RequestShortener { + constructor(directory) { + directory = directory.replace(/\\/g, "/"); + if(/[\/\\]$/.test(directory)) directory = directory.substr(0, directory.length - 1); + + if(directory) { + const currentDirectoryRegExpString = directory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); + this.currentDirectoryRegExp = new RegExp("^" + currentDirectoryRegExpString + "|(!)" + currentDirectoryRegExpString, "g"); + } + + const dirname = path.dirname(directory); + const endsWithSeperator = /[\/\\]$/.test(dirname); + const parentDirectory = endsWithSeperator ? dirname.substr(0, dirname.length - 1) : dirname; + if(parentDirectory && parentDirectory !== directory) { + const parentDirectoryRegExpString = parentDirectory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); + this.parentDirectoryRegExp = new RegExp("^" + parentDirectoryRegExpString + "|(!)" + parentDirectoryRegExpString, "g"); + } + + if(__dirname.length >= 2) { + const buildins = path.join(__dirname, "..").replace(/\\/g, "/"); + const buildinsAsModule = this.currentDirectoryRegExp && this.currentDirectoryRegExp.test(buildins); + this.buildinsAsModule = buildinsAsModule; + const buildinsRegExpString = buildins.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); + this.buildinsRegExp = new RegExp("^" + buildinsRegExpString + "|(!)" + buildinsRegExpString, "g"); + } + + this.nodeModulesRegExp = /\/node_modules\//g; + this.indexJsRegExp = /\/index.js(!|\?|\(query\))/g; + } + + shorten(request) { + if(!request) return request; + request = request.replace(/\\/g, "/"); + if(this.buildinsAsModule && this.buildinsRegExp) + request = request.replace(this.buildinsRegExp, "!(webpack)"); + if(this.currentDirectoryRegExp) + request = request.replace(this.currentDirectoryRegExp, "!."); + if(this.parentDirectoryRegExp) + request = request.replace(this.parentDirectoryRegExp, "!.."); + if(!this.buildinsAsModule && this.buildinsRegExp) + request = request.replace(this.buildinsRegExp, "!(webpack)"); + request = request.replace(this.nodeModulesRegExp, "/~/"); + request = request.replace(this.indexJsRegExp, "$1"); + return request.replace(/^!|!$/, ""); + } +} + +module.exports = RequestShortener; diff --git a/node_modules/webpack/lib/RequireJsStuffPlugin.js b/node_modules/webpack/lib/RequireJsStuffPlugin.js new file mode 100644 index 000000000..0bd6aa7d5 --- /dev/null +++ b/node_modules/webpack/lib/RequireJsStuffPlugin.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ParserHelpers = require("./ParserHelpers"); +const ConstDependency = require("./dependencies/ConstDependency"); +const NullFactory = require("./NullFactory"); + +module.exports = class RequireJsStuffPlugin { + + apply(compiler) { + compiler.plugin("compilation", function(compilation, params) { + compilation.dependencyFactories.set(ConstDependency, new NullFactory()); + compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template()); + params.normalModuleFactory.plugin("parser", function(parser, parserOptions) { + + if(typeof parserOptions.requireJs !== "undefined" && !parserOptions.requireJs) + return; + + parser.plugin("call require.config", ParserHelpers.toConstantDependency("undefined")); + parser.plugin("call requirejs.config", ParserHelpers.toConstantDependency("undefined")); + + parser.plugin("expression require.version", ParserHelpers.toConstantDependency(JSON.stringify("0.0.0"))); + parser.plugin("expression requirejs.onError", ParserHelpers.toConstantDependency(JSON.stringify("__webpack_require__.oe"))); + }); + }); + } + +}; diff --git a/node_modules/webpack/lib/RuleSet.js b/node_modules/webpack/lib/RuleSet.js new file mode 100644 index 000000000..c52226b84 --- /dev/null +++ b/node_modules/webpack/lib/RuleSet.js @@ -0,0 +1,444 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/* +: +: [] +: { + resource: { + test: , + include: , + exclude: , + }, + resource: , -> resource.test + test: , -> resource.test + include: , -> resource.include + exclude: , -> resource.exclude + resourceQuery: , + compiler: , + issuer: , + use: "loader", -> use[0].loader + loader: <>, -> use[0].loader + loaders: <>, -> use + options: {}, -> use[0].options, + query: {}, -> options + parser: {}, + use: [ + "loader" -> use[x].loader + ], + use: [ + { + loader: "loader", + options: {} + } + ], + rules: [ + + ], + oneOf: [ + + ] +} + +: /regExp/ +: function(arg) {} +: "starting" +: [] // or +: { and: [] } +: { or: [] } +: { not: [] } +: { test: , include: , exclude: } + + +normalized: + +{ + resource: function(), + resourceQuery: function(), + compiler: function(), + issuer: function(), + use: [ + { + loader: string, + options: string, + : + } + ], + rules: [], + oneOf: [], + : , +} + +*/ + +"use strict"; + +module.exports = class RuleSet { + constructor(rules) { + this.references = Object.create(null); + this.rules = RuleSet.normalizeRules(rules, this.references, "ref-"); + } + + static normalizeRules(rules, refs, ident) { + if(Array.isArray(rules)) { + return rules.map((rule, idx) => { + return RuleSet.normalizeRule(rule, refs, `${ident}-${idx}`); + }); + } else if(rules) { + return [RuleSet.normalizeRule(rules, refs, ident)]; + } else { + return []; + } + } + + static normalizeRule(rule, refs, ident) { + if(typeof rule === "string") + return { + use: [{ + loader: rule + }] + }; + if(!rule) + throw new Error("Unexcepted null when object was expected as rule"); + if(typeof rule !== "object") + throw new Error("Unexcepted " + typeof rule + " when object was expected as rule (" + rule + ")"); + + let newRule = {}; + let useSource; + let resourceSource; + let condition; + + if(rule.test || rule.include || rule.exclude) { + checkResourceSource("test + include + exclude"); + condition = { + test: rule.test, + include: rule.include, + exclude: rule.exclude + }; + try { + newRule.resource = RuleSet.normalizeCondition(condition); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(condition, error)); + } + } + + if(rule.resource) { + checkResourceSource("resource"); + try { + newRule.resource = RuleSet.normalizeCondition(rule.resource); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.resource, error)); + } + } + + if(rule.resourceQuery) { + try { + newRule.resourceQuery = RuleSet.normalizeCondition(rule.resourceQuery); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.resourceQuery, error)); + } + } + + if(rule.compiler) { + try { + newRule.compiler = RuleSet.normalizeCondition(rule.compiler); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.compiler, error)); + } + } + + if(rule.issuer) { + try { + newRule.issuer = RuleSet.normalizeCondition(rule.issuer); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.issuer, error)); + } + } + + if(rule.loader && rule.loaders) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Provided loader and loaders for rule (use only one of them)"))); + + const loader = rule.loaders || rule.loader; + if(typeof loader === "string" && !rule.options && !rule.query) { + checkUseSource("loader"); + newRule.use = RuleSet.normalizeUse(loader.split("!"), ident); + } else if(typeof loader === "string" && (rule.options || rule.query)) { + checkUseSource("loader + options/query"); + newRule.use = RuleSet.normalizeUse({ + loader: loader, + options: rule.options, + query: rule.query + }, ident); + } else if(loader && (rule.options || rule.query)) { + throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query cannot be used with loaders (use options for each array item)"))); + } else if(loader) { + checkUseSource("loaders"); + newRule.use = RuleSet.normalizeUse(loader, ident); + } else if(rule.options || rule.query) { + throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query provided without loader (use loader + options)"))); + } + + if(rule.use) { + checkUseSource("use"); + newRule.use = RuleSet.normalizeUse(rule.use, ident); + } + + if(rule.rules) + newRule.rules = RuleSet.normalizeRules(rule.rules, refs, `${ident}-rules`); + + if(rule.oneOf) + newRule.oneOf = RuleSet.normalizeRules(rule.oneOf, refs, `${ident}-oneOf`); + + const keys = Object.keys(rule).filter((key) => { + return ["resource", "resourceQuery", "compiler", "test", "include", "exclude", "issuer", "loader", "options", "query", "loaders", "use", "rules", "oneOf"].indexOf(key) < 0; + }); + keys.forEach((key) => { + newRule[key] = rule[key]; + }); + + function checkUseSource(newSource) { + if(useSource && useSource !== newSource) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Rule can only have one result source (provided " + newSource + " and " + useSource + ")"))); + useSource = newSource; + } + + function checkResourceSource(newSource) { + if(resourceSource && resourceSource !== newSource) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Rule can only have one resource source (provided " + newSource + " and " + resourceSource + ")"))); + resourceSource = newSource; + } + + if(Array.isArray(newRule.use)) { + newRule.use.forEach((item) => { + if(item.ident) { + refs[item.ident] = item.options; + } + }); + } + + return newRule; + } + + static buildErrorMessage(condition, error) { + const conditionAsText = JSON.stringify(condition, (key, value) => { + return value === undefined ? "undefined" : value; + }, 2); + return error.message + " in " + conditionAsText; + } + + static normalizeUse(use, ident) { + if(Array.isArray(use)) { + return use + .map((item, idx) => RuleSet.normalizeUse(item, `${ident}-${idx}`)) + .reduce((arr, items) => arr.concat(items), []); + } + return [RuleSet.normalizeUseItem(use, ident)]; + } + + static normalizeUseItemFunction(use, data) { + const result = use(data); + if(typeof result === "string") { + return RuleSet.normalizeUseItem(result); + } + return result; + } + + static normalizeUseItemString(useItemString) { + const idx = useItemString.indexOf("?"); + if(idx >= 0) { + return { + loader: useItemString.substr(0, idx), + options: useItemString.substr(idx + 1) + }; + } + return { + loader: useItemString + }; + } + + static normalizeUseItem(item, ident) { + if(typeof item === "function") + return item; + + if(typeof item === "string") { + return RuleSet.normalizeUseItemString(item); + } + + let newItem = {}; + + if(item.options && item.query) + throw new Error("Provided options and query in use"); + + if(!item.loader) + throw new Error("No loader specified"); + + newItem.options = item.options || item.query; + + if(typeof newItem.options === "object" && newItem.options) { + if(newItem.options.ident) + newItem.ident = newItem.options.ident; + else + newItem.ident = ident; + } + + const keys = Object.keys(item).filter(function(key) { + return ["options", "query"].indexOf(key) < 0; + }); + + keys.forEach(function(key) { + newItem[key] = item[key]; + }); + + return newItem; + } + + static normalizeCondition(condition) { + if(!condition) + throw new Error("Expected condition but got falsy value"); + if(typeof condition === "string") { + return str => str.indexOf(condition) === 0; + } + if(typeof condition === "function") { + return condition; + } + if(condition instanceof RegExp) { + return condition.test.bind(condition); + } + if(Array.isArray(condition)) { + const items = condition.map(c => RuleSet.normalizeCondition(c)); + return orMatcher(items); + } + if(typeof condition !== "object") + throw Error("Unexcepted " + typeof condition + " when condition was expected (" + condition + ")"); + + let matchers = []; + Object.keys(condition).forEach(key => { + const value = condition[key]; + switch(key) { + case "or": + case "include": + case "test": + if(value) + matchers.push(RuleSet.normalizeCondition(value)); + break; + case "and": + if(value) { + const items = value.map(c => RuleSet.normalizeCondition(c)); + matchers.push(andMatcher(items)); + } + break; + case "not": + case "exclude": + if(value) { + const matcher = RuleSet.normalizeCondition(value); + matchers.push(notMatcher(matcher)); + } + break; + default: + throw new Error("Unexcepted property " + key + " in condition"); + } + }); + if(matchers.length === 0) + throw new Error("Excepted condition but got " + condition); + if(matchers.length === 1) + return matchers[0]; + return andMatcher(matchers); + } + + exec(data) { + const result = []; + this._run(data, { + rules: this.rules + }, result); + return result; + } + + _run(data, rule, result) { + // test conditions + if(rule.resource && !data.resource) + return false; + if(rule.resourceQuery && !data.resourceQuery) + return false; + if(rule.compiler && !data.compiler) + return false; + if(rule.issuer && !data.issuer) + return false; + if(rule.resource && !rule.resource(data.resource)) + return false; + if(data.issuer && rule.issuer && !rule.issuer(data.issuer)) + return false; + if(data.resourceQuery && rule.resourceQuery && !rule.resourceQuery(data.resourceQuery)) + return false; + if(data.compiler && rule.compiler && !rule.compiler(data.compiler)) + return false; + + // apply + const keys = Object.keys(rule).filter((key) => { + return ["resource", "resourceQuery", "compiler", "issuer", "rules", "oneOf", "use", "enforce"].indexOf(key) < 0; + }); + keys.forEach((key) => { + result.push({ + type: key, + value: rule[key] + }); + }); + + if(rule.use) { + rule.use.forEach((use) => { + result.push({ + type: "use", + value: typeof use === "function" ? RuleSet.normalizeUseItemFunction(use, data) : use, + enforce: rule.enforce + }); + }); + } + + if(rule.rules) { + for(let i = 0; i < rule.rules.length; i++) { + this._run(data, rule.rules[i], result); + } + } + + if(rule.oneOf) { + for(let i = 0; i < rule.oneOf.length; i++) { + if(this._run(data, rule.oneOf[i], result)) + break; + } + } + + return true; + } + + findOptionsByIdent(ident) { + const options = this.references[ident]; + if(!options) throw new Error("Can't find options with ident '" + ident + "'"); + return options; + } +}; + +function notMatcher(matcher) { + return function(str) { + return !matcher(str); + }; +} + +function orMatcher(items) { + return function(str) { + for(let i = 0; i < items.length; i++) { + if(items[i](str)) + return true; + } + return false; + }; +} + +function andMatcher(items) { + return function(str) { + for(let i = 0; i < items.length; i++) { + if(!items[i](str)) + return false; + } + return true; + }; +} diff --git a/node_modules/webpack/lib/SetVarMainTemplatePlugin.js b/node_modules/webpack/lib/SetVarMainTemplatePlugin.js new file mode 100644 index 000000000..67b3e744e --- /dev/null +++ b/node_modules/webpack/lib/SetVarMainTemplatePlugin.js @@ -0,0 +1,41 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class SetVarMainTemplatePlugin { + constructor(varExpression, copyObject) { + this.varExpression = varExpression; + this.copyObject = copyObject; + } + + apply(compilation) { + const mainTemplate = compilation.mainTemplate; + compilation.templatesPlugin("render-with-entry", (source, chunk, hash) => { + const varExpression = mainTemplate.applyPluginsWaterfall("asset-path", this.varExpression, { + hash, + chunk + }); + if(this.copyObject) { + return new ConcatSource(`(function(e, a) { for(var i in a) e[i] = a[i]; }(${varExpression}, `, source, "))"); + } else { + const prefix = `${varExpression} =\n`; + return new ConcatSource(prefix, source); + } + }); + mainTemplate.plugin("global-hash-paths", (paths) => { + if(this.varExpression) paths.push(this.varExpression); + return paths; + }); + mainTemplate.plugin("hash", hash => { + hash.update("set var"); + hash.update(`${this.varExpression}`); + hash.update(`${this.copyObject}`); + }); + } +} + +module.exports = SetVarMainTemplatePlugin; diff --git a/node_modules/webpack/lib/SingleEntryPlugin.js b/node_modules/webpack/lib/SingleEntryPlugin.js new file mode 100644 index 000000000..aa5da3a0a --- /dev/null +++ b/node_modules/webpack/lib/SingleEntryPlugin.js @@ -0,0 +1,35 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const SingleEntryDependency = require("./dependencies/SingleEntryDependency"); + +class SingleEntryPlugin { + constructor(context, entry, name) { + this.context = context; + this.entry = entry; + this.name = name; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory); + }); + + compiler.plugin("make", (compilation, callback) => { + const dep = SingleEntryPlugin.createDependency(this.entry, this.name); + compilation.addEntry(this.context, dep, this.name, callback); + }); + } + + static createDependency(entry, name) { + const dep = new SingleEntryDependency(entry); + dep.loc = name; + return dep; + } +} + +module.exports = SingleEntryPlugin; diff --git a/node_modules/webpack/lib/SizeFormatHelpers.js b/node_modules/webpack/lib/SizeFormatHelpers.js new file mode 100644 index 000000000..3b7732199 --- /dev/null +++ b/node_modules/webpack/lib/SizeFormatHelpers.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ +"use strict"; + +const SizeFormatHelpers = exports; + +SizeFormatHelpers.formatSize = size => { + if(size <= 0) { + return "0 bytes"; + } + + const abbreviations = ["bytes", "kB", "MB", "GB"]; + const index = Math.floor(Math.log(size) / Math.log(1000)); + + return `${+(size / Math.pow(1000, index)).toPrecision(3)} ${abbreviations[index]}`; +}; diff --git a/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js b/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js new file mode 100644 index 000000000..312ad43fe --- /dev/null +++ b/node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); + +class SourceMapDevToolModuleOptionsPlugin { + constructor(options) { + this.options = options; + } + + apply(compilation) { + const options = this.options; + if(options.module !== false) { + compilation.plugin("build-module", module => { + module.useSourceMap = true; + }); + } + if(options.lineToLine === true) { + compilation.plugin("build-module", module => { + module.lineToLine = true; + }); + } else if(options.lineToLine) { + compilation.plugin("build-module", module => { + if(!module.resource) return; + let resourcePath = module.resource; + const idx = resourcePath.indexOf("?"); + if(idx >= 0) resourcePath = resourcePath.substr(0, idx); + module.lineToLine = ModuleFilenameHelpers.matchObject(options.lineToLine, resourcePath); + }); + } + } +} + +module.exports = SourceMapDevToolModuleOptionsPlugin; diff --git a/node_modules/webpack/lib/SourceMapDevToolPlugin.js b/node_modules/webpack/lib/SourceMapDevToolPlugin.js new file mode 100644 index 000000000..53645fb4e --- /dev/null +++ b/node_modules/webpack/lib/SourceMapDevToolPlugin.js @@ -0,0 +1,166 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const RequestShortener = require("./RequestShortener"); +const ConcatSource = require("webpack-sources").ConcatSource; +const RawSource = require("webpack-sources").RawSource; +const ModuleFilenameHelpers = require("./ModuleFilenameHelpers"); +const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin"); + +const basename = (name) => { + if(name.indexOf("/") < 0) return name; + return name.substr(name.lastIndexOf("/") + 1); +}; + +class SourceMapDevToolPlugin { + constructor(options) { + if(arguments.length > 1) + throw new Error("SourceMapDevToolPlugin only takes one argument (pass an options object)"); + // TODO: remove in webpack 3 + if(typeof options === "string") { + options = { + sourceMapFilename: options + }; + } + if(!options) options = {}; + this.sourceMapFilename = options.filename; + this.sourceMappingURLComment = options.append === false ? false : options.append || "\n//# sourceMappingURL=[url]"; + this.moduleFilenameTemplate = options.moduleFilenameTemplate || "webpack:///[resourcePath]"; + this.fallbackModuleFilenameTemplate = options.fallbackModuleFilenameTemplate || "webpack:///[resourcePath]?[hash]"; + this.options = options; + } + + apply(compiler) { + const sourceMapFilename = this.sourceMapFilename; + const sourceMappingURLComment = this.sourceMappingURLComment; + const moduleFilenameTemplate = this.moduleFilenameTemplate; + const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate; + const requestShortener = new RequestShortener(compiler.context); + const options = this.options; + options.test = options.test || /\.(js|css)($|\?)/i; + compiler.plugin("compilation", compilation => { + new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation); + compilation.plugin("after-optimize-chunk-assets", function(chunks) { + let allModules = []; + let allModuleFilenames = []; + const tasks = []; + chunks.forEach(function(chunk) { + chunk.files.filter(ModuleFilenameHelpers.matchObject.bind(undefined, options)).map(function(file) { + const asset = compilation.assets[file]; + if(asset.__SourceMapDevToolFile === file && asset.__SourceMapDevToolData) { + const data = asset.__SourceMapDevToolData; + for(const cachedFile in data) { + compilation.assets[cachedFile] = data[cachedFile]; + if(cachedFile !== file) + chunk.files.push(cachedFile); + } + return; + } + let source, sourceMap; + if(asset.sourceAndMap) { + const sourceAndMap = asset.sourceAndMap(options); + sourceMap = sourceAndMap.map; + source = sourceAndMap.source; + } else { + sourceMap = asset.map(options); + source = asset.source(); + } + if(sourceMap) { + return { + chunk, + file, + asset, + source, + sourceMap + }; + } + }).filter(Boolean).map(task => { + const modules = task.sourceMap.sources.map(source => { + const module = compilation.findModule(source); + return module || source; + }); + const moduleFilenames = modules.map(module => ModuleFilenameHelpers.createFilename(module, moduleFilenameTemplate, requestShortener)); + task.modules = modules; + task.moduleFilenames = moduleFilenames; + return task; + }).forEach(task => { + allModules = allModules.concat(task.modules); + allModuleFilenames = allModuleFilenames.concat(task.moduleFilenames); + tasks.push(task); + }); + }); + allModuleFilenames = ModuleFilenameHelpers.replaceDuplicates(allModuleFilenames, (filename, i) => ModuleFilenameHelpers.createFilename(allModules[i], fallbackModuleFilenameTemplate, requestShortener), (ai, bi) => { + let a = allModules[ai]; + let b = allModules[bi]; + a = !a ? "" : typeof a === "string" ? a : a.identifier(); + b = !b ? "" : typeof b === "string" ? b : b.identifier(); + return a.length - b.length; + }); + allModuleFilenames = ModuleFilenameHelpers.replaceDuplicates(allModuleFilenames, (filename, i, n) => { + for(let j = 0; j < n; j++) + filename += "*"; + return filename; + }); + tasks.forEach(task => { + task.moduleFilenames = allModuleFilenames.slice(0, task.moduleFilenames.length); + allModuleFilenames = allModuleFilenames.slice(task.moduleFilenames.length); + }); + tasks.forEach(function(task) { + const chunk = task.chunk; + const file = task.file; + const asset = task.asset; + const sourceMap = task.sourceMap; + const source = task.source; + const moduleFilenames = task.moduleFilenames; + const modules = task.modules; + sourceMap.sources = moduleFilenames; + if(sourceMap.sourcesContent && !options.noSources) { + sourceMap.sourcesContent = sourceMap.sourcesContent.map((content, i) => `${content}\n\n\n${ModuleFilenameHelpers.createFooter(modules[i], requestShortener)}`); + } else { + sourceMap.sourcesContent = undefined; + } + sourceMap.sourceRoot = options.sourceRoot || ""; + sourceMap.file = file; + asset.__SourceMapDevToolFile = file; + asset.__SourceMapDevToolData = {}; + let currentSourceMappingURLComment = sourceMappingURLComment; + if(currentSourceMappingURLComment !== false && /\.css($|\?)/i.test(file)) { + currentSourceMappingURLComment = currentSourceMappingURLComment.replace(/^\n\/\/(.*)$/, "\n/*$1*/"); + } + if(sourceMapFilename) { + let filename = file; + let query = ""; + const idx = filename.indexOf("?"); + if(idx >= 0) { + query = filename.substr(idx); + filename = filename.substr(0, idx); + } + const sourceMapFile = compilation.getPath(sourceMapFilename, { + chunk, + filename, + query, + basename: basename(filename) + }); + const sourceMapUrl = path.relative(path.dirname(file), sourceMapFile).replace(/\\/g, "/"); + if(currentSourceMappingURLComment !== false) { + asset.__SourceMapDevToolData[file] = compilation.assets[file] = new ConcatSource(new RawSource(source), currentSourceMappingURLComment.replace(/\[url\]/g, sourceMapUrl)); + } + asset.__SourceMapDevToolData[sourceMapFile] = compilation.assets[sourceMapFile] = new RawSource(JSON.stringify(sourceMap)); + chunk.files.push(sourceMapFile); + } else { + asset.__SourceMapDevToolData[file] = compilation.assets[file] = new ConcatSource(new RawSource(source), currentSourceMappingURLComment + .replace(/\[map\]/g, () => JSON.stringify(sourceMap)) + .replace(/\[url\]/g, () => `data:application/json;charset=utf-8;base64,${new Buffer(JSON.stringify(sourceMap), "utf-8").toString("base64")}`) // eslint-disable-line + ); + } + }); + }); + }); + } +} + +module.exports = SourceMapDevToolPlugin; diff --git a/node_modules/webpack/lib/Stats.js b/node_modules/webpack/lib/Stats.js new file mode 100644 index 000000000..f7e21777a --- /dev/null +++ b/node_modules/webpack/lib/Stats.js @@ -0,0 +1,894 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequestShortener = require("./RequestShortener"); +const SizeFormatHelpers = require("./SizeFormatHelpers"); +const formatLocation = require("./formatLocation"); + +const optionOrFallback = (optionValue, fallbackValue) => optionValue !== undefined ? optionValue : fallbackValue; + +class Stats { + constructor(compilation) { + this.compilation = compilation; + this.hash = compilation.hash; + } + + static filterWarnings(warnings, warningsFilter) { + // we dont have anything to filter so all warnings can be shown + if(!warningsFilter) { + return warnings; + } + + // create a chain of filters + // if they return "true" a warning should be surpressed + const normalizedWarningsFilters = [].concat(warningsFilter).map(filter => { + if(typeof filter === "string") { + return warning => warning.indexOf(filter) > -1; + } + + if(filter instanceof RegExp) { + return warning => filter.test(warning); + } + + if(typeof filter === "function") { + return filter; + } + + throw new Error(`Can only filter warnings with Strings or RegExps. (Given: ${filter})`); + }); + return warnings.filter(warning => { + return !normalizedWarningsFilters.some(check => check(warning)); + }); + } + + hasWarnings() { + return this.compilation.warnings.length > 0; + } + + hasErrors() { + return this.compilation.errors.length > 0; + } + + // remove a prefixed "!" that can be specified to reverse sort order + normalizeFieldKey(field) { + if(field[0] === "!") { + return field.substr(1); + } + return field; + } + + // if a field is prefixed by a "!" reverse sort order + sortOrderRegular(field) { + if(field[0] === "!") { + return false; + } + return true; + } + + toJson(options, forToString) { + if(typeof options === "boolean" || typeof options === "string") { + options = Stats.presetToOptions(options); + } else if(!options) { + options = {}; + } + + const compilation = this.compilation; + const requestShortener = new RequestShortener(optionOrFallback(options.context, process.cwd())); + const showPerformance = optionOrFallback(options.performance, true); + const showHash = optionOrFallback(options.hash, true); + const showVersion = optionOrFallback(options.version, true); + const showTimings = optionOrFallback(options.timings, true); + const showAssets = optionOrFallback(options.assets, true); + const showEntrypoints = optionOrFallback(options.entrypoints, !forToString); + const showChunks = optionOrFallback(options.chunks, true); + const showChunkModules = optionOrFallback(options.chunkModules, !!forToString); + const showChunkOrigins = optionOrFallback(options.chunkOrigins, !forToString); + const showModules = optionOrFallback(options.modules, !forToString); + const showDepth = optionOrFallback(options.depth, !forToString); + const showCachedModules = optionOrFallback(options.cached, true); + const showCachedAssets = optionOrFallback(options.cachedAssets, true); + const showReasons = optionOrFallback(options.reasons, !forToString); + const showUsedExports = optionOrFallback(options.usedExports, !forToString); + const showProvidedExports = optionOrFallback(options.providedExports, !forToString); + const showChildren = optionOrFallback(options.children, true); + const showSource = optionOrFallback(options.source, !forToString); + const showErrors = optionOrFallback(options.errors, true); + const showErrorDetails = optionOrFallback(options.errorDetails, !forToString); + const showWarnings = optionOrFallback(options.warnings, true); + const warningsFilter = optionOrFallback(options.warningsFilter, null); + const showPublicPath = optionOrFallback(options.publicPath, !forToString); + const excludeModules = [].concat(optionOrFallback(options.exclude, [])).map(str => { + if(typeof str !== "string") return str; + return new RegExp(`[\\\\/]${str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")}([\\\\/]|$|!|\\?)`); + }); + const maxModules = optionOrFallback(options.maxModules, forToString ? 15 : Infinity); + const sortModules = optionOrFallback(options.modulesSort, "id"); + const sortChunks = optionOrFallback(options.chunksSort, "id"); + const sortAssets = optionOrFallback(options.assetsSort, ""); + + const createModuleFilter = () => { + let i = 0; + return module => { + if(!showCachedModules && !module.built) { + return false; + } + if(excludeModules.length > 0) { + const ident = requestShortener.shorten(module.resource); + const excluded = excludeModules.some(regExp => regExp.test(ident)); + if(excluded) + return false; + } + return i++ < maxModules; + }; + }; + + const sortByFieldAndOrder = (fieldKey, a, b) => { + if(a[fieldKey] === null && b[fieldKey] === null) return 0; + if(a[fieldKey] === null) return 1; + if(b[fieldKey] === null) return -1; + if(a[fieldKey] === b[fieldKey]) return 0; + return a[fieldKey] < b[fieldKey] ? -1 : 1; + }; + + const sortByField = (field) => (a, b) => { + if(!field) { + return 0; + } + + const fieldKey = this.normalizeFieldKey(field); + + // if a field is prefixed with a "!" the sort is reversed! + const sortIsRegular = this.sortOrderRegular(field); + + return sortByFieldAndOrder(fieldKey, sortIsRegular ? a : b, sortIsRegular ? b : a); + }; + + const formatError = (e) => { + let text = ""; + if(typeof e === "string") + e = { + message: e + }; + if(e.chunk) { + text += `chunk ${e.chunk.name || e.chunk.id}${e.chunk.hasRuntime() ? " [entry]" : e.chunk.isInitial() ? " [initial]" : ""}\n`; + } + if(e.file) { + text += `${e.file}\n`; + } + if(e.module && e.module.readableIdentifier && typeof e.module.readableIdentifier === "function") { + text += `${e.module.readableIdentifier(requestShortener)}\n`; + } + text += e.message; + if(showErrorDetails && e.details) text += `\n${e.details}`; + if(showErrorDetails && e.missing) text += e.missing.map(item => `\n[${item}]`).join(""); + if(e.dependencies && e.origin) { + text += `\n @ ${e.origin.readableIdentifier(requestShortener)}`; + e.dependencies.forEach(dep => { + if(!dep.loc) return; + if(typeof dep.loc === "string") return; + const locInfo = formatLocation(dep.loc); + if(!locInfo) return; + text += ` ${locInfo}`; + }); + let current = e.origin; + while(current.issuer) { + current = current.issuer; + text += `\n @ ${current.readableIdentifier(requestShortener)}`; + } + } + return text; + }; + + const obj = { + errors: compilation.errors.map(formatError), + warnings: Stats.filterWarnings(compilation.warnings.map(formatError), warningsFilter) + }; + + //We just hint other renderers since actually omitting + //errors/warnings from the JSON would be kind of weird. + Object.defineProperty(obj, "_showWarnings", { + value: showWarnings, + enumerable: false + }); + Object.defineProperty(obj, "_showErrors", { + value: showErrors, + enumerable: false + }); + + if(showVersion) { + obj.version = require("../package.json").version; + } + + if(showHash) obj.hash = this.hash; + if(showTimings && this.startTime && this.endTime) { + obj.time = this.endTime - this.startTime; + } + if(compilation.needAdditionalPass) { + obj.needAdditionalPass = true; + } + if(showPublicPath) { + obj.publicPath = this.compilation.mainTemplate.getPublicPath({ + hash: this.compilation.hash + }); + } + if(showAssets) { + const assetsByFile = {}; + obj.assetsByChunkName = {}; + obj.assets = Object.keys(compilation.assets).map(asset => { + const obj = { + name: asset, + size: compilation.assets[asset].size(), + chunks: [], + chunkNames: [], + emitted: compilation.assets[asset].emitted + }; + + if(showPerformance) { + obj.isOverSizeLimit = compilation.assets[asset].isOverSizeLimit; + } + + assetsByFile[asset] = obj; + return obj; + }).filter(asset => showCachedAssets || asset.emitted); + + compilation.chunks.forEach(chunk => { + chunk.files.forEach(asset => { + if(assetsByFile[asset]) { + chunk.ids.forEach(id => { + assetsByFile[asset].chunks.push(id); + }); + if(chunk.name) { + assetsByFile[asset].chunkNames.push(chunk.name); + if(obj.assetsByChunkName[chunk.name]) + obj.assetsByChunkName[chunk.name] = [].concat(obj.assetsByChunkName[chunk.name]).concat([asset]); + else + obj.assetsByChunkName[chunk.name] = asset; + } + } + }); + }); + obj.assets.sort(sortByField(sortAssets)); + } + + if(showEntrypoints) { + obj.entrypoints = {}; + Object.keys(compilation.entrypoints).forEach(name => { + const ep = compilation.entrypoints[name]; + obj.entrypoints[name] = { + chunks: ep.chunks.map(c => c.id), + assets: ep.chunks.reduce((array, c) => array.concat(c.files || []), []) + }; + if(showPerformance) { + obj.entrypoints[name].isOverSizeLimit = ep.isOverSizeLimit; + } + }); + } + + function fnModule(module) { + const obj = { + id: module.id, + identifier: module.identifier(), + name: module.readableIdentifier(requestShortener), + index: module.index, + index2: module.index2, + size: module.size(), + cacheable: !!module.cacheable, + built: !!module.built, + optional: !!module.optional, + prefetched: !!module.prefetched, + chunks: module.chunks.map(chunk => chunk.id), + assets: Object.keys(module.assets || {}), + issuer: module.issuer && module.issuer.identifier(), + issuerId: module.issuer && module.issuer.id, + issuerName: module.issuer && module.issuer.readableIdentifier(requestShortener), + profile: module.profile, + failed: !!module.error, + errors: module.errors && module.dependenciesErrors && (module.errors.length + module.dependenciesErrors.length), + warnings: module.errors && module.dependenciesErrors && (module.warnings.length + module.dependenciesWarnings.length) + }; + if(showReasons) { + obj.reasons = module.reasons.filter(reason => reason.dependency && reason.module).map(reason => { + const obj = { + moduleId: reason.module.id, + moduleIdentifier: reason.module.identifier(), + module: reason.module.readableIdentifier(requestShortener), + moduleName: reason.module.readableIdentifier(requestShortener), + type: reason.dependency.type, + userRequest: reason.dependency.userRequest + }; + const locInfo = formatLocation(reason.dependency.loc); + if(locInfo) obj.loc = locInfo; + return obj; + }).sort((a, b) => a.moduleId - b.moduleId); + } + if(showUsedExports) { + obj.usedExports = module.used ? module.usedExports : false; + } + if(showProvidedExports) { + obj.providedExports = Array.isArray(module.providedExports) ? module.providedExports : null; + } + if(showDepth) { + obj.depth = module.depth; + } + if(showSource && module._source) { + obj.source = module._source.source(); + } + return obj; + } + if(showChunks) { + obj.chunks = compilation.chunks.map(chunk => { + const obj = { + id: chunk.id, + rendered: chunk.rendered, + initial: chunk.isInitial(), + entry: chunk.hasRuntime(), + recorded: chunk.recorded, + extraAsync: !!chunk.extraAsync, + size: chunk.modules.reduce((size, module) => size + module.size(), 0), + names: chunk.name ? [chunk.name] : [], + files: chunk.files.slice(), + hash: chunk.renderedHash, + parents: chunk.parents.map(c => c.id) + }; + if(showChunkModules) { + obj.modules = chunk.modules + .slice() + .sort(sortByField("depth")) + .filter(createModuleFilter()) + .map(fnModule); + obj.filteredModules = chunk.modules.length - obj.modules.length; + obj.modules.sort(sortByField(sortModules)); + } + if(showChunkOrigins) { + obj.origins = chunk.origins.map(origin => ({ + moduleId: origin.module ? origin.module.id : undefined, + module: origin.module ? origin.module.identifier() : "", + moduleIdentifier: origin.module ? origin.module.identifier() : "", + moduleName: origin.module ? origin.module.readableIdentifier(requestShortener) : "", + loc: formatLocation(origin.loc), + name: origin.name, + reasons: origin.reasons || [] + })); + } + return obj; + }); + obj.chunks.sort(sortByField(sortChunks)); + } + if(showModules) { + obj.modules = compilation.modules + .slice() + .sort(sortByField("depth")) + .filter(createModuleFilter()) + .map(fnModule); + obj.filteredModules = compilation.modules.length - obj.modules.length; + obj.modules.sort(sortByField(sortModules)); + } + if(showChildren) { + obj.children = compilation.children.map((child, idx) => { + const childOptions = Stats.getChildOptions(options, idx); + const obj = new Stats(child).toJson(childOptions, forToString); + delete obj.hash; + delete obj.version; + obj.name = child.name; + return obj; + }); + } + + return obj; + } + + toString(options) { + if(typeof options === "boolean" || typeof options === "string") { + options = Stats.presetToOptions(options); + } else if(!options) { + options = {}; + } + + const useColors = optionOrFallback(options.colors, false); + + const obj = this.toJson(options, true); + + return Stats.jsonToString(obj, useColors); + } + + static jsonToString(obj, useColors) { + const buf = []; + + const defaultColors = { + bold: "\u001b[1m", + yellow: "\u001b[1m\u001b[33m", + red: "\u001b[1m\u001b[31m", + green: "\u001b[1m\u001b[32m", + cyan: "\u001b[1m\u001b[36m", + magenta: "\u001b[1m\u001b[35m" + }; + + const colors = Object.keys(defaultColors).reduce((obj, color) => { + obj[color] = str => { + if(useColors) { + buf.push( + (useColors === true || useColors[color] === undefined) ? + defaultColors[color] : useColors[color] + ); + } + buf.push(str); + if(useColors) { + buf.push("\u001b[39m\u001b[22m"); + } + }; + return obj; + }, { + normal: (str) => buf.push(str) + }); + + const coloredTime = (time) => { + let times = [800, 400, 200, 100]; + if(obj.time) { + times = [obj.time / 2, obj.time / 4, obj.time / 8, obj.time / 16]; + } + if(time < times[3]) + colors.normal(`${time}ms`); + else if(time < times[2]) + colors.bold(`${time}ms`); + else if(time < times[1]) + colors.green(`${time}ms`); + else if(time < times[0]) + colors.yellow(`${time}ms`); + else + colors.red(`${time}ms`); + }; + + const newline = () => buf.push("\n"); + + const getText = (arr, row, col) => { + return arr[row][col].value; + }; + + const table = (array, align, splitter) => { + const rows = array.length; + const cols = array[0].length; + const colSizes = new Array(cols); + for(let col = 0; col < cols; col++) + colSizes[col] = 0; + for(let row = 0; row < rows; row++) { + for(let col = 0; col < cols; col++) { + const value = `${getText(array, row, col)}`; + if(value.length > colSizes[col]) { + colSizes[col] = value.length; + } + } + } + for(let row = 0; row < rows; row++) { + for(let col = 0; col < cols; col++) { + const format = array[row][col].color; + const value = `${getText(array, row, col)}`; + let l = value.length; + if(align[col] === "l") + format(value); + for(; l < colSizes[col] && col !== cols - 1; l++) + colors.normal(" "); + if(align[col] === "r") + format(value); + if(col + 1 < cols && colSizes[col] !== 0) + colors.normal(splitter || " "); + } + newline(); + } + }; + + const getAssetColor = (asset, defaultColor) => { + if(asset.isOverSizeLimit) { + return colors.yellow; + } + + return defaultColor; + }; + + if(obj.hash) { + colors.normal("Hash: "); + colors.bold(obj.hash); + newline(); + } + if(obj.version) { + colors.normal("Version: webpack "); + colors.bold(obj.version); + newline(); + } + if(typeof obj.time === "number") { + colors.normal("Time: "); + colors.bold(obj.time); + colors.normal("ms"); + newline(); + } + if(obj.publicPath) { + colors.normal("PublicPath: "); + colors.bold(obj.publicPath); + newline(); + } + + if(obj.assets && obj.assets.length > 0) { + const t = [ + [{ + value: "Asset", + color: colors.bold + }, { + value: "Size", + color: colors.bold + }, { + value: "Chunks", + color: colors.bold + }, { + value: "", + color: colors.bold + }, { + value: "", + color: colors.bold + }, { + value: "Chunk Names", + color: colors.bold + }] + ]; + obj.assets.forEach(asset => { + t.push([{ + value: asset.name, + color: getAssetColor(asset, colors.green) + }, { + value: SizeFormatHelpers.formatSize(asset.size), + color: getAssetColor(asset, colors.normal) + }, { + value: asset.chunks.join(", "), + color: colors.bold + }, { + value: asset.emitted ? "[emitted]" : "", + color: colors.green + }, { + value: asset.isOverSizeLimit ? "[big]" : "", + color: getAssetColor(asset, colors.normal) + }, { + value: asset.chunkNames.join(", "), + color: colors.normal + }]); + }); + table(t, "rrrlll"); + } + if(obj.entrypoints) { + Object.keys(obj.entrypoints).forEach(name => { + const ep = obj.entrypoints[name]; + colors.normal("Entrypoint "); + colors.bold(name); + if(ep.isOverSizeLimit) { + colors.normal(" "); + colors.yellow("[big]"); + } + colors.normal(" ="); + ep.assets.forEach(asset => { + colors.normal(" "); + colors.green(asset); + }); + newline(); + }); + } + const modulesByIdentifier = {}; + if(obj.modules) { + obj.modules.forEach(module => { + modulesByIdentifier[`$${module.identifier}`] = module; + }); + } else if(obj.chunks) { + obj.chunks.forEach(chunk => { + if(chunk.modules) { + chunk.modules.forEach(module => { + modulesByIdentifier[`$${module.identifier}`] = module; + }); + } + }); + } + + const processModuleAttributes = (module) => { + colors.normal(" "); + colors.normal(SizeFormatHelpers.formatSize(module.size)); + if(module.chunks) { + module.chunks.forEach(chunk => { + colors.normal(" {"); + colors.yellow(chunk); + colors.normal("}"); + }); + } + if(typeof module.depth === "number") { + colors.normal(` [depth ${module.depth}]`); + } + if(!module.cacheable) { + colors.red(" [not cacheable]"); + } + if(module.optional) { + colors.yellow(" [optional]"); + } + if(module.built) { + colors.green(" [built]"); + } + if(module.prefetched) { + colors.magenta(" [prefetched]"); + } + if(module.failed) + colors.red(" [failed]"); + if(module.warnings) + colors.yellow(` [${module.warnings} warning${module.warnings === 1 ? "" : "s"}]`); + if(module.errors) + colors.red(` [${module.errors} error${module.errors === 1 ? "" : "s"}]`); + }; + + const processModuleContent = (module, prefix) => { + if(Array.isArray(module.providedExports)) { + colors.normal(prefix); + colors.cyan(`[exports: ${module.providedExports.join(", ")}]`); + newline(); + } + if(module.usedExports !== undefined) { + if(module.usedExports !== true) { + colors.normal(prefix); + if(module.usedExports === false) + colors.cyan("[no exports used]"); + else + colors.cyan(`[only some exports used: ${module.usedExports.join(", ")}]`); + newline(); + } + } + if(module.reasons) { + module.reasons.forEach(reason => { + colors.normal(prefix); + colors.normal(reason.type); + colors.normal(" "); + colors.cyan(reason.userRequest); + colors.normal(" ["); + colors.normal(reason.moduleId); + colors.normal("] "); + colors.magenta(reason.module); + if(reason.loc) { + colors.normal(" "); + colors.normal(reason.loc); + } + newline(); + }); + } + if(module.profile) { + colors.normal(prefix); + let sum = 0; + const path = []; + let current = module; + while(current.issuer) { + path.unshift(current = current.issuer); + } + path.forEach(module => { + colors.normal("["); + colors.normal(module.id); + colors.normal("] "); + if(module.profile) { + const time = (module.profile.factory || 0) + (module.profile.building || 0); + coloredTime(time); + sum += time; + colors.normal(" "); + } + colors.normal("->"); + }); + Object.keys(module.profile).forEach(key => { + colors.normal(` ${key}:`); + const time = module.profile[key]; + coloredTime(time); + sum += time; + }); + colors.normal(" = "); + coloredTime(sum); + newline(); + } + }; + + if(obj.chunks) { + obj.chunks.forEach(chunk => { + colors.normal("chunk "); + if(chunk.id < 1000) colors.normal(" "); + if(chunk.id < 100) colors.normal(" "); + if(chunk.id < 10) colors.normal(" "); + colors.normal("{"); + colors.yellow(chunk.id); + colors.normal("} "); + colors.green(chunk.files.join(", ")); + if(chunk.names && chunk.names.length > 0) { + colors.normal(" ("); + colors.normal(chunk.names.join(", ")); + colors.normal(")"); + } + colors.normal(" "); + colors.normal(SizeFormatHelpers.formatSize(chunk.size)); + chunk.parents.forEach(id => { + colors.normal(" {"); + colors.yellow(id); + colors.normal("}"); + }); + if(chunk.entry) { + colors.yellow(" [entry]"); + } else if(chunk.initial) { + colors.yellow(" [initial]"); + } + if(chunk.rendered) { + colors.green(" [rendered]"); + } + if(chunk.recorded) { + colors.green(" [recorded]"); + } + newline(); + if(chunk.origins) { + chunk.origins.forEach(origin => { + colors.normal(" > "); + if(origin.reasons && origin.reasons.length) { + colors.yellow(origin.reasons.join(" ")); + colors.normal(" "); + } + if(origin.name) { + colors.normal(origin.name); + colors.normal(" "); + } + if(origin.module) { + colors.normal("["); + colors.normal(origin.moduleId); + colors.normal("] "); + const module = modulesByIdentifier[`$${origin.module}`]; + if(module) { + colors.bold(module.name); + colors.normal(" "); + } + if(origin.loc) { + colors.normal(origin.loc); + } + } + newline(); + }); + } + if(chunk.modules) { + chunk.modules.forEach(module => { + colors.normal(" "); + if(module.id < 1000) colors.normal(" "); + if(module.id < 100) colors.normal(" "); + if(module.id < 10) colors.normal(" "); + colors.normal("["); + colors.normal(module.id); + colors.normal("] "); + colors.bold(module.name); + processModuleAttributes(module); + newline(); + processModuleContent(module, " "); + }); + if(chunk.filteredModules > 0) { + colors.normal(` + ${chunk.filteredModules} hidden modules`); + newline(); + } + } + }); + } + if(obj.modules) { + obj.modules.forEach(module => { + if(module.id < 1000) colors.normal(" "); + if(module.id < 100) colors.normal(" "); + if(module.id < 10) colors.normal(" "); + colors.normal("["); + colors.normal(module.id); + colors.normal("] "); + colors.bold(module.name || module.identifier); + processModuleAttributes(module); + newline(); + processModuleContent(module, " "); + }); + if(obj.filteredModules > 0) { + colors.normal(` + ${obj.filteredModules} hidden modules`); + newline(); + } + } + + if(obj._showWarnings && obj.warnings) { + obj.warnings.forEach(warning => { + newline(); + colors.yellow(`WARNING in ${warning}`); + newline(); + }); + } + if(obj._showErrors && obj.errors) { + obj.errors.forEach(error => { + newline(); + colors.red(`ERROR in ${error}`); + newline(); + }); + } + if(obj.children) { + obj.children.forEach(child => { + const childString = Stats.jsonToString(child, useColors); + if(childString) { + if(child.name) { + colors.normal("Child "); + colors.bold(child.name); + colors.normal(":"); + } else { + colors.normal("Child"); + } + newline(); + buf.push(" "); + buf.push(childString.replace(/\n/g, "\n ")); + newline(); + } + }); + } + if(obj.needAdditionalPass) { + colors.yellow("Compilation needs an additional pass and will compile again."); + } + + while(buf[buf.length - 1] === "\n") buf.pop(); + return buf.join(""); + } + + static presetToOptions(name) { + //Accepted values: none, errors-only, minimal, normal, verbose + //Any other falsy value will behave as 'none', truthy values as 'normal' + const pn = (typeof name === "string") && name.toLowerCase() || name; + if(pn === "none" || !pn) { + return { + hash: false, + version: false, + timings: false, + assets: false, + entrypoints: false, + chunks: false, + chunkModules: false, + modules: false, + reasons: false, + depth: false, + usedExports: false, + providedExports: false, + children: false, + source: false, + errors: false, + errorDetails: false, + warnings: false, + publicPath: false, + performance: false + }; + } else { + return { + hash: pn !== "errors-only" && pn !== "minimal", + version: pn === "verbose", + timings: pn !== "errors-only" && pn !== "minimal", + assets: pn === "verbose", + entrypoints: pn === "verbose", + chunks: pn !== "errors-only", + chunkModules: pn === "verbose", + //warnings: pn !== "errors-only", + errorDetails: pn !== "errors-only" && pn !== "minimal", + reasons: pn === "verbose", + depth: pn === "verbose", + usedExports: pn === "verbose", + providedExports: pn === "verbose", + colors: true, + performance: true + }; + } + + } + + static getChildOptions(options, idx) { + let innerOptions; + if(Array.isArray(options.children)) { + if(idx < options.children.length) + innerOptions = options.children[idx]; + } else if(typeof options.children === "object" && options.children) { + innerOptions = options.children; + } + if(typeof innerOptions === "boolean" || typeof innerOptions === "string") + innerOptions = Stats.presetToOptions(innerOptions); + if(!innerOptions) + return options; + const childOptions = Object.assign({}, options); + delete childOptions.children; // do not inherit children + return Object.assign(childOptions, innerOptions); + } +} + +module.exports = Stats; diff --git a/node_modules/webpack/lib/Template.js b/node_modules/webpack/lib/Template.js new file mode 100644 index 000000000..74f42b8fb --- /dev/null +++ b/node_modules/webpack/lib/Template.js @@ -0,0 +1,161 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Tapable = require("tapable"); +const ConcatSource = require("webpack-sources").ConcatSource; + +const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0); +const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0); +const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1; + +module.exports = class Template extends Tapable { + constructor(outputOptions) { + super(); + this.outputOptions = outputOptions || {}; + } + + static getFunctionContent(fn) { + return fn.toString().replace(/^function\s?\(\)\s?\{\n?|\n?\}$/g, "").replace(/^\t/mg, ""); + } + + static toIdentifier(str) { + if(typeof str !== "string") return ""; + return str.replace(/^[^a-zA-Z$_]/, "_").replace(/[^a-zA-Z0-9$_]/g, "_"); + } + + // map number to a single character a-z, A-Z or <_ + number> if number is too big + static numberToIdentifer(n) { + // lower case + if(n < DELTA_A_TO_Z) return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n); + + // upper case + n -= DELTA_A_TO_Z; + if(n < DELTA_A_TO_Z) return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n); + + // fall back to _ + number + n -= DELTA_A_TO_Z; + return "_" + n; + } + + indent(str) { + if(Array.isArray(str)) { + return str.map(this.indent.bind(this)).join("\n"); + } else { + str = str.trimRight(); + if(!str) return ""; + var ind = (str[0] === "\n" ? "" : "\t"); + return ind + str.replace(/\n([^\n])/g, "\n\t$1"); + } + } + + prefix(str, prefix) { + if(Array.isArray(str)) { + str = str.join("\n"); + } + str = str.trim(); + if(!str) return ""; + const ind = (str[0] === "\n" ? "" : prefix); + return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1"); + } + + asString(str) { + if(Array.isArray(str)) { + return str.join("\n"); + } + return str; + } + + getModulesArrayBounds(modules) { + if(!modules.every(moduleIdIsNumber)) + return false; + var maxId = -Infinity; + var minId = Infinity; + modules.forEach(function(module) { + if(maxId < module.id) maxId = module.id; + if(minId > module.id) minId = module.id; + }); + if(minId < 16 + ("" + minId).length) { + // add minId x ',' instead of 'Array(minId).concat(...)' + minId = 0; + } + var objectOverhead = modules.map(function(module) { + var idLength = (module.id + "").length; + return idLength + 2; + }).reduce(function(a, b) { + return a + b; + }, -1); + var arrayOverhead = minId === 0 ? maxId : 16 + ("" + minId).length + maxId; + return arrayOverhead < objectOverhead ? [minId, maxId] : false; + } + + renderChunkModules(chunk, moduleTemplate, dependencyTemplates, prefix) { + if(!prefix) prefix = ""; + var source = new ConcatSource(); + if(chunk.modules.length === 0) { + source.add("[]"); + return source; + } + var removedModules = chunk.removedModules; + var allModules = chunk.modules.map(function(module) { + return { + id: module.id, + source: moduleTemplate.render(module, dependencyTemplates, chunk) + }; + }); + if(removedModules && removedModules.length > 0) { + removedModules.forEach(function(id) { + allModules.push({ + id: id, + source: "false" + }); + }); + } + var bounds = this.getModulesArrayBounds(chunk.modules); + + if(bounds) { + // Render a spare array + var minId = bounds[0]; + var maxId = bounds[1]; + if(minId !== 0) source.add("Array(" + minId + ").concat("); + source.add("[\n"); + var modules = {}; + allModules.forEach(function(module) { + modules[module.id] = module; + }); + for(var idx = minId; idx <= maxId; idx++) { + var module = modules[idx]; + if(idx !== minId) source.add(",\n"); + source.add("/* " + idx + " */"); + if(module) { + source.add("\n"); + source.add(module.source); + } + } + source.add("\n" + prefix + "]"); + if(minId !== 0) source.add(")"); + } else { + // Render an object + source.add("{\n"); + allModules.sort(function(a, b) { + var aId = a.id + ""; + var bId = b.id + ""; + if(aId < bId) return -1; + if(aId > bId) return 1; + return 0; + }).forEach(function(module, idx) { + if(idx !== 0) source.add(",\n"); + source.add("\n/***/ " + JSON.stringify(module.id) + ":\n"); + source.add(module.source); + }); + source.add("\n\n" + prefix + "}"); + } + return source; + } +}; + +function moduleIdIsNumber(module) { + return typeof module.id === "number"; +} diff --git a/node_modules/webpack/lib/TemplatedPathPlugin.js b/node_modules/webpack/lib/TemplatedPathPlugin.js new file mode 100644 index 000000000..6c8a2addd --- /dev/null +++ b/node_modules/webpack/lib/TemplatedPathPlugin.js @@ -0,0 +1,112 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Jason Anderson @diurnalist +*/ +"use strict"; + +const REGEXP_HASH = /\[hash(?::(\d+))?\]/gi, + REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/gi, + REGEXP_NAME = /\[name\]/gi, + REGEXP_ID = /\[id\]/gi, + REGEXP_FILE = /\[file\]/gi, + REGEXP_QUERY = /\[query\]/gi, + REGEXP_FILEBASE = /\[filebase\]/gi; + +// Using global RegExp for .test is dangerous +// We use a normal RegExp instead of .test +const REGEXP_HASH_FOR_TEST = new RegExp(REGEXP_HASH.source, "i"), + REGEXP_CHUNKHASH_FOR_TEST = new RegExp(REGEXP_CHUNKHASH.source, "i"), + REGEXP_NAME_FOR_TEST = new RegExp(REGEXP_NAME.source, "i"); + +// TODO: remove in webpack 3 +// Backwards compatibility; expose regexes on Template object +const Template = require("./Template"); +Template.REGEXP_HASH = REGEXP_HASH; +Template.REGEXP_CHUNKHASH = REGEXP_CHUNKHASH; +Template.REGEXP_NAME = REGEXP_NAME; +Template.REGEXP_ID = REGEXP_ID; +Template.REGEXP_FILE = REGEXP_FILE; +Template.REGEXP_QUERY = REGEXP_QUERY; +Template.REGEXP_FILEBASE = REGEXP_FILEBASE; + +const withHashLength = (replacer, handlerFn) => { + return function(_, hashLength) { + const length = hashLength && parseInt(hashLength, 10); + if(length && handlerFn) { + return handlerFn(length); + } + const hash = replacer.apply(this, arguments); + return length ? hash.slice(0, length) : hash; + }; +}; + +const getReplacer = (value, allowEmpty) => { + return function(match) { + // last argument in replacer is the entire input string + const input = arguments[arguments.length - 1]; + if(value === null || value === undefined) { + if(!allowEmpty) throw new Error(`Path variable ${match} not implemented in this context: ${input}`); + return ""; + } else { + return `${value}`; + } + }; +}; + +const replacePathVariables = (path, data) => { + const chunk = data.chunk; + const chunkId = chunk && chunk.id; + const chunkName = chunk && (chunk.name || chunk.id); + const chunkHash = chunk && (chunk.renderedHash || chunk.hash); + const chunkHashWithLength = chunk && chunk.hashWithLength; + + if(data.noChunkHash && REGEXP_CHUNKHASH_FOR_TEST.test(path)) { + throw new Error(`Cannot use [chunkhash] for chunk in '${path}' (use [hash] instead)`); + } + + return path + .replace(REGEXP_HASH, withHashLength(getReplacer(data.hash), data.hashWithLength)) + .replace(REGEXP_CHUNKHASH, withHashLength(getReplacer(chunkHash), chunkHashWithLength)) + .replace(REGEXP_ID, getReplacer(chunkId)) + .replace(REGEXP_NAME, getReplacer(chunkName)) + .replace(REGEXP_FILE, getReplacer(data.filename)) + .replace(REGEXP_FILEBASE, getReplacer(data.basename)) + // query is optional, it's OK if it's in a path but there's nothing to replace it with + .replace(REGEXP_QUERY, getReplacer(data.query, true)); +}; + +class TemplatedPathPlugin { + apply(compiler) { + compiler.plugin("compilation", compilation => { + const mainTemplate = compilation.mainTemplate; + + mainTemplate.plugin("asset-path", replacePathVariables); + + mainTemplate.plugin("global-hash", function(chunk, paths) { + const outputOptions = this.outputOptions; + const publicPath = outputOptions.publicPath || ""; + const filename = outputOptions.filename || ""; + const chunkFilename = outputOptions.chunkFilename || outputOptions.filename; + if(REGEXP_HASH_FOR_TEST.test(publicPath) || REGEXP_CHUNKHASH_FOR_TEST.test(publicPath) || REGEXP_NAME_FOR_TEST.test(publicPath)) + return true; + if(REGEXP_HASH_FOR_TEST.test(filename)) + return true; + if(REGEXP_HASH_FOR_TEST.test(chunkFilename)) + return true; + if(REGEXP_HASH_FOR_TEST.test(paths.join("|"))) + return true; + }); + + mainTemplate.plugin("hash-for-chunk", function(hash, chunk) { + const outputOptions = this.outputOptions; + const chunkFilename = outputOptions.chunkFilename || outputOptions.filename; + if(REGEXP_CHUNKHASH_FOR_TEST.test(chunkFilename)) + hash.update(JSON.stringify(chunk.getChunkMaps(true, true).hash)); + if(REGEXP_NAME_FOR_TEST.test(chunkFilename)) + hash.update(JSON.stringify(chunk.getChunkMaps(true, true).name)); + }); + }); + } +} + +module.exports = TemplatedPathPlugin; diff --git a/node_modules/webpack/lib/UmdMainTemplatePlugin.js b/node_modules/webpack/lib/UmdMainTemplatePlugin.js new file mode 100644 index 000000000..81873305a --- /dev/null +++ b/node_modules/webpack/lib/UmdMainTemplatePlugin.js @@ -0,0 +1,176 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; +const OriginalSource = require("webpack-sources").OriginalSource; +const Template = require("./Template"); + +function accessorToObjectAccess(accessor) { + return accessor.map(a => `[${JSON.stringify(a)}]`).join(""); +} + +function accessorAccess(base, accessor) { + accessor = [].concat(accessor); + return accessor.map((a, idx) => { + a = base + accessorToObjectAccess(accessor.slice(0, idx + 1)); + if(idx === accessor.length - 1) return a; + return `${a} = ${a} || {}`; + }).join(", "); +} + +class UmdMainTemplatePlugin { + constructor(name, options) { + this.name = name; + this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal; + this.namedDefine = options.namedDefine; + this.auxiliaryComment = options.auxiliaryComment; + } + + apply(compilation) { + const mainTemplate = compilation.mainTemplate; + compilation.templatesPlugin("render-with-entry", function(source, chunk, hash) { + let externals = chunk.modules.filter(m => m.external); + const optionalExternals = []; + let requiredExternals = []; + if(this.optionalAmdExternalAsGlobal) { + externals.forEach(m => { + if(m.optional) { + optionalExternals.push(m); + } else { + requiredExternals.push(m); + } + }); + externals = requiredExternals.concat(optionalExternals); + } else { + requiredExternals = externals; + } + + function replaceKeys(str) { + return mainTemplate.applyPluginsWaterfall("asset-path", str, { + hash, + chunk + }); + } + + function externalsDepsArray(modules) { + return `[${replaceKeys(modules.map(m => JSON.stringify(typeof m.request === "object" ? m.request.amd : m.request)).join(", "))}]`; + } + + function externalsRootArray(modules) { + return replaceKeys(modules.map(m => { + let request = m.request; + if(typeof request === "object") request = request.root; + return `root${accessorToObjectAccess([].concat(request))}`; + }).join(", ")); + } + + function externalsRequireArray(type) { + return replaceKeys(externals.map(m => { + let expr; + let request = m.request; + if(typeof request === "object") request = request[type]; + if(Array.isArray(request)) { + expr = `require(${JSON.stringify(request[0])})${accessorToObjectAccess(request.slice(1))}`; + } else + expr = `require(${JSON.stringify(request)})`; + if(m.optional) { + expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`; + } + return expr; + }).join(", ")); + } + + function externalsArguments(modules) { + return modules.map(m => Template.toIdentifier(`__WEBPACK_EXTERNAL_MODULE_${m.id}__`)).join(", "); + } + + function libraryName(library) { + return JSON.stringify(replaceKeys([].concat(library).pop())); + } + + let amdFactory; + if(optionalExternals.length > 0) { + const wrapperArguments = externalsArguments(requiredExternals); + const factoryArguments = requiredExternals.length > 0 ? + externalsArguments(requiredExternals) + ", " + externalsRootArray(optionalExternals) : + externalsRootArray(optionalExternals); + amdFactory = `function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` + + ` return factory(${factoryArguments});\n` + + " }"; + } else { + amdFactory = "factory"; + } + + return new ConcatSource(new OriginalSource( + "(function webpackUniversalModuleDefinition(root, factory) {\n" + + (this.auxiliaryComment && + typeof this.auxiliaryComment === "string" ? + " //" + this.auxiliaryComment + "\n" : + this.auxiliaryComment.commonjs2 ? + " //" + this.auxiliaryComment.commonjs2 + "\n" : + "" + ) + + " if(typeof exports === 'object' && typeof module === 'object')\n" + + " module.exports = factory(" + externalsRequireArray("commonjs2") + ");\n" + + (this.auxiliaryComment && + typeof this.auxiliaryComment === "string" ? + " //" + this.auxiliaryComment + "\n" : + this.auxiliaryComment.amd ? + " //" + this.auxiliaryComment.amd + "\n" : + "" + ) + + " else if(typeof define === 'function' && define.amd)\n" + + (requiredExternals.length > 0 ? + (this.name && this.namedDefine === true ? + " define(" + libraryName(this.name) + ", " + externalsDepsArray(requiredExternals) + ", " + amdFactory + ");\n" : + " define(" + externalsDepsArray(requiredExternals) + ", " + amdFactory + ");\n" + ) : + (this.name && this.namedDefine === true ? + " define(" + libraryName(this.name) + ", [], " + amdFactory + ");\n" : + " define([], " + amdFactory + ");\n" + ) + ) + + (this.name ? + (this.auxiliaryComment && + typeof this.auxiliaryComment === "string" ? + " //" + this.auxiliaryComment + "\n" : + this.auxiliaryComment.commonjs ? + " //" + this.auxiliaryComment.commonjs + "\n" : + "" + ) + + " else if(typeof exports === 'object')\n" + + " exports[" + libraryName(this.name) + "] = factory(" + externalsRequireArray("commonjs") + ");\n" + + (this.auxiliaryComment && + typeof this.auxiliaryComment === "string" ? + " //" + this.auxiliaryComment + "\n" : + this.auxiliaryComment.root ? + " //" + this.auxiliaryComment.root + "\n" : + "" + ) + + " else\n" + + " " + replaceKeys(accessorAccess("root", this.name)) + " = factory(" + externalsRootArray(externals) + ");\n" : + " else {\n" + + (externals.length > 0 ? + " var a = typeof exports === 'object' ? factory(" + externalsRequireArray("commonjs") + ") : factory(" + externalsRootArray(externals) + ");\n" : + " var a = factory();\n" + ) + + " for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" + + " }\n" + ) + + "})(this, function(" + externalsArguments(externals) + ") {\nreturn ", "webpack/universalModuleDefinition"), source, ";\n})"); + }.bind(this)); + mainTemplate.plugin("global-hash-paths", function(paths) { + if(this.name) paths = paths.concat(this.name); + return paths; + }.bind(this)); + mainTemplate.plugin("hash", function(hash) { + hash.update("umd"); + hash.update(`${this.name}`); + }.bind(this)); + } +} + +module.exports = UmdMainTemplatePlugin; diff --git a/node_modules/webpack/lib/UnsupportedFeatureWarning.js b/node_modules/webpack/lib/UnsupportedFeatureWarning.js new file mode 100644 index 000000000..d2b270336 --- /dev/null +++ b/node_modules/webpack/lib/UnsupportedFeatureWarning.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); + +class UnsupportedFeatureWarning extends WebpackError { + constructor(module, message) { + super(); + + this.name = "UnsupportedFeatureWarning"; + this.message = message; + this.origin = this.module = module; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = UnsupportedFeatureWarning; diff --git a/node_modules/webpack/lib/UseStrictPlugin.js b/node_modules/webpack/lib/UseStrictPlugin.js new file mode 100644 index 000000000..2135839cf --- /dev/null +++ b/node_modules/webpack/lib/UseStrictPlugin.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConstDependency = require("./dependencies/ConstDependency"); + +class UseStrictPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + params.normalModuleFactory.plugin("parser", (parser) => { + const parserInstance = parser; + parser.plugin("program", (ast) => { + const firstNode = ast.body[0]; + if(firstNode && + firstNode.type === "ExpressionStatement" && + firstNode.expression.type === "Literal" && + firstNode.expression.value === "use strict") { + // Remove "use strict" expression. It will be added later by the renderer again. + // This is necessary in order to not break the strict mode when webpack prepends code. + // @see https://github.com/webpack/webpack/issues/1970 + const dep = new ConstDependency("", firstNode.range); + dep.loc = firstNode.loc; + parserInstance.state.current.addDependency(dep); + parserInstance.state.module.strict = true; + } + }); + }); + }); + } +} + +module.exports = UseStrictPlugin; diff --git a/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js b/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js new file mode 100644 index 000000000..54edb4ac7 --- /dev/null +++ b/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js @@ -0,0 +1,31 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning"); + +class WarnCaseSensitiveModulesPlugin { + apply(compiler) { + compiler.plugin("compilation", compilation => { + compilation.plugin("seal", () => { + const moduleWithoutCase = Object.create(null); + compilation.modules.forEach(module => { + const identifier = module.identifier().toLowerCase(); + if(moduleWithoutCase[identifier]) { + moduleWithoutCase[identifier].push(module); + } else { + moduleWithoutCase[identifier] = [module]; + } + }); + Object.keys(moduleWithoutCase).forEach(key => { + if(moduleWithoutCase[key].length > 1) + compilation.warnings.push(new CaseSensitiveModulesWarning(moduleWithoutCase[key])); + }); + }); + }); + } +} + +module.exports = WarnCaseSensitiveModulesPlugin; diff --git a/node_modules/webpack/lib/WatchIgnorePlugin.js b/node_modules/webpack/lib/WatchIgnorePlugin.js new file mode 100644 index 000000000..9b74b3c20 --- /dev/null +++ b/node_modules/webpack/lib/WatchIgnorePlugin.js @@ -0,0 +1,49 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class WatchIgnorePlugin { + constructor(paths) { + this.paths = paths; + } + + apply(compiler) { + compiler.plugin("after-environment", () => { + compiler.watchFileSystem = new IgnoringWatchFileSystem(compiler.watchFileSystem, this.paths); + }); + } +} + +module.exports = WatchIgnorePlugin; + +class IgnoringWatchFileSystem { + constructor(wfs, paths) { + this.wfs = wfs; + this.paths = paths; + } + + watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) { + const ignored = path => this.paths.some(p => p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0); + + const notIgnored = path => !ignored(path); + + const ignoredFiles = files.filter(ignored); + const ignoredDirs = dirs.filter(ignored); + + this.wfs.watch(files.filter(notIgnored), dirs.filter(notIgnored), missing, startTime, options, (err, filesModified, dirsModified, missingModified, fileTimestamps, dirTimestamps) => { + if(err) return callback(err); + + ignoredFiles.forEach(path => { + fileTimestamps[path] = 1; + }); + + ignoredDirs.forEach(path => { + dirTimestamps[path] = 1; + }); + + callback(err, filesModified, dirsModified, missingModified, fileTimestamps, dirTimestamps); + }, callbackUndelayed); + } +} diff --git a/node_modules/webpack/lib/WebpackError.js b/node_modules/webpack/lib/WebpackError.js new file mode 100644 index 000000000..abd716a63 --- /dev/null +++ b/node_modules/webpack/lib/WebpackError.js @@ -0,0 +1,11 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Jarid Margolin @jaridmargolin +*/ +"use strict"; + +module.exports = class WebpackError extends Error { + inspect() { + return this.stack + (this.details ? `\n${this.details}` : ""); + } +}; diff --git a/node_modules/webpack/lib/WebpackOptionsApply.js b/node_modules/webpack/lib/WebpackOptionsApply.js new file mode 100644 index 000000000..ed37c7723 --- /dev/null +++ b/node_modules/webpack/lib/WebpackOptionsApply.js @@ -0,0 +1,298 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const OptionsApply = require("./OptionsApply"); + +const LoaderTargetPlugin = require("./LoaderTargetPlugin"); +const FunctionModulePlugin = require("./FunctionModulePlugin"); +const EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin"); +const SourceMapDevToolPlugin = require("./SourceMapDevToolPlugin"); +const EvalSourceMapDevToolPlugin = require("./EvalSourceMapDevToolPlugin"); + +const EntryOptionPlugin = require("./EntryOptionPlugin"); +const RecordIdsPlugin = require("./RecordIdsPlugin"); + +const APIPlugin = require("./APIPlugin"); +const ConstPlugin = require("./ConstPlugin"); +const RequireJsStuffPlugin = require("./RequireJsStuffPlugin"); +const NodeStuffPlugin = require("./NodeStuffPlugin"); +const CompatibilityPlugin = require("./CompatibilityPlugin"); + +const TemplatedPathPlugin = require("./TemplatedPathPlugin"); +const WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin"); +const UseStrictPlugin = require("./UseStrictPlugin"); + +const LoaderPlugin = require("./dependencies/LoaderPlugin"); +const CommonJsPlugin = require("./dependencies/CommonJsPlugin"); +const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin"); +const SystemPlugin = require("./dependencies/SystemPlugin"); +const ImportPlugin = require("./dependencies/ImportPlugin"); +const AMDPlugin = require("./dependencies/AMDPlugin"); +const RequireContextPlugin = require("./dependencies/RequireContextPlugin"); +const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin"); +const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin"); + +const EnsureChunkConditionsPlugin = require("./optimize/EnsureChunkConditionsPlugin"); +const RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin"); +const RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin"); +const MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin"); +const FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin"); +const OccurrenceOrderPlugin = require("./optimize/OccurrenceOrderPlugin"); +const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin"); +const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin"); +const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin"); + +const ResolverFactory = require("enhanced-resolve").ResolverFactory; + +class WebpackOptionsApply extends OptionsApply { + constructor() { + super(); + } + + process(options, compiler) { + let ExternalsPlugin; + compiler.outputPath = options.output.path; + compiler.recordsInputPath = options.recordsInputPath || options.recordsPath; + compiler.recordsOutputPath = options.recordsOutputPath || options.recordsPath; + compiler.name = options.name; + compiler.dependencies = options.dependencies; + if(typeof options.target === "string") { + let JsonpTemplatePlugin; + let NodeSourcePlugin; + let NodeTargetPlugin; + let NodeTemplatePlugin; + + switch(options.target) { + case "web": + JsonpTemplatePlugin = require("./JsonpTemplatePlugin"); + NodeSourcePlugin = require("./node/NodeSourcePlugin"); + compiler.apply( + new JsonpTemplatePlugin(options.output), + new FunctionModulePlugin(options.output), + new NodeSourcePlugin(options.node), + new LoaderTargetPlugin("web") + ); + break; + case "webworker": + { + let WebWorkerTemplatePlugin = require("./webworker/WebWorkerTemplatePlugin"); + NodeSourcePlugin = require("./node/NodeSourcePlugin"); + compiler.apply( + new WebWorkerTemplatePlugin(), + new FunctionModulePlugin(options.output), + new NodeSourcePlugin(options.node), + new LoaderTargetPlugin("webworker") + ); + break; + } + case "node": + case "async-node": + NodeTemplatePlugin = require("./node/NodeTemplatePlugin"); + NodeTargetPlugin = require("./node/NodeTargetPlugin"); + compiler.apply( + new NodeTemplatePlugin({ + asyncChunkLoading: options.target === "async-node" + }), + new FunctionModulePlugin(options.output), + new NodeTargetPlugin(), + new LoaderTargetPlugin("node") + ); + break; + case "node-webkit": + JsonpTemplatePlugin = require("./JsonpTemplatePlugin"); + NodeTargetPlugin = require("./node/NodeTargetPlugin"); + ExternalsPlugin = require("./ExternalsPlugin"); + compiler.apply( + new JsonpTemplatePlugin(options.output), + new FunctionModulePlugin(options.output), + new NodeTargetPlugin(), + new ExternalsPlugin("commonjs", "nw.gui"), + new LoaderTargetPlugin("node-webkit") + ); + break; + case "atom": + case "electron": + case "electron-main": + NodeTemplatePlugin = require("./node/NodeTemplatePlugin"); + NodeTargetPlugin = require("./node/NodeTargetPlugin"); + ExternalsPlugin = require("./ExternalsPlugin"); + compiler.apply( + new NodeTemplatePlugin({ + asyncChunkLoading: true + }), + new FunctionModulePlugin(options.output), + new NodeTargetPlugin(), + new ExternalsPlugin("commonjs", [ + "app", + "auto-updater", + "browser-window", + "content-tracing", + "dialog", + "electron", + "global-shortcut", + "ipc", + "ipc-main", + "menu", + "menu-item", + "power-monitor", + "power-save-blocker", + "protocol", + "session", + "web-contents", + "tray", + "clipboard", + "crash-reporter", + "native-image", + "screen", + "shell" + ]), + new LoaderTargetPlugin(options.target) + ); + break; + case "electron-renderer": + JsonpTemplatePlugin = require("./JsonpTemplatePlugin"); + NodeTargetPlugin = require("./node/NodeTargetPlugin"); + ExternalsPlugin = require("./ExternalsPlugin"); + compiler.apply( + new JsonpTemplatePlugin(options.output), + new FunctionModulePlugin(options.output), + new NodeTargetPlugin(), + new ExternalsPlugin("commonjs", [ + "desktop-capturer", + "electron", + "ipc", + "ipc-renderer", + "remote", + "web-frame", + "clipboard", + "crash-reporter", + "native-image", + "screen", + "shell" + ]), + new LoaderTargetPlugin(options.target) + ); + break; + default: + throw new Error("Unsupported target '" + options.target + "'."); + } + } else if(options.target !== false) { + options.target(compiler); + } else { + throw new Error("Unsupported target '" + options.target + "'."); + } + + if(options.output.library || options.output.libraryTarget !== "var") { + let LibraryTemplatePlugin = require("./LibraryTemplatePlugin"); + compiler.apply(new LibraryTemplatePlugin(options.output.library, options.output.libraryTarget, options.output.umdNamedDefine, options.output.auxiliaryComment || "")); + } + if(options.externals) { + ExternalsPlugin = require("./ExternalsPlugin"); + compiler.apply(new ExternalsPlugin(options.output.libraryTarget, options.externals)); + } + let noSources; + let legacy; + let modern; + let comment; + if(options.devtool && (options.devtool.indexOf("sourcemap") >= 0 || options.devtool.indexOf("source-map") >= 0)) { + const hidden = options.devtool.indexOf("hidden") >= 0; + const inline = options.devtool.indexOf("inline") >= 0; + const evalWrapped = options.devtool.indexOf("eval") >= 0; + const cheap = options.devtool.indexOf("cheap") >= 0; + const moduleMaps = options.devtool.indexOf("module") >= 0; + noSources = options.devtool.indexOf("nosources") >= 0; + legacy = options.devtool.indexOf("@") >= 0; + modern = options.devtool.indexOf("#") >= 0; + comment = legacy && modern ? "\n/*\n//@ sourceMappingURL=[url]\n//# sourceMappingURL=[url]\n*/" : + legacy ? "\n/*\n//@ sourceMappingURL=[url]\n*/" : + modern ? "\n//# sourceMappingURL=[url]" : + null; + let Plugin = evalWrapped ? EvalSourceMapDevToolPlugin : SourceMapDevToolPlugin; + compiler.apply(new Plugin({ + filename: inline ? null : options.output.sourceMapFilename, + moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate, + fallbackModuleFilenameTemplate: options.output.devtoolFallbackModuleFilenameTemplate, + append: hidden ? false : comment, + module: moduleMaps ? true : cheap ? false : true, + columns: cheap ? false : true, + lineToLine: options.output.devtoolLineToLine, + noSources: noSources, + })); + } else if(options.devtool && options.devtool.indexOf("eval") >= 0) { + legacy = options.devtool.indexOf("@") >= 0; + modern = options.devtool.indexOf("#") >= 0; + comment = legacy && modern ? "\n//@ sourceURL=[url]\n//# sourceURL=[url]" : + legacy ? "\n//@ sourceURL=[url]" : + modern ? "\n//# sourceURL=[url]" : + null; + compiler.apply(new EvalDevToolModulePlugin(comment, options.output.devtoolModuleFilenameTemplate)); + } + + compiler.apply(new EntryOptionPlugin()); + compiler.applyPluginsBailResult("entry-option", options.context, options.entry); + + compiler.apply( + new CompatibilityPlugin(), + new HarmonyModulesPlugin(options.module), + new AMDPlugin(options.module, options.amd || {}), + new CommonJsPlugin(options.module), + new LoaderPlugin(), + new NodeStuffPlugin(options.node), + new RequireJsStuffPlugin(), + new APIPlugin(), + new ConstPlugin(), + new UseStrictPlugin(), + new RequireIncludePlugin(), + new RequireEnsurePlugin(), + new RequireContextPlugin(options.resolve.modules, options.resolve.extensions), + new ImportPlugin(options.module), + new SystemPlugin(options.module) + ); + + compiler.apply( + new EnsureChunkConditionsPlugin(), + new RemoveParentModulesPlugin(), + new RemoveEmptyChunksPlugin(), + new MergeDuplicateChunksPlugin(), + new FlagIncludedChunksPlugin(), + new OccurrenceOrderPlugin(true), + new FlagDependencyExportsPlugin(), + new FlagDependencyUsagePlugin() + ); + + if(options.performance) { + compiler.apply(new SizeLimitsPlugin(options.performance)); + } + + compiler.apply(new TemplatedPathPlugin()); + + compiler.apply(new RecordIdsPlugin()); + + compiler.apply(new WarnCaseSensitiveModulesPlugin()); + + if(options.cache) { + let CachePlugin = require("./CachePlugin"); + compiler.apply(new CachePlugin(typeof options.cache === "object" ? options.cache : null)); + } + + compiler.applyPlugins("after-plugins", compiler); + if(!compiler.inputFileSystem) throw new Error("No input filesystem provided"); + compiler.resolvers.normal = ResolverFactory.createResolver(Object.assign({ + fileSystem: compiler.inputFileSystem + }, options.resolve)); + compiler.resolvers.context = ResolverFactory.createResolver(Object.assign({ + fileSystem: compiler.inputFileSystem, + resolveToContext: true + }, options.resolve)); + compiler.resolvers.loader = ResolverFactory.createResolver(Object.assign({ + fileSystem: compiler.inputFileSystem + }, options.resolveLoader)); + compiler.applyPlugins("after-resolvers", compiler); + return options; + } +} + +module.exports = WebpackOptionsApply; diff --git a/node_modules/webpack/lib/WebpackOptionsDefaulter.js b/node_modules/webpack/lib/WebpackOptionsDefaulter.js new file mode 100644 index 000000000..02dec7c63 --- /dev/null +++ b/node_modules/webpack/lib/WebpackOptionsDefaulter.js @@ -0,0 +1,105 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const OptionsDefaulter = require("./OptionsDefaulter"); +const Template = require("./Template"); + +class WebpackOptionsDefaulter extends OptionsDefaulter { + constructor() { + super(); + this.set("devtool", false); + this.set("cache", true); + + this.set("context", process.cwd()); + this.set("target", "web"); + + this.set("module.unknownContextRequest", "."); + this.set("module.unknownContextRegExp", false); + this.set("module.unknownContextRecursive", true); + this.set("module.unknownContextCritical", true); + this.set("module.exprContextRequest", "."); + this.set("module.exprContextRegExp", false); + this.set("module.exprContextRecursive", true); + this.set("module.exprContextCritical", true); + this.set("module.wrappedContextRegExp", /.*/); + this.set("module.wrappedContextRecursive", true); + this.set("module.wrappedContextCritical", false); + this.set("module.strictExportPresence", false); + + this.set("module.unsafeCache", true); + + this.set("output", "call", (value, options) => { + if(typeof value === "string") { + return { + filename: value + }; + } else if(typeof value !== "object") { + return {}; + } else { + return value; + } + }); + this.set("output.filename", "[name].js"); + this.set("output.chunkFilename", "make", (options) => { + const filename = options.output.filename; + return filename.indexOf("[name]") >= 0 ? filename.replace("[name]", "[id]") : "[id]." + filename; + }); + this.set("output.library", ""); + this.set("output.hotUpdateFunction", "make", (options) => { + return Template.toIdentifier("webpackHotUpdate" + options.output.library); + }); + this.set("output.jsonpFunction", "make", (options) => { + return Template.toIdentifier("webpackJsonp" + options.output.library); + }); + this.set("output.libraryTarget", "var"); + this.set("output.path", process.cwd()); + this.set("output.sourceMapFilename", "[file].map[query]"); + this.set("output.hotUpdateChunkFilename", "[id].[hash].hot-update.js"); + this.set("output.hotUpdateMainFilename", "[hash].hot-update.json"); + this.set("output.crossOriginLoading", false); + this.set("output.hashFunction", "md5"); + this.set("output.hashDigest", "hex"); + this.set("output.hashDigestLength", 20); + this.set("output.devtoolLineToLine", false); + this.set("output.strictModuleExceptionHandling", false); + + this.set("node", {}); + this.set("node.console", false); + this.set("node.process", true); + this.set("node.global", true); + this.set("node.Buffer", true); + this.set("node.setImmediate", true); + this.set("node.__filename", "mock"); + this.set("node.__dirname", "mock"); + + this.set("performance.maxAssetSize", 250000); + this.set("performance.maxEntrypointSize", 250000); + this.set("performance.hints", false); + + this.set("resolve", {}); + this.set("resolve.unsafeCache", true); + this.set("resolve.modules", ["node_modules"]); + this.set("resolve.extensions", [".js", ".json"]); + this.set("resolve.aliasFields", "make", (options) => { + if(options.target === "web" || options.target === "webworker") + return ["browser"]; + else + return []; + }); + this.set("resolve.mainFields", "make", (options) => { + if(options.target === "web" || options.target === "webworker") + return ["browser", "module", "main"]; + else + return ["module", "main"]; + }); + this.set("resolveLoader", {}); + this.set("resolveLoader.unsafeCache", true); + this.set("resolveLoader.mainFields", ["loader", "main"]); + this.set("resolveLoader.extensions", [".js", ".json"]); + } +} + +module.exports = WebpackOptionsDefaulter; diff --git a/node_modules/webpack/lib/WebpackOptionsValidationError.js b/node_modules/webpack/lib/WebpackOptionsValidationError.js new file mode 100644 index 000000000..61cb99bd7 --- /dev/null +++ b/node_modules/webpack/lib/WebpackOptionsValidationError.js @@ -0,0 +1,196 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Gajus Kuizinas @gajus +*/ +"use strict"; + +const WebpackError = require("./WebpackError"); +const webpackOptionsSchema = require("../schemas/webpackOptionsSchema.json"); + +const getSchemaPart = (path, parents, additionalPath) => { + parents = parents || 0; + path = path.split("/"); + path = path.slice(0, path.length - parents); + if(additionalPath) { + additionalPath = additionalPath.split("/"); + path = path.concat(additionalPath); + } + let schemaPart = webpackOptionsSchema; + for(let i = 1; i < path.length; i++) { + const inner = schemaPart[path[i]]; + if(inner) + schemaPart = inner; + } + return schemaPart; +}; + +const getSchemaPartText = (schemaPart, additionalPath) => { + if(additionalPath) { + for(let i = 0; i < additionalPath.length; i++) { + const inner = schemaPart[additionalPath[i]]; + if(inner) + schemaPart = inner; + } + } + while(schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref); + let schemaText = WebpackOptionsValidationError.formatSchema(schemaPart); + if(schemaPart.description) + schemaText += `\n${schemaPart.description}`; + return schemaText; +}; + +const indent = (str, prefix, firstLine) => { + if(firstLine) { + return prefix + str.replace(/\n(?!$)/g, "\n" + prefix); + } else { + return str.replace(/\n(?!$)/g, `\n${prefix}`); + } +}; + +class WebpackOptionsValidationError extends WebpackError { + constructor(validationErrors) { + super(); + + this.name = "WebpackOptionsValidationError"; + this.message = "Invalid configuration object. " + + "Webpack has been initialised using a configuration object that does not match the API schema.\n" + + validationErrors.map(err => " - " + indent(WebpackOptionsValidationError.formatValidationError(err), " ", false)).join("\n"); + this.validationErrors = validationErrors; + + Error.captureStackTrace(this, this.constructor); + } + + static formatSchema(schema, prevSchemas) { + prevSchemas = prevSchemas || []; + + const formatInnerSchema = (innerSchema, addSelf) => { + if(!addSelf) return WebpackOptionsValidationError.formatSchema(innerSchema, prevSchemas); + if(prevSchemas.indexOf(innerSchema) >= 0) return "(recursive)"; + return WebpackOptionsValidationError.formatSchema(innerSchema, prevSchemas.concat(schema)); + }; + + if(schema.type === "string") { + if(schema.minLength === 1) + return "non-empty string"; + else if(schema.minLength > 1) + return `string (min length ${schema.minLength})`; + return "string"; + } else if(schema.type === "boolean") { + return "boolean"; + } else if(schema.type === "number") { + return "number"; + } else if(schema.type === "object") { + if(schema.properties) { + const required = schema.required || []; + return `object { ${Object.keys(schema.properties).map(property => { + if(required.indexOf(property) < 0) return property + "?"; + return property; + }).concat(schema.additionalProperties ? ["..."] : []).join(", ")} }`; + } + if(schema.additionalProperties) { + return `object { : ${formatInnerSchema(schema.additionalProperties)} }`; + } + return "object"; + } else if(schema.type === "array") { + return `[${formatInnerSchema(schema.items)}]`; + } + + switch(schema.instanceof) { + case "Function": + return "function"; + case "RegExp": + return "RegExp"; + } + if(schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true); + if(schema.allOf) return schema.allOf.map(formatInnerSchema).join(" & "); + if(schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(" | "); + if(schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(" | "); + if(schema.enum) return schema.enum.map(item => JSON.stringify(item)).join(" | "); + return JSON.stringify(schema, 0, 2); + } + + static formatValidationError(err) { + const dataPath = `configuration${err.dataPath}`; + if(err.keyword === "additionalProperties") { + const baseMessage = `${dataPath} has an unknown property '${err.params.additionalProperty}'. These properties are valid:\n${getSchemaPartText(err.parentSchema)}`; + if(!err.dataPath) { + switch(err.params.additionalProperty) { + case "debug": + return `${baseMessage}\n` + + "The 'debug' property was removed in webpack 2.\n" + + "Loaders should be updated to allow passing this option via loader options in module.rules.\n" + + "Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" + + "plugins: [\n" + + " new webpack.LoaderOptionsPlugin({\n" + + " debug: true\n" + + " })\n" + + "]"; + } + return baseMessage + "\n" + + "For typos: please correct them.\n" + + "For loader options: webpack 2 no longer allows custom properties in configuration.\n" + + " Loaders should be updated to allow passing options via loader options in module.rules.\n" + + " Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" + + " plugins: [\n" + + " new webpack.LoaderOptionsPlugin({\n" + + " // test: /\\.xxx$/, // may apply this only for some modules\n" + + " options: {\n" + + ` ${err.params.additionalProperty}: ...\n` + + " }\n" + + " })\n" + + " ]"; + } + return baseMessage; + } else if(err.keyword === "oneOf" || err.keyword === "anyOf") { + if(err.children && err.children.length > 0) { + return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}\n` + + `Details:\n${err.children.map(err => " * " + indent(WebpackOptionsValidationError.formatValidationError(err), " ", false)).join("\n")}`; + } + return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`; + + } else if(err.keyword === "enum") { + if(err.parentSchema && err.parentSchema.enum && err.parentSchema.enum.length === 1) { + return `${dataPath} should be ${getSchemaPartText(err.parentSchema)}`; + } + return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`; + } else if(err.keyword === "allOf") { + return `${dataPath} should be:\n${getSchemaPartText(err.parentSchema)}`; + } else if(err.keyword === "type") { + switch(err.params.type) { + case "object": + return `${dataPath} should be an object.`; + case "string": + return `${dataPath} should be a string.`; + case "boolean": + return `${dataPath} should be a boolean.`; + case "number": + return `${dataPath} should be a number.`; + case "array": + return `${dataPath} should be an array:\n${getSchemaPartText(err.parentSchema)}`; + } + return `${dataPath} should be ${err.params.type}:\n${getSchemaPartText(err.parentSchema)}`; + } else if(err.keyword === "instanceof") { + return `${dataPath} should be an instance of ${getSchemaPartText(err.parentSchema)}.`; + } else if(err.keyword === "required") { + const missingProperty = err.params.missingProperty.replace(/^\./, ""); + return `${dataPath} misses the property '${missingProperty}'.\n${getSchemaPartText(err.parentSchema, ["properties", missingProperty])}`; + } else if(err.keyword === "minLength" || err.keyword === "minItems") { + if(err.params.limit === 1) + return `${dataPath} should not be empty.`; + else + return `${dataPath} ${err.message}`; + } else if(err.keyword === "absolutePath") { + const baseMessage = `${dataPath}: ${err.message}`; + if(dataPath === "configuration.output.filename") { + return `${baseMessage}\n` + + "Please use output.path to specify absolute path and output.filename for the file name."; + } + return baseMessage; + } else { + // eslint-disable-line no-fallthrough + return `${dataPath} ${err.message} (${JSON.stringify(err, 0, 2)}).\n${getSchemaPartText(err.parentSchema)}`; + } + } +} + +module.exports = WebpackOptionsValidationError; diff --git a/node_modules/webpack/lib/compareLocations.js b/node_modules/webpack/lib/compareLocations.js new file mode 100644 index 000000000..b8a4a118a --- /dev/null +++ b/node_modules/webpack/lib/compareLocations.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +module.exports = function compareLocations(a, b) { + if(typeof a === "string") { + if(typeof b === "string") { + if(a < b) return -1; + if(a > b) return 1; + return 0; + } else if(typeof b === "object") { + return 1; + } else { + return 0; + } + } else if(typeof a === "object") { + if(typeof b === "string") { + return -1; + } else if(typeof b === "object") { + if(a.start && b.start) { + const ap = a.start; + const bp = b.start; + if(ap.line < bp.line) return -1; + if(ap.line > bp.line) return 1; + if(ap.column < bp.column) return -1; + if(ap.column > bp.column) return 1; + } + if(a.index < b.index) return -1; + if(a.index > b.index) return 1; + return 0; + } else { + return 0; + } + } +}; diff --git a/node_modules/webpack/lib/dependencies/AMDDefineDependency.js b/node_modules/webpack/lib/dependencies/AMDDefineDependency.js new file mode 100644 index 000000000..7d81ec123 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDDefineDependency.js @@ -0,0 +1,142 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class AMDDefineDependency extends NullDependency { + constructor(range, arrayRange, functionRange, objectRange, namedModule) { + super(); + this.range = range; + this.arrayRange = arrayRange; + this.functionRange = functionRange; + this.objectRange = objectRange; + this.namedModule = namedModule; + } + + get type() { + return "amd define"; + } +} + +AMDDefineDependency.Template = class AMDDefineDependencyTemplate { + get definitions() { + return { + f: [ + "var __WEBPACK_AMD_DEFINE_RESULT__;", + `!(__WEBPACK_AMD_DEFINE_RESULT__ = #.call(exports, __webpack_require__, exports, module), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))` + ], + o: [ + "", + "!(module.exports = #)" + ], + of: [ + "var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;", + `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : + __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))` + ], + af: [ + "var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;", + `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = #.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))` + ], + ao: [ + "", + "!(#, module.exports = #)" + ], + aof: [ + "var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;", + `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))` + ], + lf: [ + "var XXX, XXXmodule;", + "!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = #.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))" + ], + lo: [ + "var XXX;", + "!(XXX = #)" + ], + lof: [ + "var XXX, XXXfactory, XXXmodule;", + "!(XXXfactory = (#), (XXXmodule = { id: YYY, exports: {}, loaded: false }), XXX = (typeof XXXfactory === 'function' ? (XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)) : XXXfactory), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports))" + ], + laf: [ + "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX;", + "!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)))" + ], + lao: [ + "var XXX;", + "!(#, XXX = #)" + ], + laof: [ + "var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_FACTORY__, XXX;", + `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#), + XXX = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__))` + ] + }; + } + + apply(dependency, source) { + const branch = this.branch(dependency); + const defAndText = this.definitions[branch]; + const definitions = defAndText[0]; + const text = defAndText[1]; + this.replace(dependency, source, definitions, text); + } + + localModuleVar(dependency) { + return dependency.localModule && dependency.localModule.used && dependency.localModule.variableName(); + } + + branch(dependency) { + const localModuleVar = this.localModuleVar(dependency) ? "l" : ""; + const arrayRange = dependency.arrayRange ? "a" : ""; + const objectRange = dependency.objectRange ? "o" : ""; + const functionRange = dependency.functionRange ? "f" : ""; + return localModuleVar + arrayRange + objectRange + functionRange; + } + + replace(dependency, source, definition, text) { + const localModuleVar = this.localModuleVar(dependency); + if(localModuleVar) { + text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$")); + definition = definition.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$")); + } + + if(dependency.namedModule) { + text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule)); + } + + const texts = text.split("#"); + + if(definition) source.insert(0, definition); + + let current = dependency.range[0]; + if(dependency.arrayRange) { + source.replace(current, dependency.arrayRange[0] - 1, texts.shift()); + current = dependency.arrayRange[1]; + } + + if(dependency.objectRange) { + source.replace(current, dependency.objectRange[0] - 1, texts.shift()); + current = dependency.objectRange[1]; + } else if(dependency.functionRange) { + source.replace(current, dependency.functionRange[0] - 1, texts.shift()); + current = dependency.functionRange[1]; + } + source.replace(current, dependency.range[1] - 1, texts.shift()); + if(texts.length > 0) + throw new Error("Implementation error"); + } +}; + +module.exports = AMDDefineDependency; diff --git a/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js new file mode 100644 index 000000000..8590162c6 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js @@ -0,0 +1,250 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const AMDRequireItemDependency = require("./AMDRequireItemDependency"); +const AMDRequireContextDependency = require("./AMDRequireContextDependency"); +const ConstDependency = require("./ConstDependency"); +const AMDDefineDependency = require("./AMDDefineDependency"); +const AMDRequireArrayDependency = require("./AMDRequireArrayDependency"); +const LocalModuleDependency = require("./LocalModuleDependency"); +const ContextDependencyHelpers = require("./ContextDependencyHelpers"); +const LocalModulesHelpers = require("./LocalModulesHelpers"); + +function isBoundFunctionExpression(expr) { + if(expr.type !== "CallExpression") return false; + if(expr.callee.type !== "MemberExpression") return false; + if(expr.callee.computed) return false; + if(expr.callee.object.type !== "FunctionExpression") return false; + if(expr.callee.property.type !== "Identifier") return false; + if(expr.callee.property.name !== "bind") return false; + return true; +} + +class AMDDefineDependencyParserPlugin { + constructor(options) { + this.options = options; + } + + apply(parser) { + const options = this.options; + parser.plugin("call define", (expr) => { + let array, fn, obj, namedModule; + switch(expr.arguments.length) { + case 1: + if(expr.arguments[0].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[0])) { + // define(f() {...}) + fn = expr.arguments[0]; + } else if(expr.arguments[0].type === "ObjectExpression") { + // define({...}) + obj = expr.arguments[0]; + } else { + // define(expr) + // unclear if function or object + obj = fn = expr.arguments[0]; + } + break; + case 2: + if(expr.arguments[0].type === "Literal") { + namedModule = expr.arguments[0].value; + // define("...", ...) + if(expr.arguments[1].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[1])) { + // define("...", f() {...}) + fn = expr.arguments[1]; + } else if(expr.arguments[1].type === "ObjectExpression") { + // define("...", {...}) + obj = expr.arguments[1]; + } else { + // define("...", expr) + // unclear if function or object + obj = fn = expr.arguments[1]; + } + } else { + array = expr.arguments[0]; + if(expr.arguments[1].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[1])) { + // define([...], f() {}) + fn = expr.arguments[1]; + } else if(expr.arguments[1].type === "ObjectExpression") { + // define([...], {...}) + obj = expr.arguments[1]; + } else { + // define([...], expr) + // unclear if function or object + obj = fn = expr.arguments[1]; + } + } + break; + case 3: + // define("...", [...], f() {...}) + namedModule = expr.arguments[0].value; + array = expr.arguments[1]; + if(expr.arguments[2].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[2])) { + // define("...", [...], f() {}) + fn = expr.arguments[2]; + } else if(expr.arguments[2].type === "ObjectExpression") { + // define("...", [...], {...}) + obj = expr.arguments[2]; + } else { + // define("...", [...], expr) + // unclear if function or object + obj = fn = expr.arguments[2]; + } + break; + default: + return; + } + let fnParams = null; + let fnParamsOffset = 0; + if(fn) { + if(fn.type === "FunctionExpression") fnParams = fn.params; + else if(isBoundFunctionExpression(fn)) { + fnParams = fn.callee.object.params; + fnParamsOffset = fn.arguments.length - 1; + if(fnParamsOffset < 0) fnParamsOffset = 0; + } + } + let fnRenames = Object.create(parser.scope.renames); + let identifiers; + if(array) { + identifiers = {}; + const param = parser.evaluateExpression(array); + const result = parser.applyPluginsBailResult("call define:amd:array", expr, param, identifiers, namedModule); + if(!result) return; + if(fnParams) fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => { + if(identifiers[idx]) { + fnRenames["$" + param.name] = identifiers[idx]; + return false; + } + return true; + }); + } else { + identifiers = ["require", "exports", "module"]; + if(fnParams) fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => { + if(identifiers[idx]) { + fnRenames["$" + param.name] = identifiers[idx]; + return false; + } + return true; + }); + } + let inTry; + if(fn && fn.type === "FunctionExpression") { + inTry = parser.scope.inTry; + parser.inScope(fnParams, () => { + parser.scope.renames = fnRenames; + parser.scope.inTry = inTry; + if(fn.body.type === "BlockStatement") + parser.walkStatement(fn.body); + else + parser.walkExpression(fn.body); + }); + } else if(fn && isBoundFunctionExpression(fn)) { + inTry = parser.scope.inTry; + parser.inScope(fn.callee.object.params.filter((i) => ["require", "module", "exports"].indexOf(i.name) < 0), () => { + parser.scope.renames = fnRenames; + parser.scope.inTry = inTry; + if(fn.callee.object.body.type === "BlockStatement") + parser.walkStatement(fn.callee.object.body); + else + parser.walkExpression(fn.callee.object.body); + }); + if(fn.arguments) + parser.walkExpressions(fn.arguments); + } else if(fn || obj) { + parser.walkExpression(fn || obj); + } + + const dep = new AMDDefineDependency( + expr.range, + array ? array.range : null, + fn ? fn.range : null, + obj ? obj.range : null, + namedModule ? namedModule : null + ); + dep.loc = expr.loc; + if(namedModule) { + dep.localModule = LocalModulesHelpers.addLocalModule(parser.state, namedModule); + } + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("call define:amd:array", (expr, param, identifiers, namedModule) => { + if(param.isArray()) { + param.items.forEach((param, idx) => { + if(param.isString() && ["require", "module", "exports"].indexOf(param.string) >= 0) + identifiers[idx] = param.string; + const result = parser.applyPluginsBailResult("call define:amd:item", expr, param, namedModule); + if(result === undefined) { + parser.applyPluginsBailResult("call define:amd:context", expr, param); + } + }); + return true; + } else if(param.isConstArray()) { + const deps = []; + param.array.forEach((request, idx) => { + let dep; + let localModule; + if(request === "require") { + identifiers[idx] = request; + dep = "__webpack_require__"; + } else if(["exports", "module"].indexOf(request) >= 0) { + identifiers[idx] = request; + dep = request; + } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign + dep = new LocalModuleDependency(localModule); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + } else { + dep = new AMDRequireItemDependency(request); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + } + deps.push(dep); + }); + const dep = new AMDRequireArrayDependency(deps, param.range); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call define:amd:item", (expr, param, namedModule) => { + if(param.isConditional()) { + param.options.forEach((param) => { + const result = parser.applyPluginsBailResult("call define:amd:item", expr, param); + if(result === undefined) { + parser.applyPluginsBailResult("call define:amd:context", expr, param); + } + }); + return true; + } else if(param.isString()) { + let dep, localModule; + if(param.string === "require") { + dep = new ConstDependency("__webpack_require__", param.range); + } else if(["require", "exports", "module"].indexOf(param.string) >= 0) { + dep = new ConstDependency(param.string, param.range); + } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string, namedModule)) { // eslint-disable-line no-cond-assign + dep = new LocalModuleDependency(localModule, param.range); + } else { + dep = new AMDRequireItemDependency(param.string, param.range); + } + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call define:amd:context", (expr, param) => { + const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options); + if(!dep) return; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + }); + } +} +module.exports = AMDDefineDependencyParserPlugin; diff --git a/node_modules/webpack/lib/dependencies/AMDPlugin.js b/node_modules/webpack/lib/dependencies/AMDPlugin.js new file mode 100644 index 000000000..d1d5cf09e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDPlugin.js @@ -0,0 +1,119 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const path = require("path"); +const AMDRequireDependency = require("./AMDRequireDependency"); +const AMDRequireItemDependency = require("./AMDRequireItemDependency"); +const AMDRequireArrayDependency = require("./AMDRequireArrayDependency"); +const AMDRequireContextDependency = require("./AMDRequireContextDependency"); +const AMDDefineDependency = require("./AMDDefineDependency"); +const UnsupportedDependency = require("./UnsupportedDependency"); +const LocalModuleDependency = require("./LocalModuleDependency"); + +const NullFactory = require("../NullFactory"); + +const AMDRequireDependenciesBlockParserPlugin = require("./AMDRequireDependenciesBlockParserPlugin"); +const AMDDefineDependencyParserPlugin = require("./AMDDefineDependencyParserPlugin"); + +const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin"); + +const ParserHelpers = require("../ParserHelpers"); + +class AMDPlugin { + constructor(options, amdOptions) { + this.amdOptions = amdOptions; + this.options = options; + } + + apply(compiler) { + const options = this.options; + const amdOptions = this.amdOptions; + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + const contextModuleFactory = params.contextModuleFactory; + + compilation.dependencyFactories.set(AMDRequireDependency, new NullFactory()); + compilation.dependencyTemplates.set(AMDRequireDependency, new AMDRequireDependency.Template()); + + compilation.dependencyFactories.set(AMDRequireItemDependency, normalModuleFactory); + compilation.dependencyTemplates.set(AMDRequireItemDependency, new AMDRequireItemDependency.Template()); + + compilation.dependencyFactories.set(AMDRequireArrayDependency, new NullFactory()); + compilation.dependencyTemplates.set(AMDRequireArrayDependency, new AMDRequireArrayDependency.Template()); + + compilation.dependencyFactories.set(AMDRequireContextDependency, contextModuleFactory); + compilation.dependencyTemplates.set(AMDRequireContextDependency, new AMDRequireContextDependency.Template()); + + compilation.dependencyFactories.set(AMDDefineDependency, new NullFactory()); + compilation.dependencyTemplates.set(AMDDefineDependency, new AMDDefineDependency.Template()); + + compilation.dependencyFactories.set(UnsupportedDependency, new NullFactory()); + compilation.dependencyTemplates.set(UnsupportedDependency, new UnsupportedDependency.Template()); + + compilation.dependencyFactories.set(LocalModuleDependency, new NullFactory()); + compilation.dependencyTemplates.set(LocalModuleDependency, new LocalModuleDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.amd !== "undefined" && !parserOptions.amd) + return; + + function setExpressionToModule(outerExpr, module) { + parser.plugin("expression " + outerExpr, (expr) => { + const dep = new AMDRequireItemDependency(module, expr.range); + dep.userRequest = outerExpr; + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + }); + } + + parser.apply( + new AMDRequireDependenciesBlockParserPlugin(options), + new AMDDefineDependencyParserPlugin(options) + ); + setExpressionToModule("require.amd", "!!webpack amd options"); + setExpressionToModule("define.amd", "!!webpack amd options"); + setExpressionToModule("define", "!!webpack amd define"); + parser.plugin("expression __webpack_amd_options__", () => + parser.state.current.addVariable("__webpack_amd_options__", JSON.stringify(amdOptions))); + parser.plugin("evaluate typeof define.amd", ParserHelpers.evaluateToString(typeof amdOptions)); + parser.plugin("evaluate typeof require.amd", ParserHelpers.evaluateToString(typeof amdOptions)); + parser.plugin("evaluate Identifier define.amd", ParserHelpers.evaluateToBoolean(true)); + parser.plugin("evaluate Identifier require.amd", ParserHelpers.evaluateToBoolean(true)); + parser.plugin("typeof define", ParserHelpers.toConstantDependency(JSON.stringify("function"))); + parser.plugin("evaluate typeof define", ParserHelpers.evaluateToString("function")); + parser.plugin("can-rename define", ParserHelpers.approve); + parser.plugin("rename define", (expr) => { + const dep = new AMDRequireItemDependency("!!webpack amd define", expr.range); + dep.userRequest = "define"; + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return false; + }); + parser.plugin("typeof require", ParserHelpers.toConstantDependency(JSON.stringify("function"))); + parser.plugin("evaluate typeof require", ParserHelpers.evaluateToString("function")); + }); + }); + compiler.plugin("after-resolvers", () => { + compiler.resolvers.normal.apply( + new AliasPlugin("described-resolve", { + name: "amdefine", + alias: path.join(__dirname, "..", "..", "buildin", "amd-define.js") + }, "resolve"), + new AliasPlugin("described-resolve", { + name: "webpack amd options", + alias: path.join(__dirname, "..", "..", "buildin", "amd-options.js") + }, "resolve"), + new AliasPlugin("described-resolve", { + name: "webpack amd define", + alias: path.join(__dirname, "..", "..", "buildin", "amd-define.js") + }, "resolve") + ); + }); + } +} +module.exports = AMDPlugin; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js new file mode 100644 index 000000000..666a887e3 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js @@ -0,0 +1,56 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); +const webpackMissingModuleModule = require("./WebpackMissingModule").module; + +class AMDRequireArrayDependency extends Dependency { + constructor(depsArray, range) { + super(); + this.depsArray = depsArray; + this.range = range; + } + + get type() { + return "amd require array"; + } +} + +AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const content = this.getContent(dep, outputOptions, requestShortener); + source.replace(dep.range[0], dep.range[1] - 1, content); + } + + getContent(dep, outputOptions, requestShortener) { + const requires = dep.depsArray.map((dependency) => { + const optionalComment = this.optionalComment(outputOptions.pathinfo, requestShortener.shorten(dependency.request)); + return this.contentForDependency(dependency, optionalComment); + }); + return `[${requires.join(", ")}]`; + } + + optionalComment(pathInfo, shortenedRequest) { + if(!pathInfo) { + return ""; + } + return `/*! ${shortenedRequest} */ `; + } + + contentForDependency(dep, comment) { + if(typeof dep === "string") { + return dep; + } + + if(dep.module) { + const stringifiedId = JSON.stringify(dep.module.id); + return `__webpack_require__(${comment}${stringifiedId})`; + } + + return webpackMissingModuleModule(dep.request); + } +}; + +module.exports = AMDRequireArrayDependency; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js new file mode 100644 index 000000000..9248927e1 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ContextDependency = require("./ContextDependency"); +const CriticalDependencyWarning = require("./CriticalDependencyWarning"); +class AMDRequireContextDependency extends ContextDependency { + constructor(request, recursive, regExp, range, valueRange) { + super(request, recursive, regExp); + this.range = range; + this.valueRange = valueRange; + } + + get type() { + return "amd require context"; + } + + getWarnings() { + if(this.critical) { + return [ + new CriticalDependencyWarning(this.critical) + ]; + } + } +} +AMDRequireContextDependency.Template = require("./ContextDependencyTemplateAsRequireCall"); +module.exports = AMDRequireContextDependency; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js new file mode 100644 index 000000000..92f5299ee --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const AsyncDependenciesBlock = require("../AsyncDependenciesBlock"); +const AMDRequireDependency = require("./AMDRequireDependency"); + +module.exports = class AMDRequireDependenciesBlock extends AsyncDependenciesBlock { + constructor(expr, arrayRange, functionRange, errorCallbackRange, module, loc) { + super(null, module, loc); + this.expr = expr; + this.outerRange = expr.range; + this.arrayRange = arrayRange; + this.functionRange = functionRange; + this.errorCallbackRange = errorCallbackRange; + this.bindThis = true; + if(arrayRange && functionRange && errorCallbackRange) { + this.range = [arrayRange[0], errorCallbackRange[1]]; + } else if(arrayRange && functionRange) { + this.range = [arrayRange[0], functionRange[1]]; + } else if(arrayRange) { + this.range = arrayRange; + } else if(functionRange) { + this.range = functionRange; + } else { + this.range = expr.range; + } + const dep = new AMDRequireDependency(this); + dep.loc = loc; + this.addDependency(dep); + } +}; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js new file mode 100644 index 000000000..8bd7ae425 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js @@ -0,0 +1,177 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const AMDRequireItemDependency = require("./AMDRequireItemDependency"); +const AMDRequireArrayDependency = require("./AMDRequireArrayDependency"); +const AMDRequireContextDependency = require("./AMDRequireContextDependency"); +const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock"); +const UnsupportedDependency = require("./UnsupportedDependency"); +const LocalModuleDependency = require("./LocalModuleDependency"); +const ContextDependencyHelpers = require("./ContextDependencyHelpers"); +const LocalModulesHelpers = require("./LocalModulesHelpers"); +const ConstDependency = require("./ConstDependency"); +const getFunctionExpression = require("./getFunctionExpression"); +const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning"); + +class AMDRequireDependenciesBlockParserPlugin { + constructor(options) { + this.options = options; + } + + processFunctionArgument(parser, expression) { + let bindThis = true; + const fnData = getFunctionExpression(expression); + if(fnData) { + parser.inScope(fnData.fn.params.filter((i) => { + return ["require", "module", "exports"].indexOf(i.name) < 0; + }), () => { + if(fnData.fn.body.type === "BlockStatement") + parser.walkStatement(fnData.fn.body); + else + parser.walkExpression(fnData.fn.body); + }); + parser.walkExpressions(fnData.expressions); + if(fnData.needThis === false) { + bindThis = false; + } + } else { + parser.walkExpression(expression); + } + return bindThis; + } + + apply(parser) { + const options = this.options; + parser.plugin("call require", (expr) => { + let param; + let dep; + let result; + + const old = parser.state.current; + + if(expr.arguments.length >= 1) { + param = parser.evaluateExpression(expr.arguments[0]); + dep = new AMDRequireDependenciesBlock( + expr, + param.range, + (expr.arguments.length > 1) ? expr.arguments[1].range : null, + (expr.arguments.length > 2) ? expr.arguments[2].range : null, + parser.state.module, + expr.loc + ); + parser.state.current = dep; + } + + if(expr.arguments.length === 1) { + parser.inScope([], () => { + result = parser.applyPluginsBailResult("call require:amd:array", expr, param); + }); + parser.state.current = old; + if(!result) return; + parser.state.current.addBlock(dep); + return true; + } + + if(expr.arguments.length === 2 || expr.arguments.length === 3) { + try { + parser.inScope([], () => { + result = parser.applyPluginsBailResult("call require:amd:array", expr, param); + }); + if(!result) { + dep = new UnsupportedDependency("unsupported", expr.range); + old.addDependency(dep); + if(parser.state.module) + parser.state.module.errors.push(new UnsupportedFeatureWarning(parser.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line)); + dep = null; + return true; + } + dep.functionBindThis = this.processFunctionArgument(parser, expr.arguments[1]); + if(expr.arguments.length === 3) { + dep.errorCallbackBindThis = this.processFunctionArgument(parser, expr.arguments[2]); + } + } finally { + parser.state.current = old; + if(dep) + parser.state.current.addBlock(dep); + } + return true; + } + }); + parser.plugin("call require:amd:array", (expr, param) => { + if(param.isArray()) { + param.items.forEach((param) => { + const result = parser.applyPluginsBailResult("call require:amd:item", expr, param); + if(result === undefined) { + parser.applyPluginsBailResult("call require:amd:context", expr, param); + } + }); + return true; + } else if(param.isConstArray()) { + const deps = []; + param.array.forEach((request) => { + let dep, localModule; + if(request === "require") { + dep = "__webpack_require__"; + } else if(["exports", "module"].indexOf(request) >= 0) { + dep = request; + } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign + dep = new LocalModuleDependency(localModule); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + } else { + dep = new AMDRequireItemDependency(request); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + } + deps.push(dep); + }); + const dep = new AMDRequireArrayDependency(deps, param.range); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call require:amd:item", (expr, param) => { + if(param.isConditional()) { + param.options.forEach((param) => { + const result = parser.applyPluginsBailResult("call require:amd:item", expr, param); + if(result === undefined) { + parser.applyPluginsBailResult("call require:amd:context", expr, param); + } + }); + return true; + } else if(param.isString()) { + let dep, localModule; + if(param.string === "require") { + dep = new ConstDependency("__webpack_require__", param.string); + } else if(param.string === "module") { + dep = new ConstDependency(parser.state.module.moduleArgument || "module", param.range); + } else if(param.string === "exports") { + dep = new ConstDependency(parser.state.module.exportsArgument || "exports", param.range); + } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string)) { // eslint-disable-line no-cond-assign + dep = new LocalModuleDependency(localModule, param.range); + } else { + dep = new AMDRequireItemDependency(param.string, param.range); + } + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call require:amd:context", (expr, param) => { + const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options); + if(!dep) return; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + }); + } +} +module.exports = AMDRequireDependenciesBlockParserPlugin; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireDependency.js new file mode 100644 index 000000000..6cfaa2de2 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependency.js @@ -0,0 +1,67 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const DepBlockHelpers = require("./DepBlockHelpers"); + +class AMDRequireDependency extends NullDependency { + constructor(block) { + super(); + this.block = block; + } +} + +AMDRequireDependency.Template = class AMDRequireDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const depBlock = dep.block; + const wrapper = DepBlockHelpers.getLoadDepBlockWrapper(depBlock, outputOptions, requestShortener, "require"); + + // has array range but no function range + if(depBlock.arrayRange && !depBlock.functionRange) { + const startBlock = wrapper[0] + "function() {"; + const endBlock = `;}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`; + source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock); + source.replace(depBlock.arrayRange[1], depBlock.outerRange[1] - 1, endBlock); + return; + } + + // has function range but no array range + if(depBlock.functionRange && !depBlock.arrayRange) { + const startBlock = wrapper[0] + "function() {("; + const endBlock = `.call(exports, __webpack_require__, exports, module));}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`; + source.replace(depBlock.outerRange[0], depBlock.functionRange[0] - 1, startBlock); + source.replace(depBlock.functionRange[1], depBlock.outerRange[1] - 1, endBlock); + return; + } + + // has array range, function range, and errorCallbackRange + if(depBlock.arrayRange && depBlock.functionRange && depBlock.errorCallbackRange) { + const startBlock = wrapper[0] + "function() { "; + const errorRangeBlock = `}${depBlock.functionBindThis ? ".bind(this)" : ""}${wrapper[1]}`; + const endBlock = `${depBlock.errorCallbackBindThis ? ".bind(this)" : ""}${wrapper[2]}`; + + source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock); + source.insert(depBlock.arrayRange[0] + 0.9, "var __WEBPACK_AMD_REQUIRE_ARRAY__ = "); + source.replace(depBlock.arrayRange[1], depBlock.functionRange[0] - 1, "; ("); + source.insert(depBlock.functionRange[1], ".apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__));"); + source.replace(depBlock.functionRange[1], depBlock.errorCallbackRange[0] - 1, errorRangeBlock); + source.replace(depBlock.errorCallbackRange[1], depBlock.outerRange[1] - 1, endBlock); + return; + } + + // has array range, function range, but no errorCallbackRange + if(depBlock.arrayRange && depBlock.functionRange) { + const startBlock = wrapper[0] + "function() { "; + const endBlock = `}${depBlock.functionBindThis ? ".bind(this)" : ""}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`; + source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock); + source.insert(depBlock.arrayRange[0] + 0.9, "var __WEBPACK_AMD_REQUIRE_ARRAY__ = "); + source.replace(depBlock.arrayRange[1], depBlock.functionRange[0] - 1, "; ("); + source.insert(depBlock.functionRange[1], ".apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__));"); + source.replace(depBlock.functionRange[1], depBlock.outerRange[1] - 1, endBlock); + } + } +}; + +module.exports = AMDRequireDependency; diff --git a/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js new file mode 100644 index 000000000..60401d533 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId"); + +class AMDRequireItemDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + } + + get type() { + return "amd require"; + } +} + +AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId; + +module.exports = AMDRequireItemDependency; diff --git a/node_modules/webpack/lib/dependencies/CommonJsPlugin.js b/node_modules/webpack/lib/dependencies/CommonJsPlugin.js new file mode 100644 index 000000000..e514fd99e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsPlugin.js @@ -0,0 +1,88 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ConstDependency = require("./ConstDependency"); +const CommonJsRequireDependency = require("./CommonJsRequireDependency"); +const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency"); +const RequireResolveDependency = require("./RequireResolveDependency"); +const RequireResolveContextDependency = require("./RequireResolveContextDependency"); +const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency"); +const RequireHeaderDependency = require("./RequireHeaderDependency"); + +const NullFactory = require("../NullFactory"); + +const RequireResolveDependencyParserPlugin = require("./RequireResolveDependencyParserPlugin"); +const CommonJsRequireDependencyParserPlugin = require("./CommonJsRequireDependencyParserPlugin"); + +const ParserHelpers = require("../ParserHelpers"); + +class CommonJsPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + const contextModuleFactory = params.contextModuleFactory; + + compilation.dependencyFactories.set(CommonJsRequireDependency, normalModuleFactory); + compilation.dependencyTemplates.set(CommonJsRequireDependency, new CommonJsRequireDependency.Template()); + + compilation.dependencyFactories.set(CommonJsRequireContextDependency, contextModuleFactory); + compilation.dependencyTemplates.set(CommonJsRequireContextDependency, new CommonJsRequireContextDependency.Template()); + + compilation.dependencyFactories.set(RequireResolveDependency, normalModuleFactory); + compilation.dependencyTemplates.set(RequireResolveDependency, new RequireResolveDependency.Template()); + + compilation.dependencyFactories.set(RequireResolveContextDependency, contextModuleFactory); + compilation.dependencyTemplates.set(RequireResolveContextDependency, new RequireResolveContextDependency.Template()); + + compilation.dependencyFactories.set(RequireResolveHeaderDependency, new NullFactory()); + compilation.dependencyTemplates.set(RequireResolveHeaderDependency, new RequireResolveHeaderDependency.Template()); + + compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory()); + compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs) + return; + + const requireExpressions = ["require", "require.resolve", "require.resolveWeak"]; + for(let expression of requireExpressions) { + parser.plugin(`typeof ${expression}`, ParserHelpers.toConstantDependency("function")); + parser.plugin(`evaluate typeof ${expression}`, ParserHelpers.evaluateToString("function")); + } + + parser.plugin("evaluate typeof module", ParserHelpers.evaluateToString("object")); + parser.plugin("assign require", (expr) => { + // to not leak to global "require", we need to define a local require here. + const dep = new ConstDependency("var require;", 0); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + parser.scope.definitions.push("require"); + return true; + }); + parser.plugin("can-rename require", () => true); + parser.plugin("rename require", (expr) => { + // define the require variable. It's still undefined, but not "not defined". + const dep = new ConstDependency("var require;", 0); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return false; + }); + parser.plugin("typeof module", () => true); + parser.plugin("evaluate typeof exports", ParserHelpers.evaluateToString("object")); + parser.apply( + new CommonJsRequireDependencyParserPlugin(options), + new RequireResolveDependencyParserPlugin(options) + ); + }); + }); + } +} +module.exports = CommonJsPlugin; diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js b/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js new file mode 100644 index 000000000..74822aebd --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ContextDependency = require("./ContextDependency"); +const CriticalDependencyWarning = require("./CriticalDependencyWarning"); +const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall"); + +class CommonJsRequireContextDependency extends ContextDependency { + constructor(request, recursive, regExp, range, valueRange) { + super(request, recursive, regExp); + this.range = range; + this.valueRange = valueRange; + } + + get type() { + return "cjs require context"; + } + + getWarnings() { + if(!this.critical) { + return; + } + + return [ + new CriticalDependencyWarning(this.critical) + ]; + } +} + +CommonJsRequireContextDependency.Template = ContextDependencyTemplateAsRequireCall; + +module.exports = CommonJsRequireContextDependency; diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js b/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js new file mode 100644 index 000000000..bd9e68e46 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId"); + +class CommonJsRequireDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + } + + get type() { + return "cjs require"; + } +} + +CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId; + +module.exports = CommonJsRequireDependency; diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js new file mode 100644 index 000000000..2e2fee613 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js @@ -0,0 +1,89 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const CommonJsRequireDependency = require("./CommonJsRequireDependency"); +const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency"); +const RequireHeaderDependency = require("./RequireHeaderDependency"); +const LocalModuleDependency = require("./LocalModuleDependency"); +const ContextDependencyHelpers = require("./ContextDependencyHelpers"); +const LocalModulesHelpers = require("./LocalModulesHelpers"); +const ParserHelpers = require("../ParserHelpers"); + +class CommonJsRequireDependencyParserPlugin { + constructor(options) { + this.options = options; + } + + apply(parser) { + const options = this.options; + parser.plugin("expression require.cache", ParserHelpers.toConstantDependency("__webpack_require__.c")); + parser.plugin("expression require", (expr) => { + const dep = new CommonJsRequireContextDependency(options.unknownContextRequest, options.unknownContextRecursive, options.unknownContextRegExp, expr.range); + dep.critical = options.unknownContextCritical && "require function is used in a way in which dependencies cannot be statically extracted"; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("call require", (expr) => { + if(expr.arguments.length !== 1) return; + let localModule; + const param = parser.evaluateExpression(expr.arguments[0]); + if(param.isConditional()) { + let isExpression = false; + const prevLength = parser.state.current.dependencies.length; + const dep = new RequireHeaderDependency(expr.callee.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + param.options.forEach(function(param) { + const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param); + if(result === undefined) { + isExpression = true; + } + }); + if(isExpression) { + parser.state.current.dependencies.length = prevLength; + } else { + return true; + } + } + if(param.isString() && (localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string))) { + const dep = new LocalModuleDependency(localModule, expr.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + } else { + const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param); + if(result === undefined) { + parser.applyPluginsBailResult("call require:commonjs:context", expr, param); + } else { + const dep = new RequireHeaderDependency(expr.callee.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + } + return true; + } + }); + parser.plugin("call require:commonjs:item", (expr, param) => { + if(param.isString()) { + const dep = new CommonJsRequireDependency(param.string, param.range); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call require:commonjs:context", (expr, param) => { + const dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency, expr.range, param, expr, options); + if(!dep) return; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + }); + } +} +module.exports = CommonJsRequireDependencyParserPlugin; diff --git a/node_modules/webpack/lib/dependencies/ConstDependency.js b/node_modules/webpack/lib/dependencies/ConstDependency.js new file mode 100644 index 000000000..2bf2008e5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ConstDependency.js @@ -0,0 +1,32 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class ConstDependency extends NullDependency { + constructor(expression, range) { + super(); + this.expression = expression; + this.range = range; + } + + updateHash(hash) { + hash.update(this.range + ""); + hash.update(this.expression + ""); + } +} + +ConstDependency.Template = class ConstDependencyTemplate { + apply(dep, source) { + if(typeof dep.range === "number") { + source.insert(dep.range, dep.expression); + return; + } + + source.replace(dep.range[0], dep.range[1] - 1, dep.expression); + } +}; + +module.exports = ConstDependency; diff --git a/node_modules/webpack/lib/dependencies/ContextDependency.js b/node_modules/webpack/lib/dependencies/ContextDependency.js new file mode 100644 index 000000000..7f8772a55 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependency.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); + +class ContextDependency extends Dependency { + constructor(request, recursive, regExp) { + super(); + this.request = request; + this.userRequest = request; + this.recursive = recursive; + this.regExp = regExp; + this.async = false; + } + + isEqualResource(other) { + if(!(other instanceof ContextDependency)) + return false; + + return this.request === other.request && + this.recursive === other.recursive && + this.regExp === other.regExp && + this.async === other.async; + } +} + +module.exports = ContextDependency; diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js b/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js new file mode 100644 index 000000000..412cee701 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js @@ -0,0 +1,71 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ContextDependencyHelpers = exports; + +/** + * Escapes regular expression metacharacters + * @param {string} str String to quote + * @return {string} Escaped string + */ +function quotemeta(str) { + return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&"); +} + +ContextDependencyHelpers.create = function(Dep, range, param, expr, options, chunkName) { + let dep; + let prefix; + let postfix; + let prefixRange; + let valueRange; + let idx; + let context; + let regExp; + if(param.isTemplateString()) { + prefix = param.quasis[0].string; + postfix = param.quasis.length > 1 ? param.quasis[param.quasis.length - 1].string : ""; + prefixRange = [param.quasis[0].range[0], param.quasis[0].range[1]]; + valueRange = param.range; + idx = prefix.lastIndexOf("/"); + context = "."; + if(idx >= 0) { + context = prefix.substr(0, idx); + prefix = `.${prefix.substr(idx)}`; + } + // If there are more than two quasis, maybe the generated RegExp can be more precise? + regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`); + dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName); + dep.loc = expr.loc; + dep.replaces = [{ + range: prefixRange, + value: prefix + }]; + dep.critical = options.wrappedContextCritical && "a part of the request of a dependency is an expression"; + return dep; + } else if(param.isWrapped() && (param.prefix && param.prefix.isString() || param.postfix && param.postfix.isString())) { + prefix = param.prefix && param.prefix.isString() ? param.prefix.string : ""; + postfix = param.postfix && param.postfix.isString() ? param.postfix.string : ""; + prefixRange = param.prefix && param.prefix.isString() ? param.prefix.range : null; + valueRange = [prefixRange ? prefixRange[1] : param.range[0], param.range[1]]; + idx = prefix.lastIndexOf("/"); + context = "."; + if(idx >= 0) { + context = prefix.substr(0, idx); + prefix = `.${prefix.substr(idx)}`; + } + regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`); + dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName); + dep.loc = expr.loc; + dep.prepend = param.prefix && param.prefix.isString() ? prefix : null; + dep.critical = options.wrappedContextCritical && "a part of the request of a dependency is an expression"; + return dep; + } else { + dep = new Dep(options.exprContextRequest, options.exprContextRecursive, options.exprContextRegExp, range, param.range, chunkName); + dep.loc = expr.loc; + dep.critical = options.exprContextCritical && "the request of a dependency is an expression"; + return dep; + } +}; diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js new file mode 100644 index 000000000..f88f6c85c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js @@ -0,0 +1,32 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class ContextDependencyTemplateAsId { + + apply(dep, source, outputOptions, requestShortener) { + const comment = outputOptions.pathinfo ? + "/*! " + requestShortener.shorten(dep.request) + " */ " : ""; + + if(dep.module && dep.module.dependencies && dep.module.dependencies.length > 0) { + if(dep.valueRange) { + if(Array.isArray(dep.replaces)) { + for(let i = 0; i < dep.replaces.length; i++) { + const rep = dep.replaces[i]; + source.replace(rep.range[0], rep.range[1] - 1, rep.value); + } + } + source.replace(dep.valueRange[1], dep.range[1] - 1, ")"); + source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + ""); + } else { + source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve"); + } + } else { + const content = require("./WebpackMissingModule").module(dep.request); + source.replace(dep.range[0], dep.range[1] - 1, content); + } + } +} +module.exports = ContextDependencyTemplateAsId; diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js new file mode 100644 index 000000000..eeb135f38 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class ContextDependencyTemplateAsRequireCall { + + apply(dep, source, outputOptions, requestShortener) { + const comment = outputOptions.pathinfo ? + "/*! " + requestShortener.shorten(dep.request) + " */ " : ""; + + const containsDeps = dep.module && dep.module.dependencies && dep.module.dependencies.length > 0; + const isAsync = dep.module && dep.module.async; + if(dep.module && (isAsync || containsDeps)) { + if(dep.valueRange) { + if(Array.isArray(dep.replaces)) { + for(let i = 0; i < dep.replaces.length; i++) { + const rep = dep.replaces[i]; + source.replace(rep.range[0], rep.range[1] - 1, rep.value); + } + } + source.replace(dep.valueRange[1], dep.range[1] - 1, ")"); + source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + ""); + } else { + source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")"); + } + } else { + const content = require("./WebpackMissingModule").module(dep.request); + source.replace(dep.range[0], dep.range[1] - 1, content); + } + } +} +module.exports = ContextDependencyTemplateAsRequireCall; diff --git a/node_modules/webpack/lib/dependencies/ContextElementDependency.js b/node_modules/webpack/lib/dependencies/ContextElementDependency.js new file mode 100644 index 000000000..8e5fafe52 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextElementDependency.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class ContextElementDependency extends ModuleDependency { + constructor(request, userRequest) { + super(request); + if(userRequest) { + this.userRequest = userRequest; + } + } + + get type() { + return "context element"; + } +} + +module.exports = ContextElementDependency; diff --git a/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js b/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js new file mode 100644 index 000000000..990109782 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebpackError = require("../WebpackError"); + +class CriticalDependencyWarning extends WebpackError { + constructor(message) { + super(); + + this.name = "CriticalDependencyWarning"; + this.message = "Critical dependency: " + message; + + Error.captureStackTrace(this, this.constructor); + } +} + +module.exports = CriticalDependencyWarning; diff --git a/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js b/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js new file mode 100644 index 000000000..86341d59a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class DelegatedSourceDependency extends ModuleDependency { + constructor(request) { + super(request); + } + + get type() { + return "delegated source"; + } +} + +module.exports = DelegatedSourceDependency; diff --git a/node_modules/webpack/lib/dependencies/DepBlockHelpers.js b/node_modules/webpack/lib/dependencies/DepBlockHelpers.js new file mode 100644 index 000000000..aef63fded --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DepBlockHelpers.js @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var DepBlockHelpers = exports; + +DepBlockHelpers.getLoadDepBlockWrapper = function(depBlock, outputOptions, requestShortener, name) { + var promiseCode = DepBlockHelpers.getDepBlockPromise(depBlock, outputOptions, requestShortener, name); + return [ + promiseCode + ".then(", + ").catch(", + ")" + ]; +}; + +DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestShortener, name) { + if(depBlock.chunks) { + var chunks = depBlock.chunks.filter(function(chunk) { + return !chunk.hasRuntime() && chunk.id !== null; + }); + if(chunks.length === 1) { + var chunk = chunks[0]; + return "__webpack_require__.e" + asComment(name) + "(" + JSON.stringify(chunk.id) + "" + + (outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") + + asComment(depBlock.chunkReason) + ")"; + } else if(chunks.length > 0) { + return "Promise.all" + asComment(name) + "(" + + (outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") + + "[" + + chunks.map(function(chunk) { + return "__webpack_require__.e(" + JSON.stringify(chunk.id) + ")"; + }).join(", ") + + "])"; + } + } + return "Promise.resolve()"; +}; + +function asComment(str) { + if(!str) return ""; + return "/* " + str + " */"; +} diff --git a/node_modules/webpack/lib/dependencies/DllEntryDependency.js b/node_modules/webpack/lib/dependencies/DllEntryDependency.js new file mode 100644 index 000000000..113249de8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DllEntryDependency.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); + +class DllEntryDependency extends Dependency { + constructor(dependencies, name) { + super(); + this.dependencies = dependencies; + this.name = name; + } + + get type() { + return "dll entry"; + } +} + +module.exports = DllEntryDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js b/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js new file mode 100644 index 000000000..91998126a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const makeHarmonyImportStatement = require("./HarmonyImportDependency").makeImportStatement; + +class HarmonyAcceptDependency extends NullDependency { + constructor(range, dependencies, hasCallback) { + super(); + this.range = range; + this.dependencies = dependencies; + this.hasCallback = hasCallback; + } + + get type() { + return "accepted harmony modules"; + } +} + +HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const content = dep.dependencies + .map(dependency => makeHarmonyImportStatement( + false, + dependency, + outputOptions, + requestShortener + )).join(""); + + if(dep.hasCallback) { + source.insert(dep.range[0], `function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`); + source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }"); + return; + } + + source.insert(dep.range[1] - 0.5, `, function() { ${content} }`); + } +}; + +module.exports = HarmonyAcceptDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js b/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js new file mode 100644 index 000000000..8b0689ad7 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const HarmonyImportDependency = require("./HarmonyImportDependency"); + +class HarmonyAcceptImportDependency extends HarmonyImportDependency { + constructor(request, importedVar, range) { + super(request, importedVar, range); + } + + get type() { + return "harmony accept"; + } +} + +HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) {} +}; + +module.exports = HarmonyAcceptImportDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js b/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js new file mode 100644 index 000000000..8016dac80 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class HarmonyCompatibilityDependency extends NullDependency { + constructor(originModule) { + super(); + this.originModule = originModule; + } + + get type() { + return "harmony export header"; + } +} + +HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate { + apply(dep, source) { + const usedExports = dep.originModule.usedExports; + if(usedExports && !Array.isArray(usedExports)) { + const exportName = dep.originModule.exportsArgument || "exports"; + const content = `Object.defineProperty(${exportName}, \"__esModule\", { value: true });\n`; + source.insert(-1, content); + } + } +}; + +module.exports = HarmonyCompatibilityDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js new file mode 100644 index 000000000..59eceecd8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js @@ -0,0 +1,56 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency"); + +module.exports = class HarmonyDetectionParserPlugin { + apply(parser) { + parser.plugin("program", (ast) => { + var isHarmony = ast.body.some(statement => { + return /^(Import|Export).*Declaration$/.test(statement.type); + }); + if(isHarmony) { + const module = parser.state.module; + const dep = new HarmonyCompatibilityDependency(module); + dep.loc = { + start: { + line: -1, + column: 0 + }, + end: { + line: -1, + column: 0 + }, + index: -2 + }; + module.addDependency(dep); + module.meta.harmonyModule = true; + module.strict = true; + module.exportsArgument = "__webpack_exports__"; + } + }); + var nonHarmonyIdentifiers = ["define", "exports"]; + nonHarmonyIdentifiers.forEach(identifer => { + parser.plugin(`evaluate typeof ${identifer}`, nullInHarmony); + parser.plugin(`typeof ${identifer}`, skipInHarmony); + parser.plugin(`evaluate ${identifer}`, nullInHarmony); + parser.plugin(`expression ${identifer}`, skipInHarmony); + parser.plugin(`call ${identifer}`, skipInHarmony); + }); + + function skipInHarmony() { + const module = this.state.module; + if(module && module.meta && module.meta.harmonyModule) + return true; + } + + function nullInHarmony() { + const module = this.state.module; + if(module && module.meta && module.meta.harmonyModule) + return null; + } + } +}; diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js new file mode 100644 index 000000000..3edf6e642 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency"); +const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency"); +const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency"); +const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency"); +const HarmonyImportDependency = require("./HarmonyImportDependency"); +const HarmonyModulesHelpers = require("./HarmonyModulesHelpers"); + +module.exports = class HarmonyExportDependencyParserPlugin { + apply(parser) { + parser.plugin("export", statement => { + const dep = new HarmonyExportHeaderDependency(statement.declaration && statement.declaration.range, statement.range); + dep.loc = Object.create(statement.loc); + dep.loc.index = -1; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("export import", (statement, source) => { + const dep = new HarmonyImportDependency(source, HarmonyModulesHelpers.getNewModuleVar(parser.state, source), statement.range); + dep.loc = Object.create(statement.loc); + dep.loc.index = -1; + parser.state.current.addDependency(dep); + parser.state.lastHarmonyImport = dep; + return true; + }); + parser.plugin("export expression", (statement, expr) => { + const dep = new HarmonyExportExpressionDependency(parser.state.module, expr.range, statement.range); + dep.loc = Object.create(statement.loc); + dep.loc.index = -1; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("export declaration", statement => {}); + parser.plugin("export specifier", (statement, id, name, idx) => { + const rename = parser.scope.renames[`$${id}`]; + let dep; + if(rename === "imported var") { + const settings = parser.state.harmonySpecifier[`$${id}`]; + dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, settings[0], settings[1], settings[2], name); + } else { + const immutable = statement.declaration && isImmutableStatement(statement.declaration); + const hoisted = statement.declaration && isHoistedStatement(statement.declaration); + dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -0.5 : (statement.range[1] + 0.5), immutable); + } + dep.loc = Object.create(statement.loc); + dep.loc.index = idx; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("export import specifier", (statement, source, id, name, idx) => { + const dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, parser.state.lastHarmonyImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id, name); + dep.loc = Object.create(statement.loc); + dep.loc.index = idx; + parser.state.current.addDependency(dep); + return true; + }); + } +}; + +function isImmutableStatement(statement) { + if(statement.type === "FunctionDeclaration") return true; + if(statement.type === "ClassDeclaration") return true; + if(statement.type === "VariableDeclaration" && statement.kind === "const") return true; + return false; +} + +function isHoistedStatement(statement) { + if(statement.type === "FunctionDeclaration") return true; + return false; +} diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js new file mode 100644 index 000000000..17881438f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class HarmonyExportExpressionDependency extends NullDependency { + constructor(originModule, range, rangeStatement) { + super(); + this.originModule = originModule; + this.range = range; + this.rangeStatement = rangeStatement; + } + + get type() { + return "harmony export expression"; + } + + getExports() { + return { + exports: ["default"] + }; + } + + describeHarmonyExport() { + return { + exportedName: "default", + precedence: 1, + }; + } +} + +HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate { + apply(dep, source) { + const used = dep.originModule.isUsed("default"); + const content = this.getContent(dep.originModule, used); + + if(dep.range) { + source.replace(dep.rangeStatement[0], dep.range[0] - 1, content + "("); + source.replace(dep.range[1], dep.rangeStatement[1] - 1, ");"); + return; + } + + source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content); + } + + getContent(module, used) { + const exportsName = module.exportsArgument || "exports"; + if(used) { + return `/* harmony default export */ ${exportsName}[${JSON.stringify(used)}] = `; + } + return "/* unused harmony default export */ var _unused_webpack_default_export = "; + } +}; + +module.exports = HarmonyExportExpressionDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js new file mode 100644 index 000000000..86033ce95 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js @@ -0,0 +1,28 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class HarmonyExportHeaderDependency extends NullDependency { + constructor(range, rangeStatement) { + super(); + this.range = range; + this.rangeStatement = rangeStatement; + } + + get type() { + return "harmony export header"; + } +} + +HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate { + apply(dep, source) { + const content = ""; + const replaceUntil = dep.range ? dep.range[0] - 1 : dep.rangeStatement[1] - 1; + source.replace(dep.rangeStatement[0], replaceUntil, content); + } +}; + +module.exports = HarmonyExportHeaderDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js new file mode 100644 index 000000000..114bd455a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js @@ -0,0 +1,286 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const HarmonyModulesHelpers = require("./HarmonyModulesHelpers"); + +class HarmonyExportImportedSpecifierDependency extends NullDependency { + constructor(originModule, importDependency, importedVar, id, name) { + super(); + this.originModule = originModule; + this.importDependency = importDependency; + this.importedVar = importedVar; + this.id = id; + this.name = name; + } + + get type() { + return "harmony export imported specifier"; + } + + getReference() { + const name = this.name; + const used = this.originModule.isUsed(name); + const active = HarmonyModulesHelpers.isActive(this.originModule, this); + const importedModule = this.importDependency.module; + + if(!importedModule || !used || !active) return null; + if(!this.originModule.usedExports) return null; + + if(name) { + const nameIsNotInUsedExports = Array.isArray(this.originModule.usedExports) && this.originModule.usedExports.indexOf(name) < 0; + if(nameIsNotInUsedExports) return null; + + // export { name as name } + if(this.id) { + return { + module: importedModule, + importedNames: [this.id] + }; + } + + // export { * as name } + return { + module: importedModule, + importedNames: true + }; + } + + // export * + if(Array.isArray(this.originModule.usedExports)) { + // reexport * with known used exports + var activeExports = HarmonyModulesHelpers.getActiveExports(this.originModule, this); + if(Array.isArray(importedModule.providedExports)) { + return { + module: importedModule, + importedNames: this.originModule.usedExports.filter((id) => { + const notInActiveExports = activeExports.indexOf(id) < 0; + const notDefault = id !== "default"; + const inProvidedExports = importedModule.providedExports.indexOf(id) >= 0; + return notInActiveExports && notDefault && inProvidedExports; + }), + }; + } + + return { + module: importedModule, + importedNames: this.originModule.usedExports.filter(id => { + const notInActiveExports = activeExports.indexOf(id) < 0; + const notDefault = id !== "default"; + return notInActiveExports && notDefault; + }), + }; + } + + if(Array.isArray(importedModule.providedExports)) { + return { + module: importedModule, + importedNames: importedModule.providedExports.filter(id => id !== "default"), + }; + } + + return { + module: importedModule, + importedNames: true, + }; + } + + getExports() { + if(this.name) { + return { + exports: [this.name] + }; + } + + const importedModule = this.importDependency.module; + + if(!importedModule) { + // no imported module available + return { + exports: null + }; + } + + if(Array.isArray(importedModule.providedExports)) { + return { + exports: importedModule.providedExports.filter(id => id !== "default"), + dependencies: [importedModule] + }; + } + + if(importedModule.providedExports) { + return { + exports: true + }; + } + + return { + exports: null, + dependencies: [importedModule] + }; + } + + describeHarmonyExport() { + const importedModule = this.importDependency.module; + if(!this.name && importedModule && Array.isArray(importedModule.providedExports)) { + // for a star export and when we know which exports are provided, we can tell so + return { + exportedName: importedModule.providedExports, + precedence: 3 + }; + } + + return { + exportedName: this.name, + precedence: this.name ? 2 : 3 + }; + } + + updateHash(hash) { + super.updateHash(hash); + const hashValue = this.getHashValue(this.importDependency.module); + hash.update(hashValue); + } + + getHashValue(importedModule) { + if(!importedModule) { + return ""; + } + + const stringifiedUsedExport = JSON.stringify(importedModule.usedExports); + const stringifiedProvidedExport = JSON.stringify(importedModule.providedExports); + return importedModule.used + stringifiedUsedExport + stringifiedProvidedExport; + } +} + +module.exports = HarmonyExportImportedSpecifierDependency; + +HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const content = this.getContent(dep); + source.insert(-1, content); + } + + getContent(dep) { + const name = dep.importedVar; + const used = dep.originModule.isUsed(dep.name); + const importedModule = dep.importDependency.module; + const active = HarmonyModulesHelpers.isActive(dep.originModule, dep); + const importsExportsUnknown = !importedModule || !Array.isArray(importedModule.providedExports); + + const getReexportStatement = this.reexportStatementCreator(dep.originModule, importsExportsUnknown, name); + + // we want to rexport something, but the export isn't used + if(!used) { + return "/* unused harmony reexport " + dep.name + " */\n"; + } + + // we want to reexport something but another exports overrides this one + if(!active) { + return "/* inactive harmony reexport " + (dep.name || "namespace") + " */\n"; + } + + // we want to reexport the default export from a non-hamory module + const isNotAHarmonyModule = !(importedModule && (!importedModule.meta || importedModule.meta.harmonyModule)); + if(dep.name && dep.id === "default" && isNotAHarmonyModule) { + return "/* harmony reexport (default from non-hamory) */ " + getReexportStatement(JSON.stringify(used), null); + } + + // we want to reexport a key as new key + if(dep.name && dep.id) { + var idUsed = importedModule && importedModule.isUsed(dep.id); + return "/* harmony reexport (binding) */ " + getReexportStatement(JSON.stringify(used), JSON.stringify(idUsed)); + } + + // we want to reexport the module object as named export + if(dep.name) { + return "/* harmony reexport (module object) */ " + getReexportStatement(JSON.stringify(used), ""); + } + + // we know which exports are used + if(Array.isArray(dep.originModule.usedExports)) { + const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep); + const items = dep.originModule.usedExports.map(function(id) { + if(id === "default") return; + if(activeExports.indexOf(id) >= 0) return; + if(importedModule.isProvided(id) === false) return; + var exportUsed = dep.originModule.isUsed(id); + var idUsed = importedModule && importedModule.isUsed(id); + return [exportUsed, idUsed]; + }).filter(Boolean); + + if(items.length === 0) { + return "/* unused harmony namespace reexport */\n"; + } + + return items.map(function(item) { + return "/* harmony namespace reexport (by used) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1])); + }).join(""); + } + + // not sure which exports are used, but we know which are provided + if(dep.originModule.usedExports && importedModule && Array.isArray(importedModule.providedExports)) { + const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep); + const items = importedModule.providedExports.map(function(id) { + if(id === "default") return; + if(activeExports.indexOf(id) >= 0) return; + var exportUsed = dep.originModule.isUsed(id); + var idUsed = importedModule && importedModule.isUsed(id); + return [exportUsed, idUsed]; + }).filter(Boolean); + + if(items.length === 0) { + return "/* empty harmony namespace reexport */\n"; + } + + return items.map(function(item) { + return "/* harmony namespace reexport (by provided) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1])); + }).join(""); + } + + // not sure which exports are used and provided + if(dep.originModule.usedExports) { + const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep); + let content = "/* harmony namespace reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in " + name + ") "; + + // Filter out exports which are defined by other exports + // and filter out default export because it cannot be reexported with * + if(activeExports.length > 0) + content += "if(" + JSON.stringify(activeExports.concat("default")) + ".indexOf(__WEBPACK_IMPORT_KEY__) < 0) "; + else + content += "if(__WEBPACK_IMPORT_KEY__ !== 'default') "; + const exportsName = dep.originModule.exportsArgument || "exports"; + return content + `(function(key) { __webpack_require__.d(${exportsName}, key, function() { return ${name}[key]; }) }(__WEBPACK_IMPORT_KEY__));\n`; + } + + return "/* unused harmony reexport namespace */\n"; + } + + reexportStatementCreator(module, importsExportsUnknown, name) { + const exportsName = module.exportsArgument || "exports"; + const getReexportStatement = (key, valueKey) => { + const conditional = this.getConditional(importsExportsUnknown, valueKey, name); + const returnValue = this.getReturnValue(valueKey); + return `${conditional}__webpack_require__.d(${exportsName}, ${key}, function() { return ${name}${returnValue}; });\n`; + }; + return getReexportStatement; + } + + getConditional(importsExportsUnknown, valueKey, name) { + if(!importsExportsUnknown || !valueKey) { + return ""; + } + + return `if(__webpack_require__.o(${name}, ${valueKey})) `; + } + + getReturnValue(valueKey) { + if(valueKey === null) { + return "_default.a"; + } + + return valueKey && "[" + valueKey + "]"; + } +}; diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js new file mode 100644 index 000000000..024ceeb00 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js @@ -0,0 +1,67 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const HarmonyModulesHelpers = require("./HarmonyModulesHelpers"); + +class HarmonyExportSpecifierDependency extends NullDependency { + constructor(originModule, id, name, position, immutable) { + super(); + this.originModule = originModule; + this.id = id; + this.name = name; + this.position = position; + this.immutable = immutable; + } + + get type() { + return "harmony export specifier"; + } + + getExports() { + return { + exports: [this.name] + }; + } + + describeHarmonyExport() { + return { + exportedName: this.name, + precedence: 1 + }; + } +} + +HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate { + apply(dep, source) { + const content = this.getPrefix(dep) + this.getContent(dep); + source.insert(dep.position, content); + } + + getPrefix(dep) { + return dep.position > 0 ? "\n" : ""; + } + + getContent(dep) { + const used = dep.originModule.isUsed(dep.name); + const active = HarmonyModulesHelpers.isActive(dep.originModule, dep); + if(!used) { + return `/* unused harmony export ${(dep.name || "namespace")} */\n`; + } + + if(!active) { + return `/* inactive harmony export ${(dep.name || "namespace")} */\n`; + } + + const exportsName = dep.originModule.exportsArgument || "exports"; + if(dep.immutable) { + return `/* harmony export (immutable) */ ${exportsName}[${JSON.stringify(used)}] = ${dep.id};\n`; + } + + return `/* harmony export (binding) */ __webpack_require__.d(${exportsName}, ${JSON.stringify(used)}, function() { return ${dep.id}; });\n`; + } +}; + +module.exports = HarmonyExportSpecifierDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js b/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js new file mode 100644 index 000000000..f20b3cee2 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js @@ -0,0 +1,72 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +var ModuleDependency = require("./ModuleDependency"); + +class HarmonyImportDependency extends ModuleDependency { + constructor(request, importedVar, range) { + super(request); + this.range = range; + this.importedVar = importedVar; + } + + get type() { + return "harmony import"; + } + + getReference() { + if(!this.module) return null; + + return { + module: this.module, + importedNames: false + }; + } + + updateHash(hash) { + super.updateHash(hash); + hash.update((this.module && (!this.module.meta || this.module.meta.harmonyModule)) + ""); + } +} + +HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const content = makeImportStatement(true, dep, outputOptions, requestShortener); + source.replace(dep.range[0], dep.range[1] - 1, ""); + source.insert(-1, content); + } +}; + +function getOptionalComment(pathinfo, shortenedRequest) { + if(!pathinfo) { + return ""; + } + return `/*! ${shortenedRequest} */ `; +} + +function makeImportStatement(declare, dep, outputOptions, requestShortener) { + const comment = getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request)); + const declaration = declare ? "var " : ""; + const newline = declare ? "\n" : " "; + + if(!dep.module) { + const stringifiedError = JSON.stringify(`Cannot find module "${dep.request}"`); + return `throw new Error(${stringifiedError});${newline}`; + } + + if(dep.importedVar) { + const isHarmonyModule = dep.module.meta && dep.module.meta.harmonyModule; + const content = `/* harmony import */ ${declaration}${dep.importedVar} = __webpack_require__(${comment}${JSON.stringify(dep.module.id)});${newline}`; + if(isHarmonyModule) { + return content; + } + return `${content}/* harmony import */ ${declaration}${dep.importedVar}_default = __webpack_require__.n(${dep.importedVar});${newline}`; + } + + return ""; +} +HarmonyImportDependency.makeImportStatement = makeImportStatement; + +module.exports = HarmonyImportDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js new file mode 100644 index 000000000..973383551 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js @@ -0,0 +1,102 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const HarmonyImportDependency = require("./HarmonyImportDependency"); +const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency"); +const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency"); +const HarmonyAcceptDependency = require("./HarmonyAcceptDependency"); +const HarmonyModulesHelpers = require("./HarmonyModulesHelpers"); + +module.exports = class HarmonyImportDependencyParserPlugin { + constructor(moduleOptions) { + this.strictExportPresence = moduleOptions.strictExportPresence; + } + + apply(parser) { + parser.plugin("import", (statement, source) => { + const dep = new HarmonyImportDependency(source, HarmonyModulesHelpers.getNewModuleVar(parser.state, source), statement.range); + dep.loc = statement.loc; + parser.state.current.addDependency(dep); + parser.state.lastHarmonyImport = dep; + return true; + }); + parser.plugin("import specifier", (statement, source, id, name) => { + parser.scope.definitions.length--; + parser.scope.renames[`$${name}`] = "imported var"; + if(!parser.state.harmonySpecifier) parser.state.harmonySpecifier = {}; + parser.state.harmonySpecifier[`$${name}`] = [parser.state.lastHarmonyImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id]; + return true; + }); + parser.plugin("expression imported var", (expr) => { + const name = expr.name; + const settings = parser.state.harmonySpecifier[`$${name}`]; + const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], settings[2], name, expr.range, this.strictExportPresence); + dep.shorthand = parser.scope.inShorthand; + dep.directImport = true; + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("expression imported var.*", (expr) => { + const name = expr.object.name; + const settings = parser.state.harmonySpecifier[`$${name}`]; + if(settings[2] !== null) + return false; + const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], expr.property.name || expr.property.value, name, expr.range, this.strictExportPresence); + dep.shorthand = parser.scope.inShorthand; + dep.directImport = false; + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + }); + parser.plugin("call imported var", (expr) => { + const args = expr.arguments; + const fullExpr = expr; + expr = expr.callee; + const name = expr.name; + const settings = parser.state.harmonySpecifier[`$${name}`]; + const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], settings[2], name, expr.range, this.strictExportPresence); + dep.directImport = true; + dep.callArgs = args; + dep.call = fullExpr; + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + if(args) + parser.walkExpressions(args); + return true; + }); + parser.plugin("hot accept callback", (expr, requests) => { + const dependencies = requests + .filter(request => HarmonyModulesHelpers.checkModuleVar(parser.state, request)) + .map(request => { + const dep = new HarmonyAcceptImportDependency(request, HarmonyModulesHelpers.getModuleVar(parser.state, request), expr.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return dep; + }); + if(dependencies.length > 0) { + const dep = new HarmonyAcceptDependency(expr.range, dependencies, true); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + } + }); + parser.plugin("hot accept without callback", (expr, requests) => { + const dependencies = requests + .filter(request => HarmonyModulesHelpers.checkModuleVar(parser.state, request)) + .map(request => { + const dep = new HarmonyAcceptImportDependency(request, HarmonyModulesHelpers.getModuleVar(parser.state, request), expr.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return dep; + }); + if(dependencies.length > 0) { + const dep = new HarmonyAcceptDependency(expr.range, dependencies, false); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + } + }); + } +}; diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js new file mode 100644 index 000000000..01290b962 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js @@ -0,0 +1,125 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class HarmonyImportSpecifierDependency extends NullDependency { + constructor(importDependency, importedVar, id, name, range, strictExportPresence) { + super(); + this.importDependency = importDependency; + this.importedVar = importedVar; + this.id = id; + this.name = name; + this.range = range; + this.strictExportPresence = strictExportPresence; + } + + get type() { + return "harmony import specifier"; + } + + getReference() { + if(!this.importDependency.module) return null; + return { + module: this.importDependency.module, + importedNames: this.id ? [this.id] : true + }; + } + + getWarnings() { + if(this.strictExportPresence) { + return []; + } + return this._getErrors(); + } + + getErrors() { + if(this.strictExportPresence) { + return this._getErrors(); + } + return []; + } + + _getErrors() { + const importedModule = this.importDependency.module; + if(!importedModule || !importedModule.meta || !importedModule.meta.harmonyModule) { + return; + } + + if(!this.id) { + return; + } + + if(importedModule.isProvided(this.id) !== false) { + return; + } + + const idIsNotNameMessage = this.id !== this.name ? ` (imported as '${this.name}')` : ""; + const errorMessage = `"export '${this.id}'${idIsNotNameMessage} was not found in '${this.importDependency.userRequest}'`; + const err = new Error(errorMessage); + err.hideStack = true; + return [err]; + } + + updateHash(hash) { + super.updateHash(hash); + const importedModule = this.importDependency.module; + hash.update((importedModule && importedModule.id) + ""); + hash.update((importedModule && this.id) + ""); + hash.update((importedModule && this.importedVar) + ""); + hash.update((importedModule && this.id && importedModule.isUsed(this.id)) + ""); + hash.update((importedModule && (!importedModule.meta || importedModule.meta.harmonyModule)) + ""); + hash.update((importedModule && (importedModule.used + JSON.stringify(importedModule.usedExports))) + ""); + } +} + +HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate { + apply(dep, source) { + const content = this.getContent(dep); + source.replace(dep.range[0], dep.range[1] - 1, content); + } + + getContent(dep) { + const importedModule = dep.importDependency.module; + const defaultImport = dep.directImport && dep.id === "default" && !(importedModule && (!importedModule.meta || importedModule.meta.harmonyModule)); + const shortHandPrefix = this.getShortHandPrefix(dep); + const importedVar = dep.importedVar; + const importedVarSuffix = this.getImportVarSuffix(dep, defaultImport, importedModule); + + if(dep.call && defaultImport) { + return `${shortHandPrefix}${importedVar}_default()`; + } + + if(dep.call && dep.id) { + return `${shortHandPrefix}__webpack_require__.i(${importedVar}${importedVarSuffix})`; + } + + return `${shortHandPrefix}${importedVar}${importedVarSuffix}`; + } + + getImportVarSuffix(dep, defaultImport, importedModule) { + if(defaultImport) { + return "_default.a"; + } + + if(dep.id) { + const used = importedModule ? importedModule.isUsed(dep.id) : dep.id; + const optionalComment = dep.id !== used ? " /* " + dep.id + " */" : ""; + return `[${JSON.stringify(used)}${optionalComment}]`; + } + + return ""; + } + + getShortHandPrefix(dep) { + if(!dep.shorthand) { + return ""; + } + + return dep.name + ": "; + } +}; + +module.exports = HarmonyImportSpecifierDependency; diff --git a/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js b/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js new file mode 100644 index 000000000..cd3b63115 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js @@ -0,0 +1,85 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class HarmonyModulesHelpers { + + static getModuleVar(state, request) { + if(!state.harmonyModules) state.harmonyModules = []; + var idx = state.harmonyModules.indexOf(request); + if(idx < 0) { + idx = state.harmonyModules.length; + state.harmonyModules.push(request); + } + return "__WEBPACK_IMPORTED_MODULE_" + idx + "_" + request.replace(/[^A-Za-z0-9_]/g, "_").replace(/__+/g, "_") + "__"; + } + + static getNewModuleVar(state, request) { + if(state.harmonyModules && state.harmonyModules.indexOf(request) >= 0) + return null; + return this.getModuleVar(state, request); + } + + static checkModuleVar(state, request) { + if(!state.harmonyModules || state.harmonyModules.indexOf(request) < 0) + return null; + return this.getModuleVar(state, request); + } + + // checks if an harmony dependency is active in a module according to + // precedence rules. + static isActive(module, depInQuestion) { + var desc = depInQuestion.describeHarmonyExport(); + if(!desc.exportedName) return true; + var before = true; + for(var i = 0; i < module.dependencies.length; i++) { + var dep = module.dependencies[i]; + if(dep === depInQuestion) { + before = false; + continue; + } + if(!dep.describeHarmonyExport) continue; + var d = dep.describeHarmonyExport(); + if(!d || !d.exportedName) continue; + if(d.exportedName === desc.exportedName) { + if(d.precedence < desc.precedence) { + return false; + } + if(d.precedence === desc.precedence && !before) { + return false; + } + } + } + return true; + } + + // get a list of named exports defined in a module + // doesn't include * reexports. + static getActiveExports(module, currentDependency) { + var desc = currentDependency && currentDependency.describeHarmonyExport(); + var currentIndex = currentDependency ? module.dependencies.indexOf(currentDependency) : -1; + return module.dependencies.map((dep, idx) => { + return { + dep: dep, + idx: idx + }; + }).reduce((arr, data) => { + var dep = data.dep; + if(!dep.describeHarmonyExport) return arr; + var d = dep.describeHarmonyExport(); + if(!d) return arr; + if(!desc || (d.precedence < desc.precedence) || (d.precedence === desc.precedence && data.idx < currentIndex)) { + var names = [].concat(d.exportedName); + names.forEach(function(name) { + if(name && arr.indexOf(name) < 0) + arr.push(name); + }); + } + return arr; + }, []); + } +} + +module.exports = HarmonyModulesHelpers; diff --git a/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js new file mode 100644 index 000000000..896d8a2bb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js @@ -0,0 +1,72 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const HarmonyImportDependency = require("./HarmonyImportDependency"); +const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency"); +const HarmonyCompatiblilityDependency = require("./HarmonyCompatibilityDependency"); +const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency"); +const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency"); +const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency"); +const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency"); +const HarmonyAcceptDependency = require("./HarmonyAcceptDependency"); +const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency"); + +const NullFactory = require("../NullFactory"); + +const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin"); +const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin"); +const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin"); + +class HarmonyModulesPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(HarmonyImportDependency, normalModuleFactory); + compilation.dependencyTemplates.set(HarmonyImportDependency, new HarmonyImportDependency.Template()); + + compilation.dependencyFactories.set(HarmonyImportSpecifierDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyImportSpecifierDependency, new HarmonyImportSpecifierDependency.Template()); + + compilation.dependencyFactories.set(HarmonyCompatiblilityDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyCompatiblilityDependency, new HarmonyCompatiblilityDependency.Template()); + + compilation.dependencyFactories.set(HarmonyExportHeaderDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyExportHeaderDependency, new HarmonyExportHeaderDependency.Template()); + + compilation.dependencyFactories.set(HarmonyExportExpressionDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyExportExpressionDependency, new HarmonyExportExpressionDependency.Template()); + + compilation.dependencyFactories.set(HarmonyExportSpecifierDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyExportSpecifierDependency, new HarmonyExportSpecifierDependency.Template()); + + compilation.dependencyFactories.set(HarmonyExportImportedSpecifierDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyExportImportedSpecifierDependency, new HarmonyExportImportedSpecifierDependency.Template()); + + compilation.dependencyFactories.set(HarmonyAcceptDependency, new NullFactory()); + compilation.dependencyTemplates.set(HarmonyAcceptDependency, new HarmonyAcceptDependency.Template()); + + compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory); + compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony) + return; + + parser.apply( + new HarmonyDetectionParserPlugin(), + new HarmonyImportDependencyParserPlugin(this.options), + new HarmonyExportDependencyParserPlugin() + ); + }); + }); + } +} +module.exports = HarmonyModulesPlugin; diff --git a/node_modules/webpack/lib/dependencies/ImportContextDependency.js b/node_modules/webpack/lib/dependencies/ImportContextDependency.js new file mode 100644 index 000000000..7b688d5d9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportContextDependency.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ContextDependency = require("./ContextDependency"); +const CriticalDependencyWarning = require("./CriticalDependencyWarning"); +const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall"); + +class ImportContextDependency extends ContextDependency { + constructor(request, recursive, regExp, range, valueRange, chunkName) { + super(request, recursive, regExp); + this.range = range; + this.valueRange = valueRange; + this.async = true; + this.chunkName = chunkName; + } + + get type() { + return "import() context"; + } + + getWarnings() { + if(!this.critical) { + return; + } + + return [ + new CriticalDependencyWarning(this.critical) + ]; + } +} + +ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall; + +module.exports = ImportContextDependency; diff --git a/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js b/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js new file mode 100644 index 000000000..2797276b9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js @@ -0,0 +1,17 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const AsyncDependenciesBlock = require("../AsyncDependenciesBlock"); +const ImportDependency = require("./ImportDependency"); + +module.exports = class ImportDependenciesBlock extends AsyncDependenciesBlock { + constructor(request, range, chunkName, module, loc) { + super(chunkName, module, loc); + this.range = range; + const dep = new ImportDependency(request, this); + dep.loc = loc; + this.addDependency(dep); + } +}; diff --git a/node_modules/webpack/lib/dependencies/ImportDependency.js b/node_modules/webpack/lib/dependencies/ImportDependency.js new file mode 100644 index 000000000..8858ba20b --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportDependency.js @@ -0,0 +1,54 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const DepBlockHelpers = require("./DepBlockHelpers"); +const webpackMissingPromiseModule = require("./WebpackMissingModule").promise; + +class ImportDependency extends ModuleDependency { + constructor(request, block) { + super(request); + this.block = block; + } + + get type() { + return "import()"; + } +} + +ImportDependency.Template = class ImportDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const depBlock = dep.block; + const promise = DepBlockHelpers.getDepBlockPromise(depBlock, outputOptions, requestShortener, "import()"); + const comment = this.getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request)); + + const content = this.getContent(promise, dep, comment); + source.replace(depBlock.range[0], depBlock.range[1] - 1, content); + } + + getOptionalComment(pathinfo, shortenedRequest) { + if(!pathinfo) { + return ""; + } + + return `/*! ${shortenedRequest} */ `; + } + + getContent(promise, dep, comment) { + if(promise && dep.module) { + const stringifiedId = JSON.stringify(dep.module.id); + return `${promise}.then(__webpack_require__.bind(null, ${comment}${stringifiedId}))`; + } + + if(dep.module) { + const stringifiedId = JSON.stringify(dep.module.id); + return `Promise.resolve(__webpack_require__(${comment}${stringifiedId}))`; + } + + return webpackMissingPromiseModule(dep.request); + } +}; + +module.exports = ImportDependency; diff --git a/node_modules/webpack/lib/dependencies/ImportParserPlugin.js b/node_modules/webpack/lib/dependencies/ImportParserPlugin.js new file mode 100644 index 000000000..73972ebee --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportParserPlugin.js @@ -0,0 +1,51 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ImportContextDependency = require("./ImportContextDependency"); +const ImportDependenciesBlock = require("./ImportDependenciesBlock"); +const ContextDependencyHelpers = require("./ContextDependencyHelpers"); + +class ImportParserPlugin { + constructor(options) { + this.options = options; + } + + apply(parser) { + const options = this.options; + + parser.plugin(["call System.import", "import-call"], (expr) => { + if(expr.arguments.length !== 1) + throw new Error("Incorrect number of arguments provided to 'import(module: string) -> Promise'."); + + const param = parser.evaluateExpression(expr.arguments[0]); + + let chunkName = null; + + const importOptions = parser.getCommentOptions(expr.range); + if(importOptions) { + if(typeof importOptions.webpackChunkName !== "undefined") { + if(typeof importOptions.webpackChunkName !== "string") + throw new Error(`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`); + chunkName = importOptions.webpackChunkName; + } + } + + if(param.isString()) { + const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc); + parser.state.current.addBlock(depBlock); + return true; + } else { + const dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options, chunkName); + if(!dep) return; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + }); + } +} +module.exports = ImportParserPlugin; diff --git a/node_modules/webpack/lib/dependencies/ImportPlugin.js b/node_modules/webpack/lib/dependencies/ImportPlugin.js new file mode 100644 index 000000000..487b97455 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportPlugin.js @@ -0,0 +1,40 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ImportDependency = require("./ImportDependency"); +const ImportContextDependency = require("./ImportContextDependency"); +const ImportParserPlugin = require("./ImportParserPlugin"); + +class ImportPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + const contextModuleFactory = params.contextModuleFactory; + + compilation.dependencyFactories.set(ImportDependency, normalModuleFactory); + compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template()); + + compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory); + compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.import !== "undefined" && !parserOptions.import) + return; + + parser.apply( + new ImportParserPlugin(options) + ); + }); + }); + } +} +module.exports = ImportPlugin; diff --git a/node_modules/webpack/lib/dependencies/LoaderDependency.js b/node_modules/webpack/lib/dependencies/LoaderDependency.js new file mode 100644 index 000000000..4b5aff7c5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LoaderDependency.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class LoaderDependency extends ModuleDependency { + constructor(request) { + super(request); + } + + get type() { + return "loader"; + } +} + +module.exports = LoaderDependency; diff --git a/node_modules/webpack/lib/dependencies/LoaderPlugin.js b/node_modules/webpack/lib/dependencies/LoaderPlugin.js new file mode 100644 index 000000000..a565ebbc4 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LoaderPlugin.js @@ -0,0 +1,60 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const LoaderDependency = require("./LoaderDependency"); + +class LoaderPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(LoaderDependency, normalModuleFactory); + }); + compiler.plugin("compilation", (compilation) => { + compilation.plugin("normal-module-loader", (loaderContext, module) => { + loaderContext.loadModule = function loadModule(request, callback) { + const dep = new LoaderDependency(request); + dep.loc = request; + compilation.addModuleDependencies(module, [ + [dep] + ], true, "lm", false, (err) => { + if(err) return callback(err); + + if(!dep.module) return callback(new Error("Cannot load the module")); + if(dep.module.building) dep.module.building.push(next); + else next(); + + function next(err) { + if(err) return callback(err); + + if(dep.module.error) return callback(dep.module.error); + if(!dep.module._source) throw new Error("The module created for a LoaderDependency must have a property _source"); + let source, map; + const moduleSource = dep.module._source; + if(moduleSource.sourceAndMap) { + const sourceAndMap = moduleSource.sourceAndMap(); + map = sourceAndMap.map; + source = sourceAndMap.source; + } else { + map = moduleSource.map(); + source = moduleSource.source(); + } + if(dep.module.fileDependencies) { + dep.module.fileDependencies.forEach((dep) => loaderContext.addDependency(dep)); + } + if(dep.module.contextDependencies) { + dep.module.contextDependencies.forEach((dep) => loaderContext.addContextDependency(dep)); + } + return callback(null, source, map, dep.module); + } + }); + }; + }); + }); + } +} +module.exports = LoaderPlugin; diff --git a/node_modules/webpack/lib/dependencies/LocalModule.js b/node_modules/webpack/lib/dependencies/LocalModule.js new file mode 100644 index 000000000..7245828cb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModule.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class LocalModule { + constructor(module, name, idx) { + this.module = module; + this.name = name; + this.idx = idx; + this.used = false; + } + + flagUsed() { + this.used = true; + } + + variableName() { + return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__"; + } +} +module.exports = LocalModule; diff --git a/node_modules/webpack/lib/dependencies/LocalModuleDependency.js b/node_modules/webpack/lib/dependencies/LocalModuleDependency.js new file mode 100644 index 000000000..0358dca26 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModuleDependency.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class LocalModuleDependency extends NullDependency { + constructor(localModule, range) { + super(); + localModule.flagUsed(); + this.localModule = localModule; + this.range = range; + } +} + +LocalModuleDependency.Template = class LocalModuleDependencyTemplate { + apply(dep, source) { + if(!dep.range) return; + source.replace(dep.range[0], dep.range[1] - 1, dep.localModule.variableName()); + } +}; + +module.exports = LocalModuleDependency; diff --git a/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js b/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js new file mode 100644 index 000000000..4e2301e16 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js @@ -0,0 +1,46 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const LocalModule = require("./LocalModule"); +const LocalModulesHelpers = exports; + +const lookup = (parent, mod) => { + if(mod.charAt(0) !== ".") return mod; + + var path = parent.split("/"), + segs = mod.split("/"); + path.pop(); + + for(var i = 0; i < segs.length; i++) { + var seg = segs[i]; + if(seg === "..") path.pop(); + else if(seg !== ".") path.push(seg); + } + + return path.join("/"); +}; + +LocalModulesHelpers.addLocalModule = (state, name) => { + if(!state.localModules) state.localModules = []; + var m = new LocalModule(state.module, name, state.localModules.length); + state.localModules.push(m); + return m; +}; + +LocalModulesHelpers.getLocalModule = (state, name, namedModule) => { + if(!state.localModules) return null; + if(namedModule) { + // resolve dependency name relative to the defining named module + name = lookup(namedModule, name); + } + for(var i = 0; i < state.localModules.length; i++) { + if(state.localModules[i].name === name) + return state.localModules[i]; + } + return null; +}; + +module.exports = LocalModulesHelpers; diff --git a/node_modules/webpack/lib/dependencies/ModuleDependency.js b/node_modules/webpack/lib/dependencies/ModuleDependency.js new file mode 100644 index 000000000..b8cfb47bc --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependency.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); + +class ModuleDependency extends Dependency { + constructor(request) { + super(); + this.request = request; + this.userRequest = request; + } + + isEqualResource(other) { + if(!(other instanceof ModuleDependency)) + return false; + + return this.request === other.request; + } +} + +module.exports = ModuleDependency; diff --git a/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js new file mode 100644 index 000000000..a83924819 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class ModuleDependencyTemplateAsId { + + apply(dep, source, outputOptions, requestShortener) { + if(!dep.range) return; + const comment = outputOptions.pathinfo ? + `/*! ${requestShortener.shorten(dep.request)} */ ` : ""; + let content; + if(dep.module) + content = comment + JSON.stringify(dep.module.id); + else + content = require("./WebpackMissingModule").module(dep.request); + source.replace(dep.range[0], dep.range[1] - 1, content); + } +} +module.exports = ModuleDependencyTemplateAsId; diff --git a/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js new file mode 100644 index 000000000..863ed3b31 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class ModuleDependencyTemplateAsRequireId { + + apply(dep, source, outputOptions, requestShortener) { + if(!dep.range) return; + const comment = outputOptions.pathinfo ? + `/*! ${requestShortener.shorten(dep.request)} */ ` : ""; + let content; + if(dep.module) + content = `__webpack_require__(${comment}${JSON.stringify(dep.module.id)})`; + else + content = require("./WebpackMissingModule").module(dep.request); + source.replace(dep.range[0], dep.range[1] - 1, content); + } +} +module.exports = ModuleDependencyTemplateAsRequireId; diff --git a/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js b/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js new file mode 100644 index 000000000..4297e57d8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId"); + +class ModuleHotAcceptDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + this.weak = true; + } + + get type() { + return "module.hot.accept"; + } +} + +ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId; + +module.exports = ModuleHotAcceptDependency; diff --git a/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js b/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js new file mode 100644 index 000000000..cab86cecb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId"); + +class ModuleHotDeclineDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + this.weak = true; + } + + get type() { + return "module.hot.decline"; + } +} + +ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId; + +module.exports = ModuleHotDeclineDependency; diff --git a/node_modules/webpack/lib/dependencies/MultiEntryDependency.js b/node_modules/webpack/lib/dependencies/MultiEntryDependency.js new file mode 100644 index 000000000..6196b95a5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/MultiEntryDependency.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); + +class MultiEntryDependency extends Dependency { + constructor(dependencies, name) { + super(); + this.dependencies = dependencies; + this.name = name; + } + + get type() { + return "multi entry"; + } +} + +module.exports = MultiEntryDependency; diff --git a/node_modules/webpack/lib/dependencies/NullDependency.js b/node_modules/webpack/lib/dependencies/NullDependency.js new file mode 100644 index 000000000..5d389e67e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/NullDependency.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const Dependency = require("../Dependency"); + +class NullDependency extends Dependency { + get type() { + return "null"; + } + + isEqualResource() { + return false; + } + + updateHash() {} +} + +NullDependency.Template = class NullDependencyTemplate { + apply() {} +}; + +module.exports = NullDependency; diff --git a/node_modules/webpack/lib/dependencies/PrefetchDependency.js b/node_modules/webpack/lib/dependencies/PrefetchDependency.js new file mode 100644 index 000000000..98ca185b8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/PrefetchDependency.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class PrefetchDependency extends ModuleDependency { + constructor(request) { + super(request); + } + + get type() { + return "prefetch"; + } +} + +module.exports = PrefetchDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireContextDependency.js b/node_modules/webpack/lib/dependencies/RequireContextDependency.js new file mode 100644 index 000000000..c0f6bdc75 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextDependency.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ContextDependency = require("./ContextDependency"); +const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId"); + +class RequireContextDependency extends ContextDependency { + constructor(request, recursive, regExp, range) { + super(request, recursive, regExp); + this.range = range; + } + + get type() { + return "require.context"; + } +} + +RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId; + +module.exports = RequireContextDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js new file mode 100644 index 000000000..8587fba8d --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js @@ -0,0 +1,42 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireContextDependency = require("./RequireContextDependency"); + +module.exports = class RequireContextDependencyParserPlugin { + apply(parser) { + parser.plugin("call require.context", expr => { + let regExp = /^\.\/.*$/; + let recursive = true; + switch(expr.arguments.length) { + case 3: + { + const regExpExpr = parser.evaluateExpression(expr.arguments[2]); + if(!regExpExpr.isRegExp()) return; + regExp = regExpExpr.regExp; + } + // falls through + case 2: + { + const recursiveExpr = parser.evaluateExpression(expr.arguments[1]); + if(!recursiveExpr.isBoolean()) return; + recursive = recursiveExpr.bool; + } + // falls through + case 1: + { + const requestExpr = parser.evaluateExpression(expr.arguments[0]); + if(!requestExpr.isString()) return; + const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, expr.range); + dep.loc = expr.loc; + dep.optional = parser.scope.inTry; + parser.state.current.addDependency(dep); + return true; + } + } + }); + } +}; diff --git a/node_modules/webpack/lib/dependencies/RequireContextPlugin.js b/node_modules/webpack/lib/dependencies/RequireContextPlugin.js new file mode 100644 index 000000000..57acda586 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextPlugin.js @@ -0,0 +1,77 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireContextDependency = require("./RequireContextDependency"); +const ContextElementDependency = require("./ContextElementDependency"); + +const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin"); + +class RequireContextPlugin { + constructor(modulesDirectories, extensions) { + if(!Array.isArray(modulesDirectories)) + throw new Error("modulesDirectories must be an array"); + if(!Array.isArray(extensions)) + throw new Error("extensions must be an array"); + this.modulesDirectories = modulesDirectories; + this.extensions = extensions; + } + + apply(compiler) { + const modulesDirectories = this.modulesDirectories; + const extensions = this.extensions; + compiler.plugin("compilation", (compilation, params) => { + const contextModuleFactory = params.contextModuleFactory; + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(RequireContextDependency, contextModuleFactory); + compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template()); + + compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext) + return; + + parser.apply(new RequireContextDependencyParserPlugin()); + }); + + params.contextModuleFactory.plugin("alternatives", (items, callback) => { + if(items.length === 0) return callback(null, items); + + callback(null, items.map((obj) => { + return extensions.filter((ext) => { + const l = obj.request.length; + return l > ext.length && obj.request.substr(l - ext.length, l) === ext; + }).map((ext) => { + const l = obj.request.length; + return { + context: obj.context, + request: obj.request.substr(0, l - ext.length) + }; + }).concat(obj); + }).reduce((a, b) => a.concat(b), [])); + }); + + params.contextModuleFactory.plugin("alternatives", (items, callback) => { + if(items.length === 0) return callback(null, items); + + callback(null, items.map((obj) => { + for(let i = 0; i < modulesDirectories.length; i++) { + const dir = modulesDirectories[i]; + const idx = obj.request.indexOf("./" + dir + "/"); + if(idx === 0) { + obj.request = obj.request.slice(dir.length + 3); + break; + } + } + return obj; + })); + }); + }); + } +} +module.exports = RequireContextPlugin; diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js new file mode 100644 index 000000000..4b3a378e9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js @@ -0,0 +1,28 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const AsyncDependenciesBlock = require("../AsyncDependenciesBlock"); +const RequireEnsureDependency = require("./RequireEnsureDependency"); + +module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock { + constructor(expr, successExpression, errorExpression, chunkName, chunkNameRange, module, loc) { + super(chunkName, module, loc); + this.expr = expr; + const successBodyRange = successExpression && successExpression.body && successExpression.body.range; + const errorBodyRange = errorExpression && errorExpression.body && errorExpression.body.range; + this.range = null; + if(successBodyRange) { + if(errorBodyRange) { + this.range = [successBodyRange[0] + 1, errorBodyRange[1] - 1]; + } else { + this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1]; + } + } + this.chunkNameRange = chunkNameRange; + const dep = new RequireEnsureDependency(this); + dep.loc = loc; + this.addDependency(dep); + } +}; diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js new file mode 100644 index 000000000..73b7d0c8c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js @@ -0,0 +1,102 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock"); +const RequireEnsureItemDependency = require("./RequireEnsureItemDependency"); +const getFunctionExpression = require("./getFunctionExpression"); + +module.exports = class RequireEnsureDependenciesBlockParserPlugin { + apply(parser) { + parser.plugin("call require.ensure", expr => { + let chunkName = null; + let chunkNameRange = null; + let errorExpressionArg = null; + let errorExpression = null; + switch(expr.arguments.length) { + case 4: + { + const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]); + if(!chunkNameExpr.isString()) return; + chunkNameRange = chunkNameExpr.range; + chunkName = chunkNameExpr.string; + } + // falls through + case 3: + { + errorExpressionArg = expr.arguments[2]; + errorExpression = getFunctionExpression(errorExpressionArg); + + if(!errorExpression && !chunkName) { + const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]); + if(!chunkNameExpr.isString()) return; + chunkNameRange = chunkNameExpr.range; + chunkName = chunkNameExpr.string; + } + } + // falls through + case 2: + { + const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]); + const dependenciesItems = dependenciesExpr.isArray() ? dependenciesExpr.items : [dependenciesExpr]; + const successExpressionArg = expr.arguments[1]; + const successExpression = getFunctionExpression(successExpressionArg); + + if(successExpression) { + parser.walkExpressions(successExpression.expressions); + } + if(errorExpression) { + parser.walkExpressions(errorExpression.expressions); + } + + const dep = new RequireEnsureDependenciesBlock(expr, + successExpression ? successExpression.fn : successExpressionArg, + errorExpression ? errorExpression.fn : errorExpressionArg, + chunkName, chunkNameRange, parser.state.module, expr.loc); + const old = parser.state.current; + parser.state.current = dep; + try { + let failed = false; + parser.inScope([], () => { + dependenciesItems.forEach(ee => { + if(ee.isString()) { + const edep = new RequireEnsureItemDependency(ee.string, ee.range); + edep.loc = dep.loc; + dep.addDependency(edep); + } else { + failed = true; + } + }); + }); + if(failed) { + return; + } + if(successExpression) { + if(successExpression.fn.body.type === "BlockStatement") + parser.walkStatement(successExpression.fn.body); + else + parser.walkExpression(successExpression.fn.body); + } + old.addBlock(dep); + } finally { + parser.state.current = old; + } + if(!successExpression) { + parser.walkExpression(successExpressionArg); + } + if(errorExpression) { + if(errorExpression.fn.body.type === "BlockStatement") + parser.walkStatement(errorExpression.fn.body); + else + parser.walkExpression(errorExpression.fn.body); + } else if(errorExpressionArg) { + parser.walkExpression(errorExpressionArg); + } + return true; + } + } + }); + } +}; diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js new file mode 100644 index 000000000..65a9c8a3f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js @@ -0,0 +1,38 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const DepBlockHelpers = require("./DepBlockHelpers"); + +class RequireEnsureDependency extends NullDependency { + constructor(block) { + super(); + this.block = block; + } + + get type() { + return "require.ensure"; + } +} + +RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const depBlock = dep.block; + const wrapper = DepBlockHelpers.getLoadDepBlockWrapper(depBlock, outputOptions, requestShortener, "require.ensure"); + const errorCallbackExists = depBlock.expr.arguments.length === 4 || (!depBlock.chunkName && depBlock.expr.arguments.length === 3); + const startBlock = wrapper[0] + "("; + const middleBlock = `).bind(null, __webpack_require__)${wrapper[1]}`; + const endBlock = `${middleBlock}__webpack_require__.oe${wrapper[2]}`; + source.replace(depBlock.expr.range[0], depBlock.expr.arguments[1].range[0] - 1, startBlock); + if(errorCallbackExists) { + source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.arguments[2].range[0] - 1, middleBlock); + source.replace(depBlock.expr.arguments[2].range[1], depBlock.expr.range[1] - 1, wrapper[2]); + } else { + source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.range[1] - 1, endBlock); + } + } +}; + +module.exports = RequireEnsureDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js b/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js new file mode 100644 index 000000000..ca2b699ae --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const NullDependency = require("./NullDependency"); + +class RequireEnsureItemDependency extends ModuleDependency { + constructor(request) { + super(request); + } + + get type() { + return "require.ensure item"; + } +} + +RequireEnsureItemDependency.Template = NullDependency.Template; + +module.exports = RequireEnsureItemDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js b/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js new file mode 100644 index 000000000..b8a66727d --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js @@ -0,0 +1,40 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireEnsureItemDependency = require("./RequireEnsureItemDependency"); +const RequireEnsureDependency = require("./RequireEnsureDependency"); + +const NullFactory = require("../NullFactory"); + +const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin"); + +const ParserHelpers = require("../ParserHelpers"); + +class RequireEnsurePlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(RequireEnsureItemDependency, normalModuleFactory); + compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template()); + + compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory()); + compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure) + return; + + parser.apply(new RequireEnsureDependenciesBlockParserPlugin()); + parser.plugin("evaluate typeof require.ensure", ParserHelpers.evaluateToString("function")); + parser.plugin("typeof require.ensure", ParserHelpers.toConstantDependency(JSON.stringify("function"))); + }); + }); + } +} +module.exports = RequireEnsurePlugin; diff --git a/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js b/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js new file mode 100644 index 000000000..7ba24ca0b --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js @@ -0,0 +1,26 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class RequireHeaderDependency extends NullDependency { + constructor(range) { + super(); + if(!Array.isArray(range)) throw new Error("range must be valid"); + this.range = range; + } +} + +RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate { + apply(dep, source) { + source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__"); + } + + applyAsTemplateArgument(name, dep, source) { + source.replace(dep.range[0], dep.range[1] - 1, "require"); + } +}; + +module.exports = RequireHeaderDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js b/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js new file mode 100644 index 000000000..474e3696f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class RequireIncludeDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + } + + get type() { + return "require.include"; + } +} + +RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + const comment = this.getOptionalComment(outputOptions.pathinfo && dep.module, requestShortener.shorten(dep.request)); + source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`); + } + + getOptionalComment(shouldHaveComment, shortenedRequest) { + if(shouldHaveComment) { + return ""; + } + return `/*! require.include ${shortenedRequest} */`; + } +}; + +module.exports = RequireIncludeDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js new file mode 100644 index 000000000..b7b233145 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireIncludeDependency = require("./RequireIncludeDependency"); + +module.exports = class RequireIncludeDependencyParserPlugin { + apply(parser) { + parser.plugin("call require.include", expr => { + if(expr.arguments.length !== 1) return; + const param = parser.evaluateExpression(expr.arguments[0]); + if(!param.isString()) return; + const dep = new RequireIncludeDependency(param.string, expr.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + }); + } +}; diff --git a/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js b/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js new file mode 100644 index 000000000..f80e9b91f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireIncludeDependency = require("./RequireIncludeDependency"); +const RequireIncludeDependencyParserPlugin = require("./RequireIncludeDependencyParserPlugin"); + +const ParserHelpers = require("../ParserHelpers"); + +class RequireIncludePlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + const normalModuleFactory = params.normalModuleFactory; + + compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory); + compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template()); + + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude) + return; + + parser.apply(new RequireIncludeDependencyParserPlugin()); + parser.plugin("evaluate typeof require.include", ParserHelpers.evaluateToString("function")); + parser.plugin("typeof require.include", ParserHelpers.toConstantDependency(JSON.stringify("function"))); + }); + }); + } +} +module.exports = RequireIncludePlugin; diff --git a/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js new file mode 100644 index 000000000..161319e82 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ContextDependency = require("./ContextDependency"); +const CriticalDependencyWarning = require("./CriticalDependencyWarning"); +const ContextDependencyTemplateAsId = require("./ContextDependencyTemplateAsId"); + +class RequireResolveContextDependency extends ContextDependency { + constructor(request, recursive, regExp, range, valueRange) { + super(request, recursive, regExp); + this.range = range; + this.valueRange = valueRange; + } + + get type() { + return "amd require context"; + } + + getWarnings() { + if(!this.critical) { + return; + } + + return [ + new CriticalDependencyWarning(this.critical) + ]; + } +} + +RequireResolveContextDependency.Template = ContextDependencyTemplateAsId; + +module.exports = RequireResolveContextDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireResolveDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveDependency.js new file mode 100644 index 000000000..72ac48aab --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveDependency.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); +const ModuleDependencyAsId = require("./ModuleDependencyTemplateAsId"); + +class RequireResolveDependency extends ModuleDependency { + constructor(request, range) { + super(request); + this.range = range; + } + + get type() { + return "require.resolve"; + } +} + +RequireResolveDependency.Template = ModuleDependencyAsId; + +module.exports = RequireResolveDependency; diff --git a/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js new file mode 100644 index 000000000..09dd60788 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js @@ -0,0 +1,71 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const RequireResolveDependency = require("./RequireResolveDependency"); +const RequireResolveContextDependency = require("./RequireResolveContextDependency"); +const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency"); +const ContextDependencyHelpers = require("./ContextDependencyHelpers"); + +class RequireResolveDependencyParserPlugin { + constructor(options) { + this.options = options; + } + + apply(parser) { + const options = this.options; + parser.plugin("call require.resolve", (expr) => { + return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, false); + }); + parser.plugin("call require.resolveWeak", (expr) => { + return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, true); + }); + parser.plugin("call require.resolve(Weak)", (expr, weak) => { + if(expr.arguments.length !== 1) return; + const param = parser.evaluateExpression(expr.arguments[0]); + if(param.isConditional()) { + param.options.forEach((option) => { + const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, option, weak); + if(result === undefined) { + parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, option, weak); + } + }); + const dep = new RequireResolveHeaderDependency(expr.callee.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + } else { + const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, param, weak); + if(result === undefined) { + parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, param, weak); + } + const dep = new RequireResolveHeaderDependency(expr.callee.range); + dep.loc = expr.loc; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call require.resolve(Weak):item", (expr, param, weak) => { + if(param.isString()) { + const dep = new RequireResolveDependency(param.string, param.range); + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + dep.weak = weak; + parser.state.current.addDependency(dep); + return true; + } + }); + parser.plugin("call require.resolve(Weak):context", (expr, param, weak) => { + const dep = ContextDependencyHelpers.create(RequireResolveContextDependency, param.range, param, expr, options); + if(!dep) return; + dep.loc = expr.loc; + dep.optional = !!parser.scope.inTry; + dep.weak = weak; + parser.state.current.addDependency(dep); + return true; + }); + } +} +module.exports = RequireResolveDependencyParserPlugin; diff --git a/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js new file mode 100644 index 000000000..d96ff7ddb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js @@ -0,0 +1,26 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); + +class RequireResolveHeaderDependency extends NullDependency { + constructor(range) { + super(); + if(!Array.isArray(range)) throw new Error("range must be valid"); + this.range = range; + } +} + +RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate { + apply(dep, source) { + source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/"); + } + + applyAsTemplateArgument(name, dep, source) { + source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/"); + } +}; + +module.exports = RequireResolveHeaderDependency; diff --git a/node_modules/webpack/lib/dependencies/SingleEntryDependency.js b/node_modules/webpack/lib/dependencies/SingleEntryDependency.js new file mode 100644 index 000000000..02ccd8986 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/SingleEntryDependency.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ModuleDependency = require("./ModuleDependency"); + +class SingleEntryDependency extends ModuleDependency { + constructor(request) { + super(request); + } + + get type() { + return "single entry"; + } +} + +module.exports = SingleEntryDependency; diff --git a/node_modules/webpack/lib/dependencies/SystemPlugin.js b/node_modules/webpack/lib/dependencies/SystemPlugin.js new file mode 100644 index 000000000..dd457ae7c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/SystemPlugin.js @@ -0,0 +1,44 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ParserHelpers = require("../ParserHelpers"); + +class SystemPlugin { + constructor(options) { + this.options = options; + } + + apply(compiler) { + compiler.plugin("compilation", (compilation, params) => { + params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { + + if(typeof parserOptions.system !== "undefined" && !parserOptions.system) + return; + + function setNotSupported(name) { + parser.plugin("evaluate typeof " + name, ParserHelpers.evaluateToString("undefined")); + parser.plugin("expression " + name, + ParserHelpers.expressionIsUnsupported(name + " is not supported by webpack.") + ); + } + + parser.plugin("typeof System.import", ParserHelpers.toConstantDependency(JSON.stringify("function"))); + parser.plugin("evaluate typeof System.import", ParserHelpers.evaluateToString("function")); + parser.plugin("typeof System", ParserHelpers.toConstantDependency(JSON.stringify("object"))); + parser.plugin("evaluate typeof System", ParserHelpers.evaluateToString("object")); + + setNotSupported("System.set"); + setNotSupported("System.get"); + setNotSupported("System.register"); + parser.plugin("expression System", function() { + const systemPolyfillRequire = ParserHelpers.requireFileAsExpression( + this.state.module.context, require.resolve("../../buildin/system.js")); + return ParserHelpers.addParsedVariableToModule(this, "System", systemPolyfillRequire); + }); + }); + }); + } +} +module.exports = SystemPlugin; diff --git a/node_modules/webpack/lib/dependencies/UnsupportedDependency.js b/node_modules/webpack/lib/dependencies/UnsupportedDependency.js new file mode 100644 index 000000000..48f0971b6 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/UnsupportedDependency.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const NullDependency = require("./NullDependency"); +const webpackMissingModule = require("./WebpackMissingModule").module; + +class UnsupportedDependency extends NullDependency { + constructor(request, range) { + super(); + this.request = request; + this.range = range; + } +} + +UnsupportedDependency.Template = class UnsupportedDependencyTemplate { + apply(dep, source, outputOptions, requestShortener) { + source.replace(dep.range[0], dep.range[1], webpackMissingModule(dep.request)); + } +}; + +module.exports = UnsupportedDependency; diff --git a/node_modules/webpack/lib/dependencies/WebpackMissingModule.js b/node_modules/webpack/lib/dependencies/WebpackMissingModule.js new file mode 100644 index 000000000..64e76cffb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/WebpackMissingModule.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const toErrorCode = err => `var e = new Error(${JSON.stringify(err)}); e.code = 'MODULE_NOT_FOUND';`; + +exports.module = request => `!(function webpackMissingModule() { ${exports.moduleCode(request)} }())`; + +exports.promise = (request) => { + const errorCode = toErrorCode(`Cannot find module "${request}"`); + return `Promise.reject(function webpackMissingModule() { ${errorCode}; return e; }())`; +}; + +exports.moduleCode = (request) => { + const errorCode = toErrorCode(`Cannot find module "${request}"`); + return `${errorCode} throw e;`; +}; diff --git a/node_modules/webpack/lib/dependencies/getFunctionExpression.js b/node_modules/webpack/lib/dependencies/getFunctionExpression.js new file mode 100644 index 000000000..cc32585ab --- /dev/null +++ b/node_modules/webpack/lib/dependencies/getFunctionExpression.js @@ -0,0 +1,44 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function(expr) { + // + if(expr.type === "FunctionExpression" || expr.type === "ArrowFunctionExpression") { + return { + fn: expr, + expressions: [], + needThis: false + }; + } + + // .bind() + if(expr.type === "CallExpression" && + expr.callee.type === "MemberExpression" && + expr.callee.object.type === "FunctionExpression" && + expr.callee.property.type === "Identifier" && + expr.callee.property.name === "bind" && + expr.arguments.length === 1) { + return { + fn: expr.callee.object, + expressions: [expr.arguments[0]] + }; + } + // (function(_this) {return })(this) (Coffeescript) + if(expr.type === "CallExpression" && + expr.callee.type === "FunctionExpression" && + expr.callee.body.type === "BlockStatement" && + expr.arguments.length === 1 && + expr.arguments[0].type === "ThisExpression" && + expr.callee.body.body && + expr.callee.body.body.length === 1 && + expr.callee.body.body[0].type === "ReturnStatement" && + expr.callee.body.body[0].argument && + expr.callee.body.body[0].argument.type === "FunctionExpression") { + return { + fn: expr.callee.body.body[0].argument, + expressions: [], + needThis: true + }; + } +}; diff --git a/node_modules/webpack/lib/formatLocation.js b/node_modules/webpack/lib/formatLocation.js new file mode 100644 index 000000000..da8c10e23 --- /dev/null +++ b/node_modules/webpack/lib/formatLocation.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function formatLocation(loc) { + if(typeof loc === "string") + return loc; + if(typeof loc === "number") + return loc + ""; + if(loc && typeof loc === "object") { + if(loc.start && loc.end) { + if(typeof loc.start.line === "number" && typeof loc.end.line === "number" && typeof loc.end.column === "number" && loc.start.line === loc.end.line) + return formatPosition(loc.start) + "-" + loc.end.column; + return formatPosition(loc.start) + "-" + formatPosition(loc.end); + } + if(loc.start) + return formatPosition(loc.start); + return formatPosition(loc); + } + return ""; + + function formatPosition(pos) { + if(typeof pos === "string") + return pos; + if(typeof pos === "number") + return pos + ""; + if(pos && typeof pos === "object") { + if(typeof pos.line === "number" && typeof pos.column === "number") + return pos.line + ":" + pos.column; + if(typeof pos.line === "number") + return pos.line + ":?"; + if(typeof pos.index === "number") + return "+" + pos.index; + } + return ""; + } +}; diff --git a/node_modules/webpack/lib/node/NodeChunkTemplatePlugin.js b/node_modules/webpack/lib/node/NodeChunkTemplatePlugin.js new file mode 100644 index 000000000..dd5e0e354 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeChunkTemplatePlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class NodeChunkTemplatePlugin { + + apply(chunkTemplate) { + chunkTemplate.plugin("render", function(modules, chunk) { + const source = new ConcatSource(); + source.add(`exports.ids = ${JSON.stringify(chunk.ids)};\nexports.modules = `); + source.add(modules); + source.add(";"); + return source; + }); + chunkTemplate.plugin("hash", function(hash) { + hash.update("node"); + hash.update("3"); + }); + } +} + +module.exports = NodeChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/node/NodeEnvironmentPlugin.js b/node_modules/webpack/lib/node/NodeEnvironmentPlugin.js new file mode 100644 index 000000000..b8200a3ca --- /dev/null +++ b/node_modules/webpack/lib/node/NodeEnvironmentPlugin.js @@ -0,0 +1,25 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const NodeWatchFileSystem = require("./NodeWatchFileSystem"); +const NodeOutputFileSystem = require("./NodeOutputFileSystem"); +const NodeJsInputFileSystem = require("enhanced-resolve/lib/NodeJsInputFileSystem"); +const CachedInputFileSystem = require("enhanced-resolve/lib/CachedInputFileSystem"); + +class NodeEnvironmentPlugin { + apply(compiler) { + compiler.inputFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 60000); + const inputFileSystem = compiler.inputFileSystem; + compiler.outputFileSystem = new NodeOutputFileSystem(); + compiler.watchFileSystem = new NodeWatchFileSystem(compiler.inputFileSystem); + compiler.plugin("before-run", (compiler, callback) => { + if(compiler.inputFileSystem === inputFileSystem) + inputFileSystem.purge(); + callback(); + }); + } +} +module.exports = NodeEnvironmentPlugin; diff --git a/node_modules/webpack/lib/node/NodeHotUpdateChunkTemplatePlugin.js b/node_modules/webpack/lib/node/NodeHotUpdateChunkTemplatePlugin.js new file mode 100644 index 000000000..52239f7b6 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeHotUpdateChunkTemplatePlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ConcatSource = require("webpack-sources").ConcatSource; + +class NodeHotUpdateChunkTemplatePlugin { + + apply(hotUpdateChunkTemplate) { + hotUpdateChunkTemplate.plugin("render", (modulesSource, modules, removedModules, hash, id) => { + const source = new ConcatSource(); + source.add("exports.id = " + JSON.stringify(id) + ";\nexports.modules = "); + source.add(modulesSource); + source.add(";"); + return source; + }); + hotUpdateChunkTemplate.plugin("hash", function(hash) { + hash.update("NodeHotUpdateChunkTemplatePlugin"); + hash.update("3"); + hash.update(this.outputOptions.hotUpdateFunction + ""); + hash.update(this.outputOptions.library + ""); + }); + } +} +module.exports = NodeHotUpdateChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/node/NodeMainTemplate.runtime.js b/node_modules/webpack/lib/node/NodeMainTemplate.runtime.js new file mode 100644 index 000000000..2725e2e79 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeMainTemplate.runtime.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/*global installedChunks $hotChunkFilename$ hotAddUpdateChunk $hotMainFilename$ */ +module.exports = function() { + function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars + var chunk = require("./" + $hotChunkFilename$); + hotAddUpdateChunk(chunk.id, chunk.modules); + } + + function hotDownloadManifest() { // eslint-disable-line no-unused-vars + try { + var update = require("./" + $hotMainFilename$); + } catch(e) { + return Promise.resolve(); + } + return Promise.resolve(update); + } + + function hotDisposeChunk(chunkId) { //eslint-disable-line no-unused-vars + delete installedChunks[chunkId]; + } +}; diff --git a/node_modules/webpack/lib/node/NodeMainTemplateAsync.runtime.js b/node_modules/webpack/lib/node/NodeMainTemplateAsync.runtime.js new file mode 100644 index 000000000..673cfafd0 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeMainTemplateAsync.runtime.js @@ -0,0 +1,40 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/*global installedChunks $hotChunkFilename$ $require$ hotAddUpdateChunk $hotMainFilename$ */ +module.exports = function() { + function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars + var filename = require("path").join(__dirname, $hotChunkFilename$); + require("fs").readFile(filename, "utf-8", function(err, content) { + if(err) { + if($require$.onError) + return $require$.oe(err); + else + throw err; + } + var chunk = {}; + require("vm").runInThisContext("(function(exports) {" + content + "\n})", filename)(chunk); + hotAddUpdateChunk(chunk.id, chunk.modules); + }); + } + + function hotDownloadManifest() { // eslint-disable-line no-unused-vars + var filename = require("path").join(__dirname, $hotMainFilename$); + return new Promise(function(resolve, reject) { + require("fs").readFile(filename, "utf-8", function(err, content) { + if(err) return resolve(); + try { + var update = JSON.parse(content); + } catch(e) { + return reject(e); + } + resolve(update); + }); + }); + } + + function hotDisposeChunk(chunkId) { //eslint-disable-line no-unused-vars + delete installedChunks[chunkId]; + } +}; diff --git a/node_modules/webpack/lib/node/NodeMainTemplatePlugin.js b/node_modules/webpack/lib/node/NodeMainTemplatePlugin.js new file mode 100644 index 000000000..d4660dac1 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeMainTemplatePlugin.js @@ -0,0 +1,191 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Template = require("../Template"); + +function NodeMainTemplatePlugin(asyncChunkLoading) { + this.asyncChunkLoading = asyncChunkLoading; +} +module.exports = NodeMainTemplatePlugin; +NodeMainTemplatePlugin.prototype.apply = function(mainTemplate) { + var self = this; + mainTemplate.plugin("local-vars", function(source, chunk) { + if(chunk.chunks.length > 0) { + return this.asString([ + source, + "", + "// object to store loaded chunks", + "// \"0\" means \"already loaded\"", + "var installedChunks = {", + this.indent( + chunk.ids.map(function(id) { + return id + ": 0"; + }).join(",\n") + ), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("require-extensions", function(source, chunk) { + if(chunk.chunks.length > 0) { + return this.asString([ + source, + "", + "// uncatched error handler for webpack runtime", + this.requireFn + ".oe = function(err) {", + this.indent([ + "process.nextTick(function() {", + this.indent("throw err; // catch this error by using System.import().catch()"), + "});" + ]), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("require-ensure", function(_, chunk, hash) { + var chunkFilename = this.outputOptions.chunkFilename; + var chunkMaps = chunk.getChunkMaps(); + var insertMoreModules = [ + "var moreModules = chunk.modules, chunkIds = chunk.ids;", + "for(var moduleId in moreModules) {", + this.indent(this.renderAddModule(hash, chunk, "moduleId", "moreModules[moduleId]")), + "}" + ]; + if(self.asyncChunkLoading) { + return this.asString([ + "// \"0\" is the signal for \"already loaded\"", + "if(installedChunks[chunkId] === 0)", + this.indent([ + "return Promise.resolve();" + ]), + "// array of [resolve, reject, promise] means \"currently loading\"", + "if(installedChunks[chunkId])", + this.indent([ + "return installedChunks[chunkId][2];" + ]), + "// load the chunk and return promise to it", + "var promise = new Promise(function(resolve, reject) {", + this.indent([ + "installedChunks[chunkId] = [resolve, reject];", + "var filename = __dirname + " + this.applyPluginsWaterfall("asset-path", JSON.stringify("/" + chunkFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this), + chunk: { + id: "\" + chunkId + \"", + hash: "\" + " + JSON.stringify(chunkMaps.hash) + "[chunkId] + \"", + hashWithLength: function(length) { + var shortChunkHashMap = {}; + Object.keys(chunkMaps.hash).forEach(function(chunkId) { + if(typeof chunkMaps.hash[chunkId] === "string") + shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(0, length); + }); + return "\" + " + JSON.stringify(shortChunkHashMap) + "[chunkId] + \""; + }, + name: "\" + (" + JSON.stringify(chunkMaps.name) + "[chunkId]||chunkId) + \"" + } + }) + ";", + "require('fs').readFile(filename, 'utf-8', function(err, content) {", + this.indent([ + "if(err) return reject(err);", + "var chunk = {};", + "require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" + + "(chunk, require, require('path').dirname(filename), filename);" + ].concat(insertMoreModules).concat([ + "var callbacks = [];", + "for(var i = 0; i < chunkIds.length; i++) {", + this.indent([ + "if(installedChunks[chunkIds[i]])", + this.indent([ + "callbacks = callbacks.concat(installedChunks[chunkIds[i]][0]);" + ]), + "installedChunks[chunkIds[i]] = 0;" + ]), + "}", + "for(i = 0; i < callbacks.length; i++)", + this.indent("callbacks[i]();") + ])), + "});" + ]), + "});", + "return installedChunks[chunkId][2] = promise;" + ]); + } else { + var request = this.applyPluginsWaterfall("asset-path", JSON.stringify("./" + chunkFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this), + chunk: { + id: "\" + chunkId + \"", + hash: "\" + " + JSON.stringify(chunkMaps.hash) + "[chunkId] + \"", + hashWithLength: function(length) { + var shortChunkHashMap = {}; + Object.keys(chunkMaps.hash).forEach(function(chunkId) { + if(typeof chunkMaps.hash[chunkId] === "string") + shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(0, length); + }); + return "\" + " + JSON.stringify(shortChunkHashMap) + "[chunkId] + \""; + }, + name: "\" + (" + JSON.stringify(chunkMaps.name) + "[chunkId]||chunkId) + \"" + } + }); + return this.asString([ + "// \"0\" is the signal for \"already loaded\"", + "if(installedChunks[chunkId] !== 0) {", + this.indent([ + "var chunk = require(" + request + ");" + ].concat(insertMoreModules).concat([ + "for(var i = 0; i < chunkIds.length; i++)", + this.indent("installedChunks[chunkIds[i]] = 0;") + ])), + "}", + "return Promise.resolve();" + ]); + } + }); + mainTemplate.plugin("hot-bootstrap", function(source, chunk, hash) { + var hotUpdateChunkFilename = this.outputOptions.hotUpdateChunkFilename; + var hotUpdateMainFilename = this.outputOptions.hotUpdateMainFilename; + var chunkMaps = chunk.getChunkMaps(); + var currentHotUpdateChunkFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateChunkFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this), + chunk: { + id: "\" + chunkId + \"", + hash: "\" + " + JSON.stringify(chunkMaps.hash) + "[chunkId] + \"", + hashWithLength: function(length) { + var shortChunkHashMap = {}; + Object.keys(chunkMaps.hash).forEach(function(chunkId) { + if(typeof chunkMaps.hash[chunkId] === "string") + shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(0, length); + }); + return "\" + " + JSON.stringify(shortChunkHashMap) + "[chunkId] + \""; + }, + name: "\" + (" + JSON.stringify(chunkMaps.name) + "[chunkId]||chunkId) + \"" + } + }); + var currentHotUpdateMainFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateMainFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this) + }); + return Template.getFunctionContent(self.asyncChunkLoading ? require("./NodeMainTemplateAsync.runtime.js") : require("./NodeMainTemplate.runtime.js")) + .replace(/\$require\$/g, this.requireFn) + .replace(/\$hotMainFilename\$/g, currentHotUpdateMainFilename) + .replace(/\$hotChunkFilename\$/g, currentHotUpdateChunkFilename); + }); + mainTemplate.plugin("hash", function(hash) { + hash.update("node"); + hash.update("3"); + hash.update(this.outputOptions.filename + ""); + hash.update(this.outputOptions.chunkFilename + ""); + }); +}; diff --git a/node_modules/webpack/lib/node/NodeOutputFileSystem.js b/node_modules/webpack/lib/node/NodeOutputFileSystem.js new file mode 100644 index 000000000..5a6e328e1 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeOutputFileSystem.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const fs = require("fs"); +const path = require("path"); +const mkdirp = require("mkdirp"); + +class NodeOutputFileSystem { + constructor() { + this.mkdirp = mkdirp; + this.mkdir = fs.mkdir.bind(fs); + this.rmdir = fs.rmdir.bind(fs); + this.unlink = fs.unlink.bind(fs); + this.writeFile = fs.writeFile.bind(fs); + this.join = path.join.bind(path); + } +} + +module.exports = NodeOutputFileSystem; diff --git a/node_modules/webpack/lib/node/NodeSourcePlugin.js b/node_modules/webpack/lib/node/NodeSourcePlugin.js new file mode 100644 index 000000000..4e0716a25 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeSourcePlugin.js @@ -0,0 +1,84 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin"); +var ParserHelpers = require("../ParserHelpers"); +var nodeLibsBrowser = require("node-libs-browser"); + +function NodeSourcePlugin(options) { + this.options = options; +} +module.exports = NodeSourcePlugin; +NodeSourcePlugin.prototype.apply = function(compiler) { + var options = this.options; + + function getPathToModule(module, type) { + if(type === true || (type === undefined && nodeLibsBrowser[module])) { + if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available"); + return nodeLibsBrowser[module]; + } else if(type === "mock") { + return require.resolve("node-libs-browser/mock/" + module); + } else if(type === "empty") { + return require.resolve("node-libs-browser/mock/empty"); + } else return module; + } + + function addExpression(parser, name, module, type, suffix) { + suffix = suffix || ""; + parser.plugin("expression " + name, function() { + if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return; + var mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type)); + return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix); + }); + } + + compiler.plugin("compilation", function(compilation, params) { + params.normalModuleFactory.plugin("parser", function(parser, parserOptions) { + + if(parserOptions.node === false) + return; + + var localOptions = options; + if(parserOptions.node) + localOptions = Object.assign({}, localOptions, parserOptions.node); + + if(localOptions.global) { + parser.plugin("expression global", function() { + var retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js")); + return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule); + }); + } + if(localOptions.process) { + var processType = localOptions.process; + addExpression(parser, "process", "process", processType); + } + if(localOptions.console) { + var consoleType = localOptions.console; + addExpression(parser, "console", "console", consoleType); + } + var bufferType = localOptions.Buffer; + if(bufferType) { + addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer"); + } + if(localOptions.setImmediate) { + var setImmediateType = localOptions.setImmediate; + addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate"); + addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate"); + } + }); + }); + compiler.plugin("after-resolvers", function(compiler) { + Object.keys(nodeLibsBrowser).forEach(function(lib) { + if(options[lib] !== false) { + compiler.resolvers.normal.apply( + new AliasPlugin("described-resolve", { + name: lib, + onlyModule: true, + alias: getPathToModule(lib, options[lib]) + }, "resolve") + ); + } + }); + }); +}; diff --git a/node_modules/webpack/lib/node/NodeTargetPlugin.js b/node_modules/webpack/lib/node/NodeTargetPlugin.js new file mode 100644 index 000000000..528a28570 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeTargetPlugin.js @@ -0,0 +1,15 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const ExternalsPlugin = require("../ExternalsPlugin"); + +class NodeTargetPlugin { + apply(compiler) { + new ExternalsPlugin("commonjs", Object.keys(process.binding("natives"))).apply(compiler); + } +} + +module.exports = NodeTargetPlugin; diff --git a/node_modules/webpack/lib/node/NodeTemplatePlugin.js b/node_modules/webpack/lib/node/NodeTemplatePlugin.js new file mode 100644 index 000000000..ed17d1937 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeTemplatePlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const NodeMainTemplatePlugin = require("./NodeMainTemplatePlugin"); +const NodeChunkTemplatePlugin = require("./NodeChunkTemplatePlugin"); +const NodeHotUpdateChunkTemplatePlugin = require("./NodeHotUpdateChunkTemplatePlugin"); + +class NodeTemplatePlugin { + constructor(options) { + options = options || {}; + this.asyncChunkLoading = options.asyncChunkLoading; + } + + apply(compiler) { + compiler.plugin("this-compilation", (compilation) => { + compilation.mainTemplate.apply(new NodeMainTemplatePlugin(this.asyncChunkLoading)); + compilation.chunkTemplate.apply(new NodeChunkTemplatePlugin()); + compilation.hotUpdateChunkTemplate.apply(new NodeHotUpdateChunkTemplatePlugin()); + }); + } +} + +module.exports = NodeTemplatePlugin; diff --git a/node_modules/webpack/lib/node/NodeWatchFileSystem.js b/node_modules/webpack/lib/node/NodeWatchFileSystem.js new file mode 100644 index 000000000..a4ff6c6b5 --- /dev/null +++ b/node_modules/webpack/lib/node/NodeWatchFileSystem.js @@ -0,0 +1,72 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Watchpack = require("watchpack"); + +class NodeWatchFileSystem { + constructor(inputFileSystem) { + this.inputFileSystem = inputFileSystem; + this.watcherOptions = { + aggregateTimeout: 0 + }; + this.watcher = new Watchpack(this.watcherOptions); + } + + watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) { + if(!Array.isArray(files)) + throw new Error("Invalid arguments: 'files'"); + if(!Array.isArray(dirs)) + throw new Error("Invalid arguments: 'dirs'"); + if(!Array.isArray(missing)) + throw new Error("Invalid arguments: 'missing'"); + if(typeof callback !== "function") + throw new Error("Invalid arguments: 'callback'"); + if(typeof startTime !== "number" && startTime) + throw new Error("Invalid arguments: 'startTime'"); + if(typeof options !== "object") + throw new Error("Invalid arguments: 'options'"); + if(typeof callbackUndelayed !== "function" && callbackUndelayed) + throw new Error("Invalid arguments: 'callbackUndelayed'"); + const oldWatcher = this.watcher; + this.watcher = new Watchpack(options); + + if(callbackUndelayed) + this.watcher.once("change", callbackUndelayed); + + this.watcher.once("aggregated", (changes, removals) => { + changes = changes.concat(removals); + if(this.inputFileSystem && this.inputFileSystem.purge) { + this.inputFileSystem.purge(changes); + } + const times = this.watcher.getTimes(); + callback(null, + changes.filter(file => files.indexOf(file) >= 0).sort(), + changes.filter(file => dirs.indexOf(file) >= 0).sort(), + changes.filter(file => missing.indexOf(file) >= 0).sort(), times, times); + }); + + this.watcher.watch(files.concat(missing), dirs, startTime); + + if(oldWatcher) { + oldWatcher.close(); + } + return { + close: () => { + if(this.watcher) { + this.watcher.close(); + this.watcher = null; + } + }, + pause: () => { + if(this.watcher) { + this.watcher.pause(); + } + } + }; + } +} + +module.exports = NodeWatchFileSystem; diff --git a/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js b/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js new file mode 100644 index 000000000..826a6baa9 --- /dev/null +++ b/node_modules/webpack/lib/optimize/AggressiveMergingPlugin.js @@ -0,0 +1,121 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class AggressiveMergingPlugin { + constructor(options) { + if(options !== undefined && typeof options !== "object" || Array.isArray(options)) { + throw new Error("Argument should be an options object. To use defaults, pass in nothing.\nFor more info on options, see https://webpack.js.org/plugins/"); + } + this.options = options || {}; + } + + apply(compiler) { + const options = this.options; + const minSizeReduce = options.minSizeReduce || 1.5; + + function getParentsWeight(chunk) { + return chunk.parents.map((p) => { + return p.isInitial() ? options.entryChunkMultiplicator || 10 : 1; + }).reduce((a, b) => { + return a + b; + }, 0); + } + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunks-advanced", (chunks) => { + let combinations = []; + chunks.forEach((a, idx) => { + if(a.isInitial()) return; + for(let i = 0; i < idx; i++) { + const b = chunks[i]; + if(b.isInitial()) continue; + combinations.push([b, a]); + } + }); + + combinations.forEach((pair) => { + const a = pair[0].size({ + chunkOverhead: 0 + }); + const b = pair[1].size({ + chunkOverhead: 0 + }); + const ab = pair[0].integratedSize(pair[1], { + chunkOverhead: 0 + }); + pair.push({ + a: a, + b: b, + ab: ab + }); + let newSize; + if(ab === false) { + pair.unshift(false); + } else if(options.moveToParents) { + const aOnly = ab - b; + const bOnly = ab - a; + const common = a + b - ab; + newSize = common + getParentsWeight(pair[0]) * aOnly + getParentsWeight(pair[1]) * bOnly; + pair.push({ + aOnly: aOnly, + bOnly: bOnly, + common: common, + newSize: newSize + }); + } else { + newSize = ab; + } + + pair.unshift((a + b) / newSize); + }); + combinations = combinations.filter((pair) => { + return pair[0] !== false; + }); + combinations.sort((a, b) => { + return b[0] - a[0]; + }); + + const pair = combinations[0]; + + if(!pair) return; + if(pair[0] < minSizeReduce) return; + + if(options.moveToParents) { + const commonModules = pair[1].modules.filter((m) => { + return pair[2].modules.indexOf(m) >= 0; + }); + const aOnlyModules = pair[1].modules.filter((m) => { + return commonModules.indexOf(m) < 0; + }); + const bOnlyModules = pair[2].modules.filter((m) => { + return commonModules.indexOf(m) < 0; + }); + aOnlyModules.forEach((m) => { + pair[1].removeModule(m); + m.removeChunk(pair[1]); + pair[1].parents.forEach((c) => { + c.addModule(m); + m.addChunk(c); + }); + }); + bOnlyModules.forEach((m) => { + pair[2].removeModule(m); + m.removeChunk(pair[2]); + pair[2].parents.forEach((c) => { + c.addModule(m); + m.addChunk(c); + }); + }); + } + if(pair[1].integrate(pair[2], "aggressive-merge")) { + chunks.splice(chunks.indexOf(pair[2]), 1); + return true; + } + }); + }); + } +} + +module.exports = AggressiveMergingPlugin; diff --git a/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js b/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js new file mode 100644 index 000000000..e05b3eb4c --- /dev/null +++ b/node_modules/webpack/lib/optimize/AggressiveSplittingPlugin.js @@ -0,0 +1,192 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const identifierUtils = require("../util/identifier"); + +function toIndexOf(list) { + return function(item) { + return list.indexOf(item); + }; +} + +function toChunkModuleIndices(modules) { + return function(idx) { + return modules[idx]; + }; +} + +function moveModuleBetween(oldChunk, newChunk) { + return function(module) { + oldChunk.moveModule(module, newChunk); + }; +} + +function isNotAEntryModule(entryModule) { + return function(module) { + return entryModule !== module; + }; +} + +function copyWithReason(obj) { + const newObj = {}; + Object.keys(obj).forEach((key) => { + newObj[key] = obj[key]; + }); + if(!newObj.reasons || newObj.reasons.indexOf("aggressive-splitted") < 0) + newObj.reasons = (newObj.reasons || []).concat("aggressive-splitted"); + return newObj; +} + +class AggressiveSplittingPlugin { + constructor(options) { + this.options = options || {}; + if(typeof this.options.minSize !== "number") this.options.minSize = 30 * 1024; + if(typeof this.options.maxSize !== "number") this.options.maxSize = 50 * 1024; + if(typeof this.options.chunkOverhead !== "number") this.options.chunkOverhead = 0; + if(typeof this.options.entryChunkMultiplicator !== "number") this.options.entryChunkMultiplicator = 1; + } + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunks-advanced", (chunks) => { + const savedSplits = compilation.records && compilation.records.aggressiveSplits || []; + const usedSplits = compilation._aggressiveSplittingSplits ? + savedSplits.concat(compilation._aggressiveSplittingSplits) : savedSplits; + + const minSize = this.options.minSize; + const maxSize = this.options.maxSize; + // 1. try to restore to recorded splitting + for(let j = 0; j < usedSplits.length; j++) { + const splitData = usedSplits[j]; + for(let i = 0; i < chunks.length; i++) { + const chunk = chunks[i]; + const chunkModuleNames = chunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier())); + + if(chunkModuleNames.length < splitData.modules.length) + continue; + const moduleIndicies = splitData.modules.map(toIndexOf(chunkModuleNames)); + const hasAllModules = moduleIndicies.every((idx) => { + return idx >= 0; + }); + if(hasAllModules) { + if(chunkModuleNames.length > splitData.modules.length) { + const selectedModules = moduleIndicies.map(toChunkModuleIndices(chunk.modules)); + const newChunk = compilation.addChunk(); + selectedModules.forEach(moveModuleBetween(chunk, newChunk)); + chunk.split(newChunk); + chunk.name = null; + newChunk._fromAggressiveSplitting = true; + if(j < savedSplits.length) + newChunk._fromAggressiveSplittingIndex = j; + if(splitData.id !== null && splitData.id !== undefined) { + newChunk.id = splitData.id; + } + newChunk.origins = chunk.origins.map(copyWithReason); + chunk.origins = chunk.origins.map(copyWithReason); + return true; + } else { + if(j < savedSplits.length) + chunk._fromAggressiveSplittingIndex = j; + chunk.name = null; + if(splitData.id !== null && splitData.id !== undefined) { + chunk.id = splitData.id; + } + } + } + } + } + // 2. for any other chunk which isn't splitted yet, split it + for(let i = 0; i < chunks.length; i++) { + const chunk = chunks[i]; + const size = chunk.size(this.options); + if(size > maxSize && chunk.modules.length > 1) { + const newChunk = compilation.addChunk(); + const modules = chunk.modules + .filter(isNotAEntryModule(chunk.entryModule)) + .sort((a, b) => { + a = a.identifier(); + b = b.identifier(); + if(a > b) return 1; + if(a < b) return -1; + return 0; + }); + for(let k = 0; k < modules.length; k++) { + chunk.moveModule(modules[k], newChunk); + const newSize = newChunk.size(this.options); + const chunkSize = chunk.size(this.options); + // break early if it's fine + if(chunkSize < maxSize && newSize < maxSize && newSize >= minSize && chunkSize >= minSize) + break; + if(newSize > maxSize && k === 0) { + // break if there is a single module which is bigger than maxSize + break; + } + if(newSize > maxSize || chunkSize < minSize) { + // move it back + newChunk.moveModule(modules[k], chunk); + // check if it's fine now + if(newSize < maxSize && newSize >= minSize && chunkSize >= minSize) + break; + } + } + if(newChunk.modules.length > 0) { + chunk.split(newChunk); + chunk.name = null; + newChunk.origins = chunk.origins.map(copyWithReason); + chunk.origins = chunk.origins.map(copyWithReason); + compilation._aggressiveSplittingSplits = (compilation._aggressiveSplittingSplits || []).concat({ + modules: newChunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier())) + }); + return true; + } else { + chunks.splice(chunks.indexOf(newChunk), 1); + } + } + } + }); + compilation.plugin("record-hash", (records) => { + // 3. save to made splittings to records + const minSize = this.options.minSize; + if(!records.aggressiveSplits) records.aggressiveSplits = []; + compilation.chunks.forEach((chunk) => { + if(chunk.hasEntryModule()) return; + const size = chunk.size(this.options); + const incorrectSize = size < minSize; + const modules = chunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier())); + if(typeof chunk._fromAggressiveSplittingIndex === "undefined") { + if(incorrectSize) return; + chunk.recorded = true; + records.aggressiveSplits.push({ + modules: modules, + hash: chunk.hash, + id: chunk.id + }); + } else { + const splitData = records.aggressiveSplits[chunk._fromAggressiveSplittingIndex]; + if(splitData.hash !== chunk.hash || incorrectSize) { + if(chunk._fromAggressiveSplitting) { + chunk._aggressiveSplittingInvalid = true; + splitData.invalid = true; + } else { + splitData.hash = chunk.hash; + } + } + } + }); + records.aggressiveSplits = records.aggressiveSplits.filter((splitData) => { + return !splitData.invalid; + }); + }); + compilation.plugin("need-additional-seal", (callback) => { + const invalid = compilation.chunks.some((chunk) => { + return chunk._aggressiveSplittingInvalid; + }); + if(invalid) + return true; + }); + }); + } +} +module.exports = AggressiveSplittingPlugin; diff --git a/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js b/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js new file mode 100644 index 000000000..8166fc315 --- /dev/null +++ b/node_modules/webpack/lib/optimize/ChunkModuleIdRangePlugin.js @@ -0,0 +1,55 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +class ChunkModuleIdRangePlugin { + constructor(options) { + this.options = options; + } + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation) => { + compilation.plugin("module-ids", (modules) => { + const chunk = this.chunks.filter((chunk) => { + return chunk.name === options.name; + })[0]; + if(!chunk) throw new Error("ChunkModuleIdRangePlugin: Chunk with name '" + options.name + "' was not found"); + let currentId = options.start; + let chunkModules; + if(options.order) { + chunkModules = chunk.modules.slice(); + switch(options.order) { + case "index": + chunkModules.sort((a, b) => { + return a.index - b.index; + }); + break; + case "index2": + chunkModules.sort((a, b) => { + return a.index2 - b.index2; + }); + break; + default: + throw new Error("ChunkModuleIdRangePlugin: unexpected value of order"); + } + + } else { + chunkModules = modules.filter((m) => { + return m.chunks.indexOf(chunk) >= 0; + }); + } + + for(let i = 0; i < chunkModules.length; i++) { + const m = chunkModules[i]; + if(m.id === null) { + m.id = currentId++; + } + if(options.end && currentId > options.end) + break; + } + }); + }); + } +} +module.exports = ChunkModuleIdRangePlugin; diff --git a/node_modules/webpack/lib/optimize/CommonsChunkPlugin.js b/node_modules/webpack/lib/optimize/CommonsChunkPlugin.js new file mode 100644 index 000000000..d7c4849fe --- /dev/null +++ b/node_modules/webpack/lib/optimize/CommonsChunkPlugin.js @@ -0,0 +1,362 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +let nextIdent = 0; +class CommonsChunkPlugin { + constructor(options) { + if(arguments.length > 1) { + throw new Error(`Deprecation notice: CommonsChunkPlugin now only takes a single argument. Either an options +object *or* the name of the chunk. +Example: if your old code looked like this: + new webpack.optimize.CommonsChunkPlugin('vendor', 'vendor.bundle.js') +You would change it to: + new webpack.optimize.CommonsChunkPlugin({ name: 'vendor', filename: 'vendor.bundle.js' }) +The available options are: + name: string + names: string[] + filename: string + minChunks: number + chunks: string[] + children: boolean + async: boolean + minSize: number`); + } + + const normalizedOptions = this.normalizeOptions(options); + + this.chunkNames = normalizedOptions.chunkNames; + this.filenameTemplate = normalizedOptions.filenameTemplate; + this.minChunks = normalizedOptions.minChunks; + this.selectedChunks = normalizedOptions.selectedChunks; + this.children = normalizedOptions.children; + this.async = normalizedOptions.async; + this.minSize = normalizedOptions.minSize; + this.ident = __filename + (nextIdent++); + } + + normalizeOptions(options) { + if(Array.isArray(options)) { + return { + chunkNames: options, + }; + } + + if(typeof options === "string") { + return { + chunkNames: [options], + }; + } + + // options.children and options.chunk may not be used together + if(options.children && options.chunks) { + throw new Error("You can't and it does not make any sense to use \"children\" and \"chunk\" options together."); + } + + /** + * options.async and options.filename are also not possible together + * as filename specifies how the chunk is called but "async" implies + * that webpack will take care of loading this file. + */ + if(options.async && options.filename) { + throw new Error(`You can not specify a filename if you use the \"async\" option. +You can however specify the name of the async chunk by passing the desired string as the \"async\" option.`); + } + + /** + * Make sure this is either an array or undefined. + * "name" can be a string and + * "names" a string or an array + */ + const chunkNames = options.name || options.names ? [].concat(options.name || options.names) : undefined; + return { + chunkNames: chunkNames, + filenameTemplate: options.filename, + minChunks: options.minChunks, + selectedChunks: options.chunks, + children: options.children, + async: options.async, + minSize: options.minSize + }; + } + + apply(compiler) { + compiler.plugin("this-compilation", (compilation) => { + compilation.plugin(["optimize-chunks", "optimize-extracted-chunks"], (chunks) => { + // only optimize once + if(compilation[this.ident]) return; + compilation[this.ident] = true; + + /** + * Creates a list of "common"" chunks based on the options. + * The list is made up of preexisting or newly created chunks. + * - If chunk has the name as specified in the chunkNames it is put in the list + * - If no chunk with the name as given in chunkNames exists a new chunk is created and added to the list + * + * These chunks are the "targets" for extracted modules. + */ + const targetChunks = this.getTargetChunks(chunks, compilation, this.chunkNames, this.children, this.async); + + // iterate over all our new chunks + targetChunks.forEach((targetChunk, idx) => { + + /** + * These chunks are subject to get "common" modules extracted and moved to the common chunk + */ + const affectedChunks = this.getAffectedChunks(compilation, chunks, targetChunk, targetChunks, idx, this.selectedChunks, this.async, this.children); + + // bail if no chunk is affected + if(!affectedChunks) { + return; + } + + // If we are async create an async chunk now + // override the "commonChunk" with the newly created async one and use it as commonChunk from now on + let asyncChunk; + if(this.async) { + asyncChunk = this.createAsyncChunk(compilation, this.async, targetChunk); + targetChunk = asyncChunk; + } + + /** + * Check which modules are "common" and could be extracted to a "common" chunk + */ + const extractableModules = this.getExtractableModules(this.minChunks, affectedChunks, targetChunk); + + // If the minSize option is set check if the size extracted from the chunk is reached + // else bail out here. + // As all modules/commons are interlinked with each other, common modules would be extracted + // if we reach this mark at a later common chunk. (quirky I guess). + if(this.minSize) { + const modulesSize = this.calculateModulesSize(extractableModules); + // if too small, bail + if(modulesSize < this.minSize) + return; + } + + // Remove modules that are moved to commons chunk from their original chunks + // return all chunks that are affected by having modules removed - we need them later (apparently) + const chunksWithExtractedModules = this.extractModulesAndReturnAffectedChunks(extractableModules, affectedChunks); + + // connect all extracted modules with the common chunk + this.addExtractedModulesToTargetChunk(targetChunk, extractableModules); + + // set filenameTemplate for chunk + if(this.filenameTemplate) + targetChunk.filenameTemplate = this.filenameTemplate; + + // if we are async connect the blocks of the "reallyUsedChunk" - the ones that had modules removed - + // with the commonChunk and get the origins for the asyncChunk (remember "asyncChunk === commonChunk" at this moment). + // bail out + if(this.async) { + this.moveExtractedChunkBlocksToTargetChunk(chunksWithExtractedModules, targetChunk); + asyncChunk.origins = this.extractOriginsOfChunksWithExtractedModules(chunksWithExtractedModules); + return; + } + + // we are not in "async" mode + // connect used chunks with commonChunk - shouldnt this be reallyUsedChunks here? + this.makeTargetChunkParentOfAffectedChunks(affectedChunks, targetChunk); + }); + return true; + }); + }); + } + + getTargetChunks(allChunks, compilation, chunkNames, children, asyncOption) { + const asyncOrNoSelectedChunk = children || asyncOption; + + // we have specified chunk names + if(chunkNames) { + // map chunks by chunkName for quick access + const allChunksNameMap = allChunks.reduce((map, chunk) => { + if(chunk.name) { + map.set(chunk.name, chunk); + } + return map; + }, new Map()); + + // Ensure we have a chunk per specified chunk name. + // Reuse existing chunks if possible + return chunkNames.map(chunkName => { + if(allChunksNameMap.has(chunkName)) { + return allChunksNameMap.get(chunkName); + } + // add the filtered chunks to the compilation + return compilation.addChunk(chunkName); + }); + } + + // we dont have named chunks specified, so we just take all of them + if(asyncOrNoSelectedChunk) { + return allChunks; + } + + /** + * No chunk name(s) was specified nor is this an async/children commons chunk + */ + throw new Error(`You did not specify any valid target chunk settings. +Take a look at the "name"/"names" or async/children option.`); + } + + getAffectedChunks(compilation, allChunks, targetChunk, targetChunks, currentIndex, selectedChunks, asyncOption, children) { + const asyncOrNoSelectedChunk = children || asyncOption; + + if(Array.isArray(selectedChunks)) { + return allChunks.filter(chunk => { + const notCommmonChunk = chunk !== targetChunk; + const isSelectedChunk = selectedChunks.indexOf(chunk.name) > -1; + return notCommmonChunk && isSelectedChunk; + }); + } + + if(asyncOrNoSelectedChunk) { + // nothing to do here + if(!targetChunk.chunks) { + return []; + } + + return targetChunk.chunks.filter((chunk) => { + // we can only move modules from this chunk if the "commonChunk" is the only parent + return asyncOption || chunk.parents.length === 1; + }); + } + + /** + * past this point only entry chunks are allowed to become commonChunks + */ + if(targetChunk.parents.length > 0) { + compilation.errors.push(new Error("CommonsChunkPlugin: While running in normal mode it's not allowed to use a non-entry chunk (" + targetChunk.name + ")")); + return; + } + + /** + * If we find a "targetchunk" that is also a normal chunk (meaning it is probably specified as an entry) + * and the current target chunk comes after that and the found chunk has a runtime* + * make that chunk be an 'affected' chunk of the current target chunk. + * + * To understand what that means take a look at the "examples/chunkhash", this basically will + * result in the runtime to be extracted to the current target chunk. + * + * *runtime: the "runtime" is the "webpack"-block you may have seen in the bundles that resolves modules etc. + */ + return allChunks.filter((chunk) => { + const found = targetChunks.indexOf(chunk); + if(found >= currentIndex) return false; + return chunk.hasRuntime(); + }); + } + + createAsyncChunk(compilation, asyncOption, targetChunk) { + const asyncChunk = compilation.addChunk(typeof asyncOption === "string" ? asyncOption : undefined); + asyncChunk.chunkReason = "async commons chunk"; + asyncChunk.extraAsync = true; + asyncChunk.addParent(targetChunk); + targetChunk.addChunk(asyncChunk); + return asyncChunk; + } + + // If minChunks is a function use that + // otherwhise check if a module is used at least minChunks or 2 or usedChunks.length time + getModuleFilter(minChunks, targetChunk, usedChunksLength) { + if(typeof minChunks === "function") { + return minChunks; + } + const minCount = (minChunks || Math.max(2, usedChunksLength)); + const isUsedAtLeastMinTimes = (module, count) => count >= minCount; + return isUsedAtLeastMinTimes; + } + + getExtractableModules(minChunks, usedChunks, targetChunk) { + if(minChunks === Infinity) { + return []; + } + + // count how many chunks contain a module + const commonModulesToCountMap = usedChunks.reduce((map, chunk) => { + for(let module of chunk.modules) { + const count = map.has(module) ? map.get(module) : 0; + map.set(module, count + 1); + } + return map; + }, new Map()); + + // filter by minChunks + const moduleFilterCount = this.getModuleFilter(minChunks, targetChunk, usedChunks.length); + // filter by condition + const moduleFilterCondition = (module, chunk) => { + if(!module.chunkCondition) { + return true; + } + return module.chunkCondition(chunk); + }; + + return Array.from(commonModulesToCountMap).filter(entry => { + const module = entry[0]; + const count = entry[1]; + // if the module passes both filters, keep it. + return moduleFilterCount(module, count) && moduleFilterCondition(module, targetChunk); + }).map(entry => entry[0]); + } + + calculateModulesSize(modules) { + return modules.reduce((totalSize, module) => totalSize + module.size(), 0); + } + + extractModulesAndReturnAffectedChunks(reallyUsedModules, usedChunks) { + return reallyUsedModules.reduce((affectedChunksSet, module) => { + for(let chunk of usedChunks) { + // removeChunk returns true if the chunk was contained and succesfully removed + // false if the module did not have a connection to the chunk in question + if(module.removeChunk(chunk)) { + affectedChunksSet.add(chunk); + } + } + return affectedChunksSet; + }, new Set()); + } + + addExtractedModulesToTargetChunk(chunk, modules) { + for(let module of modules) { + chunk.addModule(module); + module.addChunk(chunk); + } + } + + makeTargetChunkParentOfAffectedChunks(usedChunks, commonChunk) { + for(let chunk of usedChunks) { + // set commonChunk as new sole parent + chunk.parents = [commonChunk]; + // add chunk to commonChunk + commonChunk.addChunk(chunk); + + for(let entrypoint of chunk.entrypoints) { + entrypoint.insertChunk(commonChunk, chunk); + } + } + } + + moveExtractedChunkBlocksToTargetChunk(chunks, targetChunk) { + for(let chunk of chunks) { + for(let block of chunk.blocks) { + block.chunks.unshift(targetChunk); + targetChunk.addBlock(block); + } + } + } + + extractOriginsOfChunksWithExtractedModules(chunks) { + const origins = []; + for(let chunk of chunks) { + for(let origin of chunk.origins) { + const newOrigin = Object.create(origin); + newOrigin.reasons = (origin.reasons || []).concat("async commons"); + origins.push(newOrigin); + } + } + return origins; + } +} + +module.exports = CommonsChunkPlugin; diff --git a/node_modules/webpack/lib/optimize/DedupePlugin.js b/node_modules/webpack/lib/optimize/DedupePlugin.js new file mode 100644 index 000000000..cffa43aaf --- /dev/null +++ b/node_modules/webpack/lib/optimize/DedupePlugin.js @@ -0,0 +1,15 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class DedupePlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.warnings.push(new Error("DedupePlugin: This plugin was removed from webpack. Remove it from your configuration.")); + }); + } +} + +module.exports = DedupePlugin; diff --git a/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js b/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js new file mode 100644 index 000000000..71ee18533 --- /dev/null +++ b/node_modules/webpack/lib/optimize/EnsureChunkConditionsPlugin.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class EnsureChunkConditionsPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => { + let changed = false; + chunks.forEach((chunk) => { + chunk.modules.slice().forEach((module) => { + if(!module.chunkCondition) return; + if(!module.chunkCondition(chunk)) { + const usedChunks = module._EnsureChunkConditionsPlugin_usedChunks = (module._EnsureChunkConditionsPlugin_usedChunks || []).concat(chunk); + const newChunks = []; + chunk.parents.forEach((parent) => { + if(usedChunks.indexOf(parent) < 0) { + parent.addModule(module); + newChunks.push(parent); + } + }); + module.rewriteChunkInReasons(chunk, newChunks); + chunk.removeModule(module); + changed = true; + } + }); + }); + if(changed) return true; + }); + }); + } +} +module.exports = EnsureChunkConditionsPlugin; diff --git a/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js b/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js new file mode 100644 index 000000000..e8b5a9457 --- /dev/null +++ b/node_modules/webpack/lib/optimize/FlagIncludedChunksPlugin.js @@ -0,0 +1,35 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class FlagIncludedChunksPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunk-ids", (chunks) => { + chunks.forEach((chunkA) => { + chunks.forEach((chunkB) => { + // as we iterate the same iterables twice + // skip if we find ourselves + if(chunkA === chunkB) return; + + // instead of swapping A and B just bail + // as we loop twice the current A will be B and B then A + if(chunkA.modules.length < chunkB.modules.length) return; + + if(chunkB.modules.length === 0) return; + + // is chunkB in chunkA? + for(let i = 0; i < chunkB.modules.length; i++) { + if(chunkA.modules.indexOf(chunkB.modules[i]) < 0) return; + } + chunkA.ids.push(chunkB.id); + }); + }); + }); + }); + } +} +module.exports = FlagIncludedChunksPlugin; diff --git a/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js b/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js new file mode 100644 index 000000000..c156338ff --- /dev/null +++ b/node_modules/webpack/lib/optimize/LimitChunkCountPlugin.js @@ -0,0 +1,59 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class LimitChunkCountPlugin { + constructor(options) { + if(options !== undefined && typeof options !== "object" || Array.isArray(options)) { + throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/"); + } + this.options = options || {}; + } + apply(compiler) { + const options = this.options; + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunks-advanced", (chunks) => { + const maxChunks = options.maxChunks; + if(!maxChunks) return; + if(maxChunks < 1) return; + if(chunks.length <= maxChunks) return; + + if(chunks.length > maxChunks) { + const sortedExtendedPairCombinations = chunks.reduce((combinations, a, idx) => { + // create combination pairs + for(let i = 0; i < idx; i++) { + const b = chunks[i]; + combinations.push([b, a]); + } + return combinations; + }, []).map((pair) => { + // extend combination pairs with size and integrated size + const a = pair[0].size(options); + const b = pair[1].size(options); + const ab = pair[0].integratedSize(pair[1], options); + return [a + b - ab, ab, pair[0], pair[1], a, b]; + }).filter((extendedPair) => { + // filter pairs that do not have an integratedSize + // meaning they can NOT be integrated! + return extendedPair[1] !== false; + }).sort((a, b) => { // sadly javascript does an inplace sort here + // sort them by size + const diff = b[0] - a[0]; + if(diff !== 0) return diff; + return a[1] - b[1]; + }); + + const pair = sortedExtendedPairCombinations[0]; + + if(pair && pair[2].integrate(pair[3], "limit")) { + chunks.splice(chunks.indexOf(pair[3]), 1); + return true; + } + } + }); + }); + } +} +module.exports = LimitChunkCountPlugin; diff --git a/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js b/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js new file mode 100644 index 000000000..90df06b51 --- /dev/null +++ b/node_modules/webpack/lib/optimize/MergeDuplicateChunksPlugin.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +function getChunkIdentifier(chunk) { + return chunk.modules.map((m) => { + return m.identifier(); + }).sort().join(", "); +} + +class MergeDuplicateChunksPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunks-basic", (chunks) => { + const map = {}; + chunks.slice().forEach((chunk) => { + if(chunk.hasRuntime() || chunk.hasEntryModule()) return; + const ident = getChunkIdentifier(chunk); + if(map[ident]) { + if(map[ident].integrate(chunk, "duplicate")) + chunks.splice(chunks.indexOf(chunk), 1); + return; + } + map[ident] = chunk; + }); + }); + }); + } +} +module.exports = MergeDuplicateChunksPlugin; diff --git a/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js b/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js new file mode 100644 index 000000000..87a4c21af --- /dev/null +++ b/node_modules/webpack/lib/optimize/MinChunkSizePlugin.js @@ -0,0 +1,65 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class MinChunkSizePlugin { + constructor(options) { + if(typeof options !== "object" || Array.isArray(options)) { + throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/"); + } + this.options = options; + } + + apply(compiler) { + const options = this.options; + const minChunkSize = options.minChunkSize; + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-chunks-advanced", (chunks) => { + const equalOptions = { + chunkOverhead: 1, + entryChunkMultiplicator: 1 + }; + + const sortedSizeFilteredExtendedPairCombinations = chunks.reduce((combinations, a, idx) => { + // create combination pairs + for(let i = 0; i < idx; i++) { + const b = chunks[i]; + combinations.push([b, a]); + } + return combinations; + }, []).filter((pair) => { + // check if one of the chunks sizes is smaller than the minChunkSize + const p0SmallerThanMinChunkSize = pair[0].size(equalOptions) < minChunkSize; + const p1SmallerThanMinChunkSize = pair[1].size(equalOptions) < minChunkSize; + return p0SmallerThanMinChunkSize || p1SmallerThanMinChunkSize; + }).map((pair) => { + // extend combination pairs with size and integrated size + const a = pair[0].size(options); + const b = pair[1].size(options); + const ab = pair[0].integratedSize(pair[1], options); + return [a + b - ab, ab, pair[0], pair[1]]; + }).filter((pair) => { + // filter pairs that do not have an integratedSize + // meaning they can NOT be integrated! + return pair[1] !== false; + }).sort((a, b) => { // sadly javascript does an inplace sort here + // sort by size + const diff = b[0] - a[0]; + if(diff !== 0) return diff; + return a[1] - b[1]; + }); + + if(sortedSizeFilteredExtendedPairCombinations.length === 0) return; + + const pair = sortedSizeFilteredExtendedPairCombinations[0]; + + pair[2].integrate(pair[3], "min-size"); + chunks.splice(chunks.indexOf(pair[3]), 1); + return true; + }); + }); + } +} +module.exports = MinChunkSizePlugin; diff --git a/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js b/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js new file mode 100644 index 000000000..a6bb30b34 --- /dev/null +++ b/node_modules/webpack/lib/optimize/OccurrenceOrderPlugin.js @@ -0,0 +1,116 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class OccurrenceOrderPlugin { + constructor(preferEntry) { + if(preferEntry !== undefined && typeof preferEntry !== "boolean") { + throw new Error("Argument should be a boolean.\nFor more info on this plugin, see https://webpack.js.org/plugins/"); + } + this.preferEntry = preferEntry; + } + apply(compiler) { + const preferEntry = this.preferEntry; + compiler.plugin("compilation", (compilation) => { + compilation.plugin("optimize-module-order", (modules) => { + function entryChunks(m) { + return m.chunks.map((c) => { + const sum = (c.isInitial() ? 1 : 0) + (c.entryModule === m ? 1 : 0); + return sum; + }).reduce((a, b) => { + return a + b; + }, 0); + } + + function occursInEntry(m) { + if(typeof m.__OccurenceOrderPlugin_occursInEntry === "number") return m.__OccurenceOrderPlugin_occursInEntry; + const result = m.reasons.map((r) => { + if(!r.module) return 0; + return entryChunks(r.module); + }).reduce((a, b) => { + return a + b; + }, 0) + entryChunks(m); + return m.__OccurenceOrderPlugin_occursInEntry = result; + } + + function occurs(m) { + if(typeof m.__OccurenceOrderPlugin_occurs === "number") return m.__OccurenceOrderPlugin_occurs; + const result = m.reasons.map((r) => { + if(!r.module) return 0; + return r.module.chunks.length; + }).reduce((a, b) => { + return a + b; + }, 0) + m.chunks.length + m.chunks.filter((c) => { + return c.entryModule === m; + }).length; + return m.__OccurenceOrderPlugin_occurs = result; + } + modules.sort((a, b) => { + if(preferEntry) { + const aEntryOccurs = occursInEntry(a); + const bEntryOccurs = occursInEntry(b); + if(aEntryOccurs > bEntryOccurs) return -1; + if(aEntryOccurs < bEntryOccurs) return 1; + } + const aOccurs = occurs(a); + const bOccurs = occurs(b); + if(aOccurs > bOccurs) return -1; + if(aOccurs < bOccurs) return 1; + if(a.identifier() > b.identifier()) return 1; + if(a.identifier() < b.identifier()) return -1; + return 0; + }); + // TODO refactor to Map + modules.forEach((m) => { + m.__OccurenceOrderPlugin_occursInEntry = undefined; + m.__OccurenceOrderPlugin_occurs = undefined; + }); + }); + compilation.plugin("optimize-chunk-order", (chunks) => { + function occursInEntry(c) { + if(typeof c.__OccurenceOrderPlugin_occursInEntry === "number") return c.__OccurenceOrderPlugin_occursInEntry; + const result = c.parents.filter((p) => { + return p.isInitial(); + }).length; + return c.__OccurenceOrderPlugin_occursInEntry = result; + } + + function occurs(c) { + return c.blocks.length; + } + chunks.forEach((c) => { + c.modules.sort((a, b) => { + if(a.identifier() > b.identifier()) return 1; + if(a.identifier() < b.identifier()) return -1; + return 0; + }); + }); + chunks.sort((a, b) => { + const aEntryOccurs = occursInEntry(a); + const bEntryOccurs = occursInEntry(b); + if(aEntryOccurs > bEntryOccurs) return -1; + if(aEntryOccurs < bEntryOccurs) return 1; + const aOccurs = occurs(a); + const bOccurs = occurs(b); + if(aOccurs > bOccurs) return -1; + if(aOccurs < bOccurs) return 1; + if(a.modules.length > b.modules.length) return -1; + if(a.modules.length < b.modules.length) return 1; + for(let i = 0; i < a.modules.length; i++) { + if(a.modules[i].identifier() > b.modules[i].identifier()) return -1; + if(a.modules[i].identifier() < b.modules[i].identifier()) return 1; + } + return 0; + }); + // TODO refactor to Map + chunks.forEach((c) => { + c.__OccurenceOrderPlugin_occursInEntry = undefined; + }); + }); + }); + } +} + +module.exports = OccurrenceOrderPlugin; diff --git a/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js b/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js new file mode 100644 index 000000000..4b75e4617 --- /dev/null +++ b/node_modules/webpack/lib/optimize/RemoveEmptyChunksPlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class RemoveEmptyChunksPlugin { + + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => { + chunks.filter((chunk) => chunk.isEmpty() && !chunk.hasRuntime() && !chunk.hasEntryModule()) + .forEach((chunk) => { + chunk.remove("empty"); + chunks.splice(chunks.indexOf(chunk), 1); + }); + }); + }); + } +} +module.exports = RemoveEmptyChunksPlugin; diff --git a/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js b/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js new file mode 100644 index 000000000..e73add989 --- /dev/null +++ b/node_modules/webpack/lib/optimize/RemoveParentModulesPlugin.js @@ -0,0 +1,91 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +function chunkContainsModule(chunk, module) { + const chunks = module.chunks; + const modules = chunk.modules; + if(chunks.length < modules.length) { + return chunks.indexOf(chunk) >= 0; + } else { + return modules.indexOf(module) >= 0; + } +} + +function hasModule(chunk, module, checkedChunks) { + if(chunkContainsModule(chunk, module)) return [chunk]; + if(chunk.parents.length === 0) return false; + return allHaveModule(chunk.parents.filter((c) => { + return checkedChunks.indexOf(c) < 0; + }), module, checkedChunks); +} + +function allHaveModule(someChunks, module, checkedChunks) { + if(!checkedChunks) checkedChunks = []; + var chunks = []; + for(var i = 0; i < someChunks.length; i++) { + checkedChunks.push(someChunks[i]); + var subChunks = hasModule(someChunks[i], module, checkedChunks); + if(!subChunks) return false; + + for(var index = 0; index < subChunks.length; index++) { + var item = subChunks[index]; + + if(!chunks.length || chunks.indexOf(item) < 0) { + chunks.push(item); + } + } + } + return chunks; +} + +function debugIds(chunks) { + var list = []; + for(var i = 0; i < chunks.length; i++) { + var debugId = chunks[i].debugId; + + if(typeof debugId !== "number") { + return "no"; + } + + list.push(debugId); + } + + list.sort(); + return list.join(","); +} + +class RemoveParentModulesPlugin { + apply(compiler) { + compiler.plugin("compilation", (compilation) => { + compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => { + for(var index = 0; index < chunks.length; index++) { + var chunk = chunks[index]; + if(chunk.parents.length === 0) continue; + + // TODO consider Map when performance has improved https://gist.github.com/sokra/b36098368da7b8f6792fd7c85fca6311 + var cache = Object.create(null); + var modules = chunk.modules.slice(); + for(var i = 0; i < modules.length; i++) { + var module = modules[i]; + + var dId = debugIds(module.chunks); + var parentChunksWithModule; + if((dId in cache) && dId !== "no") { + parentChunksWithModule = cache[dId]; + } else { + parentChunksWithModule = cache[dId] = allHaveModule(chunk.parents, module); + } + if(parentChunksWithModule) { + module.rewriteChunkInReasons(chunk, parentChunksWithModule); + chunk.removeModule(module); + } + } + } + }); + }); + } +} +module.exports = RemoveParentModulesPlugin; diff --git a/node_modules/webpack/lib/optimize/UglifyJsPlugin.js b/node_modules/webpack/lib/optimize/UglifyJsPlugin.js new file mode 100644 index 000000000..f95dc8eef --- /dev/null +++ b/node_modules/webpack/lib/optimize/UglifyJsPlugin.js @@ -0,0 +1,236 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const SourceMapConsumer = require("source-map").SourceMapConsumer; +const SourceMapSource = require("webpack-sources").SourceMapSource; +const RawSource = require("webpack-sources").RawSource; +const ConcatSource = require("webpack-sources").ConcatSource; +const RequestShortener = require("../RequestShortener"); +const ModuleFilenameHelpers = require("../ModuleFilenameHelpers"); +const uglify = require("uglify-js"); + +class UglifyJsPlugin { + constructor(options) { + if(typeof options !== "object" || Array.isArray(options)) options = {}; + if(typeof options.compressor !== "undefined") options.compress = options.compressor; + this.options = options; + } + + apply(compiler) { + const options = this.options; + options.test = options.test || /\.js($|\?)/i; + const warningsFilter = options.warningsFilter || (() => true); + + const requestShortener = new RequestShortener(compiler.context); + compiler.plugin("compilation", (compilation) => { + if(options.sourceMap) { + compilation.plugin("build-module", (module) => { + // to get detailed location info about errors + module.useSourceMap = true; + }); + } + compilation.plugin("optimize-chunk-assets", (chunks, callback) => { + const files = []; + chunks.forEach((chunk) => files.push.apply(files, chunk.files)); + files.push.apply(files, compilation.additionalChunkAssets); + const filterdFiles = files.filter(ModuleFilenameHelpers.matchObject.bind(undefined, options)); + filterdFiles.forEach((file) => { + const oldWarnFunction = uglify.AST_Node.warn_function; + const warnings = []; + let sourceMap; + try { + const asset = compilation.assets[file]; + if(asset.__UglifyJsPlugin) { + compilation.assets[file] = asset.__UglifyJsPlugin; + return; + } + let input; + let inputSourceMap; + if(options.sourceMap) { + if(asset.sourceAndMap) { + const sourceAndMap = asset.sourceAndMap(); + inputSourceMap = sourceAndMap.map; + input = sourceAndMap.source; + } else { + inputSourceMap = asset.map(); + input = asset.source(); + } + sourceMap = new SourceMapConsumer(inputSourceMap); + uglify.AST_Node.warn_function = (warning) => { // eslint-disable-line camelcase + const match = /\[.+:([0-9]+),([0-9]+)\]/.exec(warning); + const line = +match[1]; + const column = +match[2]; + const original = sourceMap.originalPositionFor({ + line: line, + column: column + }); + if(!original || !original.source || original.source === file) return; + if(!warningsFilter(original.source)) return; + warnings.push(warning.replace(/\[.+:([0-9]+),([0-9]+)\]/, "") + + "[" + requestShortener.shorten(original.source) + ":" + original.line + "," + original.column + "]"); + }; + } else { + input = asset.source(); + uglify.AST_Node.warn_function = (warning) => { // eslint-disable-line camelcase + warnings.push(warning); + }; + } + uglify.base54.reset(); + let ast = uglify.parse(input, { + filename: file + }); + if(options.compress !== false) { + ast.figure_out_scope(); + const compress = uglify.Compressor(options.compress || { + warnings: false + }); // eslint-disable-line new-cap + ast = compress.compress(ast); + } + if(options.mangle !== false) { + ast.figure_out_scope(options.mangle || {}); + ast.compute_char_frequency(options.mangle || {}); + ast.mangle_names(options.mangle || {}); + if(options.mangle && options.mangle.props) { + uglify.mangle_properties(ast, options.mangle.props); + } + } + const output = {}; + output.comments = Object.prototype.hasOwnProperty.call(options, "comments") ? options.comments : /^\**!|@preserve|@license/; + output.beautify = options.beautify; + for(let k in options.output) { + output[k] = options.output[k]; + } + const extractedComments = []; + if(options.extractComments) { + const condition = {}; + if(typeof options.extractComments === "string" || options.extractComments instanceof RegExp) { + // extractComments specifies the extract condition and output.comments specifies the preserve condition + condition.preserve = output.comments; + condition.extract = options.extractComments; + } else if(Object.prototype.hasOwnProperty.call(options.extractComments, "condition")) { + // Extract condition is given in extractComments.condition + condition.preserve = output.comments; + condition.extract = options.extractComments.condition; + } else { + // No extract condition is given. Extract comments that match output.comments instead of preserving them + condition.preserve = false; + condition.extract = output.comments; + } + + // Ensure that both conditions are functions + ["preserve", "extract"].forEach(key => { + switch(typeof condition[key]) { + case "boolean": + var b = condition[key]; + condition[key] = () => b; + break; + case "function": + break; + case "string": + if(condition[key] === "all") { + condition[key] = () => true; + break; + } + var regex = new RegExp(condition[key]); + condition[key] = (astNode, comment) => regex.test(comment.value); + break; + default: + regex = condition[key]; + condition[key] = (astNode, comment) => regex.test(comment.value); + } + }); + + // Redefine the comments function to extract and preserve + // comments according to the two conditions + output.comments = (astNode, comment) => { + if(condition.extract(astNode, comment)) { + extractedComments.push( + comment.type === "comment2" ? "/*" + comment.value + "*/" : "//" + comment.value + ); + } + return condition.preserve(astNode, comment); + }; + } + let map; + if(options.sourceMap) { + map = uglify.SourceMap({ // eslint-disable-line new-cap + file: file, + root: "" + }); + output.source_map = map; // eslint-disable-line camelcase + } + const stream = uglify.OutputStream(output); // eslint-disable-line new-cap + ast.print(stream); + if(map) map = map + ""; + const stringifiedStream = stream + ""; + let outputSource = (map ? + new SourceMapSource(stringifiedStream, file, JSON.parse(map), input, inputSourceMap) : + new RawSource(stringifiedStream)); + if(extractedComments.length > 0) { + let commentsFile = options.extractComments.filename || file + ".LICENSE"; + if(typeof commentsFile === "function") { + commentsFile = commentsFile(file); + } + + // Write extracted comments to commentsFile + const commentsSource = new RawSource(extractedComments.join("\n\n") + "\n"); + if(commentsFile in compilation.assets) { + // commentsFile already exists, append new comments... + if(compilation.assets[commentsFile] instanceof ConcatSource) { + compilation.assets[commentsFile].add("\n"); + compilation.assets[commentsFile].add(commentsSource); + } else { + compilation.assets[commentsFile] = new ConcatSource( + compilation.assets[commentsFile], "\n", commentsSource + ); + } + } else { + compilation.assets[commentsFile] = commentsSource; + } + + // Add a banner to the original file + if(options.extractComments.banner !== false) { + let banner = options.extractComments.banner || "For license information please see " + commentsFile; + if(typeof banner === "function") { + banner = banner(commentsFile); + } + if(banner) { + outputSource = new ConcatSource( + "/*! " + banner + " */\n", outputSource + ); + } + } + } + asset.__UglifyJsPlugin = compilation.assets[file] = outputSource; + if(warnings.length > 0) { + compilation.warnings.push(new Error(file + " from UglifyJs\n" + warnings.join("\n"))); + } + } catch(err) { + if(err.line) { + const original = sourceMap && sourceMap.originalPositionFor({ + line: err.line, + column: err.col + }); + if(original && original.source) { + compilation.errors.push(new Error(file + " from UglifyJs\n" + err.message + " [" + requestShortener.shorten(original.source) + ":" + original.line + "," + original.column + "][" + file + ":" + err.line + "," + err.col + "]")); + } else { + compilation.errors.push(new Error(file + " from UglifyJs\n" + err.message + " [" + file + ":" + err.line + "," + err.col + "]")); + } + } else if(err.msg) { + compilation.errors.push(new Error(file + " from UglifyJs\n" + err.msg)); + } else + compilation.errors.push(new Error(file + " from UglifyJs\n" + err.stack)); + } finally { + uglify.AST_Node.warn_function = oldWarnFunction; // eslint-disable-line camelcase + } + }); + callback(); + }); + }); + } +} + +module.exports = UglifyJsPlugin; diff --git a/node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js b/node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js new file mode 100644 index 000000000..17a5112d8 --- /dev/null +++ b/node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ +"use strict"; + +const WebpackError = require("../WebpackError"); +const SizeFormatHelpers = require("../SizeFormatHelpers"); + +module.exports = class AssetsOverSizeLimitWarning extends WebpackError { + constructor(assetsOverSizeLimit, assetLimit) { + super(); + + this.name = "AssetsOverSizeLimitWarning"; + this.assets = assetsOverSizeLimit; + const assetLists = this.assets.map(asset => `\n ${asset.name} (${SizeFormatHelpers.formatSize(asset.size)})`).join(""); + this.message = `asset size limit: The following asset(s) exceed the recommended size limit (${SizeFormatHelpers.formatSize(assetLimit)}). +This can impact web performance. +Assets: ${assetLists}`; + + Error.captureStackTrace(this, this.constructor); + } +}; diff --git a/node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js b/node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js new file mode 100644 index 000000000..9fb2de104 --- /dev/null +++ b/node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js @@ -0,0 +1,28 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ +"use strict"; + +const WebpackError = require("../WebpackError"); +const SizeFormatHelpers = require("../SizeFormatHelpers"); + +module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError { + constructor(entrypoints, entrypointLimit) { + super(); + + this.name = "EntrypointsOverSizeLimitWarning"; + this.entrypoints = entrypoints; + const entrypointList = this.entrypoints.map(entrypoint => `\n ${ + entrypoint.name + } (${ + SizeFormatHelpers.formatSize(entrypoint.size) + })\n${ + entrypoint.files.map(asset => ` ${asset}`).join("\n") + }`).join(""); + this.message = `entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${SizeFormatHelpers.formatSize(entrypointLimit)}). This can impact web performance. +Entrypoints:${entrypointList}\n`; + + Error.captureStackTrace(this, this.constructor); + } +}; diff --git a/node_modules/webpack/lib/performance/NoAsyncChunksWarning.js b/node_modules/webpack/lib/performance/NoAsyncChunksWarning.js new file mode 100644 index 000000000..2ca7c35b9 --- /dev/null +++ b/node_modules/webpack/lib/performance/NoAsyncChunksWarning.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ +"use strict"; + +const WebpackError = require("../WebpackError"); + +module.exports = class NoAsyncChunksWarning extends WebpackError { + constructor() { + super(); + + this.name = "NoAsyncChunksWarning"; + this.message = "webpack performance recommendations: \n" + + "You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" + + "For more info visit https://webpack.js.org/guides/code-splitting/"; + + Error.captureStackTrace(this, this.constructor); + } +}; diff --git a/node_modules/webpack/lib/performance/SizeLimitsPlugin.js b/node_modules/webpack/lib/performance/SizeLimitsPlugin.js new file mode 100644 index 000000000..e97b3b368 --- /dev/null +++ b/node_modules/webpack/lib/performance/SizeLimitsPlugin.js @@ -0,0 +1,102 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Sean Larkin @thelarkinn +*/ +"use strict"; +const EntrypointsOverSizeLimitWarning = require("./EntrypointsOverSizeLimitWarning"); +const AssetsOverSizeLimitWarning = require("./AssetsOverSizeLimitWarning"); +const NoAsyncChunksWarning = require("./NoAsyncChunksWarning"); + +module.exports = class SizeLimitsPlugin { + constructor(options) { + this.hints = options.hints; + this.maxAssetSize = options.maxAssetSize; + this.maxEntrypointSize = options.maxEntrypointSize; + this.assetFilter = options.assetFilter; + } + apply(compiler) { + const entrypointSizeLimit = this.maxEntrypointSize; + const assetSizeLimit = this.maxAssetSize; + const hints = this.hints; + const assetFilter = this.assetFilter || (asset => !(/\.map$/.test(asset))); + + compiler.plugin("after-emit", (compilation, callback) => { + const warnings = []; + + const getEntrypointSize = entrypoint => + entrypoint.getFiles() + .filter(assetFilter) + .map(file => compilation.assets[file]) + .filter(Boolean) + .map(asset => asset.size()) + .reduce((currentSize, nextSize) => currentSize + nextSize, 0); + + const assetsOverSizeLimit = []; + Object.keys(compilation.assets) + .filter(assetFilter) + .forEach(assetName => { + const asset = compilation.assets[assetName]; + const size = asset.size(); + + if(size > assetSizeLimit) { + assetsOverSizeLimit.push({ + name: assetName, + size: size, + }); + asset.isOverSizeLimit = true; + } + }); + + const entrypointsOverLimit = []; + Object.keys(compilation.entrypoints) + .forEach(key => { + const entry = compilation.entrypoints[key]; + const size = getEntrypointSize(entry, compilation); + + if(size > entrypointSizeLimit) { + entrypointsOverLimit.push({ + name: key, + size: size, + files: entry.getFiles().filter(assetFilter) + }); + entry.isOverSizeLimit = true; + } + }); + + if(hints) { + // 1. Individual Chunk: Size < 250kb + // 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb + // 3. No Async Chunks + // if !1, then 2, if !2 return + if(assetsOverSizeLimit.length > 0) { + warnings.push( + new AssetsOverSizeLimitWarning( + assetsOverSizeLimit, + assetSizeLimit)); + } + if(entrypointsOverLimit.length > 0) { + warnings.push( + new EntrypointsOverSizeLimitWarning( + entrypointsOverLimit, + entrypointSizeLimit)); + } + + if(warnings.length > 0) { + const hasAsyncChunks = compilation.chunks.filter(chunk => !chunk.isInitial()).length > 0; + + if(!hasAsyncChunks) { + warnings.push(new NoAsyncChunksWarning()); + } + + if(hints === "error") { + Array.prototype.push.apply(compilation.errors, warnings); + } else { + Array.prototype.push.apply(compilation.warnings, warnings); + } + } + } + + callback(); + }); + } +}; diff --git a/node_modules/webpack/lib/removeAndDo.js b/node_modules/webpack/lib/removeAndDo.js new file mode 100644 index 000000000..a857d8a32 --- /dev/null +++ b/node_modules/webpack/lib/removeAndDo.js @@ -0,0 +1,15 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +module.exports = function removeAndDo(collection, thing, action) { + const idx = this[collection].indexOf(thing); + const hasThingInCollection = idx >= 0; + if(hasThingInCollection) { + this[collection].splice(idx, 1); + thing[action](this); + } + return hasThingInCollection; +}; diff --git a/node_modules/webpack/lib/util/identifier.js b/node_modules/webpack/lib/util/identifier.js new file mode 100644 index 000000000..b1bcbf5df --- /dev/null +++ b/node_modules/webpack/lib/util/identifier.js @@ -0,0 +1,16 @@ +"use strict"; +const path = require("path"); + +const looksLikeAbsolutePath = (maybeAbsolutePath) => { + return /^(?:[a-z]:\\|\/)/i.test(maybeAbsolutePath); +}; + +const normalizePathSeparator = (p) => p.replace(/\\/g, "/"); + +exports.makePathsRelative = (context, identifier) => { + return identifier + .split(/([|! ])/) + .map(str => looksLikeAbsolutePath(str) ? + normalizePathSeparator(path.relative(context, str)) : str) + .join(""); +}; diff --git a/node_modules/webpack/lib/validateSchema.js b/node_modules/webpack/lib/validateSchema.js new file mode 100644 index 000000000..8d415c170 --- /dev/null +++ b/node_modules/webpack/lib/validateSchema.js @@ -0,0 +1,66 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Gajus Kuizinas @gajus +*/ +"use strict"; + +const Ajv = require("ajv"); +const ajv = new Ajv({ + errorDataPath: "configuration", + allErrors: true, + verbose: true +}); +require("ajv-keywords")(ajv, ["instanceof"]); +require("../schemas/ajv.absolutePath")(ajv); + +function validateSchema(schema, options) { + if(Array.isArray(options)) { + const errors = options.map((options) => validateObject(schema, options)); + errors.forEach((list, idx) => { + list.forEach(function applyPrefix(err) { + err.dataPath = `[${idx}]${err.dataPath}`; + if(err.children) { + err.children.forEach(applyPrefix); + } + }); + }); + return errors.reduce((arr, items) => { + return arr.concat(items); + }, []); + } else { + return validateObject(schema, options); + } +} + +function validateObject(schema, options) { + const validate = ajv.compile(schema); + const valid = validate(options); + return valid ? [] : filterErrors(validate.errors); +} + +function filterErrors(errors) { + let newErrors = []; + errors.forEach((err) => { + const dataPath = err.dataPath; + let children = []; + newErrors = newErrors.filter((oldError) => { + if(oldError.dataPath.includes(dataPath)) { + if(oldError.children) { + children = children.concat(oldError.children.slice(0)); + } + oldError.children = undefined; + children.push(oldError); + return false; + } + return true; + }); + if(children.length) { + err.children = children; + } + newErrors.push(err); + }); + + return newErrors; +} + +module.exports = validateSchema; diff --git a/node_modules/webpack/lib/web/WebEnvironmentPlugin.js b/node_modules/webpack/lib/web/WebEnvironmentPlugin.js new file mode 100644 index 000000000..46e783bbb --- /dev/null +++ b/node_modules/webpack/lib/web/WebEnvironmentPlugin.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class WebEnvironmentPlugin { + constructor(inputFileSystem, outputFileSystem) { + this.inputFileSystem = inputFileSystem; + this.outputFileSystem = outputFileSystem; + } + + apply(compiler) { + compiler.outputFileSystem = this.outputFileSystem; + } +} + +module.exports = WebEnvironmentPlugin; diff --git a/node_modules/webpack/lib/webpack.js b/node_modules/webpack/lib/webpack.js new file mode 100644 index 000000000..3e2353c49 --- /dev/null +++ b/node_modules/webpack/lib/webpack.js @@ -0,0 +1,120 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Compiler = require("./Compiler"); +const MultiCompiler = require("./MultiCompiler"); +const NodeEnvironmentPlugin = require("./node/NodeEnvironmentPlugin"); +const WebpackOptionsApply = require("./WebpackOptionsApply"); +const WebpackOptionsDefaulter = require("./WebpackOptionsDefaulter"); +const validateSchema = require("./validateSchema"); +const WebpackOptionsValidationError = require("./WebpackOptionsValidationError"); +const webpackOptionsSchema = require("../schemas/webpackOptionsSchema.json"); + +function webpack(options, callback) { + const webpackOptionsValidationErrors = validateSchema(webpackOptionsSchema, options); + if(webpackOptionsValidationErrors.length) { + throw new WebpackOptionsValidationError(webpackOptionsValidationErrors); + } + let compiler; + if(Array.isArray(options)) { + compiler = new MultiCompiler(options.map(options => webpack(options))); + } else if(typeof options === "object") { + new WebpackOptionsDefaulter().process(options); + + compiler = new Compiler(); + compiler.context = options.context; + compiler.options = options; + new NodeEnvironmentPlugin().apply(compiler); + if(options.plugins && Array.isArray(options.plugins)) { + compiler.apply.apply(compiler, options.plugins); + } + compiler.applyPlugins("environment"); + compiler.applyPlugins("after-environment"); + compiler.options = new WebpackOptionsApply().process(options, compiler); + } else { + throw new Error("Invalid argument: options"); + } + if(callback) { + if(typeof callback !== "function") throw new Error("Invalid argument: callback"); + if(options.watch === true || (Array.isArray(options) && options.some(o => o.watch))) { + const watchOptions = Array.isArray(options) ? options.map(o => o.watchOptions || {}) : (options.watchOptions || {}); + return compiler.watch(watchOptions, callback); + } + compiler.run(callback); + } + return compiler; +} +exports = module.exports = webpack; + +webpack.WebpackOptionsDefaulter = WebpackOptionsDefaulter; +webpack.WebpackOptionsApply = WebpackOptionsApply; +webpack.Compiler = Compiler; +webpack.MultiCompiler = MultiCompiler; +webpack.NodeEnvironmentPlugin = NodeEnvironmentPlugin; +webpack.validate = validateSchema.bind(this, webpackOptionsSchema); +webpack.validateSchema = validateSchema; +webpack.WebpackOptionsValidationError = WebpackOptionsValidationError; + +function exportPlugins(exports, path, plugins) { + plugins.forEach(name => { + Object.defineProperty(exports, name, { + configurable: false, + enumerable: true, + get() { + return require(`${path}/${name}`); + } + }); + }); +} + +exportPlugins(exports, ".", [ + "DefinePlugin", + "NormalModuleReplacementPlugin", + "ContextReplacementPlugin", + "IgnorePlugin", + "WatchIgnorePlugin", + "BannerPlugin", + "PrefetchPlugin", + "AutomaticPrefetchPlugin", + "ProvidePlugin", + "HotModuleReplacementPlugin", + "SourceMapDevToolPlugin", + "EvalSourceMapDevToolPlugin", + "EvalDevToolModulePlugin", + "CachePlugin", + "ExtendedAPIPlugin", + "ExternalsPlugin", + "JsonpTemplatePlugin", + "LibraryTemplatePlugin", + "LoaderTargetPlugin", + "MemoryOutputFileSystem", + "ProgressPlugin", + "SetVarMainTemplatePlugin", + "UmdMainTemplatePlugin", + "NoErrorsPlugin", + "NoEmitOnErrorsPlugin", + "NewWatchingPlugin", + "EnvironmentPlugin", + "DllPlugin", + "DllReferencePlugin", + "LoaderOptionsPlugin", + "NamedModulesPlugin", + "NamedChunksPlugin", + "HashedModuleIdsPlugin", + "ModuleFilenameHelpers" +]); +exportPlugins(exports.optimize = {}, "./optimize", [ + "AggressiveMergingPlugin", + "AggressiveSplittingPlugin", + "CommonsChunkPlugin", + "ChunkModuleIdRangePlugin", + "DedupePlugin", + "LimitChunkCountPlugin", + "MinChunkSizePlugin", + "OccurrenceOrderPlugin", + "UglifyJsPlugin" +]); +exportPlugins(exports.dependencies = {}, "./dependencies", []); diff --git a/node_modules/webpack/lib/webpack.web.js b/node_modules/webpack/lib/webpack.web.js new file mode 100644 index 000000000..9747e11e5 --- /dev/null +++ b/node_modules/webpack/lib/webpack.web.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Compiler = require("./Compiler"); +const WebEnvironmentPlugin = require("./web/WebEnvironmentPlugin"); +const WebpackOptionsApply = require("./WebpackOptionsApply"); +const WebpackOptionsDefaulter = require("./WebpackOptionsDefaulter"); + +function webpack(options, callback) { + new WebpackOptionsDefaulter().process(options); + + const compiler = new Compiler(); + compiler.options = options; + compiler.options = new WebpackOptionsApply().process(options, compiler); + new WebEnvironmentPlugin(options.inputFileSystem, options.outputFileSystem).apply(compiler); + if(callback) { + compiler.run(callback); + } + return compiler; +} +module.exports = webpack; + +webpack.WebpackOptionsDefaulter = WebpackOptionsDefaulter; +webpack.WebpackOptionsApply = WebpackOptionsApply; +webpack.Compiler = Compiler; +webpack.WebEnvironmentPlugin = WebEnvironmentPlugin; diff --git a/node_modules/webpack/lib/webworker/WebWorkerChunkTemplatePlugin.js b/node_modules/webpack/lib/webworker/WebWorkerChunkTemplatePlugin.js new file mode 100644 index 000000000..0b7fa525b --- /dev/null +++ b/node_modules/webpack/lib/webworker/WebWorkerChunkTemplatePlugin.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +var ConcatSource = require("webpack-sources").ConcatSource; +var Template = require("../Template"); + +class WebWorkerChunkTemplatePlugin { + + apply(chunkTemplate) { + chunkTemplate.plugin("render", function(modules, chunk) { + const chunkCallbackName = this.outputOptions.chunkCallbackName || Template.toIdentifier("webpackChunk" + (this.outputOptions.library || "")); + const source = new ConcatSource(); + source.add(`${chunkCallbackName}(${JSON.stringify(chunk.ids)},`); + source.add(modules); + source.add(")"); + return source; + }); + chunkTemplate.plugin("hash", function(hash) { + hash.update("webworker"); + hash.update("3"); + hash.update(`${this.outputOptions.chunkCallbackName}`); + hash.update(`${this.outputOptions.library}`); + }); + } +} +module.exports = WebWorkerChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/webworker/WebWorkerHotUpdateChunkTemplatePlugin.js b/node_modules/webpack/lib/webworker/WebWorkerHotUpdateChunkTemplatePlugin.js new file mode 100644 index 000000000..c128be7c7 --- /dev/null +++ b/node_modules/webpack/lib/webworker/WebWorkerHotUpdateChunkTemplatePlugin.js @@ -0,0 +1,28 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; +const ConcatSource = require("webpack-sources").ConcatSource; +const Template = require("../Template"); + +class WebWorkerHotUpdateChunkTemplatePlugin { + + apply(hotUpdateChunkTemplate) { + hotUpdateChunkTemplate.plugin("render", function(modulesSource, modules, removedModules, hash, id) { + const chunkCallbackName = this.outputOptions.hotUpdateFunction || Template.toIdentifier("webpackHotUpdate" + (this.outputOptions.library || "")); + const source = new ConcatSource(); + source.add(chunkCallbackName + "(" + JSON.stringify(id) + ","); + source.add(modulesSource); + source.add(")"); + return source; + }); + hotUpdateChunkTemplate.plugin("hash", function(hash) { + hash.update("WebWorkerHotUpdateChunkTemplatePlugin"); + hash.update("3"); + hash.update(this.outputOptions.hotUpdateFunction + ""); + hash.update(this.outputOptions.library + ""); + }); + } +} +module.exports = WebWorkerHotUpdateChunkTemplatePlugin; diff --git a/node_modules/webpack/lib/webworker/WebWorkerMainTemplate.runtime.js b/node_modules/webpack/lib/webworker/WebWorkerMainTemplate.runtime.js new file mode 100644 index 000000000..bcead37e4 --- /dev/null +++ b/node_modules/webpack/lib/webworker/WebWorkerMainTemplate.runtime.js @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/*globals installedChunks hotAddUpdateChunk parentHotUpdateCallback importScripts XMLHttpRequest $require$ $hotChunkFilename$ $hotMainFilename$ */ +module.exports = function() { + function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars + hotAddUpdateChunk(chunkId, moreModules); + if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules); + } //$semicolon + + function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars + importScripts($require$.p + $hotChunkFilename$); + } + + function hotDownloadManifest(callback) { // eslint-disable-line no-unused-vars + return new Promise(function(resolve, reject) { + if(typeof XMLHttpRequest === "undefined") + return reject(new Error("No browser support")); + try { + var request = new XMLHttpRequest(); + var requestPath = $require$.p + $hotMainFilename$; + request.open("GET", requestPath, true); + request.timeout = 10000; + request.send(null); + } catch(err) { + return reject(err); + } + request.onreadystatechange = function() { + if(request.readyState !== 4) return; + if(request.status === 0) { + // timeout + reject(new Error("Manifest request to " + requestPath + " timed out.")); + } else if(request.status === 404) { + // no update available + resolve(); + } else if(request.status !== 200 && request.status !== 304) { + // other failure + reject(new Error("Manifest request to " + requestPath + " failed.")); + } else { + // success + try { + var update = JSON.parse(request.responseText); + } catch(e) { + reject(e); + return; + } + resolve(update); + } + }; + }); + } + + function hotDisposeChunk(chunkId) { //eslint-disable-line no-unused-vars + delete installedChunks[chunkId]; + } +}; diff --git a/node_modules/webpack/lib/webworker/WebWorkerMainTemplatePlugin.js b/node_modules/webpack/lib/webworker/WebWorkerMainTemplatePlugin.js new file mode 100644 index 000000000..a0e6cc2f3 --- /dev/null +++ b/node_modules/webpack/lib/webworker/WebWorkerMainTemplatePlugin.js @@ -0,0 +1,108 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const Template = require("../Template"); + +class WebWorkerMainTemplatePlugin { + apply(mainTemplate) { + mainTemplate.plugin("local-vars", function(source, chunk) { + if(chunk.chunks.length > 0) { + return this.asString([ + source, + "", + "// object to store loaded chunks", + "// \"1\" means \"already loaded\"", + "var installedChunks = {", + this.indent( + chunk.ids.map(function(id) { + return id + ": 1"; + }).join(",\n") + ), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("require-ensure", function(_, chunk, hash) { + const chunkFilename = this.outputOptions.chunkFilename; + return this.asString([ + "// \"1\" is the signal for \"already loaded\"", + "if(!installedChunks[chunkId]) {", + this.indent([ + "importScripts(" + + this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this), + chunk: { + id: "\" + chunkId + \"" + } + }) + ");" + ]), + "}", + "return Promise.resolve();" + ]); + }); + mainTemplate.plugin("bootstrap", function(source, chunk, hash) { + if(chunk.chunks.length > 0) { + const chunkCallbackName = this.outputOptions.chunkCallbackName || Template.toIdentifier("webpackChunk" + (this.outputOptions.library || "")); + return this.asString([ + source, + "this[" + JSON.stringify(chunkCallbackName) + "] = function webpackChunkCallback(chunkIds, moreModules) {", + this.indent([ + "for(var moduleId in moreModules) {", + this.indent(this.renderAddModule(hash, chunk, "moduleId", "moreModules[moduleId]")), + "}", + "while(chunkIds.length)", + this.indent("installedChunks[chunkIds.pop()] = 1;") + ]), + "};" + ]); + } + return source; + }); + mainTemplate.plugin("hot-bootstrap", function(source, chunk, hash) { + const hotUpdateChunkFilename = this.outputOptions.hotUpdateChunkFilename; + const hotUpdateMainFilename = this.outputOptions.hotUpdateMainFilename; + const hotUpdateFunction = this.outputOptions.hotUpdateFunction || Template.toIdentifier("webpackHotUpdate" + (this.outputOptions.library || "")); + const currentHotUpdateChunkFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateChunkFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this), + chunk: { + id: "\" + chunkId + \"" + } + }); + const currentHotUpdateMainFilename = this.applyPluginsWaterfall("asset-path", JSON.stringify(hotUpdateMainFilename), { + hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"", + hashWithLength: function(length) { + return "\" + " + this.renderCurrentHashCode(hash, length) + " + \""; + }.bind(this) + }); + + return source + "\n" + + "var parentHotUpdateCallback = this[" + JSON.stringify(hotUpdateFunction) + "];\n" + + "this[" + JSON.stringify(hotUpdateFunction) + "] = " + Template.getFunctionContent(require("./WebWorkerMainTemplate.runtime.js")) + .replace(/\/\/\$semicolon/g, ";") + .replace(/\$require\$/g, this.requireFn) + .replace(/\$hotMainFilename\$/g, currentHotUpdateMainFilename) + .replace(/\$hotChunkFilename\$/g, currentHotUpdateChunkFilename) + .replace(/\$hash\$/g, JSON.stringify(hash)); + }); + mainTemplate.plugin("hash", function(hash) { + hash.update("webworker"); + hash.update("3"); + hash.update(`${this.outputOptions.publicPath}`); + hash.update(`${this.outputOptions.filename}`); + hash.update(`${this.outputOptions.chunkFilename}`); + hash.update(`${this.outputOptions.chunkCallbackName}`); + hash.update(`${this.outputOptions.library}`); + }); + } +} +module.exports = WebWorkerMainTemplatePlugin; diff --git a/node_modules/webpack/lib/webworker/WebWorkerTemplatePlugin.js b/node_modules/webpack/lib/webworker/WebWorkerTemplatePlugin.js new file mode 100644 index 000000000..64f1e00f5 --- /dev/null +++ b/node_modules/webpack/lib/webworker/WebWorkerTemplatePlugin.js @@ -0,0 +1,20 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const WebWorkerMainTemplatePlugin = require("./WebWorkerMainTemplatePlugin"); +const WebWorkerChunkTemplatePlugin = require("./WebWorkerChunkTemplatePlugin"); +const WebWorkerHotUpdateChunkTemplatePlugin = require("./WebWorkerHotUpdateChunkTemplatePlugin"); + +class WebWorkerTemplatePlugin { + apply(compiler) { + compiler.plugin("this-compilation", compilation => { + compilation.mainTemplate.apply(new WebWorkerMainTemplatePlugin()); + compilation.chunkTemplate.apply(new WebWorkerChunkTemplatePlugin()); + compilation.hotUpdateChunkTemplate.apply(new WebWorkerHotUpdateChunkTemplatePlugin()); + }); + } +} +module.exports = WebWorkerTemplatePlugin; -- cgit v1.2.3