@mtkruto/node 0.1.153 → 0.1.155

package/script/deps/raw.githubusercontent.com/MTKruto/mutex/main/mutex.d.ts

@@ -1,26 +0,0 @@
-export interface MutexInterface {
-    acquire(): Promise<MutexInterface.Releaser>;
-    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
-    waitForUnlock(): Promise<void>;
-    isLocked(): boolean;
-    release(): void;
-    cancel(): void;
-}
-export declare namespace MutexInterface {
-    interface Releaser {
-        (): void;
-    }
-    interface Worker<T> {
-        (): Promise<T> | T;
-    }
-}
-export declare class Mutex implements MutexInterface {
-    constructor(cancelError?: Error);
-    acquire(): Promise<MutexInterface.Releaser>;
-    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
-    isLocked(): boolean;
-    waitForUnlock(): Promise<void>;
-    release(): void;
-    cancel(): void;
-    private _semaphore;
-}

package/script/deps/raw.githubusercontent.com/MTKruto/mutex/main/mutex.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mutex = void 0;
-const semaphore_js_1 = require("./semaphore.js");
-class Mutex {
-    constructor(cancelError) {
-        Object.defineProperty(this, "_semaphore", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this._semaphore = new semaphore_js_1.Semaphore(1, cancelError);
-    }
-    async acquire() {
-        const [, releaser] = await this._semaphore.acquire();
-        return releaser;
-    }
-    runExclusive(callback) {
-        return this._semaphore.runExclusive(() => callback());
-    }
-    isLocked() {
-        return this._semaphore.isLocked();
-    }
-    waitForUnlock() {
-        return this._semaphore.waitForUnlock();
-    }
-    release() {
-        if (this._semaphore.isLocked())
-            this._semaphore.release();
-    }
-    cancel() {
-        return this._semaphore.cancel();
-    }
-}
-exports.Mutex = Mutex;

package/script/deps/raw.githubusercontent.com/MTKruto/mutex/main/semaphore.d.ts

@@ -1,41 +0,0 @@
-export declare const E_CANCELED: Error;
-export interface SemaphoreInterface {
-    acquire(weight?: number): Promise<[number, SemaphoreInterface.Releaser]>;
-    runExclusive<T>(callback: SemaphoreInterface.Worker<T>, weight?: number): Promise<T>;
-    waitForUnlock(weight?: number): Promise<void>;
-    isLocked(): boolean;
-    getValue(): number;
-    setValue(value: number): void;
-    release(weight?: number): void;
-    cancel(): void;
-}
-export declare namespace SemaphoreInterface {
-    interface Releaser {
-        (): void;
-    }
-    interface Worker<T> {
-        (value: number): Promise<T> | T;
-    }
-}
-export interface QueueEntry {
-    resolve(result: [number, SemaphoreInterface.Releaser]): void;
-    reject(error: unknown): void;
-}
-export declare class Semaphore implements SemaphoreInterface {
-    private _value;
-    private _cancelError;
-    constructor(_value: number, _cancelError?: Error);
-    acquire(weight?: number): Promise<[number, SemaphoreInterface.Releaser]>;
-    runExclusive<T>(callback: SemaphoreInterface.Worker<T>, weight?: number): Promise<T>;
-    waitForUnlock(weight?: number): Promise<void>;
-    isLocked(): boolean;
-    getValue(): number;
-    setValue(value: number): void;
-    release(weight?: number): void;
-    cancel(): void;
-    private _dispatch;
-    private _newReleaser;
-    private _drainUnlockWaiters;
-    private _weightedQueues;
-    private _weightedWaiters;
-}

package/script/deps/raw.githubusercontent.com/MTKruto/mutex/main/semaphore.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Semaphore = exports.E_CANCELED = void 0;
-exports.E_CANCELED = new Error("request for lock canceled");
-class Semaphore {
-    constructor(_value, _cancelError = exports.E_CANCELED) {
-        Object.defineProperty(this, "_value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: _value
-        });
-        Object.defineProperty(this, "_cancelError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: _cancelError
-        });
-        Object.defineProperty(this, "_weightedQueues", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "_weightedWaiters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    acquire(weight = 1) {
-        if (weight <= 0) {
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        }
-        return new Promise((resolve, reject) => {
-            if (!this._weightedQueues[weight - 1]) {
-                this._weightedQueues[weight - 1] = [];
-            }
-            this._weightedQueues[weight - 1].push({ resolve, reject });
-            this._dispatch();
-        });
-    }
-    async runExclusive(callback, weight = 1) {
-        const [value, release] = await this.acquire(weight);
-        try {
-            return await callback(value);
-        }
-        finally {
-            release();
-        }
-    }
-    waitForUnlock(weight = 1) {
-        if (weight <= 0) {
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        }
-        return new Promise((resolve) => {
-            if (!this._weightedWaiters[weight - 1]) {
-                this._weightedWaiters[weight - 1] = [];
-            }
-            this._weightedWaiters[weight - 1].push(resolve);
-            this._dispatch();
-        });
-    }
-    isLocked() {
-        return this._value <= 0;
-    }
-    getValue() {
-        return this._value;
-    }
-    setValue(value) {
-        this._value = value;
-        this._dispatch();
-    }
-    release(weight = 1) {
-        if (weight <= 0) {
-            throw new Error(`invalid weight ${weight}: must be positive`);
-        }
-        this._value += weight;
-        this._dispatch();
-    }
-    cancel() {
-        this._weightedQueues.forEach((queue) => queue.forEach((entry) => entry.reject(this._cancelError)));
-        this._weightedQueues = [];
-    }
-    _dispatch() {
-        for (let weight = this._value; weight > 0; weight--) {
-            const queueEntry = this._weightedQueues[weight - 1]?.shift();
-            if (!queueEntry)
-                continue;
-            const previousValue = this._value;
-            const previousWeight = weight;
-            this._value -= weight;
-            weight = this._value + 1;
-            queueEntry.resolve([previousValue, this._newReleaser(previousWeight)]);
-        }
-        this._drainUnlockWaiters();
-    }
-    _newReleaser(weight) {
-        let called = false;
-        return () => {
-            if (called)
-                return;
-            called = true;
-            this.release(weight);
-        };
-    }
-    _drainUnlockWaiters() {
-        for (let weight = this._value; weight > 0; weight--) {
-            if (!this._weightedWaiters[weight - 1])
-                continue;
-            this._weightedWaiters[weight - 1].forEach((waiter) => waiter());
-            this._weightedWaiters[weight - 1] = [];
-        }
-    }
-}
-exports.Semaphore = Semaphore;

package/script/deps/raw.githubusercontent.com/MTKruto/object-inspect/main/index.d.ts

@@ -1 +0,0 @@
-export default function inspect_(obj: any, options: any, depth: any, seen: any): any;