@carbonenginejs/runtime 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/resource/format/CjsBitReader.js

@@ -0,0 +1,263 @@
+import { CjsReader } from './CjsReader.js';
+import { CjsFormatRangeError } from './CjsFormatError.js';
+import { asUint8Array } from '#utils/bytes';
+
+// Source: blue/include/BitPacker.h
+//   `BitPackerCore::DeQueueBits` (the LSB-first bit cursor)
+//   `BitPackerCore::DeQueueAlignedBlock` (align, then hand back whole bytes)
+//   `BitPackerCore::GetBitPosition`, `WordsRemaining`
+//
+// WHAT IS PORTED, AND WHAT DELIBERATELY IS NOT. Carbon's `BitPackerCore` is two
+// things stacked: a bit cursor at the bottom and, above it, a family of
+// `Pack`/`Unpack` overloads that are Carbon's own variable-length WIRE encoding
+// (`Pack(uint32_t)` writes a 3-bit nibble-count prefix, then 4..32 bits;
+// `BitPacker.h:437-460`). Only the cursor is general. The Pack layer describes
+// one persistence format and has no business in a Vorbis, deflate or BC7
+// decoder, so it stays in its donor and is not ported here.
+//
+// THE TWO DONOR SUBCLASSES HAVE NO JS COUNTERPART, DELIBERATELY. `BitPacker`
+// (`BitPacker.h:109`) wraps a caller-provided buffer and only guards against
+// overflow; `BitPackerManaged` (`:118`) owns and grows its own allocation
+// (`GrowOwnedMemory`, `c_defaultOwnedMemorySize = 512`). That distinction is
+// manual memory management: in JavaScript a `Uint8Array` already carries its own
+// extent and is garbage collected, so there is nothing for the pair to
+// distinguish. One class covers both, and neither name is invented here.
+//
+// LSB-FIRST, AND THAT IS NOT A PREFERENCE. Carbon reads
+// `*buf = *m_bitStream >> m_bitsConsumed` (`BitPacker.h:180`), taking the low
+// bit of the byte first and accumulating towards the high bit. Every bit-level
+// consumer in this package wants exactly that: Vorbis (and therefore Wwise
+// WEM), deflate, GIF LZW, and the BC6H/BC7 block layouts all number their bits
+// from the least significant end.
+//
+// The one exception is JPEG entropy data, which is MSB-first AND interleaves
+// 0xFF00 byte-stuffing into the bit refill. It has a single consumer, its
+// distinguishing logic is the stuffing rather than the bit order, and Carbon has
+// no MSB-first counterpart to port. So JPEG keeps its own reader, and no second
+// shared class is invented for one caller.
+//
+// THE SEARCH BEHIND THAT ABSENCE CLAIM, stated so the next reader can widen it
+// rather than repeat it. `ReadBits`/`BitStream`/`BitReader`/`bitBuffer`/`GetBits`
+// across `blue/include`, `io/include`, `core`, `trinity`, `mesh`, `geo2` and
+// `videoplayer`: `BitPacker.h` and `StructPacker.h` are the only hits.
+//
+// `videoplayer` is the one worth naming explicitly, because it LOOKS like the
+// place a bit reader would live and is not. Carbon decodes Vorbis and demuxes
+// WebM there by linking reference libraries — `VorbisDecoder.h` includes
+// `vorbis/codec.h`, and `WebMParser.h` wraps `nestegg` — so the bit-level work
+// happens inside vendored C, and Carbon authored no bit reader of its own for
+// it. Our `formats/ogg` and `formats/webm` are therefore ports of a CAPABILITY
+// Carbon has rather than of code Carbon wrote: a browser cannot link libvorbis,
+// so the decoder is ours while the capability is Carbon's.
+
+
+/**
+ * Read one bit, LSB-first within its byte.
+ *
+ * Random access, so nothing is allocated. This is the primitive the cursor
+ * below is built from, and it is exported because block codecs address bits by
+ * absolute index inside a fixed-size block rather than walking a stream.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @param {number} bitIndex Absolute bit index from the start of `bytes`.
+ * @returns {number} 0 or 1.
+ */
+function readBitAt(bytes, bitIndex) {
+  return bytes[bitIndex >>> 3] >>> (bitIndex & 7) & 1;
+}
+
+/**
+ * Read `count` bits starting at `startBit`, LSB-first.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @param {number} startBit Absolute bit index of the first bit.
+ * @param {number} count Bit count, 0..32.
+ * @returns {number} Unsigned value.
+ */
+function readBitsAt(bytes, startBit, count) {
+  let value = 0;
+  for (let bit = 0; bit < count; bit++) {
+    value |= readBitAt(bytes, startBit + bit) << bit;
+  }
+  return value >>> 0;
+}
+
+/**
+ * LSB-first bit cursor over a byte range.
+ *
+ * The shared implementation behind the Wwise Vorbis reader, the Ogg packet
+ * reader, the FBX deflate reader and the BC7 block reader. Specialized readers
+ * replace the error class and message the way `CjsByteReader` subclasses do:
+ *
+ * ```js
+ * class MyBitReader extends CjsBitReader
+ * {
+ *     static ReadError = MyReadError;
+ *     static endOfDataMessage = "Unexpected end of my bitstream";
+ * }
+ * ```
+ *
+ * A reader whose end of data is NOT an error — a Vorbis packet legitimately
+ * runs out mid-read and the decoder must see that as end-of-packet rather than
+ * a throw — overrides `Exhausted()` instead. That is the one genuine
+ * behavioural axis here, and it has two real callers pulling in opposite
+ * directions, which is why it is a hook and not an option flag.
+ */
+class CjsBitReader extends CjsReader {
+  /**
+   * Error class raised when a read runs past the end.
+   *
+   * A `RangeError` lineage, matching `CjsByteReader`.
+   */
+  static ReadError = CjsFormatRangeError;
+
+  /** Message used when a read would run past the configured end. */
+  static endOfDataMessage = "Unexpected end of bitstream";
+
+  /**
+   * Creates a bit cursor over a byte payload.
+   *
+   * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.
+   * @param {object} [options] Cursor bounds and metadata.
+   * @param {number} [options.offset] Initial byte offset.
+   * @param {number} [options.end] Exclusive end BYTE offset.
+   * @param {number} [options.endBit] Exclusive end BIT position, counted from
+   *   the start of `bytes`. Takes precedence over `end`; a block codec bounds
+   *   itself in bits (a BC7 block is 128 bits), not bytes.
+   * @param {string} [options.source] Source name used in error details.
+   */
+  constructor(bytes, options = {}) {
+    super(options);
+    this.bytes = asUint8Array(bytes);
+    this.bitPosition = (Number(options.offset) || 0) * 8;
+    this.endBit = Number.isInteger(options.endBit) ? options.endBit : Number.isInteger(options.end) ? options.end * 8 : this.bytes.length * 8;
+    this.source = options.source || "memory";
+    this.startBit = this.bitPosition;
+  }
+
+  /** Bits still readable before the configured end. */
+  get remaining() {
+    return Math.max(0, this.endBit - this.bitPosition);
+  }
+
+  /** Bits consumed since construction — Carbon's `GetBitPosition`. */
+  get totalBitsRead() {
+    return this.bitPosition - this.startBit;
+  }
+
+  /** True once the cursor sits on a byte boundary. */
+  get isAligned() {
+    return (this.bitPosition & 7) === 0;
+  }
+
+  /**
+   * Read a single bit.
+   *
+   * @returns {number} 0 or 1, or whatever `Exhausted` yields at the end.
+   */
+  ReadBit() {
+    if (this.bitPosition >= this.endBit) return this.Exhausted(1);
+    const bit = readBitAt(this.bytes, this.bitPosition);
+    this.bitPosition++;
+    return bit;
+  }
+
+  /**
+   * Read `count` bits as an unsigned integer, LSB-first.
+   *
+   * Whole bytes are taken in one step rather than bit by bit, which is what
+   * makes this usable for deflate. The result is identical either way.
+   *
+   * @param {number} count Bit count, 0..32.
+   * @returns {number} Unsigned value, or whatever `Exhausted` yields.
+   */
+  ReadBits(count) {
+    if (count === 0) return 0;
+    if (this.bitPosition + count > this.endBit) return this.Exhausted(count);
+    let value = 0,
+      shift = 0,
+      remaining = count;
+    while (remaining > 0) {
+      const bitInByte = this.bitPosition & 7,
+        available = 8 - bitInByte,
+        take = remaining < available ? remaining : available,
+        chunk = this.bytes[this.bitPosition >>> 3] >>> bitInByte & (1 << take) - 1;
+      value |= chunk << shift;
+      shift += take;
+      remaining -= take;
+      this.bitPosition += take;
+    }
+    return value >>> 0;
+  }
+
+  /**
+   * Discard bits up to the next byte boundary — Carbon aligns this way before
+   * handing back a whole block (`BitPacker.h:DeQueueAlignedBlock`).
+   *
+   * @returns {number} Bits discarded, 0..7.
+   */
+  Align() {
+    const skip = 8 - (this.bitPosition & 7) & 7;
+    this.bitPosition += skip;
+    return skip;
+  }
+
+  /**
+   * Align, then return a view over the next `count` whole bytes.
+   *
+   * A view, not a copy, exactly as Carbon's `DeQueueAlignedBlock` passes back
+   * a pointer into the buffer.
+   *
+   * @param {number} count Byte count.
+   * @returns {Uint8Array} View into the source bytes.
+   */
+  ReadAlignedBytes(count) {
+    this.Align();
+    if (this.bitPosition + count * 8 > this.endBit) {
+      throw this.Error(this.constructor.endOfDataMessage, {
+        count
+      });
+    }
+    const start = this.bitPosition >>> 3;
+    this.bitPosition += count * 8;
+    return this.bytes.subarray(start, start + count);
+  }
+
+  /**
+   * What a read past the end produces.
+   *
+   * The default is a throw, because for every format whose bitstream carries
+   * its own lengths, running out means the input is truncated. Override to
+   * return a sentinel where exhaustion is an expected terminal condition.
+   *
+   * @param {number} count Bits that were requested.
+   * @returns {number} Sentinel value, when the subclass returns rather than throws.
+   */
+  Exhausted(count) {
+    throw this.Error(this.constructor.endOfDataMessage, {
+      bitPosition: this.bitPosition,
+      requested: count,
+      endBit: this.endBit
+    });
+  }
+
+  /**
+   * Build a reader error carrying this cursor's source and position.
+   *
+   * @param {string} message Error message.
+   * @param {object} [details] Extra error details.
+   * @returns {Error} The configured read error.
+   */
+  Error(message, details = {}) {
+    const {
+      ReadError
+    } = this.constructor;
+    return new ReadError(message, {
+      source: this.source,
+      ...details
+    });
+  }
+}
+
+export { CjsBitReader, readBitAt, readBitsAt };
+//# sourceMappingURL=CjsBitReader.js.map

package/dist/resource/format/CjsBitReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsBitReader.js","sources":["../../../../src/resource/format/CjsBitReader.js"],"sourcesContent":["// Source: blue/include/BitPacker.h\n//   `BitPackerCore::DeQueueBits` (the LSB-first bit cursor)\n//   `BitPackerCore::DeQueueAlignedBlock` (align, then hand back whole bytes)\n//   `BitPackerCore::GetBitPosition`, `WordsRemaining`\n//\n// WHAT IS PORTED, AND WHAT DELIBERATELY IS NOT. Carbon's `BitPackerCore` is two\n// things stacked: a bit cursor at the bottom and, above it, a family of\n// `Pack`/`Unpack` overloads that are Carbon's own variable-length WIRE encoding\n// (`Pack(uint32_t)` writes a 3-bit nibble-count prefix, then 4..32 bits;\n// `BitPacker.h:437-460`). Only the cursor is general. The Pack layer describes\n// one persistence format and has no business in a Vorbis, deflate or BC7\n// decoder, so it stays in its donor and is not ported here.\n//\n// THE TWO DONOR SUBCLASSES HAVE NO JS COUNTERPART, DELIBERATELY. `BitPacker`\n// (`BitPacker.h:109`) wraps a caller-provided buffer and only guards against\n// overflow; `BitPackerManaged` (`:118`) owns and grows its own allocation\n// (`GrowOwnedMemory`, `c_defaultOwnedMemorySize = 512`). That distinction is\n// manual memory management: in JavaScript a `Uint8Array` already carries its own\n// extent and is garbage collected, so there is nothing for the pair to\n// distinguish. One class covers both, and neither name is invented here.\n//\n// LSB-FIRST, AND THAT IS NOT A PREFERENCE. Carbon reads\n// `*buf = *m_bitStream >> m_bitsConsumed` (`BitPacker.h:180`), taking the low\n// bit of the byte first and accumulating towards the high bit. Every bit-level\n// consumer in this package wants exactly that: Vorbis (and therefore Wwise\n// WEM), deflate, GIF LZW, and the BC6H/BC7 block layouts all number their bits\n// from the least significant end.\n//\n// The one exception is JPEG entropy data, which is MSB-first AND interleaves\n// 0xFF00 byte-stuffing into the bit refill. It has a single consumer, its\n// distinguishing logic is the stuffing rather than the bit order, and Carbon has\n// no MSB-first counterpart to port. So JPEG keeps its own reader, and no second\n// shared class is invented for one caller.\n//\n// THE SEARCH BEHIND THAT ABSENCE CLAIM, stated so the next reader can widen it\n// rather than repeat it. `ReadBits`/`BitStream`/`BitReader`/`bitBuffer`/`GetBits`\n// across `blue/include`, `io/include`, `core`, `trinity`, `mesh`, `geo2` and\n// `videoplayer`: `BitPacker.h` and `StructPacker.h` are the only hits.\n//\n// `videoplayer` is the one worth naming explicitly, because it LOOKS like the\n// place a bit reader would live and is not. Carbon decodes Vorbis and demuxes\n// WebM there by linking reference libraries — `VorbisDecoder.h` includes\n// `vorbis/codec.h`, and `WebMParser.h` wraps `nestegg` — so the bit-level work\n// happens inside vendored C, and Carbon authored no bit reader of its own for\n// it. Our `formats/ogg` and `formats/webm` are therefore ports of a CAPABILITY\n// Carbon has rather than of code Carbon wrote: a browser cannot link libvorbis,\n// so the decoder is ours while the capability is Carbon's.\n\nimport { CjsReader } from \"./CjsReader.js\";\nimport { CjsFormatRangeError } from \"./CjsFormatError.js\";\nimport { asUint8Array } from \"#utils/bytes\";\n\n/**\n * Read one bit, LSB-first within its byte.\n *\n * Random access, so nothing is allocated. This is the primitive the cursor\n * below is built from, and it is exported because block codecs address bits by\n * absolute index inside a fixed-size block rather than walking a stream.\n *\n * @param {Uint8Array} bytes Source bytes.\n * @param {number} bitIndex Absolute bit index from the start of `bytes`.\n * @returns {number} 0 or 1.\n */\nexport function readBitAt(bytes, bitIndex)\n{\n    return (bytes[bitIndex >>> 3] >>> (bitIndex & 7)) & 1;\n}\n\n/**\n * Read `count` bits starting at `startBit`, LSB-first.\n *\n * @param {Uint8Array} bytes Source bytes.\n * @param {number} startBit Absolute bit index of the first bit.\n * @param {number} count Bit count, 0..32.\n * @returns {number} Unsigned value.\n */\nexport function readBitsAt(bytes, startBit, count)\n{\n    let value = 0;\n    for (let bit = 0; bit < count; bit++)\n    {\n        value |= readBitAt(bytes, startBit + bit) << bit;\n    }\n    return value >>> 0;\n}\n\n/**\n * LSB-first bit cursor over a byte range.\n *\n * The shared implementation behind the Wwise Vorbis reader, the Ogg packet\n * reader, the FBX deflate reader and the BC7 block reader. Specialized readers\n * replace the error class and message the way `CjsByteReader` subclasses do:\n *\n * ```js\n * class MyBitReader extends CjsBitReader\n * {\n *     static ReadError = MyReadError;\n *     static endOfDataMessage = \"Unexpected end of my bitstream\";\n * }\n * ```\n *\n * A reader whose end of data is NOT an error — a Vorbis packet legitimately\n * runs out mid-read and the decoder must see that as end-of-packet rather than\n * a throw — overrides `Exhausted()` instead. That is the one genuine\n * behavioural axis here, and it has two real callers pulling in opposite\n * directions, which is why it is a hook and not an option flag.\n */\nexport class CjsBitReader extends CjsReader\n{\n    /**\n     * Error class raised when a read runs past the end.\n     *\n     * A `RangeError` lineage, matching `CjsByteReader`.\n     */\n    static ReadError = CjsFormatRangeError;\n\n    /** Message used when a read would run past the configured end. */\n    static endOfDataMessage = \"Unexpected end of bitstream\";\n\n    /**\n     * Creates a bit cursor over a byte payload.\n     *\n     * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.\n     * @param {object} [options] Cursor bounds and metadata.\n     * @param {number} [options.offset] Initial byte offset.\n     * @param {number} [options.end] Exclusive end BYTE offset.\n     * @param {number} [options.endBit] Exclusive end BIT position, counted from\n     *   the start of `bytes`. Takes precedence over `end`; a block codec bounds\n     *   itself in bits (a BC7 block is 128 bits), not bytes.\n     * @param {string} [options.source] Source name used in error details.\n     */\n    constructor(bytes, options = {})\n    {\n        super(options);\n        this.bytes = asUint8Array(bytes);\n        this.bitPosition = (Number(options.offset) || 0) * 8;\n        this.endBit = Number.isInteger(options.endBit)\n            ? options.endBit\n            : (Number.isInteger(options.end) ? options.end * 8 : this.bytes.length * 8);\n        this.source = options.source || \"memory\";\n        this.startBit = this.bitPosition;\n    }\n\n    /** Bits still readable before the configured end. */\n    get remaining()\n    {\n        return Math.max(0, this.endBit - this.bitPosition);\n    }\n\n    /** Bits consumed since construction — Carbon's `GetBitPosition`. */\n    get totalBitsRead()\n    {\n        return this.bitPosition - this.startBit;\n    }\n\n    /** True once the cursor sits on a byte boundary. */\n    get isAligned()\n    {\n        return (this.bitPosition & 7) === 0;\n    }\n\n    /**\n     * Read a single bit.\n     *\n     * @returns {number} 0 or 1, or whatever `Exhausted` yields at the end.\n     */\n    ReadBit()\n    {\n        if (this.bitPosition >= this.endBit) return this.Exhausted(1);\n        const bit = readBitAt(this.bytes, this.bitPosition);\n        this.bitPosition++;\n        return bit;\n    }\n\n    /**\n     * Read `count` bits as an unsigned integer, LSB-first.\n     *\n     * Whole bytes are taken in one step rather than bit by bit, which is what\n     * makes this usable for deflate. The result is identical either way.\n     *\n     * @param {number} count Bit count, 0..32.\n     * @returns {number} Unsigned value, or whatever `Exhausted` yields.\n     */\n    ReadBits(count)\n    {\n        if (count === 0) return 0;\n        if (this.bitPosition + count > this.endBit) return this.Exhausted(count);\n\n        let value = 0,\n            shift = 0,\n            remaining = count;\n\n        while (remaining > 0)\n        {\n            const\n                bitInByte = this.bitPosition & 7,\n                available = 8 - bitInByte,\n                take = remaining < available ? remaining : available,\n                chunk = (this.bytes[this.bitPosition >>> 3] >>> bitInByte) & ((1 << take) - 1);\n\n            value |= chunk << shift;\n            shift += take;\n            remaining -= take;\n            this.bitPosition += take;\n        }\n\n        return value >>> 0;\n    }\n\n    /**\n     * Discard bits up to the next byte boundary — Carbon aligns this way before\n     * handing back a whole block (`BitPacker.h:DeQueueAlignedBlock`).\n     *\n     * @returns {number} Bits discarded, 0..7.\n     */\n    Align()\n    {\n        const skip = (8 - (this.bitPosition & 7)) & 7;\n        this.bitPosition += skip;\n        return skip;\n    }\n\n    /**\n     * Align, then return a view over the next `count` whole bytes.\n     *\n     * A view, not a copy, exactly as Carbon's `DeQueueAlignedBlock` passes back\n     * a pointer into the buffer.\n     *\n     * @param {number} count Byte count.\n     * @returns {Uint8Array} View into the source bytes.\n     */\n    ReadAlignedBytes(count)\n    {\n        this.Align();\n        if (this.bitPosition + count * 8 > this.endBit)\n        {\n            throw this.Error(this.constructor.endOfDataMessage, { count });\n        }\n        const start = this.bitPosition >>> 3;\n        this.bitPosition += count * 8;\n        return this.bytes.subarray(start, start + count);\n    }\n\n    /**\n     * What a read past the end produces.\n     *\n     * The default is a throw, because for every format whose bitstream carries\n     * its own lengths, running out means the input is truncated. Override to\n     * return a sentinel where exhaustion is an expected terminal condition.\n     *\n     * @param {number} count Bits that were requested.\n     * @returns {number} Sentinel value, when the subclass returns rather than throws.\n     */\n    Exhausted(count)\n    {\n        throw this.Error(this.constructor.endOfDataMessage, {\n            bitPosition: this.bitPosition,\n            requested: count,\n            endBit: this.endBit\n        });\n    }\n\n    /**\n     * Build a reader error carrying this cursor's source and position.\n     *\n     * @param {string} message Error message.\n     * @param {object} [details] Extra error details.\n     * @returns {Error} The configured read error.\n     */\n    Error(message, details = {})\n    {\n        const { ReadError } = this.constructor;\n        return new ReadError(message, { source: this.source, ...details });\n    }\n}\n\nexport default CjsBitReader;\n"],"names":["readBitAt","bytes","bitIndex","readBitsAt","startBit","count","value","bit","CjsBitReader","CjsReader","ReadError","CjsFormatRangeError","endOfDataMessage","constructor","options","asUint8Array","bitPosition","Number","offset","endBit","isInteger","end","length","source","remaining","Math","max","totalBitsRead","isAligned","ReadBit","Exhausted","ReadBits","shift","bitInByte","available","take","chunk","Align","skip","ReadAlignedBytes","Error","start","subarray","requested","message","details"],"mappings":";;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,SAASA,CAACC,KAAK,EAAEC,QAAQ,EACzC;AACI,EAAA,OAAQD,KAAK,CAACC,QAAQ,KAAK,CAAC,CAAC,MAAMA,QAAQ,GAAG,CAAC,CAAC,GAAI,CAAC;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,UAAUA,CAACF,KAAK,EAAEG,QAAQ,EAAEC,KAAK,EACjD;EACI,IAAIC,KAAK,GAAG,CAAC;EACb,KAAK,IAAIC,GAAG,GAAG,CAAC,EAAEA,GAAG,GAAGF,KAAK,EAAEE,GAAG,EAAE,EACpC;IACID,KAAK,IAAIN,SAAS,CAACC,KAAK,EAAEG,QAAQ,GAAGG,GAAG,CAAC,IAAIA,GAAG;AACpD,EAAA;EACA,OAAOD,KAAK,KAAK,CAAC;AACtB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,YAAY,SAASC,SAAS,CAC3C;AACI;AACJ;AACA;AACA;AACA;EACI,OAAOC,SAAS,GAAGC,mBAAmB;;AAEtC;EACA,OAAOC,gBAAgB,GAAG,6BAA6B;;AAEvD;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACIC,EAAAA,WAAWA,CAACZ,KAAK,EAAEa,OAAO,GAAG,EAAE,EAC/B;IACI,KAAK,CAACA,OAAO,CAAC;AACd,IAAA,IAAI,CAACb,KAAK,GAAGc,YAAY,CAACd,KAAK,CAAC;AAChC,IAAA,IAAI,CAACe,WAAW,GAAG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"}