// TODO reenable this code when we enable writableStreams and transport types
// // Forked from https://github.com/stardazed/sd-streams/tree/8928cf04b035fd02fb1340b7eb541c76be37e546
// // Copyright (c) 2018-Present by Arthur Langereis - @zenmumbler MIT

// /**
//  * streams/transform-internals - internal types and functions for transform streams
//  * Part of Stardazed
//  * (c) 2018-Present by Arthur Langereis - @zenmumbler
//  * https://github.com/stardazed/sd-streams
//  */

// /* eslint-disable @typescript-eslint/no-explicit-any */
// // TODO reenable this lint here

// import * as rs from "./readable-internals.ts";
// import * as ws from "./writable-internals.ts";
// import * as shared from "./shared-internals.ts";

// import { createReadableStream } from "./readable-stream.ts";
// import { createWritableStream } from "./writable-stream.ts";

// import { QueuingStrategy, QueuingStrategySizeCallback } from "../dom_types.ts";

// export const state_ = Symbol("transformState_");
// export const backpressure_ = Symbol("backpressure_");
// export const backpressureChangePromise_ = Symbol("backpressureChangePromise_");
// export const readable_ = Symbol("readable_");
// export const transformStreamController_ = Symbol("transformStreamController_");
// export const writable_ = Symbol("writable_");

// export const controlledTransformStream_ = Symbol("controlledTransformStream_");
// export const flushAlgorithm_ = Symbol("flushAlgorithm_");
// export const transformAlgorithm_ = Symbol("transformAlgorithm_");

// // ----

// export type TransformFunction<InputType, OutputType> = (
//   chunk: InputType,
//   controller: TransformStreamDefaultController<InputType, OutputType>
// ) => void | PromiseLike<void>;
// export type TransformAlgorithm<InputType> = (chunk: InputType) => Promise<void>;
// export type FlushFunction<InputType, OutputType> = (
//   controller: TransformStreamDefaultController<InputType, OutputType>
// ) => void | PromiseLike<void>;
// export type FlushAlgorithm = () => Promise<void>;

// // ----

// export interface TransformStreamDefaultController<InputType, OutputType> {
//   readonly desiredSize: number | null;
//   enqueue(chunk: OutputType): void;
//   error(reason: shared.ErrorResult): void;
//   terminate(): void;

//   [controlledTransformStream_]: TransformStream<InputType, OutputType>; // The TransformStream instance controlled; also used for the IsTransformStreamDefaultController brand check
//   [flushAlgorithm_]: FlushAlgorithm; // A promise - returning algorithm which communicates a requested close to the transformer
//   [transformAlgorithm_]: TransformAlgorithm<InputType>; // A promise - returning algorithm, taking one argument(the chunk to transform), which requests the transformer perform its transformation
// }

// export interface Transformer<InputType, OutputType> {
//   start?(
//     controller: TransformStreamDefaultController<InputType, OutputType>
//   ): void | PromiseLike<void>;
//   transform?: TransformFunction<InputType, OutputType>;
//   flush?: FlushFunction<InputType, OutputType>;

//   readableType?: undefined; // for future spec changes
//   writableType?: undefined; // for future spec changes
// }

// export declare class TransformStream<InputType, OutputType> {
//   constructor(
//     transformer: Transformer<InputType, OutputType>,
//     writableStrategy: QueuingStrategy<InputType>,
//     readableStrategy: QueuingStrategy<OutputType>
//   );

//   readonly readable: rs.SDReadableStream<OutputType>;
//   readonly writable: ws.WritableStream<InputType>;

//   [backpressure_]: boolean | undefined; // Whether there was backpressure on [[readable]] the last time it was observed
//   [backpressureChangePromise_]: shared.ControlledPromise<void> | undefined; // A promise which is fulfilled and replaced every time the value of[[backpressure]] changes
//   [readable_]: rs.SDReadableStream<OutputType>; // The ReadableStream instance controlled by this object
//   [transformStreamController_]: TransformStreamDefaultController<
//     InputType,
//     OutputType
//   >; // A TransformStreamDefaultController created with the ability to control[[readable]] and[[writable]]; also used for the IsTransformStream brand check
//   [writable_]: ws.WritableStream<InputType>; // The WritableStream instance controlled by this object
// }

// // ---- TransformStream

// export function isTransformStream(
//   value: unknown
// ): value is TransformStream<any, any> {
//   if (typeof value !== "object" || value === null) {
//     return false;
//   }
//   return transformStreamController_ in value;
// }

// export function initializeTransformStream<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   startPromise: Promise<void>,
//   writableHighWaterMark: number,
//   writableSizeAlgorithm: QueuingStrategySizeCallback<InputType>,
//   readableHighWaterMark: number,
//   readableSizeAlgorithm: QueuingStrategySizeCallback<OutputType>
// ): void {
//   const startAlgorithm = function(): Promise<void> {
//     return startPromise;
//   };
//   const writeAlgorithm = function(chunk: InputType): Promise<void> {
//     return transformStreamDefaultSinkWriteAlgorithm(stream, chunk);
//   };
//   const abortAlgorithm = function(reason: shared.ErrorResult): Promise<void> {
//     return transformStreamDefaultSinkAbortAlgorithm(stream, reason);
//   };
//   const closeAlgorithm = function(): Promise<void> {
//     return transformStreamDefaultSinkCloseAlgorithm(stream);
//   };
//   stream[writable_] = createWritableStream<InputType>(
//     startAlgorithm,
//     writeAlgorithm,
//     closeAlgorithm,
//     abortAlgorithm,
//     writableHighWaterMark,
//     writableSizeAlgorithm
//   );

//   const pullAlgorithm = function(): Promise<void> {
//     return transformStreamDefaultSourcePullAlgorithm(stream);
//   };
//   const cancelAlgorithm = function(
//     reason: shared.ErrorResult
//   ): Promise<undefined> {
//     transformStreamErrorWritableAndUnblockWrite(stream, reason);
//     return Promise.resolve(undefined);
//   };
//   stream[readable_] = createReadableStream(
//     startAlgorithm,
//     pullAlgorithm,
//     cancelAlgorithm,
//     readableHighWaterMark,
//     readableSizeAlgorithm
//   );

//   stream[backpressure_] = undefined;
//   stream[backpressureChangePromise_] = undefined;
//   transformStreamSetBackpressure(stream, true);
//   stream[transformStreamController_] = undefined!; // initialize slot for brand-check
// }

// export function transformStreamError<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   error: shared.ErrorResult
// ): void {
//   rs.readableStreamDefaultControllerError(
//     stream[readable_][
//       rs.readableStreamController_
//     ] as rs.SDReadableStreamDefaultController<OutputType>,
//     error
//   );
//   transformStreamErrorWritableAndUnblockWrite(stream, error);
// }

// export function transformStreamErrorWritableAndUnblockWrite<
//   InputType,
//   OutputType
// >(
//   stream: TransformStream<InputType, OutputType>,
//   error: shared.ErrorResult
// ): void {
//   transformStreamDefaultControllerClearAlgorithms(
//     stream[transformStreamController_]
//   );
//   ws.writableStreamDefaultControllerErrorIfNeeded(
//     stream[writable_][ws.writableStreamController_]!,
//     error
//   );
//   if (stream[backpressure_]) {
//     transformStreamSetBackpressure(stream, false);
//   }
// }

// export function transformStreamSetBackpressure<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   backpressure: boolean
// ): void {
//   // Assert: stream.[[backpressure]] is not backpressure.
//   if (stream[backpressure_] !== undefined) {
//     stream[backpressureChangePromise_]!.resolve(undefined);
//   }
//   stream[backpressureChangePromise_] = shared.createControlledPromise<void>();
//   stream[backpressure_] = backpressure;
// }

// // ---- TransformStreamDefaultController

// export function isTransformStreamDefaultController(
//   value: unknown
// ): value is TransformStreamDefaultController<any, any> {
//   if (typeof value !== "object" || value === null) {
//     return false;
//   }
//   return controlledTransformStream_ in value;
// }

// export function setUpTransformStreamDefaultController<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   controller: TransformStreamDefaultController<InputType, OutputType>,
//   transformAlgorithm: TransformAlgorithm<InputType>,
//   flushAlgorithm: FlushAlgorithm
// ): void {
//   // Assert: ! IsTransformStream(stream) is true.
//   // Assert: stream.[[transformStreamController]] is undefined.
//   controller[controlledTransformStream_] = stream;
//   stream[transformStreamController_] = controller;
//   controller[transformAlgorithm_] = transformAlgorithm;
//   controller[flushAlgorithm_] = flushAlgorithm;
// }

// export function transformStreamDefaultControllerClearAlgorithms<
//   InputType,
//   OutputType
// >(controller: TransformStreamDefaultController<InputType, OutputType>): void {
//   // Use ! assertions to override type check here, this way we don't
//   // have to perform type checks/assertions everywhere else.
//   controller[transformAlgorithm_] = undefined!;
//   controller[flushAlgorithm_] = undefined!;
// }

// export function transformStreamDefaultControllerEnqueue<InputType, OutputType>(
//   controller: TransformStreamDefaultController<InputType, OutputType>,
//   chunk: OutputType
// ): void {
//   const stream = controller[controlledTransformStream_];
//   const readableController = stream[readable_][
//     rs.readableStreamController_
//   ] as rs.SDReadableStreamDefaultController<OutputType>;
//   if (
//     !rs.readableStreamDefaultControllerCanCloseOrEnqueue(readableController)
//   ) {
//     throw new TypeError();
//   }
//   try {
//     rs.readableStreamDefaultControllerEnqueue(readableController, chunk);
//   } catch (error) {
//     transformStreamErrorWritableAndUnblockWrite(stream, error);
//     throw stream[readable_][shared.storedError_];
//   }
//   const backpressure = rs.readableStreamDefaultControllerHasBackpressure(
//     readableController
//   );
//   if (backpressure !== stream[backpressure_]) {
//     // Assert: backpressure is true.
//     transformStreamSetBackpressure(stream, true);
//   }
// }

// export function transformStreamDefaultControllerError<InputType, OutputType>(
//   controller: TransformStreamDefaultController<InputType, OutputType>,
//   error: shared.ErrorResult
// ): void {
//   transformStreamError(controller[controlledTransformStream_], error);
// }

// export function transformStreamDefaultControllerPerformTransform<
//   InputType,
//   OutputType
// >(
//   controller: TransformStreamDefaultController<InputType, OutputType>,
//   chunk: InputType
// ): Promise<void> {
//   const transformPromise = controller[transformAlgorithm_](chunk);
//   return transformPromise.catch(error => {
//     transformStreamError(controller[controlledTransformStream_], error);
//     throw error;
//   });
// }

// export function transformStreamDefaultControllerTerminate<
//   InputType,
//   OutputType
// >(controller: TransformStreamDefaultController<InputType, OutputType>): void {
//   const stream = controller[controlledTransformStream_];
//   const readableController = stream[readable_][
//     rs.readableStreamController_
//   ] as rs.SDReadableStreamDefaultController<OutputType>;
//   if (rs.readableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
//     rs.readableStreamDefaultControllerClose(readableController);
//   }
//   const error = new TypeError("The transform stream has been terminated");
//   transformStreamErrorWritableAndUnblockWrite(stream, error);
// }

// // ---- Transform Sinks

// export function transformStreamDefaultSinkWriteAlgorithm<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   chunk: InputType
// ): Promise<void> {
//   // Assert: stream.[[writable]].[[state]] is "writable".
//   const controller = stream[transformStreamController_];
//   if (stream[backpressure_]) {
//     const backpressureChangePromise = stream[backpressureChangePromise_]!;
//     // Assert: backpressureChangePromise is not undefined.
//     return backpressureChangePromise.promise.then(_ => {
//       const writable = stream[writable_];
//       const state = writable[shared.state_];
//       if (state === "erroring") {
//         throw writable[shared.storedError_];
//       }
//       // Assert: state is "writable".
//       return transformStreamDefaultControllerPerformTransform(
//         controller,
//         chunk
//       );
//     });
//   }
//   return transformStreamDefaultControllerPerformTransform(controller, chunk);
// }

// export function transformStreamDefaultSinkAbortAlgorithm<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>,
//   reason: shared.ErrorResult
// ): Promise<void> {
//   transformStreamError(stream, reason);
//   return Promise.resolve(undefined);
// }

// export function transformStreamDefaultSinkCloseAlgorithm<InputType, OutputType>(
//   stream: TransformStream<InputType, OutputType>
// ): Promise<void> {
//   const readable = stream[readable_];
//   const controller = stream[transformStreamController_];
//   const flushPromise = controller[flushAlgorithm_]();
//   transformStreamDefaultControllerClearAlgorithms(controller);

//   return flushPromise.then(
//     _ => {
//       if (readable[shared.state_] === "errored") {
//         throw readable[shared.storedError_];
//       }
//       const readableController = readable[
//         rs.readableStreamController_
//       ] as rs.SDReadableStreamDefaultController<OutputType>;
//       if (
//         rs.readableStreamDefaultControllerCanCloseOrEnqueue(readableController)
//       ) {
//         rs.readableStreamDefaultControllerClose(readableController);
//       }
//     },
//     error => {
//       transformStreamError(stream, error);
//       throw readable[shared.storedError_];
//     }
//   );
// }

// // ---- Transform Sources

// export function transformStreamDefaultSourcePullAlgorithm<
//   InputType,
//   OutputType
// >(stream: TransformStream<InputType, OutputType>): Promise<void> {
//   // Assert: stream.[[backpressure]] is true.
//   // Assert: stream.[[backpressureChangePromise]] is not undefined.
//   transformStreamSetBackpressure(stream, false);
//   return stream[backpressureChangePromise_]!.promise;
// }