{"version":3,"file":"compression.mjs","sources":["../../../../src/room/data-stream/compression.ts"],"sourcesContent":["/**\n * Compression helpers for data streams. The buffered deflate-raw variant ({@link deflateRawCompress})\n * is for the inline (single-packet) case where the payload is small and bounded;\n * {@link deflateRawTransform} / {@link inflateRawTransform} serve the chunked (multi-packet)\n * `sendText`/`sendBytes`/`sendFile` paths, streaming the bytes through without buffering the whole\n * payload.\n *\n * These operate on bytes (not strings) so a single set of helpers serves both text and byte streams;\n * the `TextEncoder`/`TextDecoder` boundary lives at the manager/reader edges.\n *\n * Both streaming variants are exposed as `ReadableWritablePair`s so they drop straight into a\n * `pipeThrough` chain. Each needs one localized cast to bridge a DOM lib-type mismatch: the platform\n * `CompressionStream`/`DecompressionStream` type their `writable` as `WritableStream<BufferSource>`\n * (a wider element type than `Uint8Array`), and `WritableStream<W>` is covariant in `W`, so neither\n * is structurally a `ReadableWritablePair<Uint8Array, Uint8Array>` without help.\n *\n * @internal\n */\nimport { type NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';\nimport { DataStreamError, DataStreamErrorReason } from '../errors';\n\n/**\n * A `deflate-raw` compression transform (inverse of {@link inflateRawTransform}): pipe a byte stream\n * through it to get the compressed bytes without buffering the whole payload. Used for the chunked\n * `sendText`/`sendBytes`/`sendFile` paths, where the full payload is known up front but is streamed\n * (e.g. from `file.stream()`) rather than held in memory.\n */\nexport function deflateRawTransform(): ReadableWritablePair<\n  NonSharedUint8Array,\n  NonSharedUint8Array\n> {\n  return new CompressionStream('deflate-raw') as unknown as ReadableWritablePair<\n    NonSharedUint8Array,\n    NonSharedUint8Array\n  >;\n}\n\n/**\n * A `deflate-raw` decompression transform (inverse of {@link deflateRawTransform}): pipe a\n * stream of compressed bytes through it to get the decompressed bytes. Inflate emits output greedily,\n * so as long as the sender flushed at write boundaries each write's content is produced as soon as\n * its compressed bytes arrive.\n */\nexport function inflateRawTransform(): ReadableWritablePair<\n  NonSharedUint8Array,\n  NonSharedUint8Array\n> {\n  return new DecompressionStream('deflate-raw') as unknown as ReadableWritablePair<\n    NonSharedUint8Array,\n    NonSharedUint8Array\n  >;\n}\n\n/** deflate-raw compresses a byte array in full. Use for inline payloads; prefer the streaming\n * path for the chunked case. */\nexport async function deflateRawCompress(data: NonSharedUint8Array): Promise<NonSharedUint8Array> {\n  const cs = new CompressionStream('deflate-raw');\n  const writer = cs.writable.getWriter();\n  writer.write(data as NonSharedUint8Array);\n  writer.close();\n  return collect(cs.readable);\n}\n\n/**\n * Decompresses a raw-deflate byte array in full (inverse of {@link deflateRawCompress}).\n * `maxByteLength` bounds the decompressed output (decompression-bomb guard); exceeding it rejects\n * with a `PayloadTooLarge` error.\n */\nexport async function deflateRawDecompress(\n  data: NonSharedUint8Array,\n  maxByteLength?: number,\n): Promise<NonSharedUint8Array> {\n  const ds = new DecompressionStream('deflate-raw');\n  const writer = ds.writable.getWriter();\n  // The writer promises are intentionally not awaited (output is consumed via `collect`), but\n  // they reject when the byte cap cancels the readable mid-stream — swallow that so an enforced\n  // cap doesn't surface as an unhandled rejection.\n  writer.write(data as NonSharedUint8Array).catch(() => {});\n  writer.close().catch(() => {});\n  return collect(ds.readable, maxByteLength);\n}\n\n/**\n * Drains a byte stream, concatenating all of its chunks into a single array. When\n * `maxByteLength` is given, drops the stream and throws `PayloadTooLarge` as soon as the\n * accumulated output exceeds it.\n */\nexport async function collect(\n  stream: ReadableStream<NonSharedUint8Array>,\n  maxByteLength?: number,\n): Promise<NonSharedUint8Array> {\n  const reader = stream.getReader();\n  const chunks: Array<NonSharedUint8Array> = [];\n  let total = 0;\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n    total += value.byteLength;\n    if (typeof maxByteLength === 'number' && total > maxByteLength) {\n      await reader.cancel();\n      throw new DataStreamError(\n        `Decompressed payload exceeds the maximum payload size of ${maxByteLength} bytes`,\n        DataStreamErrorReason.PayloadTooLarge,\n      );\n    }\n  }\n  const result = new Uint8Array(total);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return result;\n}\n"],"names":["deflateRawTransform","CompressionStream","inflateRawTransform","DecompressionStream","deflateRawDecompress","data","maxByteLength","ds","writer","writable","getWriter","write","catch","close","collect","readable","stream","reader","getReader","chunks","total","_yield$reader$read","read","done","value","push","byteLength","cancel","DataStreamError","concat","DataStreamErrorReason","PayloadTooLarge","result","Uint8Array","offset","chunk","set"],"mappings":"gGAqBA;;;;;AAKG;SACaA,mBAAmBA,GAAA;AAIjC,EAAA,OAAO,IAAIC,iBAAiB,CAAC,aAAa,CAGzC;AACH;AAEA;;;;;AAKG;SACaC,mBAAmBA,GAAA;AAIjC,EAAA,OAAO,IAAIC,mBAAmB,CAAC,aAAa,CAG3C;AACH;AAYA;;;;AAIG;AACG,SAAgBC,oBAAoBA,CACxCC,IAAyB,EACzBC,aAAsB,EAAA;;AAEtB,IAAA,MAAMC,EAAE,GAAG,IAAIJ,mBAAmB,CAAC,aAAa,CAAC;IACjD,MAAMK,MAAM,GAAGD,EAAE,CAACE,QAAQ,CAACC,SAAS,EAAE;AACtC;AACA;AACA;IACAF,MAAM,CAACG,KAAK,CAACN,IAA2B,CAAC,CAACO,KAAK,CAAC,MAAK,CAAE,CAAC,CAAC;IACzDJ,MAAM,CAACK,KAAK,EAAE,CAACD,KAAK,CAAC,MAAK,CAAE,CAAC,CAAC;AAC9B,IAAA,OAAOE,OAAO,CAACP,EAAE,CAACQ,QAAQ,EAAET,aAAa,CAAC;AAC5C,EAAA,CAAC,CAAA;AAAA;AAED;;;;AAIG;AACG,SAAgBQ,OAAOA,CAC3BE,MAA2C,EAC3CV,aAAsB,EAAA;;AAEtB,IAAA,MAAMW,MAAM,GAAGD,MAAM,CAACE,SAAS,EAAE;IACjC,MAAMC,MAAM,GAA+B,EAAE;IAC7C,IAAIC,KAAK,GAAG,CAAC;AACb,IAAA,OAAO,IAAI,EAAE;AACX,MAAA,MAAAC,kBAAA,GAAwB,MAAMJ,MAAM,CAACK,IAAI,EAAE;QAAnCC,IAAI,GAAAF,kBAAA,CAAJE,IAAI;QAAEC,KAAK,GAAAH,kBAAA,CAALG,KAAK;AACnB,MAAA,IAAID,IAAI,EAAE;AACR,QAAA;AACF,MAAA;AACAJ,MAAAA,MAAM,CAACM,IAAI,CAACD,KAAK,CAAC;MAClBJ,KAAK,IAAII,KAAK,CAACE,UAAU;MACzB,IAAI,OAAOpB,aAAa,KAAK,QAAQ,IAAIc,KAAK,GAAGd,aAAa,EAAE;AAC9D,QAAA,MAAMW,MAAM,CAACU,MAAM,EAAE;QACrB,MAAM,IAAIC,eAAe,CAAA,2DAAA,CAAAC,MAAA,CACqCvB,aAAa,EAAA,QAAA,CAAA,EACzEwB,qBAAqB,CAACC,eAAe,CACtC;AACH,MAAA;AACF,IAAA;AACA,IAAA,MAAMC,MAAM,GAAG,IAAIC,UAAU,CAACb,KAAK,CAAC;IACpC,IAAIc,MAAM,GAAG,CAAC;AACd,IAAA,KAAK,MAAMC,KAAK,IAAIhB,MAAM,EAAE;AAC1Ba,MAAAA,MAAM,CAACI,GAAG,CAACD,KAAK,EAAED,MAAM,CAAC;MACzBA,MAAM,IAAIC,KAAK,CAACT,UAAU;AAC5B,IAAA;AACA,IAAA,OAAOM,MAAM;AACf,EAAA,CAAC,CAAA;AAAA"}