@coderline/alphatab-vite 1.7.0-alpha.1617 → 1.7.0-alpha.1625

package/dist/copyAssetsPlugin.mjs

@@ -0,0 +1,143 @@
+/*!
+ * alphaTab Vite Plugin v1.7.0-alpha.1625 (develop, build 1625)
+ *
+ * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This library uses code from Vite (https://github.com/vitejs/vite/), licensed under:
+ *
+ * MIT License
+ * Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @preserve
+ * @license
+ */
+
+import fs from 'node:fs';
+import * as path from 'node:path';
+import * as url from 'node:url';
+
+/**
+ * @public
+ */
+function copyAssetsPlugin(options) {
+    let resolvedConfig;
+    let output = false;
+    return {
+        name: 'vite-plugin-alphatab-copy',
+        enforce: 'pre',
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        buildEnd() {
+            // reset for watch mode
+            output = false;
+        },
+        async buildStart() {
+            // run copy only once even if multiple bundles are generated
+            if (output) {
+                return;
+            }
+            output = true;
+            let alphaTabSourceDir = options.alphaTabSourceDir;
+            if (!alphaTabSourceDir) {
+                try {
+                    const isEsm = typeof import.meta.url === 'string';
+                    if (isEsm) {
+                        alphaTabSourceDir = url.fileURLToPath(import.meta.resolve('@coderline/alphatab'));
+                    }
+                    else {
+                        alphaTabSourceDir = require.resolve('@coderline/alphatab');
+                    }
+                    alphaTabSourceDir = path.resolve(alphaTabSourceDir, '..');
+                    // walk up to package.json
+                    while (alphaTabSourceDir) {
+                        if (await fs.promises
+                            .access(path.join(alphaTabSourceDir, 'package.json'), fs.constants.F_OK)
+                            .then(() => true)
+                            .catch(() => false)) {
+                            // found package directory
+                            alphaTabSourceDir = path.resolve(alphaTabSourceDir, 'dist');
+                            break;
+                        }
+                        else {
+                            // reached root
+                            const parent = path.resolve(alphaTabSourceDir, '..');
+                            if (parent === alphaTabSourceDir) {
+                                alphaTabSourceDir = undefined;
+                            }
+                            else {
+                                alphaTabSourceDir = parent;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    alphaTabSourceDir = path.join(resolvedConfig.root, 'node_modules/@coderline/alphatab/dist/');
+                }
+            }
+            let isValidAlphaTabSourceDir;
+            if (alphaTabSourceDir) {
+                try {
+                    await fs.promises.access(path.join(alphaTabSourceDir, 'alphaTab.mjs'), fs.constants.F_OK);
+                    isValidAlphaTabSourceDir = true;
+                }
+                catch {
+                    isValidAlphaTabSourceDir = false;
+                }
+            }
+            else {
+                isValidAlphaTabSourceDir = false;
+            }
+            if (!isValidAlphaTabSourceDir) {
+                resolvedConfig.logger.error('Could not find alphaTab, please ensure it is installed into node_modules or configure alphaTabSourceDir');
+                return;
+            }
+            const outputPath = (options.assetOutputDir ?? resolvedConfig.publicDir);
+            if (!outputPath) {
+                return;
+            }
+            async function copyFiles(subdir) {
+                const fullDir = path.join(alphaTabSourceDir, subdir);
+                const files = await fs.promises.readdir(fullDir, {
+                    withFileTypes: true
+                });
+                await fs.promises.mkdir(path.join(outputPath, subdir), {
+                    recursive: true
+                });
+                await Promise.all(files
+                    .filter(f => f.isFile())
+                    .map(async (file) => {
+                    // node v20.12.0 has parentPath pointing to the path (not the file)
+                    // see https://github.com/nodejs/node/pull/50976
+                    const sourceFilename = path.join(file.parentPath ?? file.path, file.name);
+                    await fs.promises.copyFile(sourceFilename, path.join(outputPath, subdir, file.name));
+                }));
+            }
+            await Promise.all([copyFiles('font'), copyFiles('soundfont')]);
+        }
+    };
+}
+
+export { copyAssetsPlugin };

package/dist/importMetaPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { AlphaTabVitePluginOptions } from './AlphaTabVitePluginOptions';
+/**
+ * @public
+ */
+export declare function importMetaUrlPlugin(options: AlphaTabVitePluginOptions): Plugin;

package/dist/importMetaPlugin.mjs

@@ -0,0 +1,197 @@
+/*!
+ * alphaTab Vite Plugin v1.7.0-alpha.1625 (develop, build 1625)
+ *
+ * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This library uses code from Vite (https://github.com/vitejs/vite/), licensed under:
+ *
+ * MIT License
+ * Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @preserve
+ * @license
+ */
+
+import path__default from 'node:path';
+import MagicString from 'magic-string';
+import { fileToUrl } from './bridge/asset.mjs';
+import { cleanUrl, injectQuery, evalValue } from './bridge/utils.mjs';
+import { tryOptimizedDepResolve } from './bridge/optimizer.mjs';
+import { tryFsResolve } from './bridge/resolve.mjs';
+import { AlphaTabWorkerTypes, workerFileToUrl, WORKER_FILE_ID } from './bridge/worker.mjs';
+
+// This file contains a customized and adapted version of the Vite built-in workerImportMetaUrl plugin
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/plugins/workerImportMetaUrl.ts
+// The main adaptions are:
+// - Custom syntax detection for workers and audio worklets
+// - Custom worker types and worker URLs to not overlap with the original plugin
+// With https://github.com/vitejs/vite/pull/16422 integrated this custom code should not be needed anymore
+// Original Sources Licensed under:
+// MIT License
+// Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+const alphaTabWorkerPatterns = [
+    ['alphaTabWorker', 'new', 'alphaTabUrl', 'import.meta.url'],
+    ['alphaTabWorklet.addModule', 'new', 'alphaTabUrl', 'import.meta.url']
+];
+function includesAlphaTabWorker(code) {
+    for (const pattern of alphaTabWorkerPatterns) {
+        let position = 0;
+        for (const match of pattern) {
+            position = code.indexOf(match, position);
+            if (position === -1) {
+                break;
+            }
+        }
+        if (position !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+function getWorkerType(code, match) {
+    if (match[1].includes('.addModule')) {
+        return AlphaTabWorkerTypes.AudioWorklet;
+    }
+    const endOfMatch = match.indices[0][1];
+    const startOfOptions = code.indexOf('{', endOfMatch);
+    if (startOfOptions === -1) {
+        return AlphaTabWorkerTypes.WorkerClassic;
+    }
+    const endOfOptions = code.indexOf('}', endOfMatch);
+    if (endOfOptions === -1) {
+        return AlphaTabWorkerTypes.WorkerClassic;
+    }
+    const endOfWorkerCreate = code.indexOf(')', endOfMatch);
+    if (startOfOptions > endOfWorkerCreate || endOfOptions > endOfWorkerCreate) {
+        return AlphaTabWorkerTypes.WorkerClassic;
+    }
+    let workerOptions = code.slice(startOfOptions, endOfOptions + 1);
+    try {
+        workerOptions = evalValue(workerOptions);
+    }
+    catch {
+        return AlphaTabWorkerTypes.WorkerClassic;
+    }
+    if (typeof workerOptions === 'object' && workerOptions?.type === 'module') {
+        return AlphaTabWorkerTypes.WorkerModule;
+    }
+    return AlphaTabWorkerTypes.WorkerClassic;
+}
+/**
+ * @public
+ */
+function importMetaUrlPlugin(options) {
+    let resolvedConfig;
+    let isBuild;
+    let preserveSymlinks;
+    const isWorkerActive = options.webWorkers !== false;
+    const isWorkletActive = options.audioWorklets !== false;
+    const isActive = isWorkerActive || isWorkletActive;
+    return {
+        name: 'vite-plugin-alphatab-url',
+        enforce: 'pre',
+        configResolved(config) {
+            resolvedConfig = config;
+            isBuild = config.command === 'build';
+            preserveSymlinks = config.resolve.preserveSymlinks;
+        },
+        shouldTransformCachedModule({ code }) {
+            if (isActive && isBuild && resolvedConfig.build.watch && includesAlphaTabWorker(code)) {
+                return true;
+            }
+            return;
+        },
+        async transform(code, id, options) {
+            if (!isActive || options?.ssr || !includesAlphaTabWorker(code)) {
+                return;
+            }
+            let s;
+            const alphaTabWorkerPattern = /\b(alphaTabWorker|alphaTabWorklet\.addModule)\s*\(\s*(new\s+[^ (]+alphaTabUrl\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\))/dg;
+            let match = alphaTabWorkerPattern.exec(code);
+            while (match) {
+                const workerType = getWorkerType(code, match);
+                let typeActive = false;
+                switch (workerType) {
+                    case AlphaTabWorkerTypes.WorkerClassic:
+                    case AlphaTabWorkerTypes.WorkerModule:
+                        typeActive = isWorkerActive;
+                        break;
+                    case AlphaTabWorkerTypes.AudioWorklet:
+                        typeActive = isWorkletActive;
+                        break;
+                }
+                if (!typeActive) {
+                    match = alphaTabWorkerPattern.exec(code);
+                    continue;
+                }
+                s ??= new MagicString(code);
+                const url = code.slice(match.indices[3][0] + 1, match.indices[3][1] - 1);
+                let file = path__default.resolve(path__default.dirname(id), url);
+                file =
+                    tryFsResolve(file, preserveSymlinks) ??
+                        tryOptimizedDepResolve(resolvedConfig, options?.ssr === true, url, id, preserveSymlinks) ??
+                        file;
+                let builtUrl;
+                if (isBuild) {
+                    builtUrl = await workerFileToUrl(resolvedConfig, file);
+                }
+                else {
+                    builtUrl = await fileToUrl(cleanUrl(file), resolvedConfig);
+                    builtUrl = injectQuery(builtUrl, `${WORKER_FILE_ID}&type=${workerType}`);
+                }
+                s.update(match.indices[3][0], match.indices[3][1], 
+                // add `'' +` to skip vite:asset-import-meta-url plugin
+                `new URL('' + ${JSON.stringify(builtUrl)}, import.meta.url)`);
+                match = alphaTabWorkerPattern.exec(code);
+            }
+            if (s) {
+                return {
+                    code: s.toString(),
+                    map: resolvedConfig.command === 'build' && resolvedConfig.build.sourcemap
+                        ? s.generateMap({ hires: 'boundary', source: id })
+                        : null
+                };
+            }
+            return null;
+        }
+    };
+}
+
+export { importMetaUrlPlugin };

package/dist/workerPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { AlphaTabVitePluginOptions } from './AlphaTabVitePluginOptions';
+/**
+ * @public
+ */
+export declare function workerPlugin(options: AlphaTabVitePluginOptions): Plugin;

package/dist/workerPlugin.mjs

@@ -0,0 +1,201 @@
+/*!
+ * alphaTab Vite Plugin v1.7.0-alpha.1625 (develop, build 1625)
+ *
+ * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This library uses code from Vite (https://github.com/vitejs/vite/), licensed under:
+ *
+ * MIT License
+ * Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @preserve
+ * @license
+ */
+
+import * as path from 'node:path';
+import MagicString from 'magic-string';
+import { encodeURIPath } from './bridge/utils.mjs';
+import { createToImportMetaURLBasedRelativeRuntime, toOutputFilePathInJS } from './bridge/build.mjs';
+import { ENV_PUBLIC_PATH } from './bridge/constants.mjs';
+import 'node:fs';
+import 'vite';
+import { workerCache, isSameContent, AlphaTabWorkerTypes, WORKER_ASSET_ID, WORKER_FILE_ID } from './bridge/worker.mjs';
+
+// This file contains a customized and adapted version of the Vite built-in worker plugin
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/plugins/worker.ts
+// This is more or less a 1:1 copy of the original worker plugin with following adaptions:
+// - Only handle syntax variants known to be used in alphaTab
+// - Use the alphaTab URL markers
+// - Some refactoring for better code understanding
+// With https://github.com/vitejs/vite/pull/16422 integrated this custom code might not be needed anymore
+// Some adjustment for audio worklet in vite might be needed to treat them as type "module" workers
+// Original Sources Licensed under:
+// MIT License
+// Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+const workerFileRE = new RegExp(`(?:\\?|&)${WORKER_FILE_ID}&type=(\\w+)(?:&|$)`);
+const workerAssetUrlRE = new RegExp(`${WORKER_ASSET_ID}([a-z\\d]{8})__`, 'g');
+/**
+ * @public
+ */
+function workerPlugin(options) {
+    let resolvedConfig;
+    let isBuild;
+    let isWorker;
+    const isWorkerActive = options.webWorkers !== false;
+    const isWorkletActive = options.audioWorklets !== false;
+    const isActive = isWorkerActive || isWorkletActive;
+    return {
+        name: 'vite-plugin-alphatab-worker',
+        configResolved(config) {
+            resolvedConfig = config;
+            isBuild = config.command === 'build';
+            isWorker = config.isWorker;
+        },
+        buildStart() {
+            if (!isActive || isWorker) {
+                return;
+            }
+            workerCache.set(resolvedConfig, {
+                assets: new Map(),
+                bundle: new Map(),
+                fileNameHash: new Map()
+            });
+        },
+        load(id) {
+            if (isActive && isBuild && id.includes(WORKER_FILE_ID)) {
+                return '';
+            }
+            return;
+        },
+        shouldTransformCachedModule({ id }) {
+            if (isActive && isBuild && resolvedConfig.build.watch && id.includes(WORKER_FILE_ID)) {
+                return true;
+            }
+            return;
+        },
+        async transform(raw, id) {
+            if (!isActive) {
+                return;
+            }
+            const match = workerFileRE.exec(id);
+            if (!match) {
+                return;
+            }
+            // inject env to worker file, might be needed by imported scripts
+            const envScriptPath = JSON.stringify(path.posix.join(resolvedConfig.base, ENV_PUBLIC_PATH));
+            const workerType = match[1];
+            let injectEnv = '';
+            switch (workerType) {
+                case AlphaTabWorkerTypes.WorkerClassic:
+                    injectEnv = `importScripts(${envScriptPath})\n`;
+                    break;
+                case AlphaTabWorkerTypes.WorkerModule:
+                case AlphaTabWorkerTypes.AudioWorklet:
+                    injectEnv = `import ${envScriptPath}\n`;
+                    break;
+            }
+            if (injectEnv) {
+                const s = new MagicString(raw);
+                s.prepend(injectEnv);
+                return {
+                    code: s.toString(),
+                    map: s.generateMap({ hires: 'boundary' })
+                };
+            }
+            return;
+        },
+        renderChunk(code, chunk, outputOptions) {
+            // when building the worker URLs are replaced with some placeholders
+            // here we replace those placeholders with the final file names respecting chunks
+            let s;
+            const result = () => {
+                return (s && {
+                    code: s.toString(),
+                    map: resolvedConfig.build.sourcemap ? s.generateMap({ hires: 'boundary' }) : null
+                });
+            };
+            workerAssetUrlRE.lastIndex = 0;
+            if (workerAssetUrlRE.test(code)) {
+                const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(outputOptions.format, resolvedConfig.isWorker);
+                s = new MagicString(code);
+                workerAssetUrlRE.lastIndex = 0;
+                // Replace "VITE_WORKER_ASSET__5aa0ddc0" using relative paths
+                const workerMap = workerCache.get(resolvedConfig.mainConfig || resolvedConfig);
+                const { fileNameHash } = workerMap;
+                let match = workerAssetUrlRE.exec(code);
+                while (match) {
+                    const [full, hash] = match;
+                    const filename = fileNameHash.get(hash);
+                    const replacement = toOutputFilePathInJS(filename, 'asset', chunk.fileName, 'js', resolvedConfig, toRelativeRuntime);
+                    const replacementString = typeof replacement === 'string'
+                        ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1)
+                        : `"+${replacement.runtime}+"`;
+                    s.update(match.index, match.index + full.length, replacementString);
+                    match = workerAssetUrlRE.exec(code);
+                }
+            }
+            return result();
+        },
+        generateBundle(_, bundle) {
+            if (isWorker) {
+                return;
+            }
+            const workerMap = workerCache.get(resolvedConfig);
+            for (const asset of workerMap.assets.values()) {
+                const duplicateAsset = bundle[asset.fileName];
+                if (duplicateAsset) {
+                    const content = duplicateAsset.type === 'asset' ? duplicateAsset.source : duplicateAsset.code;
+                    // don't emit if the file name and the content is same
+                    if (isSameContent(content, asset.source)) {
+                        return;
+                    }
+                }
+                this.emitFile({
+                    type: 'asset',
+                    fileName: asset.fileName,
+                    source: asset.source
+                });
+            }
+            workerMap.assets.clear();
+        }
+    };
+}
+
+export { workerPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coderline/alphatab-vite",
-    "version": "1.7.0-alpha.1617",
+    "version": "1.7.0-alpha.1625",
     "description": "A plugin for Vite to bundle alphaTab into your webapps.",
     "keywords": [
         "guitar",
@@ -29,12 +29,16 @@
         "clean": "rimraf dist",
         "lint": "biome lint",
         "typecheck": "tsc --noEmit",
-        "build": "vite build --mode esm && vite build --mode cjs",
+        "build": "vite build",
         "test": "mocha"
     },
     "dependencies": {
+        "magic-string": "^0.30.21",
         "vite": "^7.2.2"
     },
+    "engines": {
+        "node": ">=20.19.0"
+    },
     "devDependencies": {
         "@biomejs/biome": "^2.2.6",
         "@microsoft/api-extractor": "^7.53.3",
@@ -45,15 +49,15 @@
         "chai": "^6.2.1",
         "mocha": "^11.7.5",
         "rimraf": "^6.1.0",
+        "rollup-plugin-node-externals": "^8.1.2",
         "terser": "^5.44.1",
         "tslib": "^2.8.1",
         "tsx": "^4.20.6",
         "typescript": "^5.9.3"
     },
     "files": [
-        "/dist/alphaTab*.js",
-        "/dist/alphaTab*.mjs",
-        "/dist/alphaTab*.ts",
+        "/dist/**",
+        "!/dist/types",
         "LICENSE",
         "LICENSE.header",
         "README.md"