codingclip-worker-loader 3.0.8

package/LICENSE

@@ -0,0 +1,20 @@
+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.

package/README.md

@@ -0,0 +1,650 @@
+# A fork of worker-loader to fix issues in webpack5
+
+<div align="center">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# worker-loader
+
+**DEPRECATED for v5**: https://webpack.js.org/guides/web-workers/
+
+Web Worker loader for webpack 4.
+
+Note that this is specific to webpack 4. To use Web Workers in webpack 5, see https://webpack.js.org/guides/web-workers/.
+
+## Getting Started
+
+To begin, you'll need to install `worker-loader`:
+
+```console
+$ npm install worker-loader --save-dev
+```
+
+### Inlined
+
+**App.js**
+
+```js
+import Worker from "worker-loader!./Worker.js";
+```
+
+### Config
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.js$/,
+        use: { loader: "worker-loader" },
+      },
+    ],
+  },
+};
+```
+
+**App.js**
+
+```js
+import Worker from "./file.worker.js";
+
+const worker = new Worker();
+
+worker.postMessage({ a: 1 });
+worker.onmessage = function (event) {};
+
+worker.addEventListener("message", function (event) {});
+```
+
+And run `webpack` via your preferred method.
+
+## Options
+
+|                 Name                  |            Type             |             Default             | Description                                                                       |
+| :-----------------------------------: | :-------------------------: | :-----------------------------: | :-------------------------------------------------------------------------------- |
+|        **[`worker`](#worker)**        |     `{String\|Object}`      |            `Worker`             | Allows to set web worker constructor name and options                             |
+|    **[`publicPath`](#publicpath)**    |    `{String\|Function}`     |  based on `output.publicPath`   | specifies the public URL address of the output files when referenced in a browser |
+|      **[`filename`](#filename)**      |    `{String\|Function}`     |   based on `output.filename`    | The filename of entry chunks for web workers                                      |
+| **[`chunkFilename`](#chunkfilename)** |         `{String}`          | based on `output.chunkFilename` | The filename of non-entry chunks for web workers                                  |
+|        **[`inline`](#inline)**        | `'no-fallback'\|'fallback'` |           `undefined`           | Allow to inline the worker as a `BLOB`                                            |
+|      **[`esModule`](#esmodule)**      |         `{Boolean}`         |             `true`              | Use ES modules syntax                                                             |
+
+### `worker`
+
+Type: `String|Object`
+Default: `Worker`
+
+Set the worker type.
+
+#### `String`
+
+Allows to set web worker constructor name.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          worker: "SharedWorker",
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `Object`
+
+Allow to set web worker constructor name and options.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          worker: {
+            type: "SharedWorker",
+            options: {
+              type: "classic",
+              credentials: "omit",
+              name: "my-custom-worker-name",
+            },
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `publicPath`
+
+Type: `String|Function`
+Default: based on `output.publicPath`
+
+The `publicPath` specifies the public URL address of the output files when referenced in a browser.
+If not specified, the same public path used for other webpack assets is used.
+
+#### `String`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          publicPath: "/scripts/workers/",
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `Function`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          publicPath: (pathData, assetInfo) => {
+            return `/scripts/${pathData.hash}/workers/`;
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `filename`
+
+Type: `String|Function`
+Default: based on `output.filename`, adding `worker` suffix, for example - `output.filename: '[name].js'` value of this option will be `[name].worker.js`
+
+The filename of entry chunks for web workers.
+
+#### `String`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          filename: "[name].[contenthash].worker.js",
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `Function`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          filename: (pathData) => {
+            if (
+              /\.worker\.(c|m)?js$/i.test(pathData.chunk.entryModule.resource)
+            ) {
+              return "[name].custom.worker.js";
+            }
+
+            return "[name].js";
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `chunkFilename`
+
+Type: `String`
+Default: based on `output.chunkFilename`, adding `worker` suffix, for example - `output.chunkFilename: '[id].js'` value of this option will be `[id].worker.js`
+
+The filename of non-entry chunks for web workers.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          chunkFilename: "[id].[contenthash].worker.js",
+        },
+      },
+    ],
+  },
+};
+```
+
+### `inline`
+
+Type: `'fallback' | 'no-fallback'`
+Default: `undefined`
+
+Allow to inline the worker as a `BLOB`.
+
+Inline mode with the `fallback` value will create file for browsers without support web workers, to disable this behavior just use `no-fallback` value.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          inline: "fallback",
+        },
+      },
+    ],
+  },
+};
+```
+
+### `esModule`
+
+Type: `Boolean`
+Default: `true`
+
+By default, `worker-loader` generates JS modules that use the ES modules syntax.
+
+You can enable a CommonJS modules syntax using:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          esModule: false,
+        },
+      },
+    ],
+  },
+};
+```
+
+## Examples
+
+### Basic
+
+The worker file can import dependencies just like any other file:
+
+**index.js**
+
+```js
+import Worker from "./my.worker.js";
+
+var worker = new Worker();
+
+var result;
+
+worker.onmessage = function (event) {
+  if (!result) {
+    result = document.createElement("div");
+    result.setAttribute("id", "result");
+
+    document.body.append(result);
+  }
+
+  result.innerText = JSON.stringify(event.data);
+};
+
+const button = document.getElementById("button");
+
+button.addEventListener("click", function () {
+  worker.postMessage({ postMessage: true });
+});
+```
+
+**my.worker.js**
+
+```js
+onmessage = function (event) {
+  var workerResult = event.data;
+
+  workerResult.onmessage = true;
+
+  postMessage(workerResult);
+};
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        loader: "worker-loader",
+        options: {
+          esModule: false,
+        },
+      },
+    ],
+  },
+};
+```
+
+### Integrating with ES6+ features
+
+You can even use ES6+ features if you have the [`babel-loader`](https://github.com/babel/babel-loader) configured.
+
+**index.js**
+
+```js
+import Worker from "./my.worker.js";
+
+const worker = new Worker();
+
+let result;
+
+worker.onmessage = (event) => {
+  if (!result) {
+    result = document.createElement("div");
+    result.setAttribute("id", "result");
+
+    document.body.append(result);
+  }
+
+  result.innerText = JSON.stringify(event.data);
+};
+
+const button = document.getElementById("button");
+
+button.addEventListener("click", () => {
+  worker.postMessage({ postMessage: true });
+});
+```
+
+**my.worker.js**
+
+```js
+onmessage = function (event) {
+  const workerResult = event.data;
+
+  workerResult.onmessage = true;
+
+  postMessage(workerResult);
+};
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.worker\.(c|m)?js$/i,
+        use: [
+          {
+            loader: "worker-loader",
+          },
+          {
+            loader: "babel-loader",
+            options: {
+              presets: ["@babel/preset-env"],
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+```
+
+### Integrating with TypeScript
+
+To integrate with TypeScript, you will need to define a custom module for the exports of your worker.
+
+#### Loading with `worker-loader!`
+
+**typings/worker-loader.d.ts**
+
+```typescript
+declare module "worker-loader!*" {
+  // You need to change `Worker`, if you specified a different value for the `workerType` option
+  class WebpackWorker extends Worker {
+    constructor();
+  }
+
+  // Uncomment this if you set the `esModule` option to `false`
+  // export = WebpackWorker;
+  export default WebpackWorker;
+}
+```
+
+**my.worker.ts**
+
+```typescript
+const ctx: Worker = self as any;
+
+// Post data to parent thread
+ctx.postMessage({ foo: "foo" });
+
+// Respond to message from parent thread
+ctx.addEventListener("message", (event) => console.log(event));
+```
+
+**index.ts**
+
+```typescript
+import Worker from "worker-loader!./Worker";
+
+const worker = new Worker();
+
+worker.postMessage({ a: 1 });
+worker.onmessage = (event) => {};
+
+worker.addEventListener("message", (event) => {});
+```
+
+#### Loading without `worker-loader!`
+
+Alternatively, you can omit the `worker-loader!` prefix passed to `import` statement by using the following notation.
+This is useful for executing the code using a non-WebPack runtime environment
+(such as Jest with [`workerloader-jest-transformer`](https://github.com/astagi/workerloader-jest-transformer)).
+
+**typings/worker-loader.d.ts**
+
+```typescript
+declare module "*.worker.ts" {
+  // You need to change `Worker`, if you specified a different value for the `workerType` option
+  class WebpackWorker extends Worker {
+    constructor();
+  }
+
+  // Uncomment this if you set the `esModule` option to `false`
+  // export = WebpackWorker;
+  export default WebpackWorker;
+}
+```
+
+**my.worker.ts**
+
+```typescript
+const ctx: Worker = self as any;
+
+// Post data to parent thread
+ctx.postMessage({ foo: "foo" });
+
+// Respond to message from parent thread
+ctx.addEventListener("message", (event) => console.log(event));
+```
+
+**index.ts**
+
+```typescript
+import MyWorker from "./my.worker.ts";
+
+const worker = new MyWorker();
+
+worker.postMessage({ a: 1 });
+worker.onmessage = (event) => {};
+
+worker.addEventListener("message", (event) => {});
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      // Place this *before* the `ts-loader`.
+      {
+        test: /\.worker\.ts$/,
+        loader: "worker-loader",
+      },
+      {
+        test: /\.ts$/,
+        loader: "ts-loader",
+      },
+    ],
+  },
+  resolve: {
+    extensions: [".ts", ".js"],
+  },
+};
+```
+
+### Cross-Origin Policy
+
+[`WebWorkers`](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) are restricted by a [same-origin policy](https://en.wikipedia.org/wiki/Same-origin_policy), so if your `webpack` assets are not being served from the same origin as your application, their download may be blocked by your browser.
+This scenario can commonly occur if you are hosting your assets under a CDN domain.
+Even downloads from the `webpack-dev-server` could be blocked.
+
+There are two workarounds:
+
+Firstly, you can inline the worker as a blob instead of downloading it as an external script via the [`inline`](#inline) parameter
+
+**App.js**
+
+```js
+import Worker from "./file.worker.js";
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        loader: "worker-loader",
+        options: { inline: "fallback" },
+      },
+    ],
+  },
+};
+```
+
+Secondly, you may override the base download URL for your worker script via the [`publicPath`](#publicpath) option
+
+**App.js**
+
+```js
+// This will cause the worker to be downloaded from `/workers/file.worker.js`
+import Worker from "./file.worker.js";
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        loader: "worker-loader",
+        options: { publicPath: "/workers/" },
+      },
+    ],
+  },
+};
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/worker-loader.svg
+[npm-url]: https://npmjs.com/package/worker-loader
+[node]: https://img.shields.io/node/v/worker-loader.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack-contrib/worker-loader.svg
+[deps-url]: https://david-dm.org/webpack-contrib/worker-loader
+[tests]: https://github.com/webpack-contrib/worker-loader/workflows/worker-loader/badge.svg
+[tests-url]: https://github.com/webpack-contrib/worker-loader/actions
+[cover]: https://codecov.io/gh/webpack-contrib/worker-loader/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/worker-loader
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=worker-loader
+[size-url]: https://packagephobia.now.sh/result?p=worker-loader

package/dist/cjs.js

@@ -0,0 +1,6 @@
+"use strict";
+
+const loader = require("./index");
+
+module.exports = loader.default;
+module.exports.pitch = loader.pitch;

package/dist/index.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loader;
+exports.pitch = pitch;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _loaderUtils = require("loader-utils");
+
+var _schemaUtils = require("schema-utils");
+
+var _NodeTargetPlugin = _interopRequireDefault(require("webpack/lib/node/NodeTargetPlugin"));
+
+var _SingleEntryPlugin = _interopRequireDefault(require("webpack/lib/SingleEntryPlugin"));
+
+var _WebWorkerTemplatePlugin = _interopRequireDefault(require("webpack/lib/webworker/WebWorkerTemplatePlugin"));
+
+var _ExternalsPlugin = _interopRequireDefault(require("webpack/lib/ExternalsPlugin"));
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+var _supportWebpack = _interopRequireDefault(require("./supportWebpack5"));
+
+var _supportWebpack2 = _interopRequireDefault(require("./supportWebpack4"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let FetchCompileWasmPlugin;
+let FetchCompileAsyncWasmPlugin; // determine the version of webpack peer dependency
+// eslint-disable-next-line global-require, import/no-unresolved
+
+const useWebpack5 = require("webpack/package.json").version.startsWith("5.");
+
+if (useWebpack5) {
+  // eslint-disable-next-line global-require, import/no-unresolved
+  FetchCompileWasmPlugin = require("webpack/lib/web/FetchCompileWasmPlugin"); // eslint-disable-next-line global-require, import/no-unresolved
+
+  FetchCompileAsyncWasmPlugin = require("webpack/lib/web/FetchCompileAsyncWasmPlugin");
+} else {
+  // eslint-disable-next-line global-require, import/no-unresolved, import/extensions
+  FetchCompileWasmPlugin = require("webpack/lib/web/FetchCompileWasmTemplatePlugin");
+}
+
+function loader() {}
+
+function pitch(request) {
+  this.cacheable(false);
+  const options = (0, _loaderUtils.getOptions)(this);
+  (0, _schemaUtils.validate)(_options.default, options, {
+    name: "Worker Loader",
+    baseDataPath: "options"
+  });
+  const workerContext = {};
+  const compilerOptions = this._compiler.options || {};
+  const filename = options.filename ? options.filename : (0, _utils.getDefaultFilename)(compilerOptions.output.filename);
+  const chunkFilename = options.chunkFilename ? options.chunkFilename : (0, _utils.getDefaultChunkFilename)(compilerOptions.output.chunkFilename);
+  const publicPath = options.publicPath ? options.publicPath : compilerOptions.output.publicPath;
+  workerContext.options = {
+    filename,
+    chunkFilename,
+    publicPath,
+    globalObject: "self"
+  };
+  workerContext.compiler = this._compilation.createChildCompiler(`worker-loader ${request}`, workerContext.options);
+  new _WebWorkerTemplatePlugin.default().apply(workerContext.compiler);
+
+  if (this.target !== "webworker" && this.target !== "web") {
+    new _NodeTargetPlugin.default().apply(workerContext.compiler);
+  }
+
+  if (FetchCompileWasmPlugin) {
+    new FetchCompileWasmPlugin({
+      mangleImports: compilerOptions.optimization.mangleWasmImports
+    }).apply(workerContext.compiler);
+  }
+
+  if (FetchCompileAsyncWasmPlugin) {
+    new FetchCompileAsyncWasmPlugin().apply(workerContext.compiler);
+  }
+
+  if (compilerOptions.externals) {
+    new _ExternalsPlugin.default((0, _utils.getExternalsType)(compilerOptions), compilerOptions.externals).apply(workerContext.compiler);
+  }
+
+  new _SingleEntryPlugin.default(this.context, `!!${request}`, _path.default.parse(this.resourcePath).name).apply(workerContext.compiler);
+  workerContext.request = request;
+  const cb = this.async();
+
+  if (workerContext.compiler.cache && typeof workerContext.compiler.cache.get === "function") {
+    (0, _supportWebpack.default)(this, workerContext, options, cb);
+  } else {
+    (0, _supportWebpack2.default)(this, workerContext, options, cb);
+  }
+}

package/dist/options.json

@@ -0,0 +1,72 @@
+{
+  "type": "object",
+  "properties": {
+    "worker": {
+      "anyOf": [
+        {
+          "type": "string",
+          "minLength": 1
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "type": {
+              "type": "string",
+              "minLength": 1
+            },
+            "options": {
+              "additionalProperties": true,
+              "type": "object"
+            }
+          },
+          "required": ["type"]
+        }
+      ],
+      "description": "Set the worker type.",
+      "link": "https://github.com/webpack-contrib/worker-loader#worker"
+    },
+    "publicPath": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "Specifies the public URL address of the output files when referenced in a browser.",
+      "link": "https://github.com/webpack-contrib/worker-loader#publicpath"
+    },
+    "filename": {
+      "anyOf": [
+        {
+          "type": "string",
+          "minLength": 1
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "The filename of entry chunks for web workers.",
+      "link": "https://github.com/webpack-contrib/worker-loader#filename"
+    },
+    "chunkFilename": {
+      "type": "string",
+      "description": "The filename of non-entry chunks for web workers.",
+      "link": "https://github.com/webpack-contrib/worker-loader#chunkfilename",
+      "minLength": 1
+    },
+    "inline": {
+      "enum": ["no-fallback", "fallback"],
+      "description": "Allow to inline the worker as a BLOB.",
+      "link": "https://github.com/webpack-contrib/worker-loader#inline"
+    },
+    "esModule": {
+      "type": "boolean",
+      "description": "Enable or disable ES module syntax.",
+      "link": "https://github.com/webpack-contrib/worker-loader#esmodule"
+    }
+  },
+  "additionalProperties": false
+}

package/dist/runtime/inline.js

@@ -0,0 +1,39 @@
+"use strict";
+
+/* eslint-env browser */
+
+/* eslint-disable no-undef, no-use-before-define, new-cap */
+module.exports = function (content, workerConstructor, workerOptions, url) {
+  var globalScope = self || window;
+
+  try {
+    try {
+      var blob;
+
+      try {
+        // New API
+        blob = new globalScope.Blob([content]);
+      } catch (e) {
+        // BlobBuilder = Deprecated, but widely implemented
+        var BlobBuilder = globalScope.BlobBuilder || globalScope.WebKitBlobBuilder || globalScope.MozBlobBuilder || globalScope.MSBlobBuilder;
+        blob = new BlobBuilder();
+        blob.append(content);
+        blob = blob.getBlob();
+      }
+
+      var URL = globalScope.URL || globalScope.webkitURL;
+      var objectURL = URL.createObjectURL(blob);
+      var worker = new globalScope[workerConstructor](objectURL, workerOptions);
+      URL.revokeObjectURL(objectURL);
+      return worker;
+    } catch (e) {
+      return new globalScope[workerConstructor]("data:application/javascript,".concat(encodeURIComponent(content)), workerOptions);
+    }
+  } catch (e) {
+    if (!url) {
+      throw Error("Inline worker is not supported");
+    }
+
+    return new globalScope[workerConstructor](url, workerOptions);
+  }
+};

package/dist/supportWebpack4.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = runAsChild;
+
+var _utils = require("./utils");
+
+function runAsChild(loaderContext, workerContext, options, callback) {
+  workerContext.compiler.runAsChild((error, entries, compilation) => {
+    if (error) {
+      return callback(error);
+    }
+
+    if (entries[0]) {
+      // eslint-disable-next-line no-param-reassign, prefer-destructuring
+      const workerFilename = entries[0].files[0];
+      let workerSource = compilation.assets[workerFilename].source();
+
+      if (options.inline === "no-fallback") {
+        // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+        delete loaderContext._compilation.assets[workerFilename]; // TODO improve it, we should store generated source maps files for file in `assetInfo`
+        // eslint-disable-next-line no-underscore-dangle
+
+        if (loaderContext._compilation.assets[`${workerFilename}.map`]) {
+          // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+          delete loaderContext._compilation.assets[`${workerFilename}.map`];
+        } // Remove `/* sourceMappingURL=url */` comment
+
+
+        workerSource = workerSource.replace(_utils.sourceMappingURLRegex, ""); // Remove `//# sourceURL=webpack-internal` comment
+
+        workerSource = workerSource.replace(_utils.sourceURLWebpackRegex, "");
+      }
+
+      const workerCode = (0, _utils.workerGenerator)(loaderContext, workerFilename, workerSource, options);
+      return callback(null, workerCode);
+    }
+
+    return callback(new Error(`Failed to compile web worker "${workerContext.request}" request`));
+  });
+}

package/dist/supportWebpack5.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = runAsChild;
+
+var _utils = require("./utils");
+
+function runAsChild(loaderContext, workerContext, options, callback) {
+  workerContext.compiler.runAsChild((error, entries, compilation) => {
+    if (error) {
+      return callback(error);
+    }
+
+    if (entries[0]) {
+      const [workerFilename] = [...entries[0].files];
+      const cache = workerContext.compiler.getCache("worker-loader");
+      const cacheIdent = workerFilename;
+      const cacheETag = cache.getLazyHashedEtag(compilation.assets[workerFilename]);
+      return cache.get(cacheIdent, cacheETag, (getCacheError, content) => {
+        if (getCacheError) {
+          return callback(getCacheError);
+        }
+
+        if (options.inline === "no-fallback") {
+          // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+          delete loaderContext._compilation.assets[workerFilename]; // TODO improve this, we should store generated source maps files for file in `assetInfo`
+          // eslint-disable-next-line no-underscore-dangle
+
+          if (loaderContext._compilation.assets[`${workerFilename}.map`]) {
+            // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+            delete loaderContext._compilation.assets[`${workerFilename}.map`];
+          }
+        }
+
+        if (content) {
+          return callback(null, content);
+        }
+
+        let workerSource = compilation.assets[workerFilename].source();
+
+        if (options.inline === "no-fallback") {
+          // Remove `/* sourceMappingURL=url */` comment
+          workerSource = workerSource.replace(_utils.sourceMappingURLRegex, ""); // Remove `//# sourceURL=webpack-internal` comment
+
+          workerSource = workerSource.replace(_utils.sourceURLWebpackRegex, "");
+        }
+
+        const workerCode = (0, _utils.workerGenerator)(loaderContext, workerFilename, workerSource, options);
+        const workerCodeBuffer = Buffer.from(workerCode);
+        return cache.store(cacheIdent, cacheETag, workerCodeBuffer, storeCacheError => {
+          if (storeCacheError) {
+            return callback(storeCacheError);
+          }
+
+          return callback(null, workerCodeBuffer);
+        });
+      });
+    }
+
+    return callback(new Error(`Failed to compile web worker "${workerContext.request}" request`));
+  });
+}

package/dist/utils.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultFilename = getDefaultFilename;
+exports.getDefaultChunkFilename = getDefaultChunkFilename;
+exports.getExternalsType = getExternalsType;
+exports.workerGenerator = workerGenerator;
+exports.sourceURLWebpackRegex = exports.sourceMappingURLRegex = void 0;
+
+var _loaderUtils = require("loader-utils");
+
+function getDefaultFilename(filename) {
+  if (typeof filename === "function") {
+    return filename;
+  }
+
+  return filename.replace(/\.([a-z]+)(\?.+)?$/i, ".worker.$1$2");
+}
+
+function getDefaultChunkFilename(chunkFilename) {
+  return chunkFilename.replace(/\.([a-z]+)(\?.+)?$/i, ".worker.$1$2");
+}
+
+function getExternalsType(compilerOptions) {
+  // For webpack@4
+  if (compilerOptions.output.libraryTarget) {
+    return compilerOptions.output.libraryTarget;
+  } // For webpack@5
+
+
+  if (compilerOptions.externalsType) {
+    return compilerOptions.externalsType;
+  }
+
+  if (compilerOptions.output.library) {
+    return compilerOptions.output.library.type;
+  }
+
+  if (compilerOptions.output.module) {
+    return "module";
+  }
+
+  return "var";
+}
+
+function workerGenerator(loaderContext, workerFilename, workerSource, options) {
+  let workerConstructor;
+  let workerOptions;
+
+  if (typeof options.worker === "undefined") {
+    workerConstructor = "Worker";
+  } else if (typeof options.worker === "string") {
+    workerConstructor = options.worker;
+  } else {
+    ({
+      type: workerConstructor,
+      options: workerOptions
+    } = options.worker);
+  }
+
+  const esModule = typeof options.esModule !== "undefined" ? options.esModule : true;
+  const fnName = `${workerConstructor}_fn`;
+  const publicPath = options.publicPath ? `"${options.publicPath}"` : "__webpack_public_path__";
+
+  if (options.inline) {
+    const InlineWorkerPath = (0, _loaderUtils.stringifyRequest)(loaderContext, `!!${require.resolve("./runtime/inline.js")}`);
+    let fallbackWorkerPath;
+
+    if (options.inline === "fallback") {
+      fallbackWorkerPath = `${publicPath} + ${JSON.stringify(workerFilename)}`;
+    }
+
+    return `
+${esModule ? `import worker from ${InlineWorkerPath};` : `var worker = require(${InlineWorkerPath});`}
+
+${esModule ? "export default" : "module.exports ="} function ${fnName}() {\n  return worker(${JSON.stringify(workerSource)}, ${JSON.stringify(workerConstructor)}, ${JSON.stringify(workerOptions)}, ${fallbackWorkerPath});\n}\n`;
+  }
+
+  return `${esModule ? "export default" : "module.exports ="} function ${fnName}() {\n  return new ${workerConstructor}(${publicPath} + ${JSON.stringify(workerFilename)}${workerOptions ? `, ${JSON.stringify(workerOptions)}` : ""});\n}\n`;
+} // Matches only the last occurrence of sourceMappingURL
+
+
+const innerRegex = /\s*[#@]\s*sourceMappingURL\s*=\s*(.*?(?=[\s'"]|\\n|\*\/|$)(?:\\n)?)\s*/;
+/* eslint-disable prefer-template */
+
+const sourceMappingURLRegex = RegExp("(?:" + "/\\*" + "(?:\\s*\r?\n(?://)?)?" + "(?:" + innerRegex.source + ")" + "\\s*" + "\\*/" + "|" + "//(?:" + innerRegex.source + ")" + ")" + "\\s*");
+exports.sourceMappingURLRegex = sourceMappingURLRegex;
+const sourceURLWebpackRegex = RegExp("\\/\\/#\\ssourceURL=webpack-internal:\\/\\/\\/(.*?)\\\\n");
+/* eslint-enable prefer-template */
+
+exports.sourceURLWebpackRegex = sourceURLWebpackRegex;

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "codingclip-worker-loader",
+  "version": "3.0.8",
+  "description": "worker loader module for webpack",
+  "license": "MIT",
+  "repository": "webpack-contrib/worker-loader",
+  "author": "Tobias Koppers @sokra",
+  "homepage": "https://github.com/webpack-contrib/worker-loader",
+  "bugs": "https://github.com/webpack-contrib/worker-loader/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/cjs.js",
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist",
+    "prebuild": "npm run clean",
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit",
+    "lint:prettier": "prettier --list-different .",
+    "lint:js": "eslint --cache .",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "webpack": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "loader-utils": "^2.0.0",
+    "schema-utils": "^3.1.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.14.5",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@commitlint/cli": "^12.1.4",
+    "@commitlint/config-conventional": "^12.1.4",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^26.6.3",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.31.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.23.4",
+    "express": "^4.17.1",
+    "get-port": "^5.1.1",
+    "html-webpack-plugin": "^4.5.0",
+    "husky": "^4.3.0",
+    "jest": "^26.6.3",
+    "lint-staged": "^10.5.4",
+    "memfs": "^3.2.0",
+    "nanoid": "^3.1.20",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "puppeteer": "^7.0.4",
+    "standard-version": "^9.3.1",
+    "webpack": "^5.45.1"
+  },
+  "keywords": [
+    "webpack"
+  ],
+  "jest": {
+    "testEnvironment": "node"
+  }
+}