node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.js

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
0 && (module.exports = {
    DANGEROUSLY_runPendingImmediatesAfterCurrentTask: null,
    expectNoPendingImmediates: null,
    unpatchedSetImmediate: null
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    DANGEROUSLY_runPendingImmediatesAfterCurrentTask: function() {
        return DANGEROUSLY_runPendingImmediatesAfterCurrentTask;
    },
    expectNoPendingImmediates: function() {
        return expectNoPendingImmediates;
    },
    unpatchedSetImmediate: function() {
        return originalSetImmediate;
    }
});
const _nodeutil = require("node:util");
const _invarianterror = require("../../shared/lib/invariant-error");
const _asynclocalstorage = require("../app-render/async-local-storage");
var ExecutionState = /*#__PURE__*/ function(ExecutionState) {
    ExecutionState[ExecutionState["Waiting"] = 1] = "Waiting";
    ExecutionState[ExecutionState["Working"] = 2] = "Working";
    ExecutionState[ExecutionState["Finished"] = 3] = "Finished";
    ExecutionState[ExecutionState["Abandoned"] = 4] = "Abandoned";
    return ExecutionState;
}(ExecutionState || {});
let wasEnabledAtLeastOnce = false;
let pendingNextTicks = 0;
let currentExecution = null;
const originalSetImmediate = globalThis.setImmediate;
const originalClearImmediate = globalThis.clearImmediate;
const originalNextTick = process.nextTick;
function install() {
    if (process.env.NEXT_RUNTIME === 'edge') {
        // Nothing to patch. The exported functions all error if used in the edge runtime,
        // so we're not going to violate any assumptions by not patching.
        return;
    } else {
        debug == null ? void 0 : debug('installing fast setImmediate patch');
        const nodeTimers = require('node:timers');
        globalThis.setImmediate = nodeTimers.setImmediate = // Workaround for missing __promisify__ which is not a real property
        patchedSetImmediate;
        globalThis.clearImmediate = nodeTimers.clearImmediate = patchedClearImmediate;
        const nodeTimersPromises = require('node:timers/promises');
        nodeTimersPromises.setImmediate = patchedSetImmediatePromise;
        process.nextTick = patchedNextTick;
    }
}
function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
    if (process.env.NEXT_RUNTIME === 'edge') {
        throw Object.defineProperty(new _invarianterror.InvariantError('DANGEROUSLY_runPendingImmediatesAfterCurrentTask cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
            value: "E960",
            enumerable: false,
            configurable: true
        });
    } else {
        const execution = startCapturingImmediates();
        try {
            scheduleWorkAfterNextTicksAndMicrotasks(execution);
        } catch (err) {
            // If this error comes from a bail() call, rethrow it.
            if (execution.state === 4) {
                throw err;
            }
            // Otherwise, bail out here.
            bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while starting to capture immediates', {
                cause: err
            }), "__NEXT_ERROR_CODE", {
                value: "E964",
                enumerable: false,
                configurable: true
            }));
        }
    }
}
function expectNoPendingImmediates() {
    if (process.env.NEXT_RUNTIME === 'edge') {
        throw Object.defineProperty(new _invarianterror.InvariantError('expectNoPendingImmediates cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
            value: "E962",
            enumerable: false,
            configurable: true
        });
    } else {
        if (currentExecution !== null) {
            bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Expected all captured immediates to have been executed (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
                value: "E958",
                enumerable: false,
                configurable: true
            }));
        }
    }
}
/**
 * Wait until all nextTicks and microtasks spawned from the current task are done,
 * then execute any immediates that they queued.
 * */ function scheduleWorkAfterNextTicksAndMicrotasks(execution) {
    if (execution.state !== 1) {
        throw Object.defineProperty(new _invarianterror.InvariantError(`scheduleWorkAfterTicksAndMicrotasks can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
            value: "E959",
            enumerable: false,
            configurable: true
        });
    }
    // We want to execute "fast immediates" after all the nextTicks and microtasks
    // spawned from the current task are done.
    // The ordering here is:
    //
    // 1. sync code
    // 2. process.nextTick (scheduled from sync code, or from one of these nextTicks)
    // 3. microtasks
    // 4. process.nextTick (scheduled from microtasks, e.g. `queueMicrotask(() => process.nextTick(callback))`)
    //
    // We want to run to run in step 4, because that's the latest point before the next tick.
    // However, there might also be other callbacks scheduled to run in that step.
    // But importantly, they had to be scheduled using a `process.nextTick`,
    // so we can detect them by checking if `pendingNextTicks > 0`.
    // In that case, we'll just reschedule ourselves in the same way again to let them run first.
    // (this process can theoretically repeat multiple times, hence the recursion).
    queueMicrotask(()=>{
        // (note that this call won't increment `pendingNextTicks`,
        // only the patched `process.nextTick` does that, so this won't loop infinitely)
        originalNextTick(()=>{
            // We're now in a nextTick, which means that we're executing inside `processTicksAndRejections`:
            // https://github.com/nodejs/node/blob/d546e7fd0bc3cbb4bcc2baae6f3aa44d2e81a413/lib/internal/process/task_queues.js#L84
            // All the work scheduled here will happen within that `processTicksAndRejections` loop.
            // Reading the source of `processTicksAndRejections` can help understand the timing here --
            // All we're really doing is strategically pushing callbacks into the two queues
            // (nextTicks and microtasks) that that function is currently looping over.
            try {
                if (execution.state === 4 || currentExecution !== execution) {
                    debug == null ? void 0 : debug(`scheduler :: the execution was abandoned`);
                    return;
                }
                if (pendingNextTicks > 0) {
                    // Other nextTicks have been scheduled. Let those run first, then try again --
                    // we're simulating a event loop task, so all nextTicks should be exhausted before we execute.
                    debug == null ? void 0 : debug(`scheduler :: yielding to ${pendingNextTicks} nextTicks`);
                    return scheduleWorkAfterNextTicksAndMicrotasks(execution);
                }
                // There's no other nextTicks, we're the last one, so we're about to move on to the next task (likely a timer).
                // Now, we can try and execute any queued immediates.
                return performWork(execution);
            } catch (err) {
                // If this error comes from a bail() call, rethrow it.
                // typescript can't tell that the state might've been mutated
                // and the narrowing from above is no longer valid
                const executionAfterWork = execution;
                if (executionAfterWork.state === 4) {
                    throw err;
                }
                // Otherwise, bail out here (which will trigger an uncaught exception)
                // Note that we're using the same microtask trick as `safelyRunNextTickCallback`.
                queueMicrotask(()=>{
                    bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while executing immediates', {
                        cause: err
                    }), "__NEXT_ERROR_CODE", {
                        value: "E955",
                        enumerable: false,
                        configurable: true
                    }));
                });
            }
        });
    });
}
/** Execute one immediate, and schedule a check for more (in case there's others in the queue) */ function performWork(execution) {
    if (execution.state === 4) {
        return;
    }
    debug == null ? void 0 : debug(`scheduler :: performing work`);
    if (execution.state !== 1) {
        throw Object.defineProperty(new _invarianterror.InvariantError(`performWork can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
            value: "E956",
            enumerable: false,
            configurable: true
        });
    }
    execution.state = 2;
    const queueItem = takeNextActiveQueueItem(execution);
    if (queueItem === null) {
        debug == null ? void 0 : debug(`scheduler :: no immediates queued, exiting`);
        stopCapturingImmediates(execution);
        return;
    }
    debug == null ? void 0 : debug(`scheduler :: executing queued immediate`);
    const { immediateObject, callback, args } = queueItem;
    immediateObject[INTERNALS].queueItem = null;
    clearQueueItem(queueItem);
    // Execute the immediate.
    // If a sync error was thrown in the immediate, we want to trigger a `uncaughtException`.
    // However, we're executing in a nextTick, and if a nextTick callback errors,
    // It'll break out of `processTicksAndRejections` (note the lack of a `catch` block):
    //   https://github.com/nodejs/node/blob/d546e7fd0bc3cbb4bcc2baae6f3aa44d2e81a413/lib/internal/process/task_queues.js#L81-L97
    // Meaning that the event loop will stop executing nextTicks and move on to the next timer
    // (or other phase of the event loop, but we expect to be running in a sequence of timers here).
    // Then, the remaining ticks will run after that timer, since they're still in the queue.
    //
    // This would completely break the timing we're trying to achieve here --
    // The point of this patch is to execute immediates before the next timer!
    // So, we need to work around this behavior. (both here and in our `process.nextTick` patch).
    //
    // We can sidestep this by catching the synchronous error and rethrowing it in a microtask.
    // (NOTE: if we use `queueMicrotask`, it'll trigger `uncaughtException`, not `unhandledRejection`,
    // because there's no promise being rejected.)
    //
    // This will make `uncaughtException` happen:
    // - Before the next fast immediate (`scheduleWorkAfterNextTicksAndMicrotasks` also uses `queueMicrotask`).
    //   This is good, and matches usual observable behavior of immediates.
    // - AFTER nextTicks scheduled from the immediate itself.
    //   This deviates from native setImmediate, which would call `uncaughtException` first,
    //   and skip ahead to the next task as explained above.
    //
    // This is technically an observable difference in behavior, but it seems niche enough that
    // it shouldn't cause problems -- we don't expect user code to use `uncaughtException` for control flow,
    // only error reporting, so subtly changing the timing shouldn't matter.
    let didThrow = false;
    let thrownValue = undefined;
    queueMicrotask(()=>{
        if (didThrow) {
            debug == null ? void 0 : debug('scheduler :: rethrowing sync error from immediate in microtask');
            throw thrownValue;
        }
    });
    try {
        if (args !== null) {
            callback.apply(null, args);
        } else {
            callback();
        }
    } catch (err) {
        // We'll rethrow the error in the microtask above.
        didThrow = true;
        thrownValue = err;
    }
    // Schedule the loop again in case there's more immediates after this one.
    // Note that we can't just check if the queue is empty now, because new immediates
    // might still be scheduled asynchronously, from an upcoming nextTick or microtask.
    execution.state = 1;
    scheduleWorkAfterNextTicksAndMicrotasks(execution);
}
function takeNextActiveQueueItem(execution) {
    // Find the first (if any) queued immediate that wasn't cleared.
    // We don't remove immediates from the array when they're cleared,
    // so this requires some legwork to exclude (and possibly drop) cleared items.
    const { queuedImmediates } = execution;
    let firstActiveItem = null;
    let firstActiveItemIndex = -1;
    for(let i = 0; i < queuedImmediates.length; i++){
        const item = queuedImmediates[i];
        if (!item.isCleared) {
            firstActiveItem = item;
            firstActiveItemIndex = i;
            break;
        }
    }
    if (firstActiveItem === null) {
        // We didn't find an active item.
        // If the queue isn't empty, then it must only contain cleared items. Empty it.
        if (queuedImmediates.length > 0) {
            queuedImmediates.length = 0;
        }
        return null;
    }
    // Remove all items up to and including `nextActiveItemIndex` from the queue.
    // (if it's not the first item, then it must be preceded by cleared items, which we want to drop anyway)
    if (firstActiveItemIndex === 0) {
        // Fast path - drop the first item
        // (`splice` creates a result array for the removed items, so this is more efficient)
        queuedImmediates.shift();
    } else {
        queuedImmediates.splice(0, firstActiveItemIndex + 1);
    }
    return firstActiveItem;
}
function startCapturingImmediates() {
    if (currentExecution !== null) {
        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Cannot start capturing immediates again without finishing the previous task (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
            value: "E954",
            enumerable: false,
            configurable: true
        }));
    }
    wasEnabledAtLeastOnce = true;
    const execution = {
        state: 1,
        queuedImmediates: []
    };
    currentExecution = execution;
    return execution;
}
function stopCapturingImmediates(execution) {
    if (execution.state === 4) {
        return;
    }
    // This check enforces that we run performWork at least once before stopping
    // to make sure that we've waited for all the nextTicks and microtasks
    // that might've scheduled some immediates after sync code.
    if (execution.state !== 2) {
        throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot stop capturing immediates before execution is finished (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
            value: "E957",
            enumerable: false,
            configurable: true
        });
    }
    execution.state = 3;
    if (currentExecution === execution) {
        currentExecution = null;
    }
}
function bail(execution, error) {
    // Reset the state as best we can to prevent further crashes.
    // Otherwise, any subsequent call to `DANGEROUSLY_runPendingImmediatesAfterCurrentTask`
    // would error, requiring a server restart to fix.
    if (currentExecution === execution) {
        currentExecution = null;
    }
    execution.state = 4;
    // If we have any queued immediates, schedule them with native `setImmediate` and clear the queue.
    // We don't want to skip running them altogether, because that could lead to
    // e.g. hanging promises (for `new Promise((resolve) => setImmediate(resolve))`),
    // but we're in an inconsistent state and can't run them as fast immediates,
    // so this is the next best thing.
    for (const queueItem of execution.queuedImmediates){
        if (queueItem.isCleared) {
            continue;
        }
        scheduleQueuedImmediateAsNativeImmediate(queueItem);
    }
    execution.queuedImmediates.length = 0;
    // Don't reset `pendingNextTicks` -- it will reset to 0 on its own as the nextTicks execute.
    // If we set it to 0 here while we still have pending ticks, they'd decrement it below 0.
    throw error;
}
function scheduleQueuedImmediateAsNativeImmediate(queueItem) {
    const { callback, args, immediateObject } = queueItem;
    const hasRef = immediateObject[INTERNALS].hasRef;
    clearQueueItem(queueItem);
    const nativeImmediate = args !== null ? originalSetImmediate(callback, ...args) : originalSetImmediate(callback);
    if (!hasRef) {
        nativeImmediate.unref();
    }
    // Make our fake immediate object proxy all relevant operations
    // (clearing, ref(), unref(), hasRef()) to the actual native immediate.
    proxyQueuedImmediateToNativeImmediate(immediateObject, nativeImmediate);
}
function clearQueueItem(originalQueueItem) {
    const queueItem = originalQueueItem;
    queueItem.isCleared = true;
    queueItem.callback = null;
    queueItem.args = null;
    queueItem.immediateObject = null;
}
function patchedNextTick() {
    if (currentExecution === null) {
        return originalNextTick.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
        arguments);
    }
    if (arguments.length === 0 || typeof arguments[0] !== 'function') {
        // Let the original nextTick error for invalid arguments
        // so that we don't have to mirror the error message.
        originalNextTick.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
        arguments);
        // We expect the above call to throw. If it didn't, something's broken.
        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected process.nextTick to reject invalid arguments'), "__NEXT_ERROR_CODE", {
            value: "E966",
            enumerable: false,
            configurable: true
        }));
    }
    debug == null ? void 0 : debug(`scheduler :: process.nextTick called (previous pending: ${pendingNextTicks})`);
    const callback = arguments[0];
    const args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : null;
    pendingNextTicks += 1;
    return originalNextTick(safelyRunNextTickCallback, callback, args);
}
function safelyRunNextTickCallback(callback, args) {
    pendingNextTicks -= 1;
    debug == null ? void 0 : debug(`scheduler :: process.nextTick executing (still pending: ${pendingNextTicks})`);
    // Synchronous errors in nextTick break out of `processTicksAndRejections` and cause us
    // to move on to the next timer without having executed the whole nextTick queue,
    // which breaks our entire scheduling mechanism. See `performWork` for more details.
    try {
        if (args !== null) {
            callback.apply(null, args);
        } else {
            callback();
        }
    } catch (err) {
        // We want to make sure `nextTick` is cheap, so unlike `performWork`,
        // we only queue the microtask if an error actually occurs.
        // This (observably) changes the timing of `uncaughtException` even more,
        // because it'll run after microtasks queued from the nextTick,
        // but hopefully this is niche enough to not affect any real world code.
        queueMicrotask(()=>{
            debug == null ? void 0 : debug(`scheduler :: rethrowing sync error from nextTick in a microtask`);
            throw err;
        });
    }
}
function patchedSetImmediate() {
    if (currentExecution === null) {
        return originalSetImmediate.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
        arguments);
    }
    if (arguments.length === 0 || typeof arguments[0] !== 'function') {
        // Let the original setImmediate error for invalid arguments
        // so that we don't have to mirror the error message.
        originalSetImmediate.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
        arguments);
        // We expect the above call to throw. If it didn't, something's broken.
        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected setImmediate to reject invalid arguments'), "__NEXT_ERROR_CODE", {
            value: "E965",
            enumerable: false,
            configurable: true
        }));
    }
    const callback = arguments[0];
    const args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : null;
    // Normally, Node would capture and propagate the async context to the immediate.
    // We'll be running it on our own queue, so we need to propagate it ourselves.
    const callbackWithAsyncContext = (0, _asynclocalstorage.bindSnapshot)(callback);
    const immediateObject = new NextImmediate();
    const queueItem = {
        isCleared: false,
        callback: callbackWithAsyncContext,
        args,
        immediateObject
    };
    currentExecution.queuedImmediates.push(queueItem);
    immediateObject[INTERNALS].queueItem = queueItem;
    return immediateObject;
}
function patchedSetImmediatePromise(value, options) {
    if (currentExecution === null) {
        const originalPromisify = // @ts-expect-error: the types for `promisify.custom` are strange
        originalSetImmediate[_nodeutil.promisify.custom];
        return originalPromisify(value, options);
    }
    return new Promise((resolve, reject)=>{
        // The abort signal makes the promise reject.
        // If it is already aborted, we reject immediately.
        const signal = options == null ? void 0 : options.signal;
        if (signal && signal.aborted) {
            return reject(signal.reason);
        }
        const immediate = patchedSetImmediate(resolve, value);
        // Unref-ing only really has an observable effect if we bail out to a native immediate,
        // but we do it for completeness
        if ((options == null ? void 0 : options.ref) === false) {
            immediate.unref();
        }
        if (signal) {
            signal.addEventListener('abort', ()=>{
                patchedClearImmediate(immediate);
                reject(signal.reason);
            }, {
                once: true
            });
        }
    });
}
patchedSetImmediate[_nodeutil.promisify.custom] = patchedSetImmediatePromise;
const patchedClearImmediate = (immediateObject)=>{
    // NOTE: we defensively check for patched immediates even if we're not
    // currently capturing immediates, because the objects returned from
    // the patched setImmediate can be kept around for arbitrarily long.
    // As an optimization, we only do this if the patch was enabled at least once --
    // otherwise, no patched objects could've been created.
    if (wasEnabledAtLeastOnce && immediateObject && typeof immediateObject === 'object' && INTERNALS in immediateObject) {
        ;
        immediateObject[Symbol.dispose]();
    } else {
        originalClearImmediate(immediateObject);
    }
};
//========================================================
const INTERNALS = Symbol.for('next.Immediate.internals');
function proxyQueuedImmediateToNativeImmediate(immediateObject, nativeImmediate) {
    immediateObject[INTERNALS].hasRef = null;
    immediateObject[INTERNALS].queueItem = null;
    immediateObject[INTERNALS].nativeImmediate = nativeImmediate;
}
/** Implements a shim for the native `Immediate` class returned by `setImmediate` */ class NextImmediate {
    hasRef() {
        const internals = this[INTERNALS];
        if (internals.queueItem) {
            return internals.hasRef;
        } else if (internals.nativeImmediate) {
            return internals.nativeImmediate.hasRef();
        } else {
            // if we're no longer queued (cleared or executed), hasRef is always false
            return false;
        }
    }
    ref() {
        const internals = this[INTERNALS];
        if (internals.queueItem) {
            internals.hasRef = true;
        } else if (internals.nativeImmediate) {
            internals.nativeImmediate.ref();
        }
        return this;
    }
    unref() {
        const internals = this[INTERNALS];
        if (internals.queueItem) {
            internals.hasRef = false;
        } else if (internals.nativeImmediate) {
            internals.nativeImmediate.unref();
        }
        return this;
    }
    /**
   * Node invokes `_onImmediate` when an immediate is executed:
   * https://github.com/nodejs/node/blob/42d363205715ffa5a4a6d90f4be1311487053d65/lib/internal/timers.js#L504
   * It's visible on the public types, so we want to have it here for parity, but it's a noop.
   * */ _onImmediate() {}
    [Symbol.dispose]() {
        // This is equivalent to `clearImmediate`.
        const internals = this[INTERNALS];
        if (internals.queueItem) {
            // this is still queued. drop it.
            const queueItem = internals.queueItem;
            internals.queueItem = null;
            clearQueueItem(queueItem);
        } else if (internals.nativeImmediate) {
            internals.nativeImmediate[Symbol.dispose]();
        }
    }
    constructor(){
        this[INTERNALS] = {
            queueItem: null,
            hasRef: true,
            nativeImmediate: null
        };
    }
}
// ==========================================
const debug = process.env.NEXT_DEBUG_IMMEDIATES !== '1' ? undefined : (...args)=>{
    if (process.env.NEXT_RUNTIME === 'edge') {
        throw Object.defineProperty(new _invarianterror.InvariantError('Fast setImmediate is not available in the edge runtime.'), "__NEXT_ERROR_CODE", {
            value: "E963",
            enumerable: false,
            configurable: true
        });
    } else {
        const { inspect } = require('node:util');
        const { writeFileSync } = require('node:fs');
        let logLine = args.map((arg)=>typeof arg === 'string' ? arg : inspect(arg, {
                colors: true
            })).join(' ') + '\n';
        logLine = '\x1B[2m' + logLine + '\x1B[22m' // styleText('dim', logLine)
        ;
        writeFileSync(process.stdout.fd, logLine);
    }
};
// ==========================================
install();

//# sourceMappingURL=fast-set-immediate.external.js.map