@supernovaio/cli 1.0.3 → 1.0.5

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Christian Speckner <cnspeckn@googlemail.com>
-
-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/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/README.md

@@ -1,482 +0,0 @@
-[![Build status](https://github.com/DirtyHairy/async-mutex/workflows/Build%20and%20Tests/badge.svg)](https://github.com/DirtyHairy/async-mutex/actions?query=workflow%3A%22Build+and+Tests%22)
-[![NPM version](https://badge.fury.io/js/async-mutex.svg)](https://badge.fury.io/js/async-mutex)
-[![Coverage Status](https://coveralls.io/repos/github/DirtyHairy/async-mutex/badge.svg?branch=master)](https://coveralls.io/github/DirtyHairy/async-mutex?branch=master)
-
-# What is it?
-
-This package implements primitives for synchronizing asynchronous operations in
-Javascript.
-
-## Mutex
-
-The term "mutex" usually refers to a data structure used to synchronize
-concurrent processes running on different threads. For example, before accessing
-a non-threadsafe resource, a thread will lock the mutex. This is guaranteed
-to block the thread until no other thread holds a lock on the mutex and thus
-enforces exclusive access to the resource. Once the operation is complete, the
-thread releases the lock, allowing other threads to acquire a lock and access the
-resource.
-
-While Javascript is strictly single-threaded, the asynchronous nature of its
-execution model allows for race conditions that require similar synchronization
-primitives. Consider for example a library communicating with a web worker that
-needs to exchange several subsequent messages with the worker in order to achieve
-a task. As these messages are exchanged in an asynchronous manner, it is perfectly
-possible that the library is called again during this process. Depending on the
-way state is handled during the async process, this will lead to race conditions
-that are hard to fix and even harder to track down.
-
-This library solves the problem by applying the concept of mutexes to Javascript.
-Locking the mutex will return a promise that resolves once the mutex becomes
-available. Once the async process is complete (usually taking multiple
-spins of the event loop), a callback supplied to the caller is called in order
-to release the mutex, allowing the next scheduled worker to execute.
-
-# Semaphore
-
-Imagine a situation where you need to control access to several instances of
-a shared resource. For example, you might want to distribute images between several
-worker processes that perform transformations, or you might want to create a web
-crawler that performs a defined number of requests in parallel.
-
-A semaphore is a data structure that is initialized to a positive integer value and that
-can be locked multiple times.
-As long as the semaphore value is positive, locking it will return the current value
-and the locking process will continue execution immediately; the semaphore will
-be decremented upon locking. Releasing the lock will increment the semaphore again.
-
-Once the semaphore has reached zero, the next process that attempts to acquire a lock
-will be suspended until another process releases its lock and this increments the semaphore
-again.
-
-This library provides a semaphore implementation for Javascript that is similar to the
-mutex implementation described above.
-
-# How to use it?
-
-## Installation
-
-You can install the library into your project via npm
-
-    npm install async-mutex
-
-The library is written in TypeScript and will work in any environment that
-supports ES5, ES6 promises and `Array.isArray`. On ancient browsers,
-a shim can be used (e.g. [core-js](https://github.com/zloirock/core-js)).
-No external typings are required for using this library with
-TypeScript (version >= 2).
-
-Starting with Node 12.16 and 13.7, native ES6 style imports are supported.
-
-**WARNING:** Node 13 versions < 13.2.0 fail to import this package correctly.
-Node 12 and earlier are fine, as are newer versions of Node 13.
-
-## Importing
-
-**CommonJS:**
-```javascript
-var Mutex = require('async-mutex').Mutex;
-var Semaphore = require('async-mutex').Semaphore;
-var withTimeout = require('async-mutex').withTimeout;
-```
-
-**ES6:**
-```javascript
-import {Mutex, Semaphore, withTimeout} from 'async-mutex';
-```
-
-**TypeScript:**
-```typescript
-import {Mutex, MutexInterface, Semaphore, SemaphoreInterface, withTimeout} from 'async-mutex';
-```
-
-With the latest version of Node, native ES6 style imports are supported.
-
-##  Mutex API
-
-### Creating
-
-```typescript
-const mutex = new Mutex();
-```
-
-Create a new mutex.
-
-### Synchronized code execution
-
-Promise style:
-```typescript
-mutex
-    .runExclusive(function() {
-        // ...
-    })
-    .then(function(result) {
-        // ...
-    });
-```
-
-async/await:
-```typescript
-await mutex.runExclusive(async () => {
-    // ...
-});
-```
-
-`runExclusive` schedules the supplied callback to be run once the mutex is unlocked.
-The function may return a promise. Once the promise is resolved or rejected (or immediately after
-execution if an immediate value was returned),
-the mutex is released. `runExclusive` returns a promise that adopts the state of the function result.
-
-The mutex is released and the result rejected if an exception occurs during execution
-if the callback.
-
-### Manual locking / releasing
-
-Promise style:
-```typescript
-mutex
-    .acquire()
-    .then(function(release) {
-        // ...
-
-        release();
-    });
-```
-
-async/await:
-```typescript
-const release = await mutex.acquire();
-try {
-    // ...
-} finally {
-    release();
-}
-```
-
-`acquire` returns an (ES6) promise that will resolve as soon as the mutex is
-available. The promise resolves with a function `release` that
-must be called once the mutex should be released again.
-
-**IMPORTANT:** Failure to call `release` will hold the mutex locked and will
-likely deadlock the application. Make sure to call `release` under all circumstances
-and handle exceptions accordingly.
-
-`acquire` / `release` should be considered a low level API. In most situations,
-`runExclusive` will be a better choice that automatically takes care of releasing
-the mutex once a block of code has executed exclusively.
-
-### Checking whether the mutex is locked
-
-```typescript
-mutex.isLocked();
-```
-
-### Cancelling pending locks.
-
-Pending locks can be cancelled by calling `cancel()` on the mutex. This will reject
-all pending locks with `E_CANCELED`:
-
-Promise style:
-```typescript
-import {E_CANCELED} from 'async-mutex';
-
-mutex
-    .runExclusive(() => {
-        // ...
-    })
-    .then(() => {
-        // ...
-    })
-    .catch(e => {
-        if (e === E_CANCELED) {
-            // ...
-        }
-    });
-```
-
-async/await:
-```typescript
-import {E_CANCELED} from 'async-mutex';
-
-try {
-    await mutex.runExclusive(() => {
-        // ...
-    });
-} catch (e) {
-    if (e === E_CANCELED) {
-        // ...
-    }
-}
-```
-
-This works with `acquire`, too:
-if `acquire` is used for locking, the resulting promise will reject with `E_CANCELED`.
-
-The error that is thrown can be customized by passing a different error to the `Mutex`
-constructor:
-
-```typescript
-const mutex = new Mutex(new Error('fancy custom error'));
-```
-
-Note that while all pending locks are cancelled, a currently held lock will not be
-revoked. In consequence, the mutex may not be available even after `cancel()` has been called.
-
-### Waiting until the mutex is available
-
-You can wait until the mutex is available without locking it by calling `waitForUnlock()`.
-This will return a promise that resolve once the mutex can be acquired again. This operation
-will not lock the mutex, and there is no gurantee that the mutex will still be available
-once a async barrier has been encountered.
-
-Promise style:
-```typescript
-mutex
-    .waitForUnlock()
-    .then(() => {
-        // ...
-    });
-```
-
-Async/await:
-```typescript
-await mutex.waitForUnlock();
-// ...
-```
-
-
-##  Semaphore API
-
-### Creating
-
-```typescript
-const semaphore = new Semaphore(initialValue);
-```
-
-Creates a new semaphore. `initialValue` is a positive integer that defines the
-initial value of the semaphore (aka the maximum number of concurrent consumers).
-
-### Synchronized code execution
-
-Promise style:
-```typescript
-semaphore
-    .runExclusive(function(value) {
-        // ...
-    })
-    .then(function(result) {
-        // ...
-    });
-```
-
-async/await:
-```typescript
-await semaphore.runExclusive(async (value) => {
-    // ...
-});
-```
-
-`runExclusive` schedules the supplied callback to be run once the semaphore is available.
-The callback will receive the current value of the semaphore as its argument.
-The function may return a promise. Once the promise is resolved or rejected (or immediately after
-execution if an immediate value was returned),
-the semaphore is released. `runExclusive` returns a promise that adopts the state of the function result.
-
-The semaphore is released and the result rejected if an exception occurs during execution
-of the callback.
-
-### Manual locking / releasing
-
-Promise style:
-```typescript
-semaphore
-    .acquire()
-    .then(function([value, release]) {
-        // ...
-
-        release();
-    });
-```
-
-async/await:
-```typescript
-const [value, release] = await semaphore.acquire();
-try {
-    // ...
-} finally {
-    release();
-}
-```
-
-`acquire` returns an (ES6) promise that will resolve as soon as the semaphore is
-available. The promise resolves to an array with the
-first entry being the current value of the semaphore, and the second value a
-function that must be called to release the semaphore once the critical operation
-has completed.
-
-**IMPORTANT:** Failure to call `release` will hold the semaphore locked and will
-likely deadlock the application. Make sure to call `release` under all circumstances
-and handle exceptions accordingly.
-
-`acquire` / `release` should be considered a low level API. In most situations,
-`runExclusive` will be a better choice that automatically takes care of releasing
-the mutex once a block of code has executed exclusively.
-
-### Checking whether the semaphore is locked
-
-```typescript
-semaphore.isLocked();
-```
-
-The semaphore is considered to be locked if it has a value of zero.
-
-### Cancelling pending locks.
-
-Pending locks can be cancelled by calling `cancel()` on the sempahore. This will reject
-all pending locks with `E_CANCELED`:
-
-Promise style:
-```typescript
-import {E_CANCELED} from 'async-mutex';
-
-semaphore
-    .runExclusive(() => {
-        // ...
-    })
-    .then(() => {
-        // ...
-    })
-    .catch(e => {
-        if (e === E_CANCELED) {
-            // ...
-        }
-    });
-```
-
-async/await:
-```typescript
-import {E_CANCELED} from 'async-mutex';
-
-try {
-    await semaphore.runExclusive(() => {
-        // ...
-    });
-} catch (e) {
-    if (e === E_CANCELED) {
-        // ...
-    }
-}
-```
-
-This works with `aquire`, too:
-if `acquire` is used for locking, the resulting promise will reject with `E_CANCELED`.
-
-The error that is thrown can be customized by passing a different error to the `Semaphore`
-constructor:
-
-```typescript
-const semaphore = new Semaphore(2, new Error('fancy custom error'));
-```
-
-Note that while all pending locks are cancelled, any currently held locks will not be
-revoked. In consequence, the semaphore may not be available even after `cancel()` has been called.
-
-### Waiting until the semaphore is available
-
-You can wait until the semaphore is available without locking it by calling `waitForUnlock()`.
-This will return a promise that resolve once the semaphore can be acquired again. This operation
-will not lock the semaphore, and there is no gurantee that the semaphore will still be available
-once a async barrier has been encountered.
-
-Promise style:
-```typescript
-semaphore
-    .waitForUnlock()
-    .then(() => {
-        // ...
-    });
-```
-
-Async/await:
-```typescript
-await semaphore.waitForUnlock();
-// ...
-```
-
-## Limiting the time waiting for a mutex or semaphore to become available
-
-Sometimes it is desirable to limit the time a program waits for a mutex or
-semaphore to become available. The `withTimeout` decorator can be applied
-to both semaphores and mutexes and changes the behavior of `acquire` and
-`runExclusive` accordingly.
-
-```typescript
-import {withTimeout, E_TIMEOUT} from 'async-mutex';
-
-const mutexWithTimeout = withTimeout(new Mutex(), 100);
-const semaphoreWithTimeout = withTimeout(new Semaphore(5), 100);
-```
-
-The API of the decorated mutex or semaphore is unchanged.
-
-The second argument of `withTimeout` is the timeout in milliseconds. After the
-timeout is exceeded, the promise returned by `acquire` and `runExclusive` will
-reject with `E_TIMEOUT`. The latter will not run the provided callback in case
-of an timeout.
-
-The third argument of `withTimeout` is optional and can be used to
-customize the error with which the promise is rejected.
-
-```typescript
-const mutexWithTimeout = withTimeout(new Mutex(), 100, new Error('new fancy error'));
-const semaphoreWithTimeout = withTimeout(new Semaphore(5), 100, new Error('new fancy error'));
-```
-
-### Failing early if the mutex or semaphore is not available
-
-A shortcut exists for the case where you do not want to wait for a lock to
-be available at all. The `tryAcquire` decorator can be applied to both mutexes
-and semaphores and changes the behavior of `acquire` and `runExclusive` to
-immediately throw `E_ALREADY_LOCKED` if the mutex is not available.
-
-Promise style:
-```typescript
-import {tryAcquire, E_ALREADY_LOCKED} from 'async-mutex';
-
-tryAcquire(semaphoreOrMutex)
-    .runExclusive(() => {
-        // ...
-    })
-    .then(() => {
-        // ...
-    })
-    .catch(e => {
-        if (e === E_ALREADY_LOCKED) {
-            // ...
-        }
-    });
-
-```
-
-async/await:
-```typescript
-import {tryAcquire, E_ALREADY_LOCKED} from 'async-mutex';
-
-try {
-    await tryAcquire(semaphoreOrMutex).runExclusive(() => {
-        // ...
-    });
-} catch (e) {
-    if (e === E_ALREADY_LOCKED) {
-        // ...
-    }
-}
-
-```
-
-Again, the error can be customized by providing a custom error as second argument to
-`tryAcquire`.
-
-# License
-
-Feel free to use this library under the conditions of the MIT license.

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/Mutex.js

@@ -1,38 +0,0 @@
-import { __awaiter, __generator } from "tslib";
-import Semaphore from './Semaphore';
-var Mutex = /** @class */ (function () {
-    function Mutex(cancelError) {
-        this._semaphore = new Semaphore(1, cancelError);
-    }
-    Mutex.prototype.acquire = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, releaser;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this._semaphore.acquire()];
-                    case 1:
-                        _a = _b.sent(), releaser = _a[1];
-                        return [2 /*return*/, releaser];
-                }
-            });
-        });
-    };
-    Mutex.prototype.runExclusive = function (callback) {
-        return this._semaphore.runExclusive(function () { return callback(); });
-    };
-    Mutex.prototype.isLocked = function () {
-        return this._semaphore.isLocked();
-    };
-    Mutex.prototype.waitForUnlock = function () {
-        return this._semaphore.waitForUnlock();
-    };
-    /** @deprecated Deprecated in 0.3.0, will be removed in 0.4.0. Use runExclusive instead. */
-    Mutex.prototype.release = function () {
-        this._semaphore.release();
-    };
-    Mutex.prototype.cancel = function () {
-        return this._semaphore.cancel();
-    };
-    return Mutex;
-}());
-export default Mutex;

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/MutexInterface.js

@@ -1 +0,0 @@
-export {};

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/Semaphore.js

@@ -1,100 +0,0 @@
-import { __awaiter, __generator } from "tslib";
-import { E_CANCELED } from './errors';
-var Semaphore = /** @class */ (function () {
-    function Semaphore(_maxConcurrency, _cancelError) {
-        if (_cancelError === void 0) { _cancelError = E_CANCELED; }
-        this._maxConcurrency = _maxConcurrency;
-        this._cancelError = _cancelError;
-        this._queue = [];
-        this._waiters = [];
-        if (_maxConcurrency <= 0) {
-            throw new Error('semaphore must be initialized to a positive value');
-        }
-        this._value = _maxConcurrency;
-    }
-    Semaphore.prototype.acquire = function () {
-        var _this = this;
-        var locked = this.isLocked();
-        var ticketPromise = new Promise(function (resolve, reject) {
-            return _this._queue.push({ resolve: resolve, reject: reject });
-        });
-        if (!locked)
-            this._dispatch();
-        return ticketPromise;
-    };
-    Semaphore.prototype.runExclusive = function (callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, value, release;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.acquire()];
-                    case 1:
-                        _a = _b.sent(), value = _a[0], release = _a[1];
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, , 4, 5]);
-                        return [4 /*yield*/, callback(value)];
-                    case 3: return [2 /*return*/, _b.sent()];
-                    case 4:
-                        release();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Semaphore.prototype.waitForUnlock = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var waitPromise;
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (!this.isLocked()) {
-                    return [2 /*return*/, Promise.resolve()];
-                }
-                waitPromise = new Promise(function (resolve) { return _this._waiters.push({ resolve: resolve }); });
-                return [2 /*return*/, waitPromise];
-            });
-        });
-    };
-    Semaphore.prototype.isLocked = function () {
-        return this._value <= 0;
-    };
-    /** @deprecated Deprecated in 0.3.0, will be removed in 0.4.0. Use runExclusive instead. */
-    Semaphore.prototype.release = function () {
-        if (this._maxConcurrency > 1) {
-            throw new Error('this method is unavailable on semaphores with concurrency > 1; use the scoped release returned by acquire instead');
-        }
-        if (this._currentReleaser) {
-            var releaser = this._currentReleaser;
-            this._currentReleaser = undefined;
-            releaser();
-        }
-    };
-    Semaphore.prototype.cancel = function () {
-        var _this = this;
-        this._queue.forEach(function (ticket) { return ticket.reject(_this._cancelError); });
-        this._queue = [];
-    };
-    Semaphore.prototype._dispatch = function () {
-        var _this = this;
-        var nextTicket = this._queue.shift();
-        if (!nextTicket)
-            return;
-        var released = false;
-        this._currentReleaser = function () {
-            if (released)
-                return;
-            released = true;
-            _this._value++;
-            _this._resolveWaiters();
-            _this._dispatch();
-        };
-        nextTicket.resolve([this._value--, this._currentReleaser]);
-    };
-    Semaphore.prototype._resolveWaiters = function () {
-        this._waiters.forEach(function (waiter) { return waiter.resolve(); });
-        this._waiters = [];
-    };
-    return Semaphore;
-}());
-export default Semaphore;

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/SemaphoreInterface.js

@@ -1 +0,0 @@
-export {};

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/errors.js

@@ -1,3 +0,0 @@
-export var E_TIMEOUT = new Error('timeout while waiting for mutex to become available');
-export var E_ALREADY_LOCKED = new Error('mutex already locked');
-export var E_CANCELED = new Error('request for lock canceled');

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/index.js

@@ -1,5 +0,0 @@
-export { default as Mutex } from './Mutex';
-export { default as Semaphore } from './Semaphore';
-export { withTimeout } from './withTimeout';
-export { tryAcquire } from './tryAcquire';
-export * from './errors';

package/node_modules/@supernova-studio/pulsar-language/node_modules/@supernovaio/supernova-sdk/node_modules/async-mutex/es6/tryAcquire.js

@@ -1,8 +0,0 @@
-import { E_ALREADY_LOCKED } from './errors';
-import { withTimeout } from './withTimeout';
-// eslint-disable-next-lisne @typescript-eslint/explicit-module-boundary-types
-export function tryAcquire(sync, alreadyAcquiredError) {
-    if (alreadyAcquiredError === void 0) { alreadyAcquiredError = E_ALREADY_LOCKED; }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return withTimeout(sync, 0, alreadyAcquiredError);
-}