summaryrefslogtreecommitdiffstats
path: root/node_modules/webpack/lib/Chunk.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/webpack/lib/Chunk.js')
-rw-r--r--node_modules/webpack/lib/Chunk.js875
1 files changed, 0 insertions, 875 deletions
diff --git a/node_modules/webpack/lib/Chunk.js b/node_modules/webpack/lib/Chunk.js
deleted file mode 100644
index db644ee..0000000
--- a/node_modules/webpack/lib/Chunk.js
+++ /dev/null
@@ -1,875 +0,0 @@
-/*
-MIT License http://www.opensource.org/licenses/mit-license.php
-Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const util = require("util");
-const SortableSet = require("./util/SortableSet");
-const intersect = require("./util/SetHelpers").intersect;
-const GraphHelpers = require("./GraphHelpers");
-const Entrypoint = require("./Entrypoint");
-let debugId = 1000;
-const ERR_CHUNK_ENTRY = "Chunk.entry was removed. Use hasRuntime()";
-const ERR_CHUNK_INITIAL =
- "Chunk.initial was removed. Use canBeInitial/isOnlyInitial()";
-
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./ModuleReason")} ModuleReason */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./util/createHash").Hash} Hash */
-
-/**
- * @typedef {Object} WithId an object who has an id property *
- * @property {string | number} id the id of the object
- */
-
-/**
- * Compare two Modules based on their ids for sorting
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} sort value
- */
-
-// TODO use @callback
-/** @typedef {(a: Module, b: Module) => -1|0|1} ModuleSortPredicate */
-/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
-/** @typedef {(c: Chunk) => boolean} ChunkFilterPredicate */
-
-const sortModuleById = (a, b) => {
- if (a.id < b.id) return -1;
- if (b.id < a.id) return 1;
- return 0;
-};
-
-/**
- * Compare two ChunkGroups based on their ids for sorting
- * @param {ChunkGroup} a chunk group
- * @param {ChunkGroup} b chunk group
- * @returns {-1|0|1} sort value
- */
-const sortChunkGroupById = (a, b) => {
- if (a.id < b.id) return -1;
- if (b.id < a.id) return 1;
- return 0;
-};
-
-/**
- * Compare two Identifiables , based on their ids for sorting
- * @param {Module} a first object with ident fn
- * @param {Module} b second object with ident fn
- * @returns {-1|0|1} The order number of the sort
- */
-const sortByIdentifier = (a, b) => {
- if (a.identifier() > b.identifier()) return 1;
- if (a.identifier() < b.identifier()) return -1;
- return 0;
-};
-
-/**
- * @returns {string} a concatenation of module identifiers sorted
- * @param {SortableSet} set to pull module identifiers from
- */
-const getModulesIdent = set => {
- set.sort();
- let str = "";
- for (const m of set) {
- str += m.identifier() + "#";
- }
- return str;
-};
-
-/**
- * @template T
- * @param {SortableSet<T>} set the sortable set to convert to array
- * @returns {Array<T>} the array returned from Array.from(set)
- */
-const getArray = set => Array.from(set);
-
-/**
- * @param {SortableSet<Module>} set the sortable Set to get the count/size of
- * @returns {number} the size of the modules
- */
-const getModulesSize = set => {
- let size = 0;
- for (const module of set) {
- size += module.size();
- }
- return size;
-};
-
-/**
- * A Chunk is a unit of encapsulation for Modules.
- * Chunks are "rendered" into bundles that get emitted when the build completes.
- */
-class Chunk {
- /**
- * @param {string=} name of chunk being created, is optional (for subclasses)
- */
- constructor(name) {
- /** @type {number | null} */
- this.id = null;
- /** @type {number[] | null} */
- this.ids = null;
- /** @type {number} */
- this.debugId = debugId++;
- /** @type {string} */
- this.name = name;
- /** @type {boolean} */
- this.preventIntegration = false;
- /** @type {Module=} */
- this.entryModule = undefined;
- /** @private @type {SortableSet<Module>} */
- this._modules = new SortableSet(undefined, sortByIdentifier);
- /** @type {string?} */
- this.filenameTemplate = undefined;
- /** @private @type {SortableSet<ChunkGroup>} */
- this._groups = new SortableSet(undefined, sortChunkGroupById);
- /** @type {string[]} */
- this.files = [];
- /** @type {boolean} */
- this.rendered = false;
- /** @type {string=} */
- this.hash = undefined;
- /** @type {Object} */
- this.contentHash = Object.create(null);
- /** @type {string=} */
- this.renderedHash = undefined;
- /** @type {string=} */
- this.chunkReason = undefined;
- /** @type {boolean} */
- this.extraAsync = false;
- this.removedModules = undefined;
- }
-
- /**
- * @deprecated Chunk.entry has been deprecated. Please use .hasRuntime() instead
- * @returns {never} Throws an error trying to access this property
- */
- get entry() {
- throw new Error(ERR_CHUNK_ENTRY);
- }
-
- /**
- * @deprecated .entry has been deprecated. Please use .hasRuntime() instead
- * @param {never} data The data that was attempting to be set
- * @returns {never} Throws an error trying to access this property
- */
- set entry(data) {
- throw new Error(ERR_CHUNK_ENTRY);
- }
-
- /**
- * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial()
- * @returns {never} Throws an error trying to access this property
- */
- get initial() {
- throw new Error(ERR_CHUNK_INITIAL);
- }
-
- /**
- * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial()
- * @param {never} data The data attempting to be set
- * @returns {never} Throws an error trying to access this property
- */
- set initial(data) {
- throw new Error(ERR_CHUNK_INITIAL);
- }
-
- /**
- * @returns {boolean} whether or not the Chunk will have a runtime
- */
- hasRuntime() {
- for (const chunkGroup of this._groups) {
- if (
- chunkGroup.isInitial() &&
- chunkGroup instanceof Entrypoint &&
- chunkGroup.getRuntimeChunk() === this
- ) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * @returns {boolean} whether or not this chunk can be an initial chunk
- */
- canBeInitial() {
- for (const chunkGroup of this._groups) {
- if (chunkGroup.isInitial()) return true;
- }
- return false;
- }
-
- /**
- * @returns {boolean} whether this chunk can only be an initial chunk
- */
- isOnlyInitial() {
- if (this._groups.size <= 0) return false;
- for (const chunkGroup of this._groups) {
- if (!chunkGroup.isInitial()) return false;
- }
- return true;
- }
-
- /**
- * @returns {boolean} if this chunk contains the entry module
- */
- hasEntryModule() {
- return !!this.entryModule;
- }
-
- /**
- * @param {Module} module the module that will be added to this chunk.
- * @returns {boolean} returns true if the chunk doesn't have the module and it was added
- */
- addModule(module) {
- if (!this._modules.has(module)) {
- this._modules.add(module);
- return true;
- }
- return false;
- }
-
- /**
- * @param {Module} module the module that will be removed from this chunk
- * @returns {boolean} returns true if chunk exists and is successfully deleted
- */
- removeModule(module) {
- if (this._modules.delete(module)) {
- module.removeChunk(this);
- return true;
- }
- return false;
- }
-
- /**
- * @param {Module[]} modules the new modules to be set
- * @returns {void} set new modules to this chunk and return nothing
- */
- setModules(modules) {
- this._modules = new SortableSet(modules, sortByIdentifier);
- }
-
- /**
- * @returns {number} the amount of modules in chunk
- */
- getNumberOfModules() {
- return this._modules.size;
- }
-
- /**
- * @returns {SortableSet} return the modules SortableSet for this chunk
- */
- get modulesIterable() {
- return this._modules;
- }
-
- /**
- * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
- * @returns {boolean} returns true if chunk is not apart of chunkGroup and is added successfully
- */
- addGroup(chunkGroup) {
- if (this._groups.has(chunkGroup)) return false;
- this._groups.add(chunkGroup);
- return true;
- }
-
- /**
- * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
- * @returns {boolean} returns true if chunk does exist in chunkGroup and is removed
- */
- removeGroup(chunkGroup) {
- if (!this._groups.has(chunkGroup)) return false;
- this._groups.delete(chunkGroup);
- return true;
- }
-
- /**
- * @param {ChunkGroup} chunkGroup the chunkGroup to check
- * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
- */
- isInGroup(chunkGroup) {
- return this._groups.has(chunkGroup);
- }
-
- /**
- * @returns {number} the amount of groups said chunk is in
- */
- getNumberOfGroups() {
- return this._groups.size;
- }
-
- /**
- * @returns {SortableSet<ChunkGroup>} the chunkGroups that said chunk is referenced in
- */
- get groupsIterable() {
- return this._groups;
- }
-
- /**
- * @param {Chunk} otherChunk the chunk to compare itself with
- * @returns {-1|0|1} this is a comparitor function like sort and returns -1, 0, or 1 based on sort order
- */
- compareTo(otherChunk) {
- if (this.name && !otherChunk.name) return -1;
- if (!this.name && otherChunk.name) return 1;
- if (this.name < otherChunk.name) return -1;
- if (this.name > otherChunk.name) return 1;
- if (this._modules.size > otherChunk._modules.size) return -1;
- if (this._modules.size < otherChunk._modules.size) return 1;
- this._modules.sort();
- otherChunk._modules.sort();
- const a = this._modules[Symbol.iterator]();
- const b = otherChunk._modules[Symbol.iterator]();
- // eslint-disable-next-line no-constant-condition
- while (true) {
- const aItem = a.next();
- if (aItem.done) return 0;
- const bItem = b.next();
- const aModuleIdentifier = aItem.value.identifier();
- const bModuleIdentifier = bItem.value.identifier();
- if (aModuleIdentifier < bModuleIdentifier) return -1;
- if (aModuleIdentifier > bModuleIdentifier) return 1;
- }
- }
-
- /**
- * @param {Module} module Module to check
- * @returns {boolean} returns true if module does exist in this chunk
- */
- containsModule(module) {
- return this._modules.has(module);
- }
-
- /**
- * @returns {Module[]} an array of modules (do not modify)
- */
- getModules() {
- return this._modules.getFromCache(getArray);
- }
-
- getModulesIdent() {
- return this._modules.getFromUnorderedCache(getModulesIdent);
- }
-
- /**
- * @param {string=} reason reason why chunk is removed
- * @returns {void}
- */
- remove(reason) {
- // cleanup modules
- // Array.from is used here to create a clone, because removeChunk modifies this._modules
- for (const module of Array.from(this._modules)) {
- module.removeChunk(this);
- }
- for (const chunkGroup of this._groups) {
- chunkGroup.removeChunk(this);
- }
- }
-
- /**
- *
- * @param {Module} module module to move
- * @param {Chunk} otherChunk other chunk to move it to
- * @returns {void}
- */
- moveModule(module, otherChunk) {
- GraphHelpers.disconnectChunkAndModule(this, module);
- GraphHelpers.connectChunkAndModule(otherChunk, module);
- module.rewriteChunkInReasons(this, [otherChunk]);
- }
-
- /**
- *
- * @param {Chunk} otherChunk the chunk to integrate with
- * @param {string} reason reason why the module is being integrated
- * @returns {boolean} returns true or false if integration succeeds or fails
- */
- integrate(otherChunk, reason) {
- if (!this.canBeIntegrated(otherChunk)) {
- return false;
- }
-
- // Pick a new name for the integrated chunk
- if (this.name && otherChunk.name) {
- if (this.hasEntryModule() === otherChunk.hasEntryModule()) {
- // When both chunks have entry modules or none have one, use
- // shortest name
- if (this.name.length !== otherChunk.name.length) {
- this.name =
- this.name.length < otherChunk.name.length
- ? this.name
- : otherChunk.name;
- } else {
- this.name = this.name < otherChunk.name ? this.name : otherChunk.name;
- }
- } else if (otherChunk.hasEntryModule()) {
- // Pick the name of the chunk with the entry module
- this.name = otherChunk.name;
- }
- } else if (otherChunk.name) {
- this.name = otherChunk.name;
- }
-
- // Array.from is used here to create a clone, because moveModule modifies otherChunk._modules
- for (const module of Array.from(otherChunk._modules)) {
- otherChunk.moveModule(module, this);
- }
- otherChunk._modules.clear();
-
- if (otherChunk.entryModule) {
- this.entryModule = otherChunk.entryModule;
- }
-
- for (const chunkGroup of otherChunk._groups) {
- chunkGroup.replaceChunk(otherChunk, this);
- this.addGroup(chunkGroup);
- }
- otherChunk._groups.clear();
-
- return true;
- }
-
- /**
- * @param {Chunk} newChunk the new chunk that will be split out of the current chunk
- * @returns {void}
- */
- split(newChunk) {
- for (const chunkGroup of this._groups) {
- chunkGroup.insertChunk(newChunk, this);
- newChunk.addGroup(chunkGroup);
- }
- }
-
- isEmpty() {
- return this._modules.size === 0;
- }
-
- updateHash(hash) {
- hash.update(`${this.id} `);
- hash.update(this.ids ? this.ids.join(",") : "");
- hash.update(`${this.name || ""} `);
- for (const m of this._modules) {
- hash.update(m.hash);
- }
- }
-
- canBeIntegrated(otherChunk) {
- if (this.preventIntegration || otherChunk.preventIntegration) {
- return false;
- }
-
- /**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {boolean} true, if a is always available when b is reached
- */
- const isAvailable = (a, b) => {
- const queue = new Set(b.groupsIterable);
- for (const chunkGroup of queue) {
- if (a.isInGroup(chunkGroup)) continue;
- if (chunkGroup.isInitial()) return false;
- for (const parent of chunkGroup.parentsIterable) {
- queue.add(parent);
- }
- }
- return true;
- };
-
- const selfHasRuntime = this.hasRuntime();
- const otherChunkHasRuntime = otherChunk.hasRuntime();
-
- if (selfHasRuntime !== otherChunkHasRuntime) {
- if (selfHasRuntime) {
- return isAvailable(this, otherChunk);
- } else if (otherChunkHasRuntime) {
- return isAvailable(otherChunk, this);
- } else {
- return false;
- }
- }
-
- if (this.hasEntryModule() || otherChunk.hasEntryModule()) {
- return false;
- }
-
- return true;
- }
-
- /**
- *
- * @param {number} size the size
- * @param {Object} options the options passed in
- * @returns {number} the multiplier returned
- */
- addMultiplierAndOverhead(size, options) {
- const overhead =
- typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
- const multiplicator = this.canBeInitial()
- ? options.entryChunkMultiplicator || 10
- : 1;
-
- return size * multiplicator + overhead;
- }
-
- /**
- * @returns {number} the size of all modules
- */
- modulesSize() {
- return this._modules.getFromUnorderedCache(getModulesSize);
- }
-
- /**
- * @param {Object} options the size display options
- * @returns {number} the chunk size
- */
- size(options = {}) {
- return this.addMultiplierAndOverhead(this.modulesSize(), options);
- }
-
- /**
- * @param {Chunk} otherChunk the other chunk
- * @param {TODO} options the options for this function
- * @returns {number | false} the size, or false if it can't be integrated
- */
- 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 (const otherModule of otherChunk._modules) {
- if (!this._modules.has(otherModule)) {
- integratedModulesSize += otherModule.size();
- }
- }
-
- return this.addMultiplierAndOverhead(integratedModulesSize, options);
- }
-
- /**
- * @param {function(Module, Module): -1|0|1=} sortByFn a predicate function used to sort modules
- * @returns {void}
- */
- sortModules(sortByFn) {
- this._modules.sortWith(sortByFn || sortModuleById);
- }
-
- sortItems() {
- this.sortModules();
- }
-
- /**
- * @returns {Set<Chunk>} a set of all the async chunks
- */
- getAllAsyncChunks() {
- const queue = new Set();
- const chunks = new Set();
-
- const initialChunks = intersect(
- Array.from(this.groupsIterable, g => new Set(g.chunks))
- );
-
- for (const chunkGroup of this.groupsIterable) {
- for (const child of chunkGroup.childrenIterable) {
- queue.add(child);
- }
- }
-
- for (const chunkGroup of queue) {
- for (const chunk of chunkGroup.chunks) {
- if (!initialChunks.has(chunk)) {
- chunks.add(chunk);
- }
- }
- for (const child of chunkGroup.childrenIterable) {
- queue.add(child);
- }
- }
-
- return chunks;
- }
-
- /**
- * @typedef {Object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
- */
-
- /**
- * @param {boolean} realHash should the full hash or the rendered hash be used
- * @returns {ChunkMaps} the chunk map information
- */
- getChunkMaps(realHash) {
- /** @type {Record<string|number, string>} */
- const chunkHashMap = Object.create(null);
- /** @type {Record<string|number, Record<string, string>>} */
- const chunkContentHashMap = Object.create(null);
- /** @type {Record<string|number, string>} */
- const chunkNameMap = Object.create(null);
-
- for (const chunk of this.getAllAsyncChunks()) {
- chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
- for (const key of Object.keys(chunk.contentHash)) {
- if (!chunkContentHashMap[key]) {
- chunkContentHashMap[key] = Object.create(null);
- }
- chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
- }
- if (chunk.name) {
- chunkNameMap[chunk.id] = chunk.name;
- }
- }
-
- return {
- hash: chunkHashMap,
- contentHash: chunkContentHashMap,
- name: chunkNameMap
- };
- }
-
- /**
- * @returns {Record<string, Set<TODO>[]>} a record object of names to lists of child ids(?)
- */
- getChildIdsByOrders() {
- const lists = new Map();
- for (const group of this.groupsIterable) {
- if (group.chunks[group.chunks.length - 1] === this) {
- for (const childGroup of group.childrenIterable) {
- // TODO webpack 5 remove this check for options
- if (typeof childGroup.options === "object") {
- for (const key of Object.keys(childGroup.options)) {
- if (key.endsWith("Order")) {
- const name = key.substr(0, key.length - "Order".length);
- let list = lists.get(name);
- if (list === undefined) lists.set(name, (list = []));
- list.push({
- order: childGroup.options[key],
- group: childGroup
- });
- }
- }
- }
- }
- }
- }
- const result = Object.create(null);
- for (const [name, list] of lists) {
- list.sort((a, b) => {
- const cmp = b.order - a.order;
- if (cmp !== 0) return cmp;
- // TODO webpack 5 remove this check of compareTo
- if (a.group.compareTo) {
- return a.group.compareTo(b.group);
- }
- return 0;
- });
- result[name] = Array.from(
- list.reduce((set, item) => {
- for (const chunk of item.group.chunks) {
- set.add(chunk.id);
- }
- return set;
- }, new Set())
- );
- }
- return result;
- }
-
- getChildIdsByOrdersMap(includeDirectChildren) {
- const chunkMaps = Object.create(null);
-
- const addChildIdsByOrdersToMap = chunk => {
- const data = chunk.getChildIdsByOrders();
- for (const key of Object.keys(data)) {
- let chunkMap = chunkMaps[key];
- if (chunkMap === undefined) {
- chunkMaps[key] = chunkMap = Object.create(null);
- }
- chunkMap[chunk.id] = data[key];
- }
- };
-
- if (includeDirectChildren) {
- const chunks = new Set();
- for (const chunkGroup of this.groupsIterable) {
- for (const chunk of chunkGroup.chunks) {
- chunks.add(chunk);
- }
- }
- for (const chunk of chunks) {
- addChildIdsByOrdersToMap(chunk);
- }
- }
-
- for (const chunk of this.getAllAsyncChunks()) {
- addChildIdsByOrdersToMap(chunk);
- }
-
- return chunkMaps;
- }
-
- /**
- * @typedef {Object} ChunkModuleMaps
- * @property {Record<string|number, (string|number)[]>} id
- * @property {Record<string|number, string>} hash
- */
-
- /**
- * @param {ModuleFilterPredicate} filterFn function used to filter modules
- * @returns {ChunkModuleMaps} module map information
- */
- getChunkModuleMaps(filterFn) {
- /** @type {Record<string|number, (string|number)[]>} */
- const chunkModuleIdMap = Object.create(null);
- /** @type {Record<string|number, string>} */
- const chunkModuleHashMap = Object.create(null);
-
- for (const chunk of this.getAllAsyncChunks()) {
- /** @type {(string|number)[]} */
- let array;
- for (const module of chunk.modulesIterable) {
- if (filterFn(module)) {
- if (array === undefined) {
- array = [];
- chunkModuleIdMap[chunk.id] = array;
- }
- array.push(module.id);
- chunkModuleHashMap[module.id] = module.renderedHash;
- }
- }
- if (array !== undefined) {
- array.sort();
- }
- }
-
- return {
- id: chunkModuleIdMap,
- hash: chunkModuleHashMap
- };
- }
-
- /**
- *
- * @param {function(Module): boolean} filterFn predicate function used to filter modules
- * @param {function(Chunk): boolean} filterChunkFn predicate function used to filter chunks
- * @returns {boolean} return true if module exists in graph
- */
- hasModuleInGraph(filterFn, filterChunkFn) {
- const queue = new Set(this.groupsIterable);
- const chunksProcessed = new Set();
-
- for (const chunkGroup of queue) {
- for (const chunk of chunkGroup.chunks) {
- if (!chunksProcessed.has(chunk)) {
- chunksProcessed.add(chunk);
- if (!filterChunkFn || filterChunkFn(chunk)) {
- for (const module of chunk.modulesIterable) {
- if (filterFn(module)) {
- return true;
- }
- }
- }
- }
- }
- for (const child of chunkGroup.childrenIterable) {
- queue.add(child);
- }
- }
- return false;
- }
-
- toString() {
- return `Chunk[${Array.from(this._modules).join()}]`;
- }
-}
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "forEachModule", {
- configurable: false,
- value: util.deprecate(
- /**
- * @deprecated
- * @this {Chunk}
- * @typedef {function(any, any, Set<any>): void} ForEachModuleCallback
- * @param {ForEachModuleCallback} fn Callback function
- * @returns {void}
- */
- function(fn) {
- this._modules.forEach(fn);
- },
- "Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead"
- )
-});
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "mapModules", {
- configurable: false,
- value: util.deprecate(
- /**
- * @deprecated
- * @this {Chunk}
- * @typedef {function(any, number): any} MapModulesCallback
- * @param {MapModulesCallback} fn Callback function
- * @returns {TODO[]} result of mapped modules
- */
- function(fn) {
- return Array.from(this._modules, fn);
- },
- "Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead"
- )
-});
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "chunks", {
- configurable: false,
- get() {
- throw new Error("Chunk.chunks: Use ChunkGroup.getChildren() instead");
- },
- set() {
- throw new Error("Chunk.chunks: Use ChunkGroup.add/removeChild() instead");
- }
-});
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "parents", {
- configurable: false,
- get() {
- throw new Error("Chunk.parents: Use ChunkGroup.getParents() instead");
- },
- set() {
- throw new Error("Chunk.parents: Use ChunkGroup.add/removeParent() instead");
- }
-});
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "blocks", {
- configurable: false,
- get() {
- throw new Error("Chunk.blocks: Use ChunkGroup.getBlocks() instead");
- },
- set() {
- throw new Error("Chunk.blocks: Use ChunkGroup.add/removeBlock() instead");
- }
-});
-
-// TODO remove in webpack 5
-Object.defineProperty(Chunk.prototype, "entrypoints", {
- configurable: false,
- get() {
- throw new Error(
- "Chunk.entrypoints: Use Chunks.groupsIterable and filter by instanceof Entrypoint instead"
- );
- },
- set() {
- throw new Error("Chunk.entrypoints: Use Chunks.addGroup instead");
- }
-});
-
-module.exports = Chunk;
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-23 16:20:18 +0000