sdfsdfs

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.d.ts

@@ -0,0 +1,22 @@
+import type { TextureSourceOptions } from '../../../rendering/renderers/shared/texture/sources/TextureSource';
+import type { ResolvedAsset } from '../../types';
+declare class WorkerManagerClass {
+    worker: Worker;
+    private _resolveHash;
+    private readonly _workerPool;
+    private readonly _queue;
+    private _initialized;
+    private _createdWorkers;
+    private _isImageBitmapSupported?;
+    constructor();
+    isImageBitmapSupported(): Promise<boolean>;
+    loadImageBitmap(src: string, asset?: ResolvedAsset<TextureSourceOptions<any>>): Promise<ImageBitmap>;
+    private _initWorkers;
+    private _getWorker;
+    private _returnWorker;
+    private _complete;
+    private _run;
+    private _next;
+}
+declare const WorkerManager: WorkerManagerClass;
+export { WorkerManager, };

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var checkImageBitmap_worker = require('../../../_virtual/checkImageBitmap.worker.js');
+var loadImageBitmap_worker = require('../../../_virtual/loadImageBitmap.worker.js');
+
+"use strict";
+let UUID = 0;
+let MAX_WORKERS;
+class WorkerManagerClass {
+  constructor() {
+    this._initialized = false;
+    this._createdWorkers = 0;
+    this._workerPool = [];
+    this._queue = [];
+    this._resolveHash = {};
+  }
+  isImageBitmapSupported() {
+    if (this._isImageBitmapSupported !== void 0)
+      return this._isImageBitmapSupported;
+    this._isImageBitmapSupported = new Promise((resolve) => {
+      const { worker } = new checkImageBitmap_worker.default();
+      worker.addEventListener("message", (event) => {
+        worker.terminate();
+        checkImageBitmap_worker.default.revokeObjectURL();
+        resolve(event.data);
+      });
+    });
+    return this._isImageBitmapSupported;
+  }
+  loadImageBitmap(src, asset) {
+    return this._run("loadImageBitmap", [src, asset?.data?.alphaMode]);
+  }
+  async _initWorkers() {
+    if (this._initialized)
+      return;
+    this._initialized = true;
+  }
+  _getWorker() {
+    if (MAX_WORKERS === void 0) {
+      MAX_WORKERS = navigator.hardwareConcurrency || 4;
+    }
+    let worker = this._workerPool.pop();
+    if (!worker && this._createdWorkers < MAX_WORKERS) {
+      this._createdWorkers++;
+      worker = new loadImageBitmap_worker.default().worker;
+      worker.addEventListener("message", (event) => {
+        this._complete(event.data);
+        this._returnWorker(event.target);
+        this._next();
+      });
+    }
+    return worker;
+  }
+  _returnWorker(worker) {
+    this._workerPool.push(worker);
+  }
+  _complete(data) {
+    if (data.error !== void 0) {
+      this._resolveHash[data.uuid].reject(data.error);
+    } else {
+      this._resolveHash[data.uuid].resolve(data.data);
+    }
+    this._resolveHash[data.uuid] = null;
+  }
+  async _run(id, args) {
+    await this._initWorkers();
+    const promise = new Promise((resolve, reject) => {
+      this._queue.push({ id, arguments: args, resolve, reject });
+    });
+    this._next();
+    return promise;
+  }
+  _next() {
+    if (!this._queue.length)
+      return;
+    const worker = this._getWorker();
+    if (!worker) {
+      return;
+    }
+    const toDo = this._queue.pop();
+    const id = toDo.id;
+    this._resolveHash[UUID] = { resolve: toDo.resolve, reject: toDo.reject };
+    worker.postMessage({
+      data: toDo.arguments,
+      uuid: UUID++,
+      id
+    });
+  }
+}
+const WorkerManager = new WorkerManagerClass();
+
+exports.WorkerManager = WorkerManager;
+//# sourceMappingURL=WorkerManager.js.map

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.mjs

@@ -0,0 +1,91 @@
+import WorkerInstance from '../../../_virtual/checkImageBitmap.worker.mjs';
+import WorkerInstance$1 from '../../../_virtual/loadImageBitmap.worker.mjs';
+
+"use strict";
+let UUID = 0;
+let MAX_WORKERS;
+class WorkerManagerClass {
+  constructor() {
+    this._initialized = false;
+    this._createdWorkers = 0;
+    this._workerPool = [];
+    this._queue = [];
+    this._resolveHash = {};
+  }
+  isImageBitmapSupported() {
+    if (this._isImageBitmapSupported !== void 0)
+      return this._isImageBitmapSupported;
+    this._isImageBitmapSupported = new Promise((resolve) => {
+      const { worker } = new WorkerInstance();
+      worker.addEventListener("message", (event) => {
+        worker.terminate();
+        WorkerInstance.revokeObjectURL();
+        resolve(event.data);
+      });
+    });
+    return this._isImageBitmapSupported;
+  }
+  loadImageBitmap(src, asset) {
+    return this._run("loadImageBitmap", [src, asset?.data?.alphaMode]);
+  }
+  async _initWorkers() {
+    if (this._initialized)
+      return;
+    this._initialized = true;
+  }
+  _getWorker() {
+    if (MAX_WORKERS === void 0) {
+      MAX_WORKERS = navigator.hardwareConcurrency || 4;
+    }
+    let worker = this._workerPool.pop();
+    if (!worker && this._createdWorkers < MAX_WORKERS) {
+      this._createdWorkers++;
+      worker = new WorkerInstance$1().worker;
+      worker.addEventListener("message", (event) => {
+        this._complete(event.data);
+        this._returnWorker(event.target);
+        this._next();
+      });
+    }
+    return worker;
+  }
+  _returnWorker(worker) {
+    this._workerPool.push(worker);
+  }
+  _complete(data) {
+    if (data.error !== void 0) {
+      this._resolveHash[data.uuid].reject(data.error);
+    } else {
+      this._resolveHash[data.uuid].resolve(data.data);
+    }
+    this._resolveHash[data.uuid] = null;
+  }
+  async _run(id, args) {
+    await this._initWorkers();
+    const promise = new Promise((resolve, reject) => {
+      this._queue.push({ id, arguments: args, resolve, reject });
+    });
+    this._next();
+    return promise;
+  }
+  _next() {
+    if (!this._queue.length)
+      return;
+    const worker = this._getWorker();
+    if (!worker) {
+      return;
+    }
+    const toDo = this._queue.pop();
+    const id = toDo.id;
+    this._resolveHash[UUID] = { resolve: toDo.resolve, reject: toDo.reject };
+    worker.postMessage({
+      data: toDo.arguments,
+      uuid: UUID++,
+      id
+    });
+  }
+}
+const WorkerManager = new WorkerManagerClass();
+
+export { WorkerManager };
+//# sourceMappingURL=WorkerManager.mjs.map

node_modules/pixi.js/lib/assets/loader/workers/checkImageBitmap.worker.d.ts

@@ -0,0 +1,2 @@
+declare const WHITE_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=";
+declare function checkImageBitmap(): Promise<boolean>;

node_modules/pixi.js/lib/assets/loader/workers/loadImageBitmap.worker.d.ts

@@ -0,0 +1,6 @@
+interface MessageData {
+    data: any[];
+    uuid: number;
+    id: string;
+}
+declare function loadImageBitmap(url: string, alphaMode?: string): Promise<ImageBitmap>;