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

package/dist/AlphaTabWebWorkerDependency.mjs

@@ -0,0 +1,102 @@
+/*!
+ * 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 { makeDependencySerializable } from './Utils.mjs';
+
+/**
+ * @internal
+ */
+function injectWebWorkerDependency(webPackWithAlphaTab) {
+    class AlphaTabWebWorkerDependency extends webPackWithAlphaTab.webpack.dependencies.ModuleDependency {
+        publicPath;
+        _hashUpdate;
+        constructor(request, range, publicPath) {
+            super(request);
+            this.range = range;
+            this.publicPath = publicPath;
+        }
+        getReferencedExports() {
+            return webPackWithAlphaTab.webpack.Dependency.NO_EXPORTS_REFERENCED;
+        }
+        get type() {
+            return 'alphaTabWorker';
+        }
+        get category() {
+            return 'worker';
+        }
+        updateHash(hash) {
+            if (this._hashUpdate === undefined) {
+                this._hashUpdate = JSON.stringify(this.publicPath);
+            }
+            hash.update(this._hashUpdate);
+        }
+        serialize(context) {
+            const { write } = context;
+            write(this.publicPath);
+            super.serialize(context);
+        }
+        deserialize(context) {
+            const { read } = context;
+            this.publicPath = read();
+            super.deserialize(context);
+        }
+    }
+    AlphaTabWebWorkerDependency.Template = class WorkerDependencyTemplate extends (webPackWithAlphaTab.webpack.dependencies.ModuleDependency.Template) {
+        apply(dependency, source, templateContext) {
+            const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+            const dep = dependency;
+            const block = moduleGraph.getParentBlock(dependency);
+            const entrypoint = chunkGraph.getBlockChunkGroup(block);
+            const chunk = entrypoint.getEntrypointChunk();
+            // We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
+            const workerImportBaseUrl = dep.publicPath
+                ? `"${dep.publicPath}"`
+                : webPackWithAlphaTab.webpack.RuntimeGlobals.publicPath;
+            runtimeRequirements.add(webPackWithAlphaTab.webpack.RuntimeGlobals.publicPath);
+            runtimeRequirements.add(webPackWithAlphaTab.webpack.RuntimeGlobals.baseURI);
+            runtimeRequirements.add(webPackWithAlphaTab.webpack.RuntimeGlobals.getChunkScriptFilename);
+            source.replace(dep.range[0], dep.range[1] - 1, `/* worker import */ ${workerImportBaseUrl} + ${webPackWithAlphaTab.webpack.RuntimeGlobals.getChunkScriptFilename}(${JSON.stringify(chunk.id)}), ${webPackWithAlphaTab.webpack.RuntimeGlobals.baseURI}`);
+        }
+    };
+    makeDependencySerializable(webPackWithAlphaTab, AlphaTabWebWorkerDependency, 'AlphaTabWebWorkerDependency');
+    webPackWithAlphaTab.alphaTab.createWebWorkerDependency = (request, range, publicPath) => new AlphaTabWebWorkerDependency(request, range, publicPath);
+    webPackWithAlphaTab.alphaTab.registerWebWorkerDependency = (compilation, normalModuleFactory) => {
+        compilation.dependencyFactories.set(AlphaTabWebWorkerDependency, normalModuleFactory);
+        compilation.dependencyTemplates.set(AlphaTabWebWorkerDependency, new AlphaTabWebWorkerDependency.Template());
+    };
+}
+
+export { injectWebWorkerDependency };

package/dist/AlphaTabWorkerRuntimeModule.mjs

@@ -0,0 +1,105 @@
+/*!
+ * 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 { isWorkerRuntime } from './Utils.mjs';
+
+/**
+ * @internal
+ */
+function injectWorkerRuntimeModule(webPackWithAlphaTab) {
+    class AlphaTabWorkerRuntimeModule extends webPackWithAlphaTab.webpack.RuntimeModule {
+        static Key = 'AlphaTabWorkerRuntime';
+        constructor() {
+            super('alphaTab audio worker chunk loading', webPackWithAlphaTab.webpack.RuntimeModule.STAGE_BASIC);
+        }
+        generate() {
+            const compilation = this.compilation;
+            const runtimeTemplate = compilation.runtimeTemplate;
+            const globalObject = runtimeTemplate.globalObject;
+            const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(compilation.outputOptions.chunkLoadingGlobal)}]`;
+            const initialChunkIds = new Set(this.chunk.ids);
+            for (const c of this.chunk.getAllInitialChunks()) {
+                if (webPackWithAlphaTab.webpack.javascript.JavascriptModulesPlugin.chunkHasJs(c, this.chunkGraph)) {
+                    continue;
+                }
+                for (const id of c.ids) {
+                    initialChunkIds.add(id);
+                }
+            }
+            return webPackWithAlphaTab.webpack.Template.asString([
+                `if ( ! ('AudioWorkletGlobalScope' in ${globalObject}) ) { return; }`,
+                'const installedChunks = {',
+                webPackWithAlphaTab.webpack.Template.indent(Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(',\n')),
+                '};',
+                '// importScripts chunk loading',
+                `const installChunk = ${runtimeTemplate.basicFunction('data', [
+                    runtimeTemplate.destructureArray(['chunkIds', 'moreModules', 'runtime'], 'data'),
+                    'for(const moduleId in moreModules) {',
+                    webPackWithAlphaTab.webpack.Template.indent([
+                        `if(${webPackWithAlphaTab.webpack.RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+                        webPackWithAlphaTab.webpack.Template.indent(`${webPackWithAlphaTab.webpack.RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`),
+                        '}'
+                    ]),
+                    '}',
+                    `if(runtime) runtime(${webPackWithAlphaTab.webpack.RuntimeGlobals.require});`,
+                    'while(chunkIds.length)',
+                    webPackWithAlphaTab.webpack.Template.indent('installedChunks[chunkIds.pop()] = 1;'),
+                    'parentChunkLoadingFunction(data);'
+                ])};`,
+                `const chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+                'const parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);',
+                'chunkLoadingGlobal.forEach(installChunk);',
+                'chunkLoadingGlobal.push = installChunk;'
+            ]);
+        }
+    }
+    webPackWithAlphaTab.alphaTab.registerWebWorkerRuntimeModule = (pluginName, compilation) => {
+        compilation.hooks.runtimeRequirementInTree
+            .for(AlphaTabWorkerRuntimeModule.Key)
+            .tap(pluginName, (chunk) => {
+            compilation.addRuntimeModule(chunk, new AlphaTabWorkerRuntimeModule());
+        });
+        compilation.hooks.additionalChunkRuntimeRequirements.tap(pluginName, (chunk, runtimeRequirements) => {
+            if (isWorkerRuntime(chunk.runtime)) {
+                runtimeRequirements.add(webPackWithAlphaTab.webpack.RuntimeGlobals.moduleFactories);
+                runtimeRequirements.add(webPackWithAlphaTab.alphaTab.WebWorkerRuntimeModuleKey);
+            }
+        });
+    };
+    webPackWithAlphaTab.alphaTab.WebWorkerRuntimeModuleKey = AlphaTabWorkerRuntimeModule.Key;
+}
+
+export { injectWorkerRuntimeModule };

package/dist/AlphaTabWorkletDependency.mjs

@@ -0,0 +1,123 @@
+/*!
+ * 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 { makeDependencySerializable } from './Utils.mjs';
+
+/**
+ * @internal
+ */
+function injectWorkletDependency(webPackWithAlphaTab) {
+    /**
+     * This module dependency injects the relevant code into a worklet bootstrap script
+     * to install chunks which have been added to the worklet via addModule before the bootstrap script starts.
+     */
+    class AlphaTabWorkletDependency extends webPackWithAlphaTab.webpack.dependencies.ModuleDependency {
+        publicPath;
+        _hashUpdate;
+        constructor(url, range, publicPath) {
+            super(url);
+            this.range = range;
+            this.publicPath = publicPath;
+        }
+        get type() {
+            return 'alphaTabWorklet';
+        }
+        get category() {
+            return 'worker';
+        }
+        updateHash(hash) {
+            if (this._hashUpdate === undefined) {
+                this._hashUpdate = JSON.stringify(this.publicPath);
+            }
+            hash.update(this._hashUpdate);
+        }
+        serialize(context) {
+            const { write } = context;
+            write(this.publicPath);
+            super.serialize(context);
+        }
+        deserialize(context) {
+            const { read } = context;
+            this.publicPath = read();
+            super.deserialize(context);
+        }
+    }
+    AlphaTabWorkletDependency.Template = class AlphaTabWorkletDependencyTemplate extends (webPackWithAlphaTab.webpack.dependencies.ModuleDependency.Template) {
+        apply(dependency, source, templateContext) {
+            const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+            const dep = dependency;
+            const block = moduleGraph.getParentBlock(dependency);
+            const entrypoint = chunkGraph.getBlockChunkGroup(block);
+            const workletImportBaseUrl = dep.publicPath
+                ? JSON.stringify(dep.publicPath)
+                : webPackWithAlphaTab.webpack.RuntimeGlobals.publicPath;
+            const chunk = entrypoint.getEntrypointChunk();
+            // worklet global scope has no 'self', need to inject it for compatibility with chunks
+            // some plugins like the auto public path need to right location. we pass this on from the main runtime
+            // some plugins rely on importScripts to be defined.
+            const workletInlineBootstrap = `
+                globalThis.self = globalThis.self || globalThis;
+                globalThis.location = \${JSON.stringify(${webPackWithAlphaTab.webpack.RuntimeGlobals.baseURI})};
+                globalThis.importScripts = (url) => { throw new Error("importScripts not available, dynamic loading of chunks not supported in this context", url) };
+            `;
+            chunkGraph.addChunkRuntimeRequirements(chunk, new Set([
+                webPackWithAlphaTab.webpack.RuntimeGlobals.moduleFactories,
+                webPackWithAlphaTab.alphaTab.WebWorkerRuntimeModuleKey
+            ]));
+            runtimeRequirements.add(webPackWithAlphaTab.alphaTab.RuntimeGlobalWorkletGetStartupChunks);
+            source.replace(dep.range[0], dep.range[1] - 1, webPackWithAlphaTab.webpack.Template.asString([
+                '(/* worklet bootstrap */ async function(__webpack_worklet__) {',
+                webPackWithAlphaTab.webpack.Template.indent([
+                    `await __webpack_worklet__.addModule(URL.createObjectURL(new Blob([\`${workletInlineBootstrap}\`], { type: "application/javascript; charset=utf-8" })));`,
+                    `for (const fileName of ${webPackWithAlphaTab.alphaTab.RuntimeGlobalWorkletGetStartupChunks}(${JSON.stringify(chunk.id)})) {`,
+                    webPackWithAlphaTab.webpack.Template.indent([
+                        `await __webpack_worklet__.addModule(new URL(${workletImportBaseUrl} + fileName, ${webPackWithAlphaTab.webpack.RuntimeGlobals.baseURI}));`
+                    ]),
+                    '}'
+                ]),
+                '})(alphaTabWorklet)'
+            ]));
+        }
+    };
+    makeDependencySerializable(webPackWithAlphaTab, AlphaTabWorkletDependency, 'AlphaTabWorkletDependency');
+    webPackWithAlphaTab.alphaTab.registerWorkletDependency = (compilation, normalModuleFactory) => {
+        compilation.dependencyFactories.set(AlphaTabWorkletDependency, normalModuleFactory);
+        compilation.dependencyTemplates.set(AlphaTabWorkletDependency, new AlphaTabWorkletDependency.Template());
+    };
+    webPackWithAlphaTab.alphaTab.createWorkletDependency = (request, range, publicPath) => new AlphaTabWorkletDependency(request, range, publicPath);
+}
+
+export { injectWorkletDependency };

package/dist/AlphaTabWorkletStartRuntimeModule.mjs

@@ -0,0 +1,89 @@
+/*!
+ * 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 { isWorkerRuntime } from './Utils.mjs';
+
+/**
+ * @internal
+ */
+function injectWorkletRuntimeModule(webPackWithAlphaTab) {
+    class AlphaTabWorkletStartRuntimeModule extends webPackWithAlphaTab.webpack.RuntimeModule {
+        static RuntimeGlobalWorkletGetStartupChunks = '__webpack_require__.wsc';
+        constructor() {
+            super('alphaTab audio worklet chunk lookup', webPackWithAlphaTab.webpack.RuntimeModule.STAGE_BASIC);
+        }
+        generate() {
+            const compilation = this.compilation;
+            const workletChunkLookup = new Map();
+            const allChunks = compilation.chunks;
+            for (const chunk of allChunks) {
+                const isWorkletEntry = isWorkerRuntime(chunk.runtime);
+                if (isWorkletEntry) {
+                    const workletChunks = Array.from(chunk.getAllReferencedChunks()).map(c => {
+                        // force content chunk to be created
+                        compilation.hooks.contentHash.call(c);
+                        return compilation.getPath(webPackWithAlphaTab.webpack.javascript.JavascriptModulesPlugin.getChunkFilenameTemplate(c, compilation.outputOptions), {
+                            chunk: c,
+                            contentHashType: 'javascript'
+                        });
+                    });
+                    workletChunkLookup.set(String(chunk.id), workletChunks);
+                }
+            }
+            return webPackWithAlphaTab.webpack.Template.asString([
+                `${AlphaTabWorkletStartRuntimeModule.RuntimeGlobalWorkletGetStartupChunks} = (() => {`,
+                webPackWithAlphaTab.webpack.Template.indent([
+                    'const lookup = new Map(',
+                    webPackWithAlphaTab.webpack.Template.indent(JSON.stringify(Array.from(workletChunkLookup.entries()))),
+                    ');',
+                    'return (chunkId) => lookup.get(String(chunkId)) ?? [];'
+                ]),
+                '})();'
+            ]);
+        }
+    }
+    webPackWithAlphaTab.alphaTab.RuntimeGlobalWorkletGetStartupChunks =
+        AlphaTabWorkletStartRuntimeModule.RuntimeGlobalWorkletGetStartupChunks;
+    webPackWithAlphaTab.alphaTab.registerWorkletRuntimeModule = (pluginName, compilation) => {
+        compilation.hooks.runtimeRequirementInTree
+            .for(AlphaTabWorkletStartRuntimeModule.RuntimeGlobalWorkletGetStartupChunks)
+            .tap(pluginName, (chunk) => {
+            compilation.addRuntimeModule(chunk, new AlphaTabWorkletStartRuntimeModule());
+        });
+    };
+}
+
+export { injectWorkletRuntimeModule };

package/dist/Utils.d.ts

@@ -0,0 +1,6 @@
+import type * as webpackTypes from 'webpack';
+/**
+ * @public
+ */
+export type { webpackTypes };
+import type { Expression } from 'estree';

package/dist/Utils.mjs

@@ -0,0 +1,104 @@
+/*!
+ * 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
+ */
+
+const JAVASCRIPT_MODULE_TYPE_AUTO = 'javascript/auto';
+const JAVASCRIPT_MODULE_TYPE_ESM = 'javascript/esm';
+/**
+ * @internal
+ */
+function makeDependencySerializable(webPackWithAlphaTab, dependency, key) {
+    webPackWithAlphaTab.webpack.util.serialization.register(dependency, key, null, {
+        serialize(obj, context) {
+            obj.serialize(context);
+        },
+        deserialize(context) {
+            if (typeof dependency.deserialize === 'function') {
+                return dependency.deserialize(context);
+            }
+            const obj = new dependency();
+            obj.deserialize(context);
+            return obj;
+        }
+    });
+}
+/**
+ * @internal
+ */
+function tapJavaScript(normalModuleFactory, pluginName, parserPlugin) {
+    normalModuleFactory.hooks.parser.for(JAVASCRIPT_MODULE_TYPE_AUTO).tap(pluginName, parserPlugin);
+    normalModuleFactory.hooks.parser.for(JAVASCRIPT_MODULE_TYPE_ESM).tap(pluginName, parserPlugin);
+}
+/**
+ * @internal
+ */
+function parseModuleUrl(parser, expr) {
+    if (expr.type !== 'NewExpression' || expr.arguments.length !== 2) {
+        return;
+    }
+    const newExpr = expr;
+    const [arg1, arg2] = newExpr.arguments;
+    const callee = parser.evaluateExpression(newExpr.callee);
+    if (!callee.isIdentifier() || !callee.identifier.includes('alphaTabUrl')) {
+        return;
+    }
+    const arg1Value = parser.evaluateExpression(arg1);
+    return [arg1Value, [arg1.range[0], arg2.range[1]]];
+}
+const ALPHATAB_WORKER_RUNTIME_PREFIX = 'atworker_';
+/**
+ * @internal
+ */
+function getWorkerRuntime(parser, compilation, cachedContextify, workerIndexMap) {
+    const i = workerIndexMap.get(parser.state) || 0;
+    workerIndexMap.set(parser.state, i + 1);
+    const name = `${cachedContextify(parser.state.module.identifier())}|${i}`;
+    const hash = compilation.compiler.webpack.util.createHash(compilation.outputOptions.hashFunction);
+    hash.update(name);
+    const digest = hash.digest(compilation.outputOptions.hashDigest);
+    const runtime = digest.slice(0, compilation.outputOptions.hashDigestLength);
+    return ALPHATAB_WORKER_RUNTIME_PREFIX + runtime;
+}
+/**
+ * @internal
+ */
+function isWorkerRuntime(runtime) {
+    if (typeof runtime !== 'string') {
+        return false;
+    }
+    return runtime.startsWith(ALPHATAB_WORKER_RUNTIME_PREFIX);
+}
+
+export { getWorkerRuntime, isWorkerRuntime, makeDependencySerializable, parseModuleUrl, tapJavaScript };

package/dist/alphaTab.webpack.d.ts

@@ -1,57 +1 @@
-import type * as webpackTypes from 'webpack';
-
-export declare class AlphaTabWebPackPlugin {
-    private _webPackWithAlphaTab;
-    options: AlphaTabWebPackPluginOptions;
-    constructor(options?: AlphaTabWebPackPluginOptions);
-    apply(compiler: webpackTypes.Compiler): void;
-    configureSoundFont(compiler: webpackTypes.Compiler): void;
-    configure(compiler: webpackTypes.Compiler): void;
-    configureAssetCopy(webPackWithAlphaTab: webPackWithAlphaTab, pluginName: string, compiler: webpackTypes.Compiler, compilation: webpackTypes.Compilation): void;
-}
-
-declare 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;
-}
-
-declare type NormalModuleFactory = webpackTypes.Compilation['params']['normalModuleFactory'];
-
-declare type webPackWithAlphaTab = {
-    webpack: webpackTypes.Compiler['webpack'];
-    alphaTab: {
-        registerWebWorkerRuntimeModule(pluginName: string, compilation: webpackTypes.Compilation): void;
-        WebWorkerRuntimeModuleKey: string;
-        createWebWorkerDependency(request: string, range: [number, number], publicPath: string | undefined): webpackTypes.dependencies.ModuleDependency;
-        registerWebWorkerDependency(compilation: webpackTypes.Compilation, normalModuleFactory: NormalModuleFactory): void;
-        registerWorkletRuntimeModule(pluginName: string, compilation: webpackTypes.Compilation): void;
-        RuntimeGlobalWorkletGetStartupChunks: string;
-        createWorkletDependency(request: string, range: [number, number], publicPath: string | undefined): webpackTypes.dependencies.ModuleDependency;
-        registerWorkletDependency(compilation: webpackTypes.Compilation, normalModuleFactory: NormalModuleFactory): void;
-    };
-};
-
-export { }
+export { AlphaTabWebPackPlugin } from "./AlphaTabWebPackPlugin";