@coderline/alphatab-webpack 1.7.0-alpha.1617 → 1.7.0-alpha.1626

package/dist/AlphaTabAudioWorklet.mjs

@@ -0,0 +1,114 @@
+/*!
+ * alphaTab WebPack Plugin v1.7.0-alpha.1626 (develop, build 1626)
+ *
+ * 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 WebPack (https://github.com/webpack/webpack/), licensed under:
+ *
+ * Copyright JS Foundation and other 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 { tapJavaScript, parseModuleUrl, getWorkerRuntime } from './Utils.mjs';
+
+const AlphaTabWorkletSpecifierTag = Symbol('alphatab worklet specifier tag');
+const workletIndexMap = new WeakMap();
+/**
+ * Configures the Audio Worklet aspects within webpack.
+ * The counterpart which this plugin detects sits in alphaTab.main.ts
+ * @param pluginName
+ * @param options
+ * @param compiler
+ * @param compilation
+ * @param normalModuleFactory
+ * @param cachedContextify
+ * @returns
+ * @internal
+ */
+function configureAudioWorklet(webPackWithAlphaTab, pluginName, options, compiler, compilation, normalModuleFactory, cachedContextify) {
+    if (options.audioWorklets === false) {
+        return;
+    }
+    webPackWithAlphaTab.alphaTab.registerWorkletDependency(compilation, normalModuleFactory);
+    const handleAlphaTabWorklet = (parser, expr) => {
+        const [arg1] = expr.arguments;
+        const parsedUrl = parseModuleUrl(parser, arg1);
+        if (!parsedUrl) {
+            return;
+        }
+        const [url] = parsedUrl;
+        if (!url.isString()) {
+            return;
+        }
+        const runtime = getWorkerRuntime(parser, compilation, cachedContextify, workletIndexMap);
+        const block = new webPackWithAlphaTab.webpack.AsyncDependenciesBlock({
+            entryOptions: {
+                chunkLoading: false,
+                wasmLoading: false,
+                runtime: runtime,
+                library: {
+                    // prevent any built-in/default library settings
+                    // to be active for this chunk
+                    type: 'at-worklet'
+                }
+            }
+        });
+        block.loc = expr.loc;
+        const workletBootstrap = webPackWithAlphaTab.alphaTab.createWorkletDependency(url.string, [expr.range[0], expr.range[1]], compiler.options.output.workerPublicPath);
+        workletBootstrap.loc = expr.loc;
+        block.addDependency(workletBootstrap);
+        parser.state.module.addBlock(block);
+        return true;
+    };
+    const parserPlugin = (parser) => {
+        const pattern = 'alphaTabWorklet';
+        const itemMembers = 'addModule';
+        parser.hooks.preDeclarator.tap(pluginName, (decl) => {
+            if (decl.id.type === 'Identifier' && decl.id.name === pattern) {
+                parser.tagVariable(decl.id.name, AlphaTabWorkletSpecifierTag);
+                return true;
+            }
+            return;
+        });
+        parser.hooks.pattern.for(pattern).tap(pluginName, (pattern) => {
+            parser.tagVariable(pattern.name, AlphaTabWorkletSpecifierTag);
+            return true;
+        });
+        parser.hooks.callMemberChain
+            .for(AlphaTabWorkletSpecifierTag)
+            .tap(pluginName, (expression, members) => {
+            if (itemMembers !== members.join('.')) {
+                return;
+            }
+            return handleAlphaTabWorklet(parser, expression);
+        });
+    };
+    tapJavaScript(normalModuleFactory, pluginName, parserPlugin);
+}
+
+export { configureAudioWorklet };

package/dist/AlphaTabWebPackPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { AlphaTabWebPackPluginOptions } from './AlphaTabWebPackPluginOptions';
+import type { webpackTypes } from './Utils';
+/**
+ * @public
+ */
+export declare class AlphaTabWebPackPlugin {
+    options: AlphaTabWebPackPluginOptions;
+    constructor(options?: AlphaTabWebPackPluginOptions);
+    apply(compiler: webpackTypes.Compiler): void;
+}

package/dist/AlphaTabWebPackPlugin.mjs

@@ -0,0 +1,311 @@
+/*!
+ * alphaTab WebPack Plugin v1.7.0-alpha.1626 (develop, build 1626)
+ *
+ * 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 WebPack (https://github.com/webpack/webpack/), licensed under:
+ *
+ * Copyright JS Foundation and other 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';
+import { injectWorkerRuntimeModule } from './AlphaTabWorkerRuntimeModule.mjs';
+import { configureAudioWorklet } from './AlphaTabAudioWorklet.mjs';
+import { configureWebWorker } from './AlphaTabWebWorker.mjs';
+import { injectWebWorkerDependency } from './AlphaTabWebWorkerDependency.mjs';
+import { injectWorkletRuntimeModule } from './AlphaTabWorkletStartRuntimeModule.mjs';
+import { injectWorkletDependency } from './AlphaTabWorkletDependency.mjs';
+
+/**@target web */
+const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+const relativePathToRequest = (relativePath) => {
+    if (relativePath === '') {
+        return './.';
+    }
+    if (relativePath === '..') {
+        return '../.';
+    }
+    if (relativePath.startsWith('../')) {
+        return relativePath;
+    }
+    return `./${relativePath}`;
+};
+const absoluteToRequest = (context, maybeAbsolutePath) => {
+    if (maybeAbsolutePath[0] === '/') {
+        if (maybeAbsolutePath.length > 1 && maybeAbsolutePath[maybeAbsolutePath.length - 1] === '/') {
+            // this 'path' is actually a regexp generated by dynamic requires.
+            // Don't treat it as an absolute path.
+            return maybeAbsolutePath;
+        }
+        const querySplitPos = maybeAbsolutePath.indexOf('?');
+        let resource = querySplitPos === -1 ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = relativePathToRequest(path.posix.relative(context, resource));
+        return querySplitPos === -1 ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
+        const querySplitPos = maybeAbsolutePath.indexOf('?');
+        let resource = querySplitPos === -1 ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = path.win32.relative(context, resource);
+        if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
+            resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, '/'));
+        }
+        return querySplitPos === -1 ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    // not an absolute path
+    return maybeAbsolutePath;
+};
+const _contextify = (context, request) => {
+    return request
+        .split('!')
+        .map(r => absoluteToRequest(context, r))
+        .join('!');
+};
+const makeCacheableWithContext = (fn) => {
+    const cache = new WeakMap();
+    const cachedFn = (context, identifier, associatedObjectForCache) => {
+        if (!associatedObjectForCache) {
+            return fn(context, identifier);
+        }
+        let innerCache = cache.get(associatedObjectForCache);
+        if (innerCache === undefined) {
+            innerCache = new Map();
+            cache.set(associatedObjectForCache, innerCache);
+        }
+        let cachedResult;
+        let innerSubCache = innerCache.get(context);
+        if (innerSubCache === undefined) {
+            innerSubCache = new Map();
+            innerCache.set(context, innerSubCache);
+        }
+        else {
+            cachedResult = innerSubCache.get(identifier);
+        }
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const result = fn(context, identifier);
+        innerSubCache.set(identifier, result);
+        return result;
+    };
+    cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+        let innerSubCache;
+        if (associatedObjectForCache) {
+            let innerCache = cache.get(associatedObjectForCache);
+            if (innerCache === undefined) {
+                innerCache = new Map();
+                cache.set(associatedObjectForCache, innerCache);
+            }
+            innerSubCache = innerCache.get(context);
+            if (innerSubCache === undefined) {
+                innerSubCache = new Map();
+                innerCache.set(context, innerSubCache);
+            }
+        }
+        else {
+            innerSubCache = new Map();
+        }
+        const boundFn = (identifier) => {
+            const cachedResult = innerSubCache.get(identifier);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const result = fn(context, identifier);
+            innerSubCache.set(identifier, result);
+            return result;
+        };
+        return boundFn;
+    };
+    return cachedFn;
+};
+const contextify = makeCacheableWithContext(_contextify);
+/**
+ * @public
+ */
+class AlphaTabWebPackPlugin {
+    _webPackWithAlphaTab;
+    options;
+    constructor(options) {
+        this.options = options ?? {};
+    }
+    apply(compiler) {
+        // here we create all plugin related class implementations using
+        // the webpack instance provided to this plugin (not as global import)
+        // after that we use the helper and factory functions we add to webpack
+        const webPackWithAlphaTab = {
+            webpack: compiler.webpack,
+            alphaTab: {}
+        };
+        if ('alphaTab' in compiler.webpack.util.serialization.register) {
+            // prevent multi registration
+            webPackWithAlphaTab.alphaTab = compiler.webpack.util.serialization.register.alphaTab;
+        }
+        else {
+            compiler.webpack.util.serialization.register.alphaTab = webPackWithAlphaTab.alphaTab;
+            injectWebWorkerDependency(webPackWithAlphaTab);
+            injectWorkerRuntimeModule(webPackWithAlphaTab);
+            injectWorkletDependency(webPackWithAlphaTab);
+            injectWorkletRuntimeModule(webPackWithAlphaTab);
+        }
+        this._webPackWithAlphaTab = webPackWithAlphaTab;
+        this._configureSoundFont(compiler);
+        this._configure(compiler);
+    }
+    _configureSoundFont(compiler) {
+        if (this.options.assetOutputDir === false) {
+            return;
+        }
+        // register soundfont as resource
+        compiler.options.module.rules.push({
+            test: /\.sf2/,
+            type: 'asset/resource'
+        });
+        compiler.options.module.rules.push({
+            test: /\.sf3/,
+            type: 'asset/resource'
+        });
+    }
+    _configure(compiler) {
+        const pluginName = this.constructor.name;
+        const cachedContextify = contextify.bindContextCache(compiler.context, compiler.root);
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation, { normalModuleFactory }) => {
+            this._webPackWithAlphaTab.alphaTab.registerWebWorkerRuntimeModule(pluginName, compilation);
+            this._webPackWithAlphaTab.alphaTab.registerWorkletRuntimeModule(pluginName, compilation);
+            configureAudioWorklet(this._webPackWithAlphaTab, pluginName, this.options, compiler, compilation, normalModuleFactory, cachedContextify);
+            configureWebWorker(this._webPackWithAlphaTab, pluginName, this.options, compiler, compilation, normalModuleFactory, cachedContextify);
+            this._configureAssetCopy(this._webPackWithAlphaTab, pluginName, compiler, compilation);
+        });
+    }
+    _configureAssetCopy(webPackWithAlphaTab, pluginName, compiler, compilation) {
+        if (this.options.assetOutputDir === false) {
+            return;
+        }
+        const options = this.options;
+        compilation.hooks.processAssets.tapAsync({
+            name: pluginName,
+            stage: this._webPackWithAlphaTab.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+        }, async (_, callback) => {
+            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 = compilation.getPath('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) {
+                compilation.errors.push(new this._webPackWithAlphaTab.webpack.WebpackError('Could not find alphaTab, please ensure it is installed into node_modules or configure alphaTabSourceDir'));
+                return;
+            }
+            const outputPath = (options.assetOutputDir ?? compiler.options.output.path);
+            if (!outputPath) {
+                compilation.errors.push(new this._webPackWithAlphaTab.webpack.WebpackError('Need output.path configured in application to store asset files.'));
+                return;
+            }
+            async function copyFiles(subdir) {
+                const fullDir = path.join(alphaTabSourceDir, subdir);
+                compilation.contextDependencies.add(path.normalize(fullDir));
+                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));
+                    const assetFileName = `${subdir}/${file.name}`;
+                    const existingAsset = compilation.getAsset(assetFileName);
+                    const data = await fs.promises.readFile(sourceFilename);
+                    const source = new webPackWithAlphaTab.webpack.sources.RawSource(data);
+                    if (existingAsset) {
+                        compilation.updateAsset(assetFileName, source, {
+                            copied: true,
+                            sourceFilename
+                        });
+                    }
+                    else {
+                        compilation.emitAsset(assetFileName, source, {
+                            copied: true,
+                            sourceFilename
+                        });
+                    }
+                }));
+            }
+            await Promise.all([copyFiles('font'), copyFiles('soundfont')]);
+            callback();
+        });
+    }
+}
+
+export { AlphaTabWebPackPlugin };

package/dist/AlphaTabWebPackPluginOptions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @public
+ */
+export interface AlphaTabWebPackPluginOptions {
+    /**
+     * The location where alphaTab can be found.
+     * (default: node_modules/@coderline/alphatab/dist)
+     */
+    alphaTabSourceDir?: string;
+    /**
+     * The location where assets of alphaTab should be placed.
+     * Set it to false to disable the copying of assets like fonts.
+     * (default: compiler.options.output.path)
+     */
+    assetOutputDir?: string | false;
+    /**
+     * Whether alphaTab should configure the audio worklet support in WebPack.
+     * This might break support for audio playback unless audio worklet support is added
+     * through other means to WebPack.
+     * (default: true)
+     */
+    audioWorklets?: boolean;
+    /**
+     * Whether alphaTab should configure the web worklet support in WebPack.
+     * This might break support for audio playback and background unless audio worklet support is added
+     * through other means to WebPack.
+     * (default: true)
+     */
+    webWorkers?: boolean;
+}

package/dist/AlphaTabWebPackPluginOptions.mjs

@@ -0,0 +1,36 @@
+/*!
+ * alphaTab WebPack Plugin v1.7.0-alpha.1626 (develop, build 1626)
+ *
+ * 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 WebPack (https://github.com/webpack/webpack/), licensed under:
+ *
+ * Copyright JS Foundation and other 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
+ */
+

package/dist/AlphaTabWebWorker.mjs

@@ -0,0 +1,101 @@
+/*!
+ * alphaTab WebPack Plugin v1.7.0-alpha.1626 (develop, build 1626)
+ *
+ * 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 WebPack (https://github.com/webpack/webpack/), licensed under:
+ *
+ * Copyright JS Foundation and other 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 { tapJavaScript, parseModuleUrl, getWorkerRuntime } from './Utils.mjs';
+
+const workerIndexMap = new WeakMap();
+/**
+ * Configures the WebWorker aspects within webpack.
+ * The counterpart which this plugin detects sits in alphaTab.main.ts
+ * @param pluginName
+ * @param options
+ * @param compiler
+ * @param compilation
+ * @param normalModuleFactory
+ * @param cachedContextify
+ * @returns
+ * @internal
+ */
+function configureWebWorker(webPackWithAlphaTab, pluginName, options, compiler, compilation, normalModuleFactory, cachedContextify) {
+    if (options.audioWorklets === false) {
+        return;
+    }
+    webPackWithAlphaTab.alphaTab.registerWebWorkerDependency(compilation, normalModuleFactory);
+    new webPackWithAlphaTab.webpack.javascript.EnableChunkLoadingPlugin('import-scripts').apply(compiler);
+    const handleAlphaTabWorker = (parser, expr) => {
+        const [arg1, arg2] = expr.arguments;
+        const parsedUrl = parseModuleUrl(parser, arg1);
+        if (!parsedUrl) {
+            return;
+        }
+        const [url, range] = parsedUrl;
+        if (!url.isString()) {
+            return;
+        }
+        const runtime = getWorkerRuntime(parser, compilation, cachedContextify, workerIndexMap);
+        const block = new webPackWithAlphaTab.webpack.AsyncDependenciesBlock({
+            entryOptions: {
+                chunkLoading: 'import-scripts',
+                wasmLoading: false,
+                runtime: runtime,
+                library: {
+                    // prevent any built-in/default library settings
+                    // to be active for this chunk
+                    type: 'at-worker'
+                }
+            }
+        });
+        block.loc = expr.loc;
+        const workletBootstrap = webPackWithAlphaTab.alphaTab.createWebWorkerDependency(url.string, range, compiler.options.output.workerPublicPath);
+        workletBootstrap.loc = expr.loc;
+        block.addDependency(workletBootstrap);
+        parser.state.module.addBlock(block);
+        const dep1 = new webPackWithAlphaTab.webpack.dependencies.ConstDependency(`{ type: ${compilation.options.output.module ? '"module"' : 'undefined'} }`, arg2.range);
+        dep1.loc = expr.loc;
+        parser.state.module.addPresentationalDependency(dep1);
+        parser.walkExpression(expr.callee);
+        parser.walkExpression(arg1.callee);
+        return true;
+    };
+    const parserPlugin = (parser) => {
+        parser.hooks.new
+            .for('alphaTab.Environment.alphaTabWorker')
+            .tap(pluginName, (expr) => handleAlphaTabWorker(parser, expr));
+    };
+    tapJavaScript(normalModuleFactory, pluginName, parserPlugin);
+}
+
+export { configureWebWorker };