FM / dist

/usr/local/lib/node_modules/pm2/node_modules/@tootallnate/quickjs-emscripten/dist/

/usr/local/lib/node_modules/pm2/node_modules/@tootallnate/quickjs-emscripten/dist

Name	Size	Mode	Actions
generated/	-	0755	rm
asyncify-helpers.d.ts	1475	0644	edit dl rm
asyncify-helpers.js	1818	0644	edit dl rm
asyncify-helpers.js.map	4205	0644	edit dl rm
context-asyncify.d.ts	2177	0644	edit dl rm
context-asyncify.js	2370	0644	edit dl rm
context-asyncify.js.map	4651	0644	edit dl rm
context.d.ts	16065	0644	edit dl rm
context.js	29595	0644	edit dl rm
context.js.map	53303	0644	edit dl rm
debug.d.ts	156	0644	edit dl rm
debug.js	327	0644	edit dl rm
debug.js.map	518	0644	edit dl rm
deferred-promise.d.ts	2957	0644	edit dl rm
deferred-promise.js	3754	0644	edit dl rm
deferred-promise.js.map	6176	0644	edit dl rm
emscripten-types.d.ts	3886	0644	edit dl rm
emscripten-types.js	776	0644	edit dl rm
emscripten-types.js.map	5484	0644	edit dl rm
errors.d.ts	836	0644	edit dl rm
errors.js	1914	0644	edit dl rm
errors.js.map	1780	0644	edit dl rm
esmHelpers.d.ts	420	0644	edit dl rm
esmHelpers.js	778	0644	edit dl rm
esmHelpers.js.map	1126	0644	edit dl rm
index.d.ts	4076	0644	edit dl rm
index.js	5949	0644	edit dl rm
index.js.map	6569	0644	edit dl rm
lifetime.d.ts	4399	0644	edit dl rm
lifetime.js	6724	0644	edit dl rm
lifetime.js.map	11858	0644	edit dl rm
memory.d.ts	775	0644	edit dl rm
memory.js	1707	0644	edit dl rm
memory.js.map	3896	0644	edit dl rm
module-asyncify.d.ts	2386	0644	edit dl rm
module-asyncify.js	4035	0644	edit dl rm
module-asyncify.js.map	6459	0644	edit dl rm
module-test.d.ts	1118	0644	edit dl rm
module-test.js	2669	0644	edit dl rm
module-test.js.map	4672	0644	edit dl rm
module.d.ts	6272	0644	edit dl rm
module.js	12740	0644	edit dl rm
module.js.map	21716	0644	edit dl rm
runtime-asyncify.d.ts	1687	0644	edit dl rm
runtime-asyncify.js	1880	0644	edit dl rm
runtime-asyncify.js.map	4082	0644	edit dl rm
runtime.d.ts	7048	0644	edit dl rm
runtime.js	12909	0644	edit dl rm
runtime.js.map	22367	0644	edit dl rm
types-ffi.d.ts	3439	0644	edit dl rm
types-ffi.js	1346	0644	edit dl rm
types-ffi.js.map	4712	0644	edit dl rm
types.d.ts	6751	0644	edit dl rm
types.js	1722	0644	edit dl rm
types.js.map	9272	0644	edit dl rm
variants.d.ts	4784	0644	edit dl rm
variants.js	6893	0644	edit dl rm
variants.js.map	10226	0644	edit dl rm
vm-interface.d.ts	2669	0644	edit dl rm
vm-interface.js	384	0644	edit dl rm
vm-interface.js.map	3179	0644	edit dl rm

Edit: /usr/local/lib/node_modules/pm2/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.js (6724B)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Scope = exports.WeakLifetime = exports.StaticLifetime = exports.Lifetime = void 0;
const asyncify_helpers_1 = require("./asyncify-helpers");
const debug_1 = require("./debug");
const errors_1 = require("./errors");
/**
 * A lifetime prevents access to a value after the lifetime has been
 * [[dispose]]ed.
 *
 * Typically, quickjs-emscripten uses Lifetimes to protect C memory pointers.
 */
class Lifetime {
    /**
     * When the Lifetime is disposed, it will call `disposer(_value)`. Use the
     * disposer function to implement whatever cleanup needs to happen at the end
     * of `value`'s lifetime.
     *
     * `_owner` is not used or controlled by the lifetime. It's just metadata for
     * the creator.
     */
    constructor(_value, copier, disposer, _owner) {
        this._value = _value;
        this.copier = copier;
        this.disposer = disposer;
        this._owner = _owner;
        this._alive = true;
        this._constructorStack = debug_1.QTS_DEBUG ? new Error("Lifetime constructed").stack : undefined;
    }
    get alive() {
        return this._alive;
    }
    /**
     * The value this Lifetime protects. You must never retain the value - it
     * may become invalid, leading to memory errors.
     *
     * @throws If the lifetime has been [[dispose]]d already.
     */
    get value() {
        this.assertAlive();
        return this._value;
    }
    get owner() {
        return this._owner;
    }
    get dupable() {
        return !!this.copier;
    }
    /**
     * Create a new handle pointing to the same [[value]].
     */
    dup() {
        this.assertAlive();
        if (!this.copier) {
            throw new Error("Non-dupable lifetime");
        }
        return new Lifetime(this.copier(this._value), this.copier, this.disposer, this._owner);
    }
    consume(map) {
        this.assertAlive();
        const result = map(this);
        this.dispose();
        return result;
    }
    /**
     * Dispose of [[value]] and perform cleanup.
     */
    dispose() {
        this.assertAlive();
        if (this.disposer) {
            this.disposer(this._value);
        }
        this._alive = false;
    }
    assertAlive() {
        if (!this.alive) {
            if (this._constructorStack) {
                throw new errors_1.QuickJSUseAfterFree(`Lifetime not alive\n${this._constructorStack}\nLifetime used`);
            }
            throw new errors_1.QuickJSUseAfterFree("Lifetime not alive");
        }
    }
}
exports.Lifetime = Lifetime;
/**
 * A Lifetime that lives forever. Used for constants.
 */
class StaticLifetime extends Lifetime {
    constructor(value, owner) {
        super(value, undefined, undefined, owner);
    }
    // Static lifetime doesn't need a copier to be copiable
    get dupable() {
        return true;
    }
    // Copy returns the same instance.
    dup() {
        return this;
    }
    // Dispose does nothing.
    dispose() { }
}
exports.StaticLifetime = StaticLifetime;
/**
 * A Lifetime that does not own its `value`. A WeakLifetime never calls its
 * `disposer` function, but can be `dup`ed to produce regular lifetimes that
 * do.
 *
 * Used for function arguments.
 */
class WeakLifetime extends Lifetime {
    constructor(value, copier, disposer, owner) {
        // We don't care if the disposer doesn't support freeing T
        super(value, copier, disposer, owner);
    }
    dispose() {
        this._alive = false;
    }
}
exports.WeakLifetime = WeakLifetime;
function scopeFinally(scope, blockError) {
    // console.log('scopeFinally', scope, blockError)
    let disposeError;
    try {
        scope.dispose();
    }
    catch (error) {
        disposeError = error;
    }
    if (blockError && disposeError) {
        Object.assign(blockError, {
            message: `${blockError.message}\n Then, failed to dispose scope: ${disposeError.message}`,
            disposeError,
        });
        throw blockError;
    }
    if (blockError || disposeError) {
        throw blockError || disposeError;
    }
}
/**
 * Scope helps reduce the burden of manually tracking and disposing of
 * Lifetimes. See [[withScope]]. and [[withScopeAsync]].
 */
class Scope {
    constructor() {
        this._disposables = new Lifetime(new Set());
    }
    /**
     * Run `block` with a new Scope instance that will be disposed after the block returns.
     * Inside `block`, call `scope.manage` on each lifetime you create to have the lifetime
     * automatically disposed after the block returns.
     *
     * @warning Do not use with async functions. Instead, use [[withScopeAsync]].
     */
    static withScope(block) {
        const scope = new Scope();
        let blockError;
        try {
            return block(scope);
        }
        catch (error) {
            blockError = error;
            throw error;
        }
        finally {
            scopeFinally(scope, blockError);
        }
    }
    static withScopeMaybeAsync(_this, block) {
        return (0, asyncify_helpers_1.maybeAsync)(undefined, function* (awaited) {
            const scope = new Scope();
            let blockError;
            try {
                return yield* awaited.of(block.call(_this, awaited, scope));
            }
            catch (error) {
                blockError = error;
                throw error;
            }
            finally {
                scopeFinally(scope, blockError);
            }
        });
    }
    /**
     * Run `block` with a new Scope instance that will be disposed after the
     * block's returned promise settles. Inside `block`, call `scope.manage` on each
     * lifetime you create to have the lifetime automatically disposed after the
     * block returns.
     */
    static async withScopeAsync(block) {
        const scope = new Scope();
        let blockError;
        try {
            return await block(scope);
        }
        catch (error) {
            blockError = error;
            throw error;
        }
        finally {
            scopeFinally(scope, blockError);
        }
    }
    /**
     * Track `lifetime` so that it is disposed when this scope is disposed.
     */
    manage(lifetime) {
        this._disposables.value.add(lifetime);
        return lifetime;
    }
    get alive() {
        return this._disposables.alive;
    }
    dispose() {
        const lifetimes = Array.from(this._disposables.value.values()).reverse();
        for (const lifetime of lifetimes) {
            if (lifetime.alive) {
                lifetime.dispose();
            }
        }
        this._disposables.dispose();
    }
}
exports.Scope = Scope;
//# sourceMappingURL=lifetime.js.map

cmd: