// deno-lint-ignore-file
// Copyright 2018-2026 the Deno authors. MIT license.

// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

(function () {
"use strict";

const { core, primordials } = __bootstrap;
const {
  ArrayBuffer,
  MathMax,
  NumberIsInteger,
  NumberIsNaN,
  ObjectDefineProperties,
  ObjectDefineProperty,
  ObjectEntries,
  ObjectFreeze,
  ObjectKeys,
  ObjectSetPrototypeOf,
  ReflectApply,
  Symbol,
  TypedArrayPrototypeGetByteLength,
  Uint32Array,
} = primordials;

const {
  codes: errorCodes,
  genericNodeError,
} = core.loadExtScript("ext:deno_node/internal/errors.ts");

const {
  ERR_BROTLI_INVALID_PARAM,
  ERR_BUFFER_TOO_LARGE,
  ERR_INVALID_ARG_TYPE,
  ERR_OUT_OF_RANGE,
  ERR_TRAILING_JUNK_AFTER_STREAM_END,
  ERR_ZLIB_INITIALIZATION_FAILED,
  ERR_ZSTD_INVALID_PARAM,
} = errorCodes;

const { finished, Transform } = core.createLazyLoader("node:stream")();
const { deprecateInstantiation } = core.loadExtScript(
  "ext:deno_node/internal/util.mjs",
);
const {
  isAnyArrayBuffer,
  isArrayBufferView,
  isUint8Array,
} = core.loadExtScript("ext:deno_node/internal/util/types.ts");
const binding = core.loadExtScript("ext:deno_node/_zlib_binding.mjs");
const { crc32: crc32Native } = binding;

const assert = core.loadExtScript(
  "ext:deno_node/internal/assert.mjs",
);
const { Buffer, kMaxLength } = core.loadExtScript(
  "ext:deno_node/internal/buffer.mjs",
);
const { ownerSymbol: owner_symbol } = core.loadExtScript(
  "ext:deno_node/internal_binding/symbols.ts",
);
const {
  checkRangesOrGetDefault,
  validateBoolean,
  validateFiniteNumber,
  validateFunction,
  validateUint32,
} = core.loadExtScript("ext:deno_node/internal/validators.mjs");
const { zlib: zlibConstants } = core.loadExtScript(
  "ext:deno_node/internal_binding/constants.ts",
);

const kFlushFlag = Symbol("kFlushFlag");
const kError = Symbol("kError");
// Hold the unwrapped native write/writeSync methods so our own call sites can
// invoke them directly, bypassing the arity-compat wrapper (see
// `setupHandleWriteState`).
const kNativeWrite = Symbol("kNativeWrite");
const kNativeWriteSync = Symbol("kNativeWriteSync");

const {
  // Zlib flush levels
  Z_NO_FLUSH,
  Z_BLOCK,
  Z_PARTIAL_FLUSH,
  Z_SYNC_FLUSH,
  Z_FULL_FLUSH,
  Z_FINISH,
  // Zlib option values
  Z_MIN_CHUNK,
  Z_MIN_WINDOWBITS,
  Z_MAX_WINDOWBITS,
  Z_MIN_LEVEL,
  Z_MAX_LEVEL,
  Z_MIN_MEMLEVEL,
  Z_MAX_MEMLEVEL,
  Z_DEFAULT_CHUNK,
  Z_DEFAULT_COMPRESSION,
  Z_DEFAULT_STRATEGY,
  Z_DEFAULT_WINDOWBITS,
  Z_DEFAULT_MEMLEVEL,
  Z_FIXED,
  // Node's compression stream modes (node_zlib_mode)
  DEFLATE,
  DEFLATERAW,
  INFLATE,
  INFLATERAW,
  GZIP,
  GUNZIP,
  UNZIP,
  BROTLI_DECODE,
  BROTLI_ENCODE,
  ZSTD_COMPRESS,
  ZSTD_DECOMPRESS,
  // Brotli operations (~flush levels)
  BROTLI_OPERATION_PROCESS,
  BROTLI_OPERATION_FLUSH,
  BROTLI_OPERATION_FINISH,
  BROTLI_OPERATION_EMIT_METADATA,
  // Zstd end directives (~flush levels)
  ZSTD_e_continue,
  ZSTD_e_flush,
  ZSTD_e_end,
} = zlibConstants;

const constants = ObjectFreeze(zlibConstants);

// Translation table for return codes.
const codes = {
  Z_OK: constants.Z_OK,
  Z_STREAM_END: constants.Z_STREAM_END,
  Z_NEED_DICT: constants.Z_NEED_DICT,
  Z_ERRNO: constants.Z_ERRNO,
  Z_STREAM_ERROR: constants.Z_STREAM_ERROR,
  Z_DATA_ERROR: constants.Z_DATA_ERROR,
  Z_MEM_ERROR: constants.Z_MEM_ERROR,
  Z_BUF_ERROR: constants.Z_BUF_ERROR,
  Z_VERSION_ERROR: constants.Z_VERSION_ERROR,
};

for (const ckey of ObjectKeys(codes)) {
  codes[codes[ckey]] = ckey;
}

ObjectFreeze(codes);

function zlibBuffer(engine, buffer, callback) {
  validateFunction(callback, "callback");
  // Streams do not support non-Uint8Array ArrayBufferViews yet. Convert it to a
  // Buffer without copying.
  if (isArrayBufferView(buffer) && !isUint8Array(buffer)) {
    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
  } else if (isAnyArrayBuffer(buffer)) {
    buffer = Buffer.from(buffer);
  }
  engine.buffers = null;
  engine.nread = 0;
  engine.cb = callback;
  engine.on("data", zlibBufferOnData);
  engine.on("error", zlibBufferOnError);
  engine.on("end", zlibBufferOnEnd);
  engine.end(buffer);
}

function zlibBufferOnData(chunk) {
  if (!this.buffers) {
    this.buffers = [chunk];
  } else {
    this.buffers.push(chunk);
  }
  this.nread += chunk.length;
  if (this.nread > this._maxOutputLength) {
    this.close();
    this.removeAllListeners("end");
    this.cb(new ERR_BUFFER_TOO_LARGE(this._maxOutputLength));
  }
}

function zlibBufferOnError(err) {
  this.removeAllListeners("end");
  this.cb(err);
}

function zlibBufferOnEnd() {
  let buf;
  if (this.nread === 0) {
    buf = Buffer.alloc(0);
  } else {
    const bufs = this.buffers;
    buf = bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, this.nread);
  }
  this.close();
  if (this._info) {
    this.cb(null, { buffer: buf, engine: this });
  } else {
    this.cb(null, buf);
  }
}

function zlibBufferSync(engine, buffer) {
  if (typeof buffer === "string") {
    buffer = Buffer.from(buffer);
  } else if (!isArrayBufferView(buffer)) {
    if (isAnyArrayBuffer(buffer)) {
      buffer = Buffer.from(buffer);
    } else {
      throw new ERR_INVALID_ARG_TYPE(
        "buffer",
        ["string", "Buffer", "TypedArray", "DataView", "ArrayBuffer"],
        buffer,
      );
    }
  }
  buffer = processChunkSync(engine, buffer, engine._finishFlushFlag);
  if (engine._info) {
    return { buffer, engine };
  }
  return buffer;
}

function zlibOnError(message, errno, code) {
  const self = this[owner_symbol];
  // There is no way to cleanly recover.
  // Continuing only obscures problems.

  code = code || codes[errno];
  const error = genericNodeError(message, { errno, code });
  error.errno = errno;
  error.code = code;
  // Set the error synchronously so sync operations can check it immediately
  self[kError] = error;

  // Defer destroy to allow error listeners to be attached.
  // In Node.js, zlib operations run on the libuv threadpool and callbacks
  // are invoked asynchronously. Deno's implementation is synchronous, so
  // we need to explicitly defer to match Node.js behavior.
  process.nextTick(() => {
    self.destroy(error);
  });
}

const FLUSH_BOUND = [
  [Z_NO_FLUSH, Z_BLOCK],
  [BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA],
  [ZSTD_e_continue, ZSTD_e_end],
];
const FLUSH_BOUND_IDX_NORMAL = 0;
const FLUSH_BOUND_IDX_BROTLI = 1;
const FLUSH_BOUND_IDX_ZSTD = 2;

// The base class for all Zlib-style streams.
function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
  let chunkSize = Z_DEFAULT_CHUNK;
  let maxOutputLength = kMaxLength;
  // The ZlibBase class is not exported to user land, the mode should only be
  // passed in by us.
  assert(typeof mode === "number");
  assert(mode >= DEFLATE && mode <= ZSTD_DECOMPRESS);

  let flushBoundIdx;
  if (mode === BROTLI_ENCODE || mode === BROTLI_DECODE) {
    flushBoundIdx = FLUSH_BOUND_IDX_BROTLI;
  } else if (mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS) {
    flushBoundIdx = FLUSH_BOUND_IDX_ZSTD;
  } else {
    flushBoundIdx = FLUSH_BOUND_IDX_NORMAL;
  }

  if (opts) {
    chunkSize = opts.chunkSize;
    if (!validateFiniteNumber(chunkSize, "options.chunkSize")) {
      chunkSize = Z_DEFAULT_CHUNK;
    } else if (chunkSize < Z_MIN_CHUNK) {
      throw new ERR_OUT_OF_RANGE(
        "options.chunkSize",
        `>= ${Z_MIN_CHUNK}`,
        chunkSize,
      );
    }

    flush = checkRangesOrGetDefault(
      opts.flush,
      "options.flush",
      FLUSH_BOUND[flushBoundIdx][0],
      FLUSH_BOUND[flushBoundIdx][1],
      flush,
    );

    finishFlush = checkRangesOrGetDefault(
      opts.finishFlush,
      "options.finishFlush",
      FLUSH_BOUND[flushBoundIdx][0],
      FLUSH_BOUND[flushBoundIdx][1],
      finishFlush,
    );

    maxOutputLength = checkRangesOrGetDefault(
      opts.maxOutputLength,
      "options.maxOutputLength",
      1,
      kMaxLength,
      kMaxLength,
    );

    if (opts.rejectGarbageAfterEnd !== undefined) {
      validateBoolean(
        opts.rejectGarbageAfterEnd,
        "options.rejectGarbageAfterEnd",
      );
    }

    if (opts.encoding || opts.objectMode || opts.writableObjectMode) {
      opts = { ...opts };
      opts.encoding = null;
      opts.objectMode = false;
      opts.writableObjectMode = false;
    }
  }

  ReflectApply(Transform, this, [{ autoDestroy: true, ...opts }]);
  this[kError] = null;
  this.bytesWritten = 0;
  this._handle = handle;
  handle[owner_symbol] = this;
  // Used by processCallback() and zlibOnError()
  handle.onerror = zlibOnError;
  this._outBuffer = Buffer.allocUnsafe(chunkSize);
  this._outOffset = 0;

  this._chunkSize = chunkSize;
  this._defaultFlushFlag = flush;
  this._finishFlushFlag = finishFlush;
  this._defaultFullFlushFlag = fullFlush;
  this._info = opts?.info;
  this._maxOutputLength = maxOutputLength;

  this._rejectGarbageAfterEnd = opts?.rejectGarbageAfterEnd === true;
}
ObjectSetPrototypeOf(ZlibBase.prototype, Transform.prototype);
ObjectSetPrototypeOf(ZlibBase, Transform);

ObjectDefineProperty(ZlibBase.prototype, "_closed", {
  __proto__: null,
  configurable: true,
  enumerable: true,
  get() {
    return !this._handle;
  },
});

/**
 * @this ZlibBase
 * @returns {void}
 */
ZlibBase.prototype.reset = function () {
  assert(this._handle, "zlib binding closed");
  return this._handle.reset();
};

// This is the _flush function called by the transform class,
// internally, when the last chunk has been written.
ZlibBase.prototype._flush = function (callback) {
  this._transform(Buffer.alloc(0), "", callback);
};

// Force Transform compat behavior.
ZlibBase.prototype._final = function (callback) {
  callback();
};

// If a flush is scheduled while another flush is still pending, a way to figure
// out which one is the "stronger" flush is needed.
// This is currently only used to figure out which flush flag to use for the
// last chunk.
// Roughly, the following holds:
// Z_NO_FLUSH < Z_BLOCK < Z_PARTIAL_FLUSH <
//     Z_SYNC_FLUSH < Z_FULL_FLUSH < Z_FINISH
const flushiness = [];
const kFlushFlagList = [
  Z_NO_FLUSH,
  Z_BLOCK,
  Z_PARTIAL_FLUSH,
  Z_SYNC_FLUSH,
  Z_FULL_FLUSH,
  Z_FINISH,
];
for (let i = 0; i < kFlushFlagList.length; i++) {
  flushiness[kFlushFlagList[i]] = i;
}

function maxFlush(a, b) {
  return flushiness[a] > flushiness[b] ? a : b;
}

// Set up a list of 'special' buffers that can be written using .write()
// from the .flush() code as a way of introducing flushing operations into the
// write sequence.
const kFlushBuffers = [];
{
  const dummyArrayBuffer = new ArrayBuffer();
  for (const flushFlag of kFlushFlagList) {
    kFlushBuffers[flushFlag] = Buffer.from(dummyArrayBuffer);
    kFlushBuffers[flushFlag][kFlushFlag] = flushFlag;
  }
}

ZlibBase.prototype.flush = function (kind, callback) {
  if (typeof kind === "function" || (kind === undefined && !callback)) {
    callback = kind;
    kind = this._defaultFullFlushFlag;
  }

  if (this.writableFinished) {
    if (callback) {
      process.nextTick(callback);
    }
  } else if (this.writableEnded) {
    if (callback) {
      this.once("end", callback);
    }
  } else {
    this.write(kFlushBuffers[kind], "", callback);
  }
};

/**
 * @this import('stream').Transform
 * @param {(err?: Error) => any} [callback]
 */
ZlibBase.prototype.close = function (callback) {
  if (callback) finished(this, callback);
  this.destroy();
};

ZlibBase.prototype._destroy = function (err, callback) {
  _close(this);
  callback(err);
};

ZlibBase.prototype._transform = function (chunk, encoding, cb) {
  let flushFlag = this._defaultFlushFlag;
  // We use a 'fake' zero-length chunk to carry information about flushes from
  // the public API to the actual stream implementation.
  if (typeof chunk[kFlushFlag] === "number") {
    flushFlag = chunk[kFlushFlag];
  }

  // For the last chunk, also apply `_finishFlushFlag`.
  if (this.writableEnded && this.writableLength === chunk.byteLength) {
    flushFlag = maxFlush(flushFlag, this._finishFlushFlag);
  }
  processChunk(this, chunk, flushFlag, cb);
};

ZlibBase.prototype._processChunk = function (chunk, flushFlag, cb) {
  // _processChunk() is left for backwards compatibility
  if (typeof cb === "function") {
    processChunk(this, chunk, flushFlag, cb);
  } else {
    return processChunkSync(this, chunk, flushFlag);
  }
};

// `byteLength` can be shadowed by an own accessor, and the write paths below
// trust the value they are handed to size the read out of the backing store.
// Check the reported size against the intrinsic one before it is used as a
// length, and likewise that the output window is inside the output buffer.
// The ops bounds-check as well, so this is about reporting Node's error rather
// than about memory safety.
function validateChunkBounds(self, chunk) {
  if (isUint8Array(chunk)) {
    const actual = TypedArrayPrototypeGetByteLength(chunk);
    if (chunk.byteLength > actual) {
      throw new ERR_OUT_OF_RANGE(
        "chunk.byteLength",
        `<= ${actual}`,
        chunk.byteLength,
      );
    }
  }
  // A fractional offset would otherwise be truncated on the way into the op,
  // so reject it here instead of silently writing somewhere else.
  if (
    !NumberIsInteger(self._outOffset) ||
    self._outOffset < 0 ||
    self._outOffset > self._chunkSize
  ) {
    throw new ERR_OUT_OF_RANGE(
      "outOffset",
      `an integer >= 0 and <= ${self._chunkSize}`,
      self._outOffset,
    );
  }
}

function processChunkSync(self, chunk, flushFlag) {
  validateChunkBounds(self, chunk);
  let availInBefore = chunk.byteLength;
  let availOutBefore = self._chunkSize - self._outOffset;
  let inOff = 0;
  let availOutAfter;
  let availInAfter;

  const buffers = [];
  let nread = 0;
  let inputRead = 0;
  const state = self._writeState;
  const handle = self._handle;
  let buffer = self._outBuffer;
  let offset = self._outOffset;
  const chunkSize = self._chunkSize;

  let error;
  self.on("error", function onError(er) {
    error = er;
  });

  // The native binding expects a Uint8Array
  if (!isUint8Array(chunk)) {
    chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
  }

  while (true) {
    handle[kNativeWriteSync](
      flushFlag,
      chunk, // in
      inOff, // in_off
      availInBefore, // in_len
      buffer, // out
      offset, // out_off
      availOutBefore, // out_len
      state,
    );
    if (error) {
      throw error;
    } else if (self[kError]) {
      throw self[kError];
    }

    availOutAfter = state[0];
    availInAfter = state[1];

    const inDelta = availInBefore - availInAfter;
    inputRead += inDelta;

    const have = availOutBefore - availOutAfter;
    if (have > 0) {
      const out = buffer.slice(offset, offset + have);
      offset += have;
      buffers.push(out);
      nread += out.byteLength;

      if (nread > self._maxOutputLength) {
        _close(self);
        throw new ERR_BUFFER_TOO_LARGE(self._maxOutputLength);
      }
    } else {
      assert(have === 0, "have should not go down");
    }

    // Exhausted the output buffer, or used all the input create a new one.
    if (availOutAfter === 0 || offset >= chunkSize) {
      availOutBefore = chunkSize;
      offset = 0;
      buffer = Buffer.allocUnsafe(chunkSize);
    }

    if (availOutAfter === 0) {
      // Not actually done. Need to reprocess.
      // Also, update the availInBefore to the availInAfter value,
      // so that if we have to hit it a third (fourth, etc.) time,
      // it'll have the correct byte counts.
      inOff += inDelta;
      availInBefore = availInAfter;
    } else {
      break;
    }
  }

  // Recorded before the trailing-junk check so the count of what was actually
  // consumed is observable on the throwing path too.
  self.bytesWritten = inputRead;

  if (availInAfter > 0 && self._rejectGarbageAfterEnd) {
    _close(self);
    throw new ERR_TRAILING_JUNK_AFTER_STREAM_END();
  }

  _close(self);

  if (nread === 0) {
    return Buffer.alloc(0);
  }

  return (buffers.length === 1 ? buffers[0] : Buffer.concat(buffers, nread));
}

function processChunk(self, chunk, flushFlag, cb) {
  const handle = self._handle;
  if (!handle) return process.nextTick(cb);

  validateChunkBounds(self, chunk);

  // The native binding expects a Uint8Array
  if (!isUint8Array(chunk)) {
    chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
  }

  handle.buffer = chunk;
  handle.cb = cb;
  handle.availOutBefore = self._chunkSize - self._outOffset;
  handle.availInBefore = chunk.byteLength;
  handle.inOff = 0;
  handle.flushFlag = flushFlag;

  handle._callbackPending = true;

  try {
    handle[kNativeWrite](
      flushFlag,
      chunk, // in
      0, // in_off
      handle.availInBefore, // in_len
      self._outBuffer, // out
      self._outOffset, // out_off
      handle.availOutBefore, // out_len
      self._writeState,
    );
  } catch (err) {
    // Set appropriate error code for zstd errors
    if (err.message && err.message.includes("Src size is incorrect")) {
      err.code = "ZSTD_error_srcSize_wrong";
    }
    self.destroy(err);
    return;
  }

  // If the native binding did not call processCallback synchronously
  // (Zlib defers it to match Node.js where compression runs on the libuv
  // threadpool), schedule it asynchronously. Always schedule even on error
  // so processCallback can call cb() to unblock the Transform write chain.
  if (handle._callbackPending) {
    process.nextTick(processCallback.bind(handle));
  }
}

function processCallback() {
  // This callback's context (`this`) is the `_handle` (ZCtx) object. It is
  // important to null out the values once they are no longer needed since
  // `_handle` can stay in memory long after the buffer is needed.
  const handle = this;
  handle._callbackPending = false;
  const self = this[owner_symbol];
  const state = self._writeState;

  if (self.destroyed) {
    this.buffer = null;
    this.cb();
    return;
  }

  if (self[kError]) {
    // An error occurred during the native write. Call cb() to unblock the
    // Transform write chain; the error event will be emitted by the nextTick
    // destroy scheduled in zlibOnError.
    this.buffer = null;
    this.cb();
    return;
  }

  const availOutAfter = state[0];
  const availInAfter = state[1];

  const inDelta = handle.availInBefore - availInAfter;
  self.bytesWritten += inDelta;

  const have = handle.availOutBefore - availOutAfter;
  let streamBufferIsFull = false;
  if (have > 0) {
    const out = self._outBuffer.slice(self._outOffset, self._outOffset + have);
    self._outOffset += have;
    streamBufferIsFull = !self.push(out);
  } else {
    assert(have === 0, "have should not go down");
  }

  if (self.destroyed) {
    this.cb();
    return;
  }

  // Exhausted the output buffer, or used all the input create a new one.
  if (availOutAfter === 0 || self._outOffset >= self._chunkSize) {
    handle.availOutBefore = self._chunkSize;
    self._outOffset = 0;
    self._outBuffer = Buffer.allocUnsafe(self._chunkSize);
  }

  if (availOutAfter === 0) {
    // Not actually done. Need to reprocess.
    // Also, update the availInBefore to the availInAfter value,
    // so that if we have to hit it a third (fourth, etc.) time,
    // it'll have the correct byte counts.
    handle.inOff += inDelta;
    handle.availInBefore = availInAfter;

    if (!streamBufferIsFull) {
      process.nextTick(() => {
        if (self.destroyed) {
          this.buffer = null;
          this.cb();
          return;
        }
        handle._callbackPending = true;
        this[kNativeWrite](
          handle.flushFlag,
          this.buffer, // in
          handle.inOff, // in_off
          handle.availInBefore, // in_len
          self._outBuffer, // out
          self._outOffset, // out_off
          self._chunkSize, // out_len
          self._writeState,
        );
        if (handle._callbackPending) {
          processCallback.call(this);
        }
      });
    } else {
      const oldRead = self._read;
      self._read = (n) => {
        self._read = oldRead;
        process.nextTick(() => {
          if (self.destroyed) {
            this.buffer = null;
            this.cb();
            return;
          }
          handle._callbackPending = true;
          this[kNativeWrite](
            handle.flushFlag,
            this.buffer, // in
            handle.inOff, // in_off
            handle.availInBefore, // in_len
            self._outBuffer, // out
            self._outOffset, // out_off
            self._chunkSize, // out_len
            self._writeState,
          );
          if (handle._callbackPending && !self[kError]) {
            processCallback.call(this);
          }
        });
        self._read(n);
      };
    }
    return;
  }

  if (availInAfter > 0) {
    // If we have more input that should be written, but we also have output
    // space available, that means that the compression library was not
    // interested in receiving more data, and in particular that the input
    // stream has ended early.
    // This applies to streams where we don't check data past the end of
    // what was consumed; that is, everything except Gunzip/Unzip.

    if (self._rejectGarbageAfterEnd) {
      const err = new ERR_TRAILING_JUNK_AFTER_STREAM_END();
      self.destroy(err);
      this.cb(err);
      return;
    }

    self.push(null);
  }

  // Finished with the chunk.
  this.buffer = null;
  this.cb();
}

/**
 * @param {ZlibBase} engine
 * @private
 */
function _close(engine) {
  // Caller may invoke .close after a zlib error (which will null _handle)
  engine._handle?.close();
  engine._handle = null;
}

// The native write/writeSync ops take the write-state buffer (where the
// post-write avail_out/avail_in values are stored) as a per-write argument
// rather than caching a pointer to it, so that detaching the buffer is a
// harmless no-op instead of a dangling write. Our own call sites always pass
// it, but some npm packages (e.g. pngjs's sync inflate) call the low-level
// `_handle.write()` / `_handle.writeSync()` directly using Node's binding
// signature, which omits that trailing argument. Wrap the handle so those
// external callers transparently get the stream's `_writeState` injected.
//
// Our own call sites always pass the buffer, so they invoke the stashed native
// methods (`handle[kNativeWrite]` / `handle[kNativeWriteSync]`) directly to skip
// the wrapper's per-write frame and argument array on every chunk.
function setupHandleWriteState(handle, writeState) {
  const nativeWrite = handle.write;
  const nativeWriteSync = handle.writeSync;
  handle[kNativeWrite] = nativeWrite;
  handle[kNativeWriteSync] = nativeWriteSync;
  const wrap = (native) =>
    function (flush, input, inOff, inLen, out, outOff, outLen, state) {
      return ReflectApply(native, this, [
        flush,
        input,
        inOff,
        inLen,
        out,
        outOff,
        outLen,
        state === undefined ? writeState : state,
      ]);
    };
  ObjectDefineProperty(handle, "write", {
    value: wrap(nativeWrite),
    writable: true,
    configurable: true,
  });
  ObjectDefineProperty(handle, "writeSync", {
    value: wrap(nativeWriteSync),
    writable: true,
    configurable: true,
  });
}

const zlibDefaultOpts = {
  flush: Z_NO_FLUSH,
  finishFlush: Z_FINISH,
  fullFlush: Z_FULL_FLUSH,
};
// Base class for all streams actually backed by zlib and using zlib-specific
// parameters.
function Zlib(opts, mode) {
  let windowBits = Z_DEFAULT_WINDOWBITS;
  let level = Z_DEFAULT_COMPRESSION;
  let memLevel = Z_DEFAULT_MEMLEVEL;
  let strategy = Z_DEFAULT_STRATEGY;
  let dictionary;

  if (opts) {
    // windowBits is special. On the compression side, 0 is an invalid value.
    // But on the decompression side, a value of 0 for windowBits tells zlib
    // to use the window size in the zlib header of the compressed stream.
    if (
      (opts.windowBits == null || opts.windowBits === 0) &&
      (mode === INFLATE ||
        mode === GUNZIP ||
        mode === UNZIP)
    ) {
      windowBits = 0;
    } else {
      // `{ windowBits: 8 }` is valid for deflate but not gzip.
      const min = Z_MIN_WINDOWBITS + (mode === GZIP ? 1 : 0);
      windowBits = checkRangesOrGetDefault(
        opts.windowBits,
        "options.windowBits",
        min,
        Z_MAX_WINDOWBITS,
        Z_DEFAULT_WINDOWBITS,
      );
    }

    level = checkRangesOrGetDefault(
      opts.level,
      "options.level",
      Z_MIN_LEVEL,
      Z_MAX_LEVEL,
      Z_DEFAULT_COMPRESSION,
    );

    memLevel = checkRangesOrGetDefault(
      opts.memLevel,
      "options.memLevel",
      Z_MIN_MEMLEVEL,
      Z_MAX_MEMLEVEL,
      Z_DEFAULT_MEMLEVEL,
    );

    strategy = checkRangesOrGetDefault(
      opts.strategy,
      "options.strategy",
      Z_DEFAULT_STRATEGY,
      Z_FIXED,
      Z_DEFAULT_STRATEGY,
    );

    dictionary = opts.dictionary;
    if (dictionary !== undefined && !isArrayBufferView(dictionary)) {
      if (isAnyArrayBuffer(dictionary)) {
        dictionary = Buffer.from(dictionary);
      } else {
        throw new ERR_INVALID_ARG_TYPE(
          "options.dictionary",
          ["Buffer", "TypedArray", "DataView", "ArrayBuffer"],
          dictionary,
        );
      }
    }
    // The native binding expects a Uint8Array, convert other ArrayBufferViews
    if (dictionary !== undefined && !isUint8Array(dictionary)) {
      dictionary = new Uint8Array(
        dictionary.buffer,
        dictionary.byteOffset,
        dictionary.byteLength,
      );
    }
  }

  const handle = new binding.Zlib(mode);
  // Ideally, we could let ZlibBase() set up _writeState. I haven't been able
  // to come up with a good solution that doesn't break our internal API,
  // and with it all supported npm versions at the time of writing.
  this._writeState = new Uint32Array(2);
  setupHandleWriteState(handle, this._writeState);
  handle.init(
    windowBits,
    level,
    memLevel,
    strategy,
    processCallback,
    dictionary,
  );

  ReflectApply(ZlibBase, this, [opts, mode, handle, zlibDefaultOpts]);

  if (this._rejectGarbageAfterEnd) {
    // Stop the engine from transparently continuing into the next gzip member,
    // so trailing input is still visible as unconsumed after the write.
    handle.setRejectGarbageAfterEnd(true);
  }

  this._level = level;
  this._strategy = strategy;
  this._mode = mode;
}
ObjectSetPrototypeOf(Zlib.prototype, ZlibBase.prototype);
ObjectSetPrototypeOf(Zlib, ZlibBase);

// This callback is used by `.params()` to wait until a full flush happened
// before adjusting the parameters. In particular, the call to the native
// `params()` function should not happen while a write is currently in progress
// on the threadpool.
function paramsAfterFlushCallback(level, strategy, callback) {
  assert(this._handle, "zlib binding closed");
  this._handle.params(level, strategy);
  if (!this.destroyed) {
    this._level = level;
    this._strategy = strategy;
    if (callback) callback();
  }
}

Zlib.prototype.params = function params(level, strategy, callback) {
  checkRangesOrGetDefault(level, "level", Z_MIN_LEVEL, Z_MAX_LEVEL);
  checkRangesOrGetDefault(strategy, "strategy", Z_DEFAULT_STRATEGY, Z_FIXED);

  if (this._level !== level || this._strategy !== strategy) {
    this.flush(
      Z_SYNC_FLUSH,
      paramsAfterFlushCallback.bind(this, level, strategy, callback),
    );
  } else {
    process.nextTick(callback);
  }
};

// generic zlib
// minimal 2-byte header
function Deflate(opts) {
  if (!(this instanceof Deflate)) {
    return deprecateInstantiation(Deflate, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, DEFLATE]);
}
ObjectSetPrototypeOf(Deflate.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Deflate, Zlib);

function Inflate(opts) {
  if (!(this instanceof Inflate)) {
    return deprecateInstantiation(Inflate, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, INFLATE]);
}
ObjectSetPrototypeOf(Inflate.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Inflate, Zlib);

function Gzip(opts) {
  if (!(this instanceof Gzip)) {
    return deprecateInstantiation(Gzip, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, GZIP]);
}
ObjectSetPrototypeOf(Gzip.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Gzip, Zlib);

function Gunzip(opts) {
  if (!(this instanceof Gunzip)) {
    return deprecateInstantiation(Gunzip, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, GUNZIP]);
}
ObjectSetPrototypeOf(Gunzip.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Gunzip, Zlib);

function DeflateRaw(opts) {
  if (opts && opts.windowBits === 8) opts.windowBits = 9;
  if (!(this instanceof DeflateRaw)) {
    return deprecateInstantiation(DeflateRaw, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, DEFLATERAW]);
}
ObjectSetPrototypeOf(DeflateRaw.prototype, Zlib.prototype);
ObjectSetPrototypeOf(DeflateRaw, Zlib);

function InflateRaw(opts) {
  if (!(this instanceof InflateRaw)) {
    return deprecateInstantiation(InflateRaw, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, INFLATERAW]);
}
ObjectSetPrototypeOf(InflateRaw.prototype, Zlib.prototype);
ObjectSetPrototypeOf(InflateRaw, Zlib);

function Unzip(opts) {
  if (!(this instanceof Unzip)) {
    return deprecateInstantiation(Unzip, "DEP0184", opts);
  }
  ReflectApply(Zlib, this, [opts, UNZIP]);
}
ObjectSetPrototypeOf(Unzip.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Unzip, Zlib);

function createConvenienceMethod(ctor, sync) {
  if (sync) {
    return function syncBufferWrapper(buffer, opts) {
      return zlibBufferSync(new ctor(opts), buffer);
    };
  }
  return function asyncBufferWrapper(buffer, opts, callback) {
    if (typeof opts === "function") {
      callback = opts;
      opts = {};
    }
    return zlibBuffer(new ctor(opts), buffer, callback);
  };
}

const kMaxBrotliParam = MathMax(
  ...ObjectEntries(constants)
    .map((
      { 0: key, 1: value },
    ) => (key.startsWith("BROTLI_PARAM_") ? value : 0)),
);
const brotliInitParamsArray = new Uint32Array(kMaxBrotliParam + 1);

const brotliDefaultOpts = {
  flush: BROTLI_OPERATION_PROCESS,
  finishFlush: BROTLI_OPERATION_FINISH,
  fullFlush: BROTLI_OPERATION_FLUSH,
};
function Brotli(opts, mode) {
  assert(mode === BROTLI_DECODE || mode === BROTLI_ENCODE);

  brotliInitParamsArray.fill(-1);
  if (opts?.params) {
    ObjectKeys(opts.params).forEach((origKey) => {
      const key = +origKey;
      if (
        NumberIsNaN(key) || key < 0 || key > kMaxBrotliParam ||
        (brotliInitParamsArray[key] | 0) !== -1
      ) {
        throw new ERR_BROTLI_INVALID_PARAM(origKey);
      }

      const value = opts.params[origKey];
      if (typeof value !== "number" && typeof value !== "boolean") {
        throw new ERR_INVALID_ARG_TYPE(
          "options.params[key]",
          "number",
          opts.params[origKey],
        );
      }
      brotliInitParamsArray[key] = value;
    });
  }

  const handle = mode === BROTLI_DECODE
    ? new binding.BrotliDecoder(mode)
    : new binding.BrotliEncoder(mode);

  this._writeState = new Uint32Array(2);
  setupHandleWriteState(handle, this._writeState);
  const success = handle.init(
    brotliInitParamsArray,
    processCallback,
  );
  if (!success) {
    throw new ERR_ZLIB_INITIALIZATION_FAILED("Initialization failed");
  }

  ReflectApply(ZlibBase, this, [opts, mode, handle, brotliDefaultOpts]);
}
ObjectSetPrototypeOf(Brotli.prototype, Zlib.prototype);
ObjectSetPrototypeOf(Brotli, Zlib);

function BrotliCompress(opts) {
  if (!(this instanceof BrotliCompress)) {
    return deprecateInstantiation(BrotliCompress, "DEP0184", opts);
  }
  ReflectApply(Brotli, this, [opts, BROTLI_ENCODE]);
}
ObjectSetPrototypeOf(BrotliCompress.prototype, Brotli.prototype);
ObjectSetPrototypeOf(BrotliCompress, Brotli);

function BrotliDecompress(opts) {
  if (!(this instanceof BrotliDecompress)) {
    return deprecateInstantiation(BrotliDecompress, "DEP0184", opts);
  }
  ReflectApply(Brotli, this, [opts, BROTLI_DECODE]);
}
ObjectSetPrototypeOf(BrotliDecompress.prototype, Brotli.prototype);
ObjectSetPrototypeOf(BrotliDecompress, Brotli);

const zstdDefaultOpts = {
  flush: ZSTD_e_continue,
  finishFlush: ZSTD_e_end,
  fullFlush: ZSTD_e_flush,
};
class Zstd extends ZlibBase {
  constructor(opts, mode, initParamsArray, maxParam) {
    assert(mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS);

    initParamsArray.fill(-1);
    if (opts?.params) {
      ObjectKeys(opts.params).forEach((origKey) => {
        const key = +origKey;
        if (
          NumberIsNaN(key) || key < 0 || key > maxParam ||
          (initParamsArray[key] | 0) !== -1
        ) {
          throw new ERR_ZSTD_INVALID_PARAM(origKey);
        }

        const value = opts.params[origKey];
        if (typeof value !== "number" && typeof value !== "boolean") {
          throw new ERR_INVALID_ARG_TYPE(
            "options.params[key]",
            "number",
            opts.params[origKey],
          );
        }
        initParamsArray[key] = value;
      });
    }

    const handle = mode === ZSTD_COMPRESS
      ? new binding.ZstdCompress(mode)
      : new binding.ZstdDecompress(mode);

    const writeState = new Uint32Array(2);
    setupHandleWriteState(handle, writeState);
    // pledgedSrcSize is only used for compression, use -1 to indicate "not set"
    const pledgedSrcSize =
      mode === ZSTD_COMPRESS && opts?.pledgedSrcSize != null
        ? opts.pledgedSrcSize
        : -1;
    const success = handle.init(
      initParamsArray,
      processCallback,
      pledgedSrcSize,
    );
    if (!success) {
      throw new ERR_ZLIB_INITIALIZATION_FAILED("Setting parameter failed");
    }
    super(opts, mode, handle, zstdDefaultOpts);
    this._writeState = writeState;
  }
}

const kMaxZstdCParam = MathMax(
  ...ObjectKeys(constants).map(
    (key) => (key.startsWith("ZSTD_c_") ? constants[key] : 0),
  ),
);

const zstdInitCParamsArray = new Uint32Array(kMaxZstdCParam + 1);

class ZstdCompress extends Zstd {
  constructor(opts) {
    super(opts, ZSTD_COMPRESS, zstdInitCParamsArray, kMaxZstdCParam);
  }
}

const kMaxZstdDParam = MathMax(
  ...ObjectKeys(constants).map(
    (key) => (key.startsWith("ZSTD_d_") ? constants[key] : 0),
  ),
);

const zstdInitDParamsArray = new Uint32Array(kMaxZstdDParam + 1);

class ZstdDecompress extends Zstd {
  constructor(opts) {
    super(opts, ZSTD_DECOMPRESS, zstdInitDParamsArray, kMaxZstdDParam);
  }
}

function createProperty(ctor) {
  return {
    __proto__: null,
    configurable: true,
    enumerable: true,
    value: function (options) {
      return new ctor(options);
    },
  };
}

function crc32(data, value = 0) {
  if (typeof data !== "string" && !isArrayBufferView(data)) {
    throw new ERR_INVALID_ARG_TYPE("data", [
      "Buffer",
      "TypedArray",
      "DataView",
      "string",
    ], data);
  }
  validateUint32(value, "value");
  return crc32Native(data, value);
}

// Legacy alias on the C++ wrapper object. This is not public API, so we may
// want to runtime-deprecate it at some point. There's no hurry, though.
ObjectDefineProperty(binding.Zlib.prototype, "jsref", {
  __proto__: null,
  get() {
    return this[owner_symbol];
  },
  set(v) {
    return this[owner_symbol] = v;
  },
});

// Convenience methods
const deflate = createConvenienceMethod(Deflate, false);
const deflateSync = createConvenienceMethod(Deflate, true);
const gzip = createConvenienceMethod(Gzip, false);
const gzipSync = createConvenienceMethod(Gzip, true);
const deflateRaw = createConvenienceMethod(DeflateRaw, false);
const deflateRawSync = createConvenienceMethod(DeflateRaw, true);
const unzip = createConvenienceMethod(Unzip, false);
const unzipSync = createConvenienceMethod(Unzip, true);
const inflate = createConvenienceMethod(Inflate, false);
const inflateSync = createConvenienceMethod(Inflate, true);
const gunzip = createConvenienceMethod(Gunzip, false);
const gunzipSync = createConvenienceMethod(Gunzip, true);
const inflateRaw = createConvenienceMethod(InflateRaw, false);
const inflateRawSync = createConvenienceMethod(InflateRaw, true);
const brotliCompress = createConvenienceMethod(BrotliCompress, false);
const brotliCompressSync = createConvenienceMethod(BrotliCompress, true);
const brotliDecompress = createConvenienceMethod(
  BrotliDecompress,
  false,
);
const brotliDecompressSync = createConvenienceMethod(
  BrotliDecompress,
  true,
);
const zstdCompress = createConvenienceMethod(ZstdCompress, false);
const zstdCompressSync = createConvenienceMethod(ZstdCompress, true);
const zstdDecompress = createConvenienceMethod(ZstdDecompress, false);
const zstdDecompressSync = createConvenienceMethod(ZstdDecompress, true);

// Factory methods (match Object.defineProperties behavior)
const createDeflate = createProperty(Deflate).value;
const createInflate = createProperty(Inflate).value;
const createDeflateRaw = createProperty(DeflateRaw).value;
const createInflateRaw = createProperty(InflateRaw).value;
const createGzip = createProperty(Gzip).value;
const createGunzip = createProperty(Gunzip).value;
const createUnzip = createProperty(Unzip).value;
const createBrotliCompress = createProperty(BrotliCompress).value;
const createBrotliDecompress = createProperty(BrotliDecompress).value;
const createZstdCompress = createProperty(ZstdCompress).value;
const createZstdDecompress = createProperty(ZstdDecompress).value;

// Deprecated constants: export individually
const deprecatedConstants = {};
for (const [key, value] of Object.entries(constants)) {
  if (!key.startsWith("BROTLI")) {
    deprecatedConstants[key] = value;
  }
}

// Default export: bundle everything like module.exports
const zlib = {
  crc32,
  Deflate,
  Inflate,
  Gzip,
  Gunzip,
  DeflateRaw,
  InflateRaw,
  Unzip,
  BrotliCompress,
  BrotliDecompress,
  ZstdCompress,
  ZstdDecompress,

  deflate,
  deflateSync,
  gzip,
  gzipSync,
  deflateRaw,
  deflateRawSync,
  unzip,
  unzipSync,
  inflate,
  inflateSync,
  gunzip,
  gunzipSync,
  inflateRaw,
  inflateRawSync,
  brotliCompress,
  brotliCompressSync,
  brotliDecompress,
  brotliDecompressSync,
  zstdCompress,
  zstdCompressSync,
  zstdDecompress,
  zstdDecompressSync,

  createDeflate,
  createInflate,
  createDeflateRaw,
  createInflateRaw,
  createGzip,
  createGunzip,
  createUnzip,
  createBrotliCompress,
  createBrotliDecompress,
  createZstdCompress,
  createZstdDecompress,

  constants,
  codes,

  ...deprecatedConstants,
};

return Object.freeze(zlib);
})();
