@rollup/wasm-node 4.9.5 → 4.10.0

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.9.5
-	Fri, 12 Jan 2024 06:15:44 GMT - commit 7fa474cc5ed91c96a4ff80e286aa8534bc15834f
+	Rollup.js v4.10.0
+	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
 
 	https://github.com/rollup/rollup
 
@@ -12,11 +12,11 @@ import { relative, dirname, basename, extname, resolve as resolve$1 } from 'node
 import require$$0$1, { win32, posix, isAbsolute, resolve } from 'path';
 import process$1, { env as env$1 } from 'node:process';
 import { performance } from 'node:perf_hooks';
-import { xxhashBase64Url } from '../../native.js';
+import { xxhashBase64Url, xxhashBase36, xxhashBase16 } from '../../native.js';
 import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
 import * as tty from 'tty';
 
-var version = "4.9.5";
+var version = "4.10.0";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -274,6 +274,16 @@ let Chunk$1 = class Chunk {
 		this.intro = content + this.intro;
 	}
 
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
 	split(index) {
 		const sliceIndex = index - this.start;
 
@@ -364,8 +374,8 @@ let Chunk$1 = class Chunk {
 };
 
 function getBtoa() {
-	if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
-		return (str) => window.btoa(unescape(encodeURIComponent(str)));
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
 	} else if (typeof Buffer === 'function') {
 		return (str) => Buffer.from(str, 'utf-8').toString('base64');
 	} else {
@@ -1042,6 +1052,28 @@ class MagicString {
 		return this;
 	}
 
+	reset(start, end) {
+		while (start < 0) start += this.original.length;
+		while (end < 0) end += this.original.length;
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
 	lastChar() {
 		if (this.outro.length) return this.outro[this.outro.length - 1];
 		let chunk = this.lastChunk;
@@ -4822,8 +4854,15 @@ class Method extends ExpressionEntity {
         this.description = description;
     }
     deoptimizeArgumentsOnInteractionAtPath({ args, type }, path) {
-        if (type === INTERACTION_CALLED && path.length === 0 && this.description.mutatesSelfAsArray) {
-            args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+        if (type === INTERACTION_CALLED && path.length === 0) {
+            if (this.description.mutatesSelfAsArray) {
+                args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+            }
+            if (this.description.mutatesArgs) {
+                for (let index = 1; index < args.length; index++) {
+                    args[index].deoptimizePath(UNKNOWN_PATH);
+                }
+            }
         }
     }
     getReturnExpressionWhenCalledAtPath(path, { args }) {
@@ -4863,6 +4902,7 @@ class Method extends ExpressionEntity {
 const METHOD_RETURNS_BOOLEAN = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
@@ -4871,6 +4911,7 @@ const METHOD_RETURNS_BOOLEAN = [
 const METHOD_RETURNS_STRING = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_STRING
@@ -4879,6 +4920,7 @@ const METHOD_RETURNS_STRING = [
 const METHOD_RETURNS_NUMBER = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -4887,6 +4929,7 @@ const METHOD_RETURNS_NUMBER = [
 const METHOD_RETURNS_UNKNOWN = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -5301,6 +5344,7 @@ const NEW_ARRAY_PROPERTIES = [
 const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
     new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
@@ -5309,6 +5353,7 @@ const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
 const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
     new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -5317,6 +5362,7 @@ const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
 const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
@@ -5325,6 +5371,7 @@ const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
 const METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
@@ -5333,14 +5380,16 @@ const METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
 const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
     })
 ];
-const METHOD_MUTATES_SELF_RETURNS_NUMBER = [
+const METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER = [
     new Method({
         callsArgs: null,
+        mutatesArgs: true,
         mutatesSelfAsArray: true,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -5349,6 +5398,7 @@ const METHOD_MUTATES_SELF_RETURNS_NUMBER = [
 const METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -5357,6 +5407,7 @@ const METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
 const METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -5365,6 +5416,7 @@ const METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
 const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
     new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -5373,6 +5425,7 @@ const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
 const METHOD_MUTATES_SELF_RETURNS_SELF = [
     new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: 'self',
         returnsPrimitive: null
@@ -5381,6 +5434,7 @@ const METHOD_MUTATES_SELF_RETURNS_SELF = [
 const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF = [
     new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: 'self',
         returnsPrimitive: null
@@ -5410,7 +5464,7 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     lastIndexOf: METHOD_RETURNS_NUMBER,
     map: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     pop: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
-    push: METHOD_MUTATES_SELF_RETURNS_NUMBER,
+    push: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
     reduce: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     reduceRight: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     reverse: METHOD_MUTATES_SELF_RETURNS_SELF,
@@ -5421,7 +5475,7 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
     toLocaleString: METHOD_RETURNS_STRING,
     toString: METHOD_RETURNS_STRING,
-    unshift: METHOD_MUTATES_SELF_RETURNS_NUMBER,
+    unshift: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
     values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
 }, OBJECT_PROTOTYPE, true);
 
@@ -12755,7 +12809,7 @@ class Module {
         this.ast.bind();
     }
     error(properties, pos) {
-        this.addLocationToLogProps(properties, pos);
+        pos !== undefined && this.addLocationToLogProps(properties, pos);
         return error(properties);
     }
     // sum up the length of all ast nodes that are included
@@ -14658,13 +14712,13 @@ const hashPlaceholderLeft = '!~{';
 const hashPlaceholderRight = '}~';
 const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
 // This is the size of a 128-bits xxhash with base64url encoding
-const maxHashSize = 22;
-const defaultHashSize = 8;
+const MAX_HASH_SIZE = 22;
+const DEFAULT_HASH_SIZE = 8;
 const getHashPlaceholderGenerator = () => {
     let nextIndex = 0;
-    return (optionName, hashSize = defaultHashSize) => {
-        if (hashSize > maxHashSize) {
-            return error(logFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
+    return (optionName, hashSize) => {
+        if (hashSize > MAX_HASH_SIZE) {
+            return error(logFailedValidation(`Hashes cannot be longer than ${MAX_HASH_SIZE} characters, received ${hashSize}. Check the "${optionName}" option.`));
         }
         const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
         if (placeholder.length > hashSize) {
@@ -14673,7 +14727,7 @@ const getHashPlaceholderGenerator = () => {
         return placeholder;
     };
 };
-const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${maxHashSize - hashPlaceholderOverhead}}${hashPlaceholderRight}`, 'g');
+const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${MAX_HASH_SIZE - hashPlaceholderOverhead}}${hashPlaceholderRight}`, 'g');
 const replacePlaceholders = (code, hashesByPlaceholder) => code.replace(REPLACER_REGEX, placeholder => hashesByPlaceholder.get(placeholder) || placeholder);
 const replaceSinglePlaceholder = (code, placeholder, value) => code.replace(REPLACER_REGEX, match => (match === placeholder ? value : match));
 const replacePlaceholdersWithDefaultAndGetContainedPlaceholders = (code, placeholders) => {
@@ -15037,7 +15091,8 @@ class Chunk {
                 : [chunkFileNames, 'output.chunkFileNames'];
             fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
                 format: () => format,
-                hash: size => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size)),
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
                 name: () => this.getChunkName()
             });
             if (!hashPlaceholder) {
@@ -15065,7 +15120,8 @@ class Chunk {
             sourcemapFileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
                 chunkhash: () => this.getPreliminaryFileName().hashPlaceholder || '',
                 format: () => format,
-                hash: size => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size)),
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
                 name: () => this.getChunkName()
             });
             if (!hashPlaceholder) {
@@ -16764,21 +16820,23 @@ function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain,
 }
 
 let textEncoder;
-function getXxhash(input) {
-    let buffer;
+const getHash64 = input => xxhashBase64Url(ensureBuffer(input));
+const getHash36 = input => xxhashBase36(ensureBuffer(input));
+const getHash16 = input => xxhashBase16(ensureBuffer(input));
+const hasherByType = {
+    base36: getHash36,
+    base64: getHash64,
+    hex: getHash16
+};
+function ensureBuffer(input) {
     if (typeof input === 'string') {
         if (typeof Buffer === 'undefined') {
             textEncoder ??= new TextEncoder();
-            buffer = textEncoder.encode(input);
+            return textEncoder.encode(input);
         }
-        else {
-            buffer = Buffer.from(input);
-        }
-    }
-    else {
-        buffer = input;
+        return Buffer.from(input);
     }
-    return xxhashBase64Url(buffer);
+    return input;
 }
 
 // this looks ridiculous, but it prevents sourcemap tooling from mistaking
@@ -16792,9 +16850,10 @@ async function renderChunks(chunks, bundle, pluginDriver, outputOptions, log) {
     const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
     timeEnd('render chunks', 2);
     timeStart('transform chunks', 2);
+    const getHash = hasherByType[outputOptions.hashCharacters];
     const chunkGraph = getChunkGraph(chunks);
-    const { initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log);
-    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle);
+    const { initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash);
     addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
     timeEnd('transform chunks', 2);
 }
@@ -16874,7 +16933,7 @@ async function transformChunk(magicString, fileName, usedModules, chunkGraph, op
         map
     };
 }
-async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log) {
+async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log) {
     const nonHashedChunksWithPlaceholders = [];
     const renderedChunksByPlaceholder = new Map();
     const hashDependenciesByPlaceholder = new Map();
@@ -16909,7 +16968,7 @@ async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGrap
             renderedChunksByPlaceholder.set(hashPlaceholder, transformedChunk);
             hashDependenciesByPlaceholder.set(hashPlaceholder, {
                 containedPlaceholders,
-                contentHash: getXxhash(contentToHash)
+                contentHash: getHash(contentToHash)
             });
         }
         else {
@@ -16917,7 +16976,7 @@ async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGrap
         }
         const sourcemapHashPlaceholder = preliminarySourcemapFileName?.hashPlaceholder;
         if (map && sourcemapHashPlaceholder) {
-            initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getXxhash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
+            initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getHash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
         }
     }));
     return {
@@ -16927,7 +16986,7 @@ async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGrap
         renderedChunksByPlaceholder
     };
 }
-function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle) {
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash) {
     const hashesByPlaceholder = new Map(initialHashesByPlaceholder);
     for (const [placeholder, { fileName }] of renderedChunksByPlaceholder) {
         let contentToHash = '';
@@ -16947,7 +17006,7 @@ function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlac
             if (finalHash) {
                 contentToHash = finalHash;
             }
-            finalHash = getXxhash(contentToHash).slice(0, placeholder.length);
+            finalHash = getHash(contentToHash).slice(0, placeholder.length);
             finalFileName = replaceSinglePlaceholder(fileName, placeholder, finalHash);
         } while (bundle[lowercaseBundleKeys].has(finalFileName.toLowerCase()));
         bundle[finalFileName] = FILE_PLACEHOLDER;
@@ -18114,7 +18173,7 @@ function generateAssetFileName(name, source, sourceHash, outputOptions, bundle)
         : outputOptions.assetFileNames, 'output.assetFileNames', {
         ext: () => extname(emittedName).slice(1),
         extname: () => extname(emittedName),
-        hash: size => sourceHash.slice(0, Math.max(0, size || defaultHashSize)),
+        hash: size => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
         name: () => emittedName.slice(0, Math.max(0, emittedName.length - extname(emittedName).length))
     }), bundle);
 }
@@ -18223,9 +18282,11 @@ class FileEmitter {
             this.facadeChunkByModule = facadeChunkByModule;
         };
         this.setOutputBundle = (bundle, outputOptions) => {
+            const getHash = hasherByType[outputOptions.hashCharacters];
             const output = (this.output = {
                 bundle,
                 fileNamesBySource: new Map(),
+                getHash,
                 outputOptions
             });
             for (const emittedFile of this.filesByReferenceId.values()) {
@@ -18240,7 +18301,7 @@ class FileEmitter {
                         this.finalizeAdditionalAsset(consumedFile, consumedFile.source, output);
                     }
                     else {
-                        const sourceHash = getXxhash(consumedFile.source);
+                        const sourceHash = getHash(consumedFile.source);
                         getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
                     }
                 }
@@ -18263,7 +18324,7 @@ class FileEmitter {
     assignReferenceId(file, idBase) {
         let referenceId = idBase;
         do {
-            referenceId = getXxhash(referenceId).slice(0, 8).replaceAll('-', '$');
+            referenceId = getHash64(referenceId).slice(0, 8).replaceAll('-', '$');
         } while (this.filesByReferenceId.has(referenceId) ||
             this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
         file.referenceId = referenceId;
@@ -18374,11 +18435,11 @@ class FileEmitter {
         }
         return referenceId;
     }
-    finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, outputOptions }) {
+    finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, getHash, outputOptions }) {
         let { fileName, needsCodeReference, referenceId } = consumedFile;
         // Deduplicate assets if an explicit fileName is not provided
         if (!fileName) {
-            const sourceHash = getXxhash(source);
+            const sourceHash = getHash(source);
             fileName = fileNamesBySource.get(sourceHash);
             if (!fileName) {
                 fileName = generateAssetFileName(consumedFile.name, source, sourceHash, outputOptions, bundle);
@@ -19236,6 +19297,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         freeze: config.freeze ?? true,
         generatedCode,
         globals: config.globals || {},
+        hashCharacters: config.hashCharacters ?? 'base64',
         hoistTransitiveImports: config.hoistTransitiveImports ?? true,
         indent: getIndent(config, compact),
         inlineDynamicImports,
@@ -19936,6 +19998,7 @@ async function mergeOutputOptions(config, overrides, log) {
         freeze: getOption('freeze'),
         generatedCode: getObjectOption(config, overrides, 'generatedCode', objectifyOptionWithPresets(generatedCodePresets, 'output.generatedCode', URL_OUTPUT_GENERATEDCODE, '')),
         globals: getOption('globals'),
+        hashCharacters: getOption('hashCharacters'),
         hoistTransitiveImports: getOption('hoistTransitiveImports'),
         indent: getOption('indent'),
         inlineDynamicImports: getOption('inlineDynamicImports'),