karajan-code 3.4.1 → 3.4.2

package/node_modules/execa/lib/terminate/graceful.js

@@ -1,71 +0,0 @@
-import {onAbortedSignal} from '../utils/abort-signal.js';
-import {sendAbort} from '../ipc/graceful.js';
-import {killOnTimeout} from './kill.js';
-
-// Validate the `gracefulCancel` option
-export const validateGracefulCancel = ({gracefulCancel, cancelSignal, ipc, serialization}) => {
-	if (!gracefulCancel) {
-		return;
-	}
-
-	if (cancelSignal === undefined) {
-		throw new Error('The `cancelSignal` option must be defined when setting the `gracefulCancel` option.');
-	}
-
-	if (!ipc) {
-		throw new Error('The `ipc` option cannot be false when setting the `gracefulCancel` option.');
-	}
-
-	if (serialization === 'json') {
-		throw new Error('The `serialization` option cannot be \'json\' when setting the `gracefulCancel` option.');
-	}
-};
-
-// Send abort reason to the subprocess when aborting the `cancelSignal` option and `gracefulCancel` is `true`
-export const throwOnGracefulCancel = ({
-	subprocess,
-	cancelSignal,
-	gracefulCancel,
-	forceKillAfterDelay,
-	context,
-	controller,
-}) => gracefulCancel
-	? [sendOnAbort({
-		subprocess,
-		cancelSignal,
-		forceKillAfterDelay,
-		context,
-		controller,
-	})]
-	: [];
-
-const sendOnAbort = async ({subprocess, cancelSignal, forceKillAfterDelay, context, controller: {signal}}) => {
-	await onAbortedSignal(cancelSignal, signal);
-	const reason = getReason(cancelSignal);
-	await sendAbort(subprocess, reason);
-	killOnTimeout({
-		kill: subprocess.kill,
-		forceKillAfterDelay,
-		context,
-		controllerSignal: signal,
-	});
-	context.terminationReason ??= 'gracefulCancel';
-	throw cancelSignal.reason;
-};
-
-// The default `reason` is a DOMException, which is not serializable with V8
-// See https://github.com/nodejs/node/issues/53225
-const getReason = ({reason}) => {
-	if (!(reason instanceof DOMException)) {
-		return reason;
-	}
-
-	const error = new Error(reason.message);
-	Object.defineProperty(error, 'stack', {
-		value: reason.stack,
-		enumerable: false,
-		configurable: true,
-		writable: true,
-	});
-	return error;
-};

package/node_modules/execa/lib/terminate/kill.js

@@ -1,93 +0,0 @@
-import {setTimeout} from 'node:timers/promises';
-import {isErrorInstance} from '../return/final-error.js';
-import {normalizeSignalArgument} from './signal.js';
-
-// Normalize the `forceKillAfterDelay` option
-export const normalizeForceKillAfterDelay = forceKillAfterDelay => {
-	if (forceKillAfterDelay === false) {
-		return forceKillAfterDelay;
-	}
-
-	if (forceKillAfterDelay === true) {
-		return DEFAULT_FORCE_KILL_TIMEOUT;
-	}
-
-	if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) {
-		throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
-	}
-
-	return forceKillAfterDelay;
-};
-
-const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
-
-// Monkey-patches `subprocess.kill()` to add `forceKillAfterDelay` behavior and `.kill(error)`
-export const subprocessKill = (
-	{kill, options: {forceKillAfterDelay, killSignal}, onInternalError, context, controller},
-	signalOrError,
-	errorArgument,
-) => {
-	const {signal, error} = parseKillArguments(signalOrError, errorArgument, killSignal);
-	emitKillError(error, onInternalError);
-	const killResult = kill(signal);
-	setKillTimeout({
-		kill,
-		signal,
-		forceKillAfterDelay,
-		killSignal,
-		killResult,
-		context,
-		controller,
-	});
-	return killResult;
-};
-
-const parseKillArguments = (signalOrError, errorArgument, killSignal) => {
-	const [signal = killSignal, error] = isErrorInstance(signalOrError)
-		? [undefined, signalOrError]
-		: [signalOrError, errorArgument];
-
-	if (typeof signal !== 'string' && !Number.isInteger(signal)) {
-		throw new TypeError(`The first argument must be an error instance or a signal name string/integer: ${String(signal)}`);
-	}
-
-	if (error !== undefined && !isErrorInstance(error)) {
-		throw new TypeError(`The second argument is optional. If specified, it must be an error instance: ${error}`);
-	}
-
-	return {signal: normalizeSignalArgument(signal), error};
-};
-
-// Fails right away when calling `subprocess.kill(error)`.
-// Does not wait for actual signal termination.
-// Uses a deferred promise instead of the `error` event on the subprocess, as this is less intrusive.
-const emitKillError = (error, onInternalError) => {
-	if (error !== undefined) {
-		onInternalError.reject(error);
-	}
-};
-
-const setKillTimeout = async ({kill, signal, forceKillAfterDelay, killSignal, killResult, context, controller}) => {
-	if (signal === killSignal && killResult) {
-		killOnTimeout({
-			kill,
-			forceKillAfterDelay,
-			context,
-			controllerSignal: controller.signal,
-		});
-	}
-};
-
-// Forcefully terminate a subprocess after a timeout
-export const killOnTimeout = async ({kill, forceKillAfterDelay, context, controllerSignal}) => {
-	if (forceKillAfterDelay === false) {
-		return;
-	}
-
-	try {
-		await setTimeout(forceKillAfterDelay, undefined, {signal: controllerSignal});
-		if (kill('SIGKILL')) {
-			context.isForcefullyTerminated ??= true;
-		}
-	} catch {}
-};

package/node_modules/execa/lib/terminate/signal.js

@@ -1,70 +0,0 @@
-import {constants} from 'node:os';
-import {signalsByName} from 'human-signals';
-
-// Normalize signals for comparison purpose.
-// Also validate the signal exists.
-export const normalizeKillSignal = killSignal => {
-	const optionName = 'option `killSignal`';
-	if (killSignal === 0) {
-		throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
-	}
-
-	return normalizeSignal(killSignal, optionName);
-};
-
-export const normalizeSignalArgument = signal => signal === 0
-	? signal
-	: normalizeSignal(signal, '`subprocess.kill()`\'s argument');
-
-const normalizeSignal = (signalNameOrInteger, optionName) => {
-	if (Number.isInteger(signalNameOrInteger)) {
-		return normalizeSignalInteger(signalNameOrInteger, optionName);
-	}
-
-	if (typeof signalNameOrInteger === 'string') {
-		return normalizeSignalName(signalNameOrInteger, optionName);
-	}
-
-	throw new TypeError(`Invalid ${optionName} ${String(signalNameOrInteger)}: it must be a string or an integer.\n${getAvailableSignals()}`);
-};
-
-const normalizeSignalInteger = (signalInteger, optionName) => {
-	if (signalsIntegerToName.has(signalInteger)) {
-		return signalsIntegerToName.get(signalInteger);
-	}
-
-	throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.\n${getAvailableSignals()}`);
-};
-
-const getSignalsIntegerToName = () => new Map(Object.entries(constants.signals)
-	.reverse()
-	.map(([signalName, signalInteger]) => [signalInteger, signalName]));
-
-const signalsIntegerToName = getSignalsIntegerToName();
-
-const normalizeSignalName = (signalName, optionName) => {
-	if (signalName in constants.signals) {
-		return signalName;
-	}
-
-	if (signalName.toUpperCase() in constants.signals) {
-		throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
-	}
-
-	throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.\n${getAvailableSignals()}`);
-};
-
-const getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
-Available signal numbers: ${getAvailableSignalIntegers()}.`;
-
-const getAvailableSignalNames = () => Object.keys(constants.signals)
-	.sort()
-	.map(signalName => `'${signalName}'`)
-	.join(', ');
-
-const getAvailableSignalIntegers = () => [...new Set(Object.values(constants.signals)
-	.sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))]
-	.join(', ');
-
-// Human-friendly description of a signal
-export const getSignalDescription = signal => signalsByName[signal].description;

package/node_modules/execa/lib/terminate/timeout.js

@@ -1,21 +0,0 @@
-import {setTimeout} from 'node:timers/promises';
-import {DiscardedError} from '../return/final-error.js';
-
-// Validate `timeout` option
-export const validateTimeout = ({timeout}) => {
-	if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
-		throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-	}
-};
-
-// Fails when the `timeout` option is exceeded
-export const throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === undefined
-	? []
-	: [killAfterTimeout(subprocess, timeout, context, controller)];
-
-const killAfterTimeout = async (subprocess, timeout, context, {signal}) => {
-	await setTimeout(timeout, undefined, {signal});
-	context.terminationReason ??= 'timeout';
-	subprocess.kill();
-	throw new DiscardedError();
-};

package/node_modules/execa/lib/transform/encoding-transform.js

@@ -1,51 +0,0 @@
-import {Buffer} from 'node:buffer';
-import {StringDecoder} from 'node:string_decoder';
-import {isUint8Array, bufferToUint8Array} from '../utils/uint-array.js';
-
-/*
-When using binary encodings, add an internal generator that converts chunks from `Buffer` to `string` or `Uint8Array`.
-Chunks might be Buffer, Uint8Array or strings since:
-- `subprocess.stdout|stderr` emits Buffers
-- `subprocess.stdin.write()` accepts Buffer, Uint8Array or string
-- Previous generators might return Uint8Array or string
-
-However, those are converted to Buffer:
-- on writes: `Duplex.writable` `decodeStrings: true` default option
-- on reads: `Duplex.readable` `readableEncoding: null` default option
-*/
-export const getEncodingTransformGenerator = (binary, encoding, skipped) => {
-	if (skipped) {
-		return;
-	}
-
-	if (binary) {
-		return {transform: encodingUint8ArrayGenerator.bind(undefined, new TextEncoder())};
-	}
-
-	const stringDecoder = new StringDecoder(encoding);
-	return {
-		transform: encodingStringGenerator.bind(undefined, stringDecoder),
-		final: encodingStringFinal.bind(undefined, stringDecoder),
-	};
-};
-
-const encodingUint8ArrayGenerator = function * (textEncoder, chunk) {
-	if (Buffer.isBuffer(chunk)) {
-		yield bufferToUint8Array(chunk);
-	} else if (typeof chunk === 'string') {
-		yield textEncoder.encode(chunk);
-	} else {
-		yield chunk;
-	}
-};
-
-const encodingStringGenerator = function * (stringDecoder, chunk) {
-	yield isUint8Array(chunk) ? stringDecoder.write(chunk) : chunk;
-};
-
-const encodingStringFinal = function * (stringDecoder) {
-	const lastChunk = stringDecoder.end();
-	if (lastChunk !== '') {
-		yield lastChunk;
-	}
-};

package/node_modules/execa/lib/transform/generator.js

@@ -1,107 +0,0 @@
-import {Transform, getDefaultHighWaterMark} from 'node:stream';
-import {isAsyncGenerator} from '../stdio/type.js';
-import {getSplitLinesGenerator, getAppendNewlineGenerator} from './split.js';
-import {getValidateTransformInput, getValidateTransformReturn} from './validate.js';
-import {getEncodingTransformGenerator} from './encoding-transform.js';
-import {
-	pushChunks,
-	transformChunk,
-	finalChunks,
-	destroyTransform,
-} from './run-async.js';
-import {
-	pushChunksSync,
-	transformChunkSync,
-	finalChunksSync,
-	runTransformSync,
-} from './run-sync.js';
-
-/*
-Generators can be used to transform/filter standard streams.
-
-Generators have a simple syntax, yet allows all of the following:
-- Sharing `state` between chunks
-- Flushing logic, by using a `final` function
-- Asynchronous logic
-- Emitting multiple chunks from a single source chunk, even if spaced in time, by using multiple `yield`
-- Filtering, by using no `yield`
-
-Therefore, there is no need to allow Node.js or web transform streams.
-
-The `highWaterMark` is kept as the default value, since this is what `subprocess.std*` uses.
-
-Chunks are currently processed serially. We could add a `concurrency` option to parallelize in the future.
-
-Transform an array of generator functions into a `Transform` stream.
-`Duplex.from(generator)` cannot be used because it does not allow setting the `objectMode` and `highWaterMark`.
-*/
-export const generatorToStream = ({
-	value,
-	value: {transform, final, writableObjectMode, readableObjectMode},
-	optionName,
-}, {encoding}) => {
-	const state = {};
-	const generators = addInternalGenerators(value, encoding, optionName);
-
-	const transformAsync = isAsyncGenerator(transform);
-	const finalAsync = isAsyncGenerator(final);
-	const transformMethod = transformAsync
-		? pushChunks.bind(undefined, transformChunk, state)
-		: pushChunksSync.bind(undefined, transformChunkSync);
-	const finalMethod = transformAsync || finalAsync
-		? pushChunks.bind(undefined, finalChunks, state)
-		: pushChunksSync.bind(undefined, finalChunksSync);
-	const destroyMethod = transformAsync || finalAsync
-		? destroyTransform.bind(undefined, state)
-		: undefined;
-
-	const stream = new Transform({
-		writableObjectMode,
-		writableHighWaterMark: getDefaultHighWaterMark(writableObjectMode),
-		readableObjectMode,
-		readableHighWaterMark: getDefaultHighWaterMark(readableObjectMode),
-		transform(chunk, encoding, done) {
-			transformMethod([chunk, generators, 0], this, done);
-		},
-		flush(done) {
-			finalMethod([generators], this, done);
-		},
-		destroy: destroyMethod,
-	});
-	return {stream};
-};
-
-// Applies transform generators in sync mode
-export const runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
-	const generators = stdioItems.filter(({type}) => type === 'generator');
-	const reversedGenerators = isInput ? generators.reverse() : generators;
-
-	for (const {value, optionName} of reversedGenerators) {
-		const generators = addInternalGenerators(value, encoding, optionName);
-		chunks = runTransformSync(generators, chunks);
-	}
-
-	return chunks;
-};
-
-// Generators used internally to convert the chunk type, validate it, and split into lines
-const addInternalGenerators = (
-	{transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines},
-	encoding,
-	optionName,
-) => {
-	const state = {};
-	return [
-		{transform: getValidateTransformInput(writableObjectMode, optionName)},
-		getEncodingTransformGenerator(binary, encoding, writableObjectMode),
-		getSplitLinesGenerator(binary, preserveNewlines, writableObjectMode, state),
-		{transform, final},
-		{transform: getValidateTransformReturn(readableObjectMode, optionName)},
-		getAppendNewlineGenerator({
-			binary,
-			preserveNewlines,
-			readableObjectMode,
-			state,
-		}),
-	].filter(Boolean);
-};

package/node_modules/execa/lib/transform/normalize.js

@@ -1,111 +0,0 @@
-import isPlainObj from 'is-plain-obj';
-import {BINARY_ENCODINGS} from '../arguments/encoding-option.js';
-import {TRANSFORM_TYPES} from '../stdio/type.js';
-import {getTransformObjectModes} from './object-mode.js';
-
-// Transforms generators/duplex/TransformStream can have multiple shapes.
-// This normalizes it and applies default values.
-export const normalizeTransforms = (stdioItems, optionName, direction, options) => [
-	...stdioItems.filter(({type}) => !TRANSFORM_TYPES.has(type)),
-	...getTransforms(stdioItems, optionName, direction, options),
-];
-
-const getTransforms = (stdioItems, optionName, direction, {encoding}) => {
-	const transforms = stdioItems.filter(({type}) => TRANSFORM_TYPES.has(type));
-	const newTransforms = Array.from({length: transforms.length});
-
-	for (const [index, stdioItem] of Object.entries(transforms)) {
-		newTransforms[index] = normalizeTransform({
-			stdioItem,
-			index: Number(index),
-			newTransforms,
-			optionName,
-			direction,
-			encoding,
-		});
-	}
-
-	return sortTransforms(newTransforms, direction);
-};
-
-const normalizeTransform = ({stdioItem, stdioItem: {type}, index, newTransforms, optionName, direction, encoding}) => {
-	if (type === 'duplex') {
-		return normalizeDuplex({stdioItem, optionName});
-	}
-
-	if (type === 'webTransform') {
-		return normalizeTransformStream({
-			stdioItem,
-			index,
-			newTransforms,
-			direction,
-		});
-	}
-
-	return normalizeGenerator({
-		stdioItem,
-		index,
-		newTransforms,
-		direction,
-		encoding,
-	});
-};
-
-const normalizeDuplex = ({
-	stdioItem,
-	stdioItem: {
-		value: {
-			transform,
-			transform: {writableObjectMode, readableObjectMode},
-			objectMode = readableObjectMode,
-		},
-	},
-	optionName,
-}) => {
-	if (objectMode && !readableObjectMode) {
-		throw new TypeError(`The \`${optionName}.objectMode\` option can only be \`true\` if \`new Duplex({objectMode: true})\` is used.`);
-	}
-
-	if (!objectMode && readableObjectMode) {
-		throw new TypeError(`The \`${optionName}.objectMode\` option cannot be \`false\` if \`new Duplex({objectMode: true})\` is used.`);
-	}
-
-	return {
-		...stdioItem,
-		value: {transform, writableObjectMode, readableObjectMode},
-	};
-};
-
-const normalizeTransformStream = ({stdioItem, stdioItem: {value}, index, newTransforms, direction}) => {
-	const {transform, objectMode} = isPlainObj(value) ? value : {transform: value};
-	const {writableObjectMode, readableObjectMode} = getTransformObjectModes(objectMode, index, newTransforms, direction);
-	return ({
-		...stdioItem,
-		value: {transform, writableObjectMode, readableObjectMode},
-	});
-};
-
-const normalizeGenerator = ({stdioItem, stdioItem: {value}, index, newTransforms, direction, encoding}) => {
-	const {
-		transform,
-		final,
-		binary: binaryOption = false,
-		preserveNewlines = false,
-		objectMode,
-	} = isPlainObj(value) ? value : {transform: value};
-	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
-	const {writableObjectMode, readableObjectMode} = getTransformObjectModes(objectMode, index, newTransforms, direction);
-	return {
-		...stdioItem,
-		value: {
-			transform,
-			final,
-			binary,
-			preserveNewlines,
-			writableObjectMode,
-			readableObjectMode,
-		},
-	};
-};
-
-const sortTransforms = (newTransforms, direction) => direction === 'input' ? newTransforms.reverse() : newTransforms;

package/node_modules/execa/lib/transform/object-mode.js

@@ -1,41 +0,0 @@
-import {TRANSFORM_TYPES} from '../stdio/type.js';
-
-/*
-Retrieve the `objectMode`s of a single transform.
-`objectMode` determines the return value's type, i.e. the `readableObjectMode`.
-The chunk argument's type is based on the previous generator's return value, i.e. the `writableObjectMode` is based on the previous `readableObjectMode`.
-The last input's generator is read by `subprocess.stdin` which:
-- should not be in `objectMode` for performance reasons.
-- can only be strings, Buffers and Uint8Arrays.
-Therefore its `readableObjectMode` must be `false`.
-The same applies to the first output's generator's `writableObjectMode`.
-*/
-export const getTransformObjectModes = (objectMode, index, newTransforms, direction) => direction === 'output'
-	? getOutputObjectModes(objectMode, index, newTransforms)
-	: getInputObjectModes(objectMode, index, newTransforms);
-
-const getOutputObjectModes = (objectMode, index, newTransforms) => {
-	const writableObjectMode = index !== 0 && newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = objectMode ?? writableObjectMode;
-	return {writableObjectMode, readableObjectMode};
-};
-
-const getInputObjectModes = (objectMode, index, newTransforms) => {
-	const writableObjectMode = index === 0
-		? objectMode === true
-		: newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode);
-	return {writableObjectMode, readableObjectMode};
-};
-
-// Retrieve the `objectMode` of a file descriptor, e.g. `stdout` or `stderr`
-export const getFdObjectMode = (stdioItems, direction) => {
-	const lastTransform = stdioItems.findLast(({type}) => TRANSFORM_TYPES.has(type));
-	if (lastTransform === undefined) {
-		return false;
-	}
-
-	return direction === 'input'
-		? lastTransform.value.writableObjectMode
-		: lastTransform.value.readableObjectMode;
-};

package/node_modules/execa/lib/transform/run-async.js

@@ -1,60 +0,0 @@
-import {callbackify} from 'node:util';
-
-// Applies a series of generator functions asynchronously
-export const pushChunks = callbackify(async (getChunks, state, getChunksArguments, transformStream) => {
-	state.currentIterable = getChunks(...getChunksArguments);
-
-	try {
-		for await (const chunk of state.currentIterable) {
-			transformStream.push(chunk);
-		}
-	} finally {
-		delete state.currentIterable;
-	}
-});
-
-// For each new chunk, apply each `transform()` method
-export const transformChunk = async function * (chunk, generators, index) {
-	if (index === generators.length) {
-		yield chunk;
-		return;
-	}
-
-	const {transform = identityGenerator} = generators[index];
-	for await (const transformedChunk of transform(chunk)) {
-		yield * transformChunk(transformedChunk, generators, index + 1);
-	}
-};
-
-// At the end, apply each `final()` method, followed by the `transform()` method of the next transforms
-export const finalChunks = async function * (generators) {
-	for (const [index, {final}] of Object.entries(generators)) {
-		yield * generatorFinalChunks(final, Number(index), generators);
-	}
-};
-
-const generatorFinalChunks = async function * (final, index, generators) {
-	if (final === undefined) {
-		return;
-	}
-
-	for await (const finalChunk of final()) {
-		yield * transformChunk(finalChunk, generators, index + 1);
-	}
-};
-
-// Cancel any ongoing async generator when the Transform is destroyed, e.g. when the subprocess errors
-export const destroyTransform = callbackify(async ({currentIterable}, error) => {
-	if (currentIterable !== undefined) {
-		await (error ? currentIterable.throw(error) : currentIterable.return());
-		return;
-	}
-
-	if (error) {
-		throw error;
-	}
-});
-
-const identityGenerator = function * (chunk) {
-	yield chunk;
-};

package/node_modules/execa/lib/transform/run-sync.js

@@ -1,50 +0,0 @@
-// Duplicate the code from `run-async.js` but as synchronous functions
-export const pushChunksSync = (getChunksSync, getChunksArguments, transformStream, done) => {
-	try {
-		for (const chunk of getChunksSync(...getChunksArguments)) {
-			transformStream.push(chunk);
-		}
-
-		done();
-	} catch (error) {
-		done(error);
-	}
-};
-
-// Run synchronous generators with `execaSync()`
-export const runTransformSync = (generators, chunks) => [
-	...chunks.flatMap(chunk => [...transformChunkSync(chunk, generators, 0)]),
-	...finalChunksSync(generators),
-];
-
-export const transformChunkSync = function * (chunk, generators, index) {
-	if (index === generators.length) {
-		yield chunk;
-		return;
-	}
-
-	const {transform = identityGenerator} = generators[index];
-	for (const transformedChunk of transform(chunk)) {
-		yield * transformChunkSync(transformedChunk, generators, index + 1);
-	}
-};
-
-export const finalChunksSync = function * (generators) {
-	for (const [index, {final}] of Object.entries(generators)) {
-		yield * generatorFinalChunksSync(final, Number(index), generators);
-	}
-};
-
-const generatorFinalChunksSync = function * (final, index, generators) {
-	if (final === undefined) {
-		return;
-	}
-
-	for (const finalChunk of final()) {
-		yield * transformChunkSync(finalChunk, generators, index + 1);
-	}
-};
-
-const identityGenerator = function * (chunk) {
-	yield chunk;
-};