@nodetool-ai/blender-nodes 0.8.1

package/blender_ops/tests/test_depth.py

@@ -0,0 +1,158 @@
+"""Unit tests for `depth.py`: normalization contracts and the PNG writer.
+
+Plain asserts, no pytest, no `bpy`: runs under system Python (`python3
+tests/test_depth.py`) and under Blender's interpreter alike. Exits nonzero
+on the first mismatch.
+"""
+
+import os
+import struct
+import sys
+import zlib
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from depth import (
+    BACKGROUND16,
+    depth_range,
+    normalize_to_u16,
+    write_gray8_png,
+    write_gray16_png,
+    write_rgb8_png,
+)
+
+
+def check(label, actual, expected):
+    if actual != expected:
+        print("MISMATCH %s: got %r want %r" % (label, actual, expected))
+        sys.exit(1)
+
+
+def check_close(label, actual, expected, tol=1e-9):
+    if abs(actual - expected) > tol:
+        print("MISMATCH %s: got %r want %r" % (label, actual, expected))
+        sys.exit(1)
+
+
+# min/max over the masked finite pixels; inf and unmasked pixels never win.
+near, far = depth_range(
+    [1.0, float("inf"), 5.0, 2.0],
+    [True, True, False, True],
+)
+check_close("near", near, 1.0)
+check_close("far", far, 2.0)
+
+# no finite foreground depth is an error, not a silent (0, 0).
+try:
+    depth_range([float("inf"), 3.0], [True, False])
+    print("MISMATCH empty-range: expected ValueError")
+    sys.exit(1)
+except ValueError:
+    pass
+
+# endpoints land exactly; background and +inf land on 65535.
+values = normalize_to_u16(
+    [1.0, 2.0, 3.0, float("inf"), 99.0],
+    [True, True, True, True, False],
+    1.0,
+    3.0,
+)
+check("normalized", values, [0, 32768, 65535, BACKGROUND16, BACKGROUND16])
+
+# degenerate range maps finite foreground to 0, never divides by zero.
+check(
+    "degenerate",
+    normalize_to_u16([2.0, float("inf")], [True, True], 2.0, 2.0),
+    [0, BACKGROUND16],
+)
+
+# past the endpoints clamps to the endpoint values.
+check(
+    "clamped",
+    normalize_to_u16([0.0, 9.0], [True, True], 1.0, 3.0),
+    [0, 65535],
+)
+
+# the writer round-trips: parse the chunks, inflate the IDAT, compare bytes.
+out = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_depth_test.png")
+try:
+    write_gray16_png(out, 2, 2, [0, 32768, 65535, 12345])
+    with open(out, "rb") as handle:
+        blob = handle.read()
+    check("png signature", blob[:8], b"\x89PNG\r\n\x1a\n")
+    pos = 8
+    seen = {}
+    while pos < len(blob):
+        (length,) = struct.unpack(">I", blob[pos : pos + 4])
+        kind = blob[pos + 4 : pos + 8]
+        payload = blob[pos + 8 : pos + 8 + length]
+        (crc,) = struct.unpack(">I", blob[pos + 8 + length : pos + 12 + length])
+        check("crc %s" % (kind,), crc, zlib.crc32(kind + payload) & 0xFFFFFFFF)
+        seen[kind] = payload
+        pos += 12 + length
+    ihdr = seen[b"IHDR"]
+    check("ihdr size", struct.unpack(">II", ihdr[:8]), (2, 2))
+    check("ihdr depth/type", (ihdr[8], ihdr[9]), (16, 0))
+    raw = zlib.decompress(seen[b"IDAT"])
+    expect = b"".join(
+        [
+            b"\x00" + struct.pack(">HH", 0, 32768),
+            b"\x00" + struct.pack(">HH", 65535, 12345),
+        ]
+    )
+    check("idat samples", raw, expect)
+finally:
+    if os.path.exists(out):
+        os.remove(out)
+
+
+def read_rows(path):
+    with open(path, "rb") as handle:
+        blob = handle.read()
+    pos = 8
+    ihdr = None
+    idat = b""
+    while pos < len(blob):
+        (length,) = struct.unpack(">I", blob[pos : pos + 4])
+        kind = blob[pos + 4 : pos + 8]
+        payload = blob[pos + 8 : pos + 8 + length]
+        if kind == b"IHDR":
+            ihdr = payload
+        elif kind == b"IDAT":
+            idat += payload
+        pos += 12 + length
+    width, height = struct.unpack(">II", ihdr[:8])
+    return width, height, ihdr[8], ihdr[9], zlib.decompress(idat)
+
+
+out8 = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_mask_test.png")
+try:
+    write_gray8_png(out8, 3, 1, [0, 255, 128])
+    width, height, depth, ctype, raw = read_rows(out8)
+    check("gray8 geometry", (width, height, depth, ctype), (3, 1, 8, 0))
+    check("gray8 samples", raw, b"\x00\x00\xff\x80")
+finally:
+    if os.path.exists(out8):
+        os.remove(out8)
+
+outn = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_normal_test.png")
+try:
+    write_rgb8_png(outn, 2, 1, [128, 128, 255, 255, 0, 0])
+    width, height, depth, ctype, raw = read_rows(outn)
+    check("rgb8 geometry", (width, height, depth, ctype), (2, 1, 8, 2))
+    check("rgb8 samples", raw, b"\x00\x80\x80\xff\xff\x00\x00")
+finally:
+    if os.path.exists(outn):
+        os.remove(outn)
+
+# a short row is an error, never a truncated file.
+try:
+    write_gray8_png(out8, 2, 2, [0, 0, 0])
+    print("MISMATCH short-row: expected ValueError")
+    sys.exit(1)
+except ValueError:
+    pass
+if os.path.exists(out8):
+    os.remove(out8)
+
+print("depth: all checks passed")

package/blender_ops/tests/test_exr.py

@@ -0,0 +1,218 @@
+"""Unit tests for `exr.py`: the minimal scanline reader.
+
+Plain asserts, no pytest, no `bpy`: runs under system Python (`python3
+tests/test_exr.py`) and under Blender's interpreter alike. Exits nonzero
+on the first mismatch.
+
+The synthetic file mirrors exactly what Blender's File Output writes for a
+staged pass: single-part scanline, `NO_COMPRESSION`, `FLOAT` channels named
+`Image.R/G/B/A`, increasing line order.
+"""
+
+import os
+import struct
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from exr import ExrError, read_exr_rgba, rewrite_background_to_inf
+
+
+def check(label, actual, expected):
+    if actual != expected:
+        print("MISMATCH %s: got %r want %r" % (label, actual, expected))
+        sys.exit(1)
+
+
+def read_channel(path, wanted):
+    """Float samples of one named channel, in row-major order."""
+    from exr import _parse_header, _parse_header_channels
+
+    with open(path, "rb") as handle:
+        blob = handle.read()
+    attrs, pos = _parse_header(blob)
+    (x0, y0, x1, y1) = struct.unpack("<iiii", attrs["dataWindow"])
+    width, height = x1 - x0 + 1, y1 - y0 + 1
+    channels = _parse_header_channels(attrs)
+    offsets = struct.unpack("<%dq" % (height,), blob[pos : pos + 8 * height])
+    values = []
+    for row, offset in enumerate(offsets):
+        cursor = offset + 8
+        for name, pixel_type, _ in channels:
+            count = width * 4
+            if name == wanted:
+                values.extend(
+                    struct.unpack(
+                        "<%df" % (width,), blob[cursor : cursor + count]
+                    )
+                )
+            cursor += count
+    return values
+
+
+def write_exr(path, width, height, channels, compression=0):
+    """Minimal uncompressed scanline EXR: `channels` is [(name, [floats])]."""
+    blob = bytearray(b"v/1\x01" + struct.pack("<I", 2))
+
+    def attr(name, typ, payload):
+        blob.extend(name + b"\x00" + typ + b"\x00")
+        blob.extend(struct.pack("<i", len(payload)) + payload)
+
+    attr(b"compression", b"compression", struct.pack("B", compression))
+    attr(
+        b"dataWindow",
+        b"box2i",
+        struct.pack("<iiii", 0, 0, width - 1, height - 1),
+    )
+    attr(
+        b"displayWindow",
+        b"box2i",
+        struct.pack("<iiii", 0, 0, width - 1, height - 1),
+    )
+    attr(b"lineOrder", b"lineOrder", b"\x00")
+    chlist = b""
+    for name, _values in channels:
+        chlist += name + b"\x00" + struct.pack("<i", 2) + b"\x00\x00\x00\x00"
+        chlist += struct.pack("<ii", 1, 1)
+    chlist += b"\x00"
+    attr(b"channels", b"chlist", chlist)
+    blob += b"\x00"
+    table_at = len(blob)
+    blob += b"\x00" * (8 * height)
+    offsets = []
+    for row in range(height):
+        offsets.append(len(blob))
+        blob += struct.pack("<i", row)
+        body = b"".join(
+            struct.pack("<%df" % (width,), *values[row * width : (row + 1) * width])
+            for _name, values in channels
+        )
+        blob += struct.pack("<i", len(body)) + body
+    struct.pack_into("<%dq" % (height,), blob, table_at, *offsets)
+    with open(path, "wb") as handle:
+        handle.write(bytes(blob))
+
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+GOOD = os.path.join(HERE, "_exr_test.exr")
+
+try:
+    depth = [float(i) for i in range(6)]
+    write_exr(
+        GOOD,
+        3,
+        2,
+        [
+            (b"Image.A", [1.0] * 6),
+            (b"Image.B", depth),
+            (b"Image.G", depth),
+            (b"Image.R", depth),
+        ],
+    )
+    width, height, r, g, b = read_exr_rgba(GOOD)
+    check("geometry", (width, height), (3, 2))
+    check("r", r, depth)
+    check("g", g, depth)
+    check("b", b, depth)
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+# inf and nan survive the round trip bit-exact (the sentinel gate needs them).
+try:
+    write_exr(
+        GOOD,
+        2,
+        1,
+        [
+            (b"L.R", [float("inf"), float("nan")]),
+            (b"L.G", [0.0, 0.0]),
+            (b"L.B", [0.0, 0.0]),
+        ],
+    )
+    _w, _h, r, _g, _b = read_exr_rgba(GOOD)
+    check("inf", r[0] == float("inf"), True)
+    check("nan", r[1] != r[1], True)
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+# a compressed file is refused, never misread.
+try:
+    write_exr(
+        GOOD,
+        1,
+        1,
+        [(b"L.R", [1.0]), (b"L.G", [1.0]), (b"L.B", [1.0])],
+        compression=3,
+    )
+    read_exr_rgba(GOOD)
+    print("MISMATCH compressed: expected ExrError")
+    sys.exit(1)
+except ExrError:
+    pass
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+# not an EXR file at all.
+try:
+    with open(GOOD, "wb") as handle:
+        handle.write(b"definitely not exr")
+    read_exr_rgba(GOOD)
+    print("MISMATCH magic: expected ExrError")
+    sys.exit(1)
+except ExrError:
+    pass
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+# background samples become +inf, foreground is bit-exact, alpha is kept.
+try:
+    write_exr(
+        GOOD,
+        3,
+        2,
+        [
+            (b"Image.A", [1.0] * 6),
+            (b"Image.B", [1e10, 2.0, 1e10, 4.0, 5.0, 1e10]),
+            (b"Image.G", [1e10, 2.0, 1e10, 4.0, 5.0, 1e10]),
+            (b"Image.R", [1e10, 2.0, 1e10, 4.0, 5.0, 1e10]),
+        ],
+    )
+    rewrite_background_to_inf(
+        GOOD, [False, True, False, True, True, False]
+    )
+    _w, _h, r, g, b = read_exr_rgba(GOOD)
+    check("bg", [r[0], r[2], r[5]], [float("inf")] * 3)
+    check("fg", [r[1], r[3], r[4]], [2.0, 4.0, 5.0])
+    check("g-matches", g, r)
+    check("b-matches", b, r)
+    check("alpha-kept", read_channel(GOOD, "Image.A"), [1.0] * 6)
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+# a mask that does not fill the frame is refused, never half-applied.
+try:
+    write_exr(
+        GOOD,
+        2,
+        1,
+        [
+            (b"L.R", [1.0, 2.0]),
+            (b"L.G", [1.0, 2.0]),
+            (b"L.B", [1.0, 2.0]),
+        ],
+    )
+    rewrite_background_to_inf(GOOD, [True])
+    print("MISMATCH mask-size: expected ValueError")
+    sys.exit(1)
+except ValueError:
+    pass
+finally:
+    if os.path.exists(GOOD):
+        os.remove(GOOD)
+
+print("exr: all checks passed")

package/blender_ops/tests/test_framing.py

@@ -0,0 +1,50 @@
+"""T3, Python side: pin the `framing.py` port to the shared goldens.
+
+Runs under Blender's own interpreter (`blender -b --python ...`), which the
+TypeScript suite (`tests/framing.test.ts`) drives when Blender is present.
+Plain asserts only: Blender's Python has no pytest. Exits nonzero on the
+first mismatch, printing both values.
+
+Goldens: radius 2, fov 40, aspect 4/3, zoom 1.2; azimuth 30, elevation 20;
+bounds center (0.5, 0.25, -1). Same numbers as `framing.test.ts`.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from framing import compute_framing, orbit_offset
+
+GOLDEN = {
+    "distance": 4.8730,
+    "near": 0.0487,
+    "far": 24.8730,
+    "offset": (2.2896, 1.6667, 3.9656),
+    "position": (2.7896, 1.9167, 2.9656),
+    "center": (0.5, 0.25, -1.0),
+}
+
+
+def check(label, actual, expected):
+    if abs(actual - expected) > 5e-5:
+        print("MISMATCH %s: got %r want %r" % (label, actual, expected))
+        sys.exit(1)
+
+
+framing = compute_framing(2, 40, 4.0 / 3.0, 1.2)
+check("distance", framing["distance"], GOLDEN["distance"])
+check("near", framing["near"], GOLDEN["near"])
+check("far", framing["far"], GOLDEN["far"])
+
+offset = orbit_offset(30, 20, framing["distance"])
+check("offset.x", offset["x"], GOLDEN["offset"][0])
+check("offset.y", offset["y"], GOLDEN["offset"][1])
+check("offset.z", offset["z"], GOLDEN["offset"][2])
+
+cx, cy, cz = GOLDEN["center"]
+check("position.x", cx + offset["x"], GOLDEN["position"][0])
+check("position.y", cy + offset["y"], GOLDEN["position"][1])
+check("position.z", cz + offset["z"], GOLDEN["position"][2])
+
+print("framing goldens ok")

package/dist/.nodetool-build-stamp

@@ -0,0 +1 @@
+2026-09-28T09:19:11.534Z

package/dist/bake.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The timeline's 3D bake: a sampled Blender render muxed into one video
+ * (design §D6).
+ *
+ * The caller hands over one model time and one camera per output frame — the
+ * evaluated clip, with its in point, speed, time remap, animation speed and
+ * camera curves already applied — and gets back an MP4 the clip can play as
+ * an ordinary video layer. Blender renders a still per entry rather than a
+ * frame range, because a trimmed, sped-up, reversed or looped clip is not a
+ * run of consecutive scene frames.
+ *
+ * The mux is ffmpeg and not Blender's own writer, which is what
+ * `render_animation`'s video mode uses. Two reasons: one sequence feeds both
+ * bake formats, and Blender cannot write VP9 with an alpha channel. ffmpeg is
+ * therefore a host binary this path needs and the video mode does not; a
+ * machine without it fails here with the binary named.
+ */
+import type { ProcessingContext } from "@nodetool-ai/runtime";
+import type { BakeCameraParams, BlenderJob, BlenderResultStats, RenderAnimationParams } from "./job.js";
+/**
+ * Ceiling on the frames one bake asks for. Every frame is a declared output
+ * the runner reads into memory, so this is the bound on that, not a limit on
+ * clip length in the abstract: two minutes at 30 fps.
+ */
+export declare const MAX_BAKE_FRAMES = 3600;
+/** What one bake renders. Cameras and times are parallel, one pair per frame. */
+export interface Model3DBakeRequest {
+    /** Model time in seconds, one entry per output frame. */
+    frameTimes: readonly number[];
+    /** The camera each of those frames renders through. */
+    cameras: readonly BakeCameraParams[];
+    /** glTF animation to play; every one plays when absent (the D2 default). */
+    animationName?: string;
+    width: number;
+    height: number;
+    fps: number;
+}
+export interface Model3DBakeOptions {
+    timeoutMs: number;
+    signal?: AbortSignal;
+    /** Reported per rendered frame, before the mux. */
+    onProgress?: (frame: number, total: number) => void;
+}
+/** The container, encoder and pixel format one bake is written as. */
+export interface BakeVideoFormat {
+    /** File extension of the muxed bytes, without the dot. */
+    extension: "mp4" | "webm";
+    mimeType: string;
+    /** ffmpeg output arguments: the encoder and its pixel format. */
+    encoderArgs: readonly string[];
+}
+/**
+ * How a bake is encoded: opaque to MP4/H.264 `yuv420p`, transparent to WebM
+ * VP9 `yuva420p` (design §D6).
+ *
+ * The alpha pair is the one `resolveTimelineOutput({ format: "webm", alpha:
+ * true })` already declares for a timeline render, copied rather than imported
+ * because `@nodetool-ai/blender-nodes` does not depend on
+ * `@nodetool-ai/video-nodes` and a bake needs four strings from it, not a
+ * package. `packages/agents/tests/timeline-bake-format.test.ts` depends on both
+ * and fails when the two drift.
+ */
+export declare function bakeVideoFormat(alpha: boolean): BakeVideoFormat;
+export interface Model3DBakeResult {
+    /** The muxed bytes, in {@link Model3DBakeResult.format}. */
+    video: Uint8Array;
+    /** What those bytes are, so the caller names and stores them correctly. */
+    format: BakeVideoFormat;
+    stats: BlenderResultStats;
+}
+/**
+ * The `frame_*` outputs a sampled job declares: one per entry, in play order.
+ * The op writes the file each name carries and reports the names back.
+ */
+export declare function bakeFrameOutputs(count: number): BlenderJob["outputs"];
+/** The sampled `render_animation` params for one bake. */
+export declare function bakeRenderAnimationParams(request: Model3DBakeRequest): RenderAnimationParams;
+/** Render the sequence. Frames come back in play order. */
+export declare function renderModel3DBakeFrames(context: ProcessingContext, modelBytes: Uint8Array, request: Model3DBakeRequest, options: Model3DBakeOptions): Promise<{
+    frames: Uint8Array[];
+    stats: BlenderResultStats;
+}>;
+/**
+ * The ffmpeg call that turns the numbered PNGs into one video.
+ *
+ * Pure, because the arguments are the whole difference between the two bakes
+ * and a test should not need ffmpeg to read them.
+ */
+export declare function bakeMuxArgs(format: BakeVideoFormat, fps: number, output: string): string[];
+/**
+ * Mux a PNG sequence into one video through ffmpeg's image2 demuxer.
+ *
+ * The frames are written under the workspace's scratch directory rather than
+ * piped: image2 reads a numbered pattern, and the same files reach either
+ * encoder unchanged — an alpha bake differs only in the arguments
+ * {@link bakeVideoFormat} names, because the PNGs already carry the channel.
+ */
+export declare function muxPngSequenceToVideo(context: ProcessingContext, frames: readonly Uint8Array[], fps: number, format: BakeVideoFormat, options: Model3DBakeOptions): Promise<Uint8Array>;
+/**
+ * Render the sampled sequence and mux it: the whole bake (§D6).
+ *
+ * Whether it carries alpha is read off the frames' own camera rather than
+ * taken as a second field: `transparent` is what Blender rendered the film
+ * under, so a separate flag could only ever disagree with the pixels.
+ */
+export declare function bakeModel3DClipToVideo(context: ProcessingContext, modelBytes: Uint8Array, request: Model3DBakeRequest, options: Model3DBakeOptions): Promise<Model3DBakeResult>;
+//# sourceMappingURL=bake.d.ts.map

package/dist/bake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bake.d.ts","sourceRoot":"","sources":["../src/bake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,UAAU,CAAC;AAIlB;;;;GAIG;AACH,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,uDAAuD;IACvD,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,4EAA4E;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,mDAAmD;IACnD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,0DAA0D;IAC1D,SAAS,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAe/D;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,KAAK,EAAE,UAAU,CAAC;IAClB,2EAA2E;IAC3E,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAOD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,SAAS,CAAC,CAMrE;AAyBD,0DAA0D;AAC1D,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,kBAAkB,GAC1B,qBAAqB,CAuBvB;AAED,2DAA2D;AAC3D,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,iBAAiB,EAC1B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAC,CA+B9D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAqBV;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,SAAS,UAAU,EAAE,EAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,UAAU,CAAC,CAiCrB;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,iBAAiB,EAC1B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAgB5B"}