@woosh/meep-engine 3.14.1 → 3.14.3

package/src/avif/native/av1/decode/get_scan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get_scan.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/get_scan.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;GAaG;AACH,kCARW,MAAM,iBACN,MAAM,GACJ,WAAW,CAoCvB"}

package/src/avif/native/av1/decode/read_lr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read_lr.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/read_lr.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH,iDARW,MAAM,KACN,MAAM,UACN,MAAM,QA0BhB;AAKD;;;;;;;;;;;;;;GAcG;AACH,qEAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,SACN,UAAU,QAgCpB"}

package/src/avif/native/av1/decode/read_lr.js

@@ -1,277 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import {
-    MI_SIZE,
-    RESTORE_NONE,
-    RESTORE_SGRPROJ,
-    RESTORE_WIENER,
-    SGRPROJ_PARAMS_BITS,
-    SGRPROJ_PRJ_BITS,
-    SGRPROJ_PRJ_SUBEXP_K,
-    SUPERRES_NUM
-} from "../tables/av1_symbols.js";
-import {
-    SGRPROJ_XQD_MAX,
-    SGRPROJ_XQD_MIN,
-    SGR_PARAMS,
-    WIENER_TAPS_K,
-    WIENER_TAPS_MAX,
-    WIENER_TAPS_MIN
-} from "../tables/filter_tables.js";
-import { NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE } from "../tables/block_tables.js";
-import { count_units_in_frame } from "../filter/loop_restoration.js";
-import { round2 } from "../util/round2.js";
-
-/**
- * Read the loop restoration units a superblock covers.
- *
- * Restoration units are not superblock-aligned: their size is signalled independently, so a
- * superblock may cover several units or part of one. The coefficients are coded as differences from
- * the previous unit's, which is why the reference values live on the context and persist across
- * superblocks within a tile.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} r superblock row in 4x4 units
- * @param {number} c superblock column in 4x4 units
- * @param {number} b_size the superblock size
- * @see AV1 spec 5.11.57 "Read loop restoration syntax"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function read_lr(ctx, r, c, b_size) {
-    const frame = ctx.frame;
-
-    if (frame.allow_intrabc === 1) {
-        return;
-    }
-
-    for (let plane = 0; plane < ctx.num_planes; plane++) {
-        if (frame.frame_restoration_type[plane] === RESTORE_NONE) {
-            continue;
-        }
-
-        loop_restoration_unit_range(ctx, r, c, b_size, plane, UNIT_RANGE);
-
-        for (let unit_row = UNIT_RANGE[0]; unit_row < UNIT_RANGE[1]; unit_row++) {
-            for (let unit_col = UNIT_RANGE[2]; unit_col < UNIT_RANGE[3]; unit_col++) {
-                read_lr_unit(ctx, plane, unit_row, unit_col);
-            }
-        }
-    }
-}
-
-/** @type {Int32Array} first and last row, then first and last column */
-const UNIT_RANGE = new Int32Array(4);
-
-/**
- * Which restoration units a superblock is responsible for coding.
- *
- * Units are not superblock-aligned — their size is signalled independently of the superblock size —
- * so this is where the two grids are reconciled, once, for the reader and the encoder's writer
- * both. A superblock codes the units whose top left corner falls inside it.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} r superblock row in 4x4 units
- * @param {number} c superblock column in 4x4 units
- * @param {number} b_size the superblock size
- * @param {number} plane
- * @param {Int32Array} range filled with the first and last unit row, then column
- * @see AV1 spec 5.11.57
- */
-export function loop_restoration_unit_range(ctx, r, c, b_size, plane, range) {
-    const frame = ctx.frame;
-
-    const w = NUM_4X4_BLOCKS_WIDE[b_size];
-    const h = NUM_4X4_BLOCKS_HIGH[b_size];
-
-    const sub_x = plane === 0 ? 0 : ctx.subsampling_x;
-    const sub_y = plane === 0 ? 0 : ctx.subsampling_y;
-
-    const unit_size = frame.loop_restoration_size[plane];
-
-    const unit_rows = count_units_in_frame(unit_size, round2(frame.frame_height, sub_y));
-    const unit_cols = count_units_in_frame(unit_size, round2(frame.upscaled_width, sub_x));
-
-    let numerator;
-    let denominator;
-
-    if (frame.use_superres === 1) {
-        numerator = (MI_SIZE >> sub_x) * frame.superres_denom;
-        denominator = unit_size * SUPERRES_NUM;
-    } else {
-        numerator = MI_SIZE >> sub_x;
-        denominator = unit_size;
-    }
-
-    range[0] = Math.floor((r * (MI_SIZE >> sub_y) + unit_size - 1) / unit_size);
-    range[1] = Math.min(unit_rows, Math.floor(((r + h) * (MI_SIZE >> sub_y) + unit_size - 1) / unit_size));
-    range[2] = Math.floor((c * numerator + denominator - 1) / denominator);
-    range[3] = Math.min(unit_cols, Math.floor(((c + w) * numerator + denominator - 1) / denominator));
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @param {number} unit_row
- * @param {number} unit_col
- * @see AV1 spec 5.11.58 "Read loop restoration unit syntax"
- */
-function read_lr_unit(ctx, plane, unit_row, unit_col) {
-    const reader = ctx.reader;
-    const cdf = ctx.cdf;
-
-    const frame_type = ctx.frame.frame_restoration_type[plane];
-
-    let restoration_type;
-
-    if (frame_type === RESTORE_WIENER) {
-        restoration_type = reader.read_symbol(cdf.use_wiener, 0, 2) === 1 ? RESTORE_WIENER : RESTORE_NONE;
-    } else if (frame_type === RESTORE_SGRPROJ) {
-        restoration_type = reader.read_symbol(cdf.use_sgrproj, 0, 2) === 1 ? RESTORE_SGRPROJ : RESTORE_NONE;
-    } else {
-        restoration_type = reader.read_symbol(cdf.restoration_type, 0, 3);
-    }
-
-    const index = ctx.lr_unit_index(plane, unit_row, unit_col);
-
-    ctx.lr_type[index] = restoration_type;
-
-    if (restoration_type === RESTORE_WIENER) {
-        for (let pass = 0; pass < 2; pass++) {
-            // chroma's outermost tap is always zero, which is what makes it a five tap filter
-            const first = plane !== 0 ? 1 : 0;
-
-            if (plane !== 0) {
-                ctx.lr_wiener[index * 6 + pass * 3] = 0;
-            }
-
-            for (let j = first; j < 3; j++) {
-                const minimum = WIENER_TAPS_MIN[j];
-                const maximum = WIENER_TAPS_MAX[j];
-                const k = WIENER_TAPS_K[j];
-
-                const reference = ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j];
-
-                const value = decode_signed_subexp_with_ref(ctx, minimum, maximum + 1, k, reference);
-
-                ctx.lr_wiener[index * 6 + pass * 3 + j] = value;
-                ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j] = value;
-            }
-        }
-
-        return;
-    }
-
-    if (restoration_type !== RESTORE_SGRPROJ) {
-        return;
-    }
-
-    const set = reader.read_literal(SGRPROJ_PARAMS_BITS);
-
-    ctx.lr_sgr_set[index] = set;
-
-    for (let i = 0; i < 2; i++) {
-        const radius = SGR_PARAMS[set * 4 + i * 2];
-
-        const minimum = SGRPROJ_XQD_MIN[i];
-        const maximum = SGRPROJ_XQD_MAX[i];
-
-        let value;
-
-        if (radius !== 0) {
-            value = decode_signed_subexp_with_ref(
-                ctx,
-                minimum,
-                maximum + 1,
-                SGRPROJ_PRJ_SUBEXP_K,
-                ctx.ref_sgr_xqd[plane * 2 + i]
-            );
-        } else {
-            // a zero radius means that pass contributes nothing, so its weight is not coded; the
-            // second one is derived so the three weights still sum to unity
-            value = i === 1
-                ? clamp((1 << SGRPROJ_PRJ_BITS) - ctx.ref_sgr_xqd[plane * 2], minimum, maximum)
-                : 0;
-        }
-
-        ctx.lr_sgr_xqd[index * 2 + i] = value;
-        ctx.ref_sgr_xqd[plane * 2 + i] = value;
-    }
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} low
- * @param {number} high
- * @param {number} k
- * @param {number} reference
- * @returns {number}
- * @see AV1 spec 5.11.58, `decode_signed_subexp_with_ref_bool`
- */
-function decode_signed_subexp_with_ref(ctx, low, high, k, reference) {
-    return decode_unsigned_subexp_with_ref(ctx, high - low, k, reference - low) + low;
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} mx
- * @param {number} k
- * @param {number} r
- * @returns {number}
- */
-function decode_unsigned_subexp_with_ref(ctx, mx, k, r) {
-    const v = decode_subexp(ctx, mx, k);
-
-    if ((r << 1) <= mx) {
-        return inverse_recenter(r, v);
-    }
-
-    return mx - 1 - inverse_recenter(mx - 1 - r, v);
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} num_symbols
- * @param {number} k
- * @returns {number}
- */
-function decode_subexp(ctx, num_symbols, k) {
-    const reader = ctx.reader;
-
-    let i = 0;
-    let mk = 0;
-
-    for (;;) {
-        const b2 = i !== 0 ? k + i - 1 : k;
-        const a = 1 << b2;
-
-        if (num_symbols <= mk + 3 * a) {
-            return reader.read_ns(num_symbols - mk) + mk;
-        }
-
-        if (reader.read_literal(1) === 1) {
-            i++;
-            mk += a;
-        } else {
-            return reader.read_literal(b2) + mk;
-        }
-    }
-}
-
-/**
- * @param {number} r
- * @param {number} v
- * @returns {number}
- * @see AV1 spec 5.9.28 "Inverse recenter function"
- */
-function inverse_recenter(r, v) {
-    if (v > 2 * r) {
-        return v;
-    }
-
-    if ((v & 1) !== 0) {
-        return r - ((v + 1) >> 1);
-    }
-
-    return r + (v >> 1);
-}

package/src/avif/native/av1/decode/read_transform_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read_transform_type.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/read_transform_type.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AACH,8DARW,MAAM,MACN,MAAM,WACN,MAAM,QAmDhB"}

package/src/avif/native/av1/decode/read_transform_type.js

@@ -1,92 +0,0 @@
-import {
-    DCT_DCT,
-    SEG_LVL_ALT_Q,
-    SEG_LVL_MAX,
-    TX_SET_INTRA_1
-} from "../tables/av1_symbols.js";
-import { TX_HEIGHT, TX_SIZE_SQR, TX_WIDTH } from "../tables/block_tables.js";
-import {
-    TX_TYPE_INTRA_INV_SET1,
-    TX_TYPE_INTRA_INV_SET2
-} from "../tables/transform_tables.js";
-import { FILTER_INTRA_MODE_TO_INTRA_DIR } from "../tables/prediction_tables.js";
-import { clamp } from "../../../../core/math/clamp.js";
-import { get_tx_set } from "./transform_type.js";
-
-/**
- * Read the transform type for a luma transform block and record it across the 4x4 positions it
- * covers.
- *
- * A type is only coded when the transform size allows more than a plain DCT *and* the block is
- * actually quantised — at quantizer index zero the residual is exact and the choice would be
- * meaningless, so the format spends no bits on it.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} x4 luma 4x4 column
- * @param {number} y4 luma 4x4 row
- * @param {number} tx_size
- * @see AV1 spec 5.11.47 "Transform type syntax"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function read_transform_type(ctx, x4, y4, tx_size) {
-    const frame = ctx.frame;
-
-    const set = get_tx_set(tx_size, 0, frame.reduced_tx_set);
-
-    let tx_type = DCT_DCT;
-
-    const qindex = frame.segmentation_enabled === 1
-        ? segment_qindex(frame, ctx.segment_id)
-        : frame.base_q_idx;
-
-    if (set > 0 && qindex > 0) {
-        const intra_direction = ctx.use_filter_intra === 1
-            ? FILTER_INTRA_MODE_TO_INTRA_DIR[ctx.filter_intra_mode]
-            : ctx.y_mode;
-
-        const square = TX_SIZE_SQR[tx_size];
-
-        if (set === TX_SET_INTRA_1) {
-            const symbol = ctx.reader.read_symbol(
-                ctx.cdf.intra_tx_type_set1,
-                (square * 13 + intra_direction) * 8,
-                7
-            );
-
-            tx_type = TX_TYPE_INTRA_INV_SET1[symbol];
-        } else {
-            const symbol = ctx.reader.read_symbol(
-                ctx.cdf.intra_tx_type_set2,
-                (square * 13 + intra_direction) * 6,
-                5
-            );
-
-            tx_type = TX_TYPE_INTRA_INV_SET2[symbol];
-        }
-    }
-
-    const width4 = TX_WIDTH[tx_size] >> 2;
-    const height4 = TX_HEIGHT[tx_size] >> 2;
-
-    for (let i = 0; i < width4; i++) {
-        for (let j = 0; j < height4; j++) {
-            ctx.tx_types[(y4 + j) * ctx.mi_stride + x4 + i] = tx_type;
-        }
-    }
-}
-
-/**
- * `get_qindex( 1, segmentId )`.
- * @param {FrameHeader} frame
- * @param {number} segment_id
- * @returns {number}
- */
-function segment_qindex(frame, segment_id) {
-    if (frame.feature_enabled[segment_id * SEG_LVL_MAX + SEG_LVL_ALT_Q] !== 0) {
-        return clamp(frame.base_q_idx + frame.feature_data[segment_id * SEG_LVL_MAX + SEG_LVL_ALT_Q], 0, 255);
-    }
-
-    return frame.base_q_idx;
-}

package/src/avif/native/av1/decode/reconstruct.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/reconstruct.js"],"names":[],"mappings":"AAkCA;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,kDAHa,MAAM,CAsBlB;AA0BD;;;;;;;;;;;;GAYG;AACH,yDATW,MAAM,KACN,MAAM,KACN,MAAM,WACN,MAAM,QAsGhB"}

package/src/avif/native/av1/decode/reconstruct.js

@@ -1,241 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import {
-    ADST_FLIPADST,
-    DCT_FLIPADST,
-    FLIPADST_ADST,
-    FLIPADST_DCT,
-    FLIPADST_FLIPADST,
-    H_FLIPADST,
-    IDTX,
-    MAX_SEGMENTS,
-    SEG_LVL_ALT_Q,
-    SEG_LVL_MAX,
-    TX_16X32,
-    TX_16X64,
-    TX_32X16,
-    TX_32X32,
-    TX_32X64,
-    TX_64X16,
-    TX_64X32,
-    TX_64X64,
-    V_FLIPADST
-} from "../tables/av1_symbols.js";
-import { QM_OFFSET, QUANTIZER_MATRIX } from "../tables/quantizer_matrix_tables.js";
-import { AC_QLOOKUP, DC_QLOOKUP } from "../tables/quantizer_tables.js";
-import { TX_HEIGHT, TX_WIDTH } from "../tables/block_tables.js";
-import { inverse_transform_2d } from "../transform/inverse_transform_2d.js";
-import { round2 } from "../util/round2.js";
-
-/**
- * `Quantizer_Matrix` covers one level and plane type in this many entries.
- * @type {number}
- */
-const QM_TOTAL_SIZE = 3344;
-
-/**
- * `dc_q( b )`. Exported because an encoder has to quantise with exactly what this dequantises with.
- * @param {number} bit_depth
- * @param {number} b
- * @returns {number}
- */
-export function dc_quant(bit_depth, b) {
-    return DC_QLOOKUP[((bit_depth - 8) >> 1) * 256 + clamp(b, 0, 255)];
-}
-
-/**
- * `ac_q( b )`.
- * @param {number} bit_depth
- * @param {number} b
- * @returns {number}
- */
-export function ac_quant(bit_depth, b) {
-    return AC_QLOOKUP[((bit_depth - 8) >> 1) * 256 + clamp(b, 0, 255)];
-}
-
-/**
- * `get_qindex( 0, segment_id )`: the block's quantizer index, honouring any per-block delta.
- * @param {Av1FrameContext} ctx
- * @returns {number}
- * @see AV1 spec 7.12.2 "Dequantization functions"
- */
-export function get_qindex(ctx) {
-    const frame = ctx.frame;
-    const segment = ctx.segment_id;
-
-    if (frame.segmentation_enabled === 1 && frame.feature_enabled[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q] !== 0) {
-        const data = frame.feature_data[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q];
-
-        const qindex = frame.delta_q_present === 1
-            ? ctx.current_q_index + data
-            : frame.base_q_idx + data;
-
-        return clamp(qindex, 0, 255);
-    }
-
-    if (frame.delta_q_present === 1) {
-        return ctx.current_q_index;
-    }
-
-    return frame.base_q_idx;
-}
-
-/**
- * Whether the transform type flips its output vertically.
- * @param {number} tx_type
- * @returns {boolean}
- */
-function flips_vertically(tx_type) {
-    return tx_type === FLIPADST_DCT
-        || tx_type === FLIPADST_ADST
-        || tx_type === V_FLIPADST
-        || tx_type === FLIPADST_FLIPADST;
-}
-
-/**
- * Whether the transform type flips its output horizontally.
- * @param {number} tx_type
- * @returns {boolean}
- */
-function flips_horizontally(tx_type) {
-    return tx_type === DCT_FLIPADST
-        || tx_type === ADST_FLIPADST
-        || tx_type === H_FLIPADST
-        || tx_type === FLIPADST_FLIPADST;
-}
-
-/**
- * Dequantise, inverse transform and add the residual into the plane.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @param {number} x left edge of the transform block in plane samples
- * @param {number} y top edge of the transform block in plane samples
- * @param {number} tx_size
- * @see AV1 spec 7.12.3 "Reconstruct process"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function reconstruct(ctx, plane, x, y, tx_size) {
-    const frame = ctx.frame;
-    const bit_depth = ctx.bit_depth;
-
-    let dq_denom = 1;
-
-    if (tx_size === TX_32X32 || tx_size === TX_16X32 || tx_size === TX_32X16 || tx_size === TX_16X64 || tx_size === TX_64X16) {
-        dq_denom = 2;
-    } else if (tx_size === TX_64X64 || tx_size === TX_32X64 || tx_size === TX_64X32) {
-        dq_denom = 4;
-    }
-
-    const w = TX_WIDTH[tx_size];
-    const h = TX_HEIGHT[tx_size];
-
-    const tw = Math.min(32, w);
-    const th = Math.min(32, h);
-
-    const tx_type = ctx.plane_tx_type;
-
-    const flip_up_down = flips_vertically(tx_type);
-    const flip_left_right = flips_horizontally(tx_type);
-
-    const qindex = get_qindex(ctx);
-
-    const dc_q = dc_quant(bit_depth, qindex + dc_delta(frame, plane));
-    const ac_q = ac_quant(bit_depth, qindex + ac_delta(frame, plane));
-
-    const residual = ctx.residual;
-    const quant = ctx.quant;
-
-    residual.fill(0, 0, w * h);
-
-    const qm_level = frame.using_qmatrix === 1 ? frame.seg_qm_level[plane * MAX_SEGMENTS + ctx.segment_id] : 15;
-    const use_qm = frame.using_qmatrix === 1 && tx_type < IDTX && qm_level < 15;
-
-    const qm_base = use_qm
-        ? (qm_level * 2 + (plane > 0 ? 1 : 0)) * QM_TOTAL_SIZE + QM_OFFSET[tx_size]
-        : 0;
-
-    const limit = 1 << (7 + bit_depth);
-
-    for (let i = 0; i < th; i++) {
-        for (let j = 0; j < tw; j++) {
-            const level = quant[i * tw + j];
-
-            // a coefficient the quantiser zeroed dequantises to zero, and the residual is already
-            // zero there. Most of a block is this
-            if (level === 0) {
-                continue;
-            }
-
-            const q = i === 0 && j === 0 ? dc_q : ac_q;
-
-            const q2 = use_qm ? round2(q * QUANTIZER_MATRIX[qm_base + i * tw + j], 5) : q;
-
-            const dq = level * q2;
-
-            const sign = dq < 0 ? -1 : 1;
-
-            // the mask is not a clamp: the specification truncates the magnitude to 24 bits and
-            // only then divides, so a value above it wraps rather than saturating
-            const dq2 = sign * Math.floor((Math.abs(dq) & 0xffffff) / dq_denom);
-
-            residual[i * w + j] = clamp(dq2, -limit, limit - 1);
-        }
-    }
-
-    inverse_transform_2d(residual, tx_size, tx_type, ctx.lossless, bit_depth, ctx.transform_scratch);
-
-    const plane_data = ctx.planes[plane];
-    const stride = ctx.plane_stride[plane];
-    const plane_width = ctx.plane_width[plane];
-    const plane_height = ctx.plane_height[plane];
-
-    const max_value = (1 << bit_depth) - 1;
-
-    for (let i = 0; i < h; i++) {
-        const yy = flip_up_down ? h - i - 1 : i;
-
-        if (y + yy >= plane_height) {
-            continue;
-        }
-
-        const row = (y + yy) * stride;
-
-        for (let j = 0; j < w; j++) {
-            const xx = flip_left_right ? w - j - 1 : j;
-
-            if (x + xx >= plane_width) {
-                continue;
-            }
-
-            plane_data[row + x + xx] = clamp(plane_data[row + x + xx] + residual[i * w + j], 0, max_value);
-        }
-    }
-}
-
-/**
- * @param {FrameHeader} frame
- * @param {number} plane
- * @returns {number}
- */
-function dc_delta(frame, plane) {
-    if (plane === 0) {
-        return frame.delta_q_y_dc;
-    }
-
-    return plane === 1 ? frame.delta_q_u_dc : frame.delta_q_v_dc;
-}
-
-/**
- * @param {FrameHeader} frame
- * @param {number} plane
- * @returns {number}
- */
-function ac_delta(frame, plane) {
-    if (plane === 0) {
-        return 0;
-    }
-
-    return plane === 1 ? frame.delta_q_u_ac : frame.delta_q_v_ac;
-}

package/src/avif/native/av1/decode/transform_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transform_type.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/transform_type.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,oCATW,MAAM,YACN,MAAM,kBACN,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;GAKG;AACH,0CALW,MAAM,WACN,MAAM,YACN,MAAM,GACJ,OAAO,CAMnB;AAED;;;;;;;;;;;;;;GAcG;AACH,6DAPW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAqBlB;AAED;;;;;;GAMG;AACH,sCAJW,MAAM,GACJ,MAAM,CAalB"}

package/src/avif/native/av1/encode/Av1BlockSnapshot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Av1BlockSnapshot.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/Av1BlockSnapshot.js"],"names":[],"mappings":"AA6IA;;;;;;;;GAQG;AACH,8DALW,gBAAgB,KAChB,MAAM,KACN,MAAM,UACN,MAAM,QAIhB;AAED;;;;;;;;GAQG;AACH,8DALW,gBAAgB,KAChB,MAAM,KACN,MAAM,UACN,MAAM,QAIhB;AA5JD;;;GAGG;AACH,8BAFU,MAAM,CAE4B;AAmB5C;;GAEG;AACH,mCAFU,MAAM,CAEsC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAWQ,oFAAoF;IACpF,QADW,WAAW,EAAE,CACR;IAQhB,2BAA2B;IAC3B,aADW,UAAU,EAAE,CACF;IAErB,2BAA2B;IAC3B,UADW,UAAU,EAAE,CACL;IAElB,2BAA2B;IAC3B,YADW,UAAU,EAAE,CACH;IAEpB,2BAA2B;IAC3B,SADW,UAAU,EAAE,CACN;IAUjB,qFAAqF;IACrF,eADW,UAAU,EAAE,CACA;IAQvB,yBAAyB;IACzB,SADW,UAAU,CACuC;IAI5D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,OADW,UAAU,CACqC;IAI1D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,UADW,UAAU,CACwC;CAEpE"}

package/src/avif/native/av1/encode/Av1EncodeContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Av1EncodeContext.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/Av1EncodeContext.js"],"names":[],"mappings":"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"}

package/src/avif/native/av1/encode/build_headers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_headers.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/build_headers.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAf2B,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACW,eAAe,GAAhC,MAAM;IACW,wBAAwB,GAAzC,MAAM;IACW,mBAAmB,GAApC,MAAM;IACW,WAAW,GAA5B,MAAM;SAqFhB;AA6BD;;;;;;;;;GASG;AACH;IAJ2B,UAAU,EAA1B,MAAM;IACU,sBAAsB,EAAtC,MAAM;SA6HhB"}

package/src/avif/native/av1/encode/choose_chroma_alpha.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"choose_chroma_alpha.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/choose_chroma_alpha.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iEATW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAuDlB"}

package/src/avif/native/av1/encode/choose_filters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"choose_filters.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/choose_filters.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2DA6CC"}

package/src/avif/native/av1/encode/choose_restoration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"choose_restoration.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/choose_restoration.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,+DA+CC"}