react-native-ensys-camera-x 1.0.7

package/lib/module/library/compressionEstimate.js

@@ -0,0 +1,507 @@
+"use strict";
+
+// ── Compression countdown: measured remaining time, seeded by an estimate ───────────────────
+// The library shell's viewer shows a countdown ("Compressing (5s left)") instead of an
+// indeterminate spinner while the displayed image or video is being compressed. Nothing here
+// touches the compression: these are pure functions the screen calls to decide what the line
+// should read, plus the size-band arithmetic the level list quotes.
+//
+// The number is driven by the compressor's OWN progress. Native reports measured progress on the
+// `onCompressionProgress` device event as it works (VideoRotationTranscoder.compress from the
+// encoder's output timestamps, ImageExporter.compress from the encodes its quality search spends),
+// and each report re-derives how long the whole job will take from how long it has taken to reach
+// that point: `total = elapsed / fraction`. The line then reads `total - elapsed`.
+//
+// That is what makes the figure honest in BOTH directions, which counting a fixed up-front
+// estimate down cannot be:
+//   • a job slower than predicted has its total re-derived UPWARD, so the count no longer reaches
+//     zero while the encoder is still running;
+//   • a job faster than predicted has it re-derived DOWNWARD, so the count is not still promising
+//     seconds when the compressed file is already on screen.
+//
+// The line opens by counting UP to the figure — a short, evenly paced ramp that reads as the app
+// working out how long the job will take — and turns around into the countdown the moment the two
+// meet. See the calculation-ramp section further down.
+//
+// The estimate below is still computed up front, but only to seed the first seconds — before
+// there is any measurement to derive a total from — and it is blended out as soon as there is. It
+// is also the whole figure for a source that reports no progress at all (a clip whose container
+// declares no duration has no denominator), which is the one case that still ends in
+// "Finalizing...".
+//
+// Every constant here mirrors the native editor's for the same overlay (MediaPreviewEditor.kt), so
+// both surfaces behave identically for the same media.
+
+/** MB of SOURCE video demuxed + decoded + re-encoded per second. */
+export const COMPRESSION_SOURCE_MB_PER_SECOND = 1.0;
+
+/** Megapixels of decoded frame data processed per second (≈ 2 s per second of 1080p). */
+export const COMPRESSION_MEGAPIXELS_PER_SECOND = 4.0;
+
+/**
+ * Deprecated per-level discount, kept at 1 (no discount).
+ *
+ * They used to model the native transcoder downscaling the frame once the quality ratio dropped
+ * under 0.6, which made a heavy level a cheaper pass. That downscale is gone — every level now
+ * re-encodes at FULL resolution so quality is protected rather than traded away
+ * (`MediaPreviewEditor.estimateCompressionSeconds` dropped its matching discount for the same
+ * reason) — so the pass costs the same at 5% as at 95% and the factor must not shorten the seed.
+ * Left in place, and exported, because they are part of this module's public surface.
+ */
+export const COMPRESSION_DOWNSCALE_QUALITY_CEILING = 60;
+export const COMPRESSION_DOWNSCALED_LEVEL_FACTOR = 1;
+
+/**
+ * Floor: below this there is no countdown worth showing, and it doubles as the allowance for the
+ * fixed codec + muxer setup that no amount of video changes.
+ */
+export const MIN_COMPRESSION_COUNTDOWN_SECONDS = 2;
+
+/** Ceiling: a very long clip shows a bounded number and finishes in "Finalizing..." if need be. */
+export const MAX_COMPRESSION_COUNTDOWN_SECONDS = 180;
+
+/**
+ * Megapixels of STILL image compressed per second, behind {@link estimateImageCompressionSeconds}.
+ *
+ * Much lower than a plain "encode one JPEG" rate because a still compression is not one encode:
+ * the native compressor decodes once and then re-encodes several times while it searches for the
+ * quality that hits the requested size.
+ */
+export const IMAGE_COMPRESSION_MEGAPIXELS_PER_SECOND = 3.0;
+
+/** Ceiling for a still: even a 100 MP source is bounded well below the video ceiling. */
+export const MAX_IMAGE_COMPRESSION_COUNTDOWN_SECONDS = 30;
+
+/** Caption shown once there is no measurable remaining time left to quote. */
+export const COMPRESSION_FINALIZING_LABEL = 'Finalizing...';
+
+/** Caption shown when there is no countdown to display (estimate unavailable). */
+export const COMPRESSION_FALLBACK_LABEL = 'Compressing...';
+
+/**
+ * The quality percentage a dropdown option asks to KEEP (5..99), or 0 for anything that is not a
+ * level (the "Original Video" / "Original Image" entries, which never start a compression).
+ */
+export const parseCompressionPercent = option => {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*%\s*$/.exec(option);
+  if (!match) return 0;
+  const percent = Number(match[1]);
+  return Number.isFinite(percent) ? percent : 0;
+};
+
+/**
+ * Durations reach this screen in milliseconds from native metadata but in seconds from some
+ * host-supplied assets, so normalise the same way the media list does: a value large enough to be
+ * an implausible number of seconds is milliseconds.
+ */
+const durationToSeconds = duration => {
+  if (!duration || duration <= 0) return 0;
+  return duration > 1000 ? duration / 1000 : duration;
+};
+/**
+ * How long compressing a clip is expected to take, in whole seconds — the value the countdown
+ * starts at, and only that: measured progress takes the figure over within the first second or so
+ * (see {@link foldCompressionProgress}).
+ *
+ * Two independent predictors are computed and the LARGER is taken, because either one alone is
+ * wrong for a whole class of clip:
+ *
+ *  - **Bytes.** The whole file is demuxed, decoded and re-encoded, so throughput measured in MB of
+ *    SOURCE per second is the most stable single predictor across devices. On its own it
+ *    under-predicts a long, low-bitrate clip (lots of frames, few bytes).
+ *  - **Pixels × frames.** Duration times megapixels per frame is what the codec actually has to
+ *    work on. On its own it under-predicts a short, very high-bitrate clip (few frames, huge
+ *    bytes).
+ *
+ * Every input must come from the ORIGINAL, so picking a second level after a first estimates
+ * against the untouched file rather than the shrunken copy. A clip with no readable metadata at
+ * all falls back to the floor rather than to zero.
+ */
+export const estimateVideoCompressionSeconds = ({
+  sizeBytes,
+  duration,
+  width,
+  height,
+  percent
+}) => {
+  const megabytes = sizeBytes && sizeBytes > 0 ? sizeBytes / (1024 * 1024) : 0;
+  const fromBytes = megabytes > 0 ? megabytes / COMPRESSION_SOURCE_MB_PER_SECOND : 0;
+  const durationSeconds = durationToSeconds(duration);
+  const megapixelsPerFrame = width && height && width > 0 && height > 0 ? width * height / 1_000_000 : 0;
+  const fromPixels = durationSeconds > 0 && megapixelsPerFrame > 0 ? durationSeconds * megapixelsPerFrame / COMPRESSION_MEGAPIXELS_PER_SECOND : 0;
+  const levelFactor = percent < COMPRESSION_DOWNSCALE_QUALITY_CEILING ? COMPRESSION_DOWNSCALED_LEVEL_FACTOR : 1;
+  const estimate = Math.max(fromBytes, fromPixels) * levelFactor;
+  return Math.min(MAX_COMPRESSION_COUNTDOWN_SECONDS, Math.max(MIN_COMPRESSION_COUNTDOWN_SECONDS, Math.ceil(estimate)));
+};
+/**
+ * How long compressing a still is expected to take, in whole seconds — the seed for its countdown.
+ *
+ * A single predictor, unlike the video estimate's two: a still has no duration and no bit rate, so
+ * the only thing that varies is how many pixels there are to decode and re-encode. The requested
+ * level does not enter into it either — the native compressor searches for the quality that hits
+ * the target, so a light level costs the same handful of encodes as a heavy one.
+ *
+ * A still with no readable dimensions falls back to the floor rather than to zero.
+ */
+export const estimateImageCompressionSeconds = ({
+  width,
+  height
+}) => {
+  const megapixels = width && height && width > 0 && height > 0 ? width * height / 1_000_000 : 0;
+  return Math.min(MAX_IMAGE_COMPRESSION_COUNTDOWN_SECONDS, Math.max(MIN_COMPRESSION_COUNTDOWN_SECONDS, Math.ceil(megapixels / IMAGE_COMPRESSION_MEGAPIXELS_PER_SECOND)));
+};
+
+/** The countdown's text for a given number of seconds remaining, e.g. `Compressing (5s left)`. */
+export const formatCompressionCountdown = (secondsLeft, t) => {
+  const seconds = Math.max(1, Math.ceil(secondsLeft));
+  const translated = t?.('compressingSecondsLeft', seconds);
+  return typeof translated === 'string' && translated.length > 0 ? translated : `Compressing (${seconds}s left)`;
+};
+
+// ── Measured progress → remaining time ──────────────────────────────────────────────────────
+// The three functions below are the whole countdown: create a tracker when the compression starts,
+// fold each native progress report into it, and read the line off it as often as you like. They
+// are pure — `now` is always passed in — so the screen owns the clock and the ticking, and the
+// model itself is trivially testable.
+
+/**
+ * Below this fraction, `elapsed / fraction` is dominated by fixed setup cost (codec configuration,
+ * the first decode) and would predict a wildly pessimistic total. Under it the prediction is
+ * blended with the up-front estimate in proportion to how far along it is, so the number is steady
+ * at the start and fully measurement-driven from here on.
+ */
+export const MIN_TRUSTED_COMPRESSION_PROGRESS = 0.08;
+
+/**
+ * At or above this the encoder has finished its frames and the pass is in its tail — flushing,
+ * muxing, reading the output back — real work with no measurable length, which the line reports as
+ * "Finalizing..." rather than quoting seconds it cannot justify.
+ */
+export const COMPRESSION_FINALIZING_PROGRESS = 0.985;
+
+/**
+ * Weight given to a freshly derived total when smoothing. Low enough that a burst of
+ * cheap-to-encode frames cannot make the figure jump, high enough that a genuinely slower job has
+ * the number corrected within a few seconds.
+ */
+export const COMPRESSION_PREDICTION_SMOOTHING = 0.4;
+
+/** How often the screen should re-read the line. Twice a second; the read is one subtraction. */
+export const COMPRESSION_COUNTDOWN_TICK_MS = 500;
+
+// ── The opening "working out how long this will take" ramp ──────────────────────────────────
+// The countdown does not appear at its full figure: it counts UP to it first, one readable step at
+// a time, and only then turns around and counts down. That opening ramp is what tells the user the
+// app is sizing the job up rather than freezing.
+//
+// It is a DISPLAY ramp — it advances on a fixed cadence of its own, never on how fast the encoder
+// happens to report. The measured prediction keeps being re-derived underneath it the whole time
+// (see {@link foldCompressionProgress}); the ramp simply decides what is shown until the two meet.
+// That separation is the point: before it, the figure was whatever the prediction happened to be
+// re-derived to, which early on moves several seconds per report and flickers through numbers far
+// too quickly to read.
+
+/**
+ * One step of the opening ramp: how long each number stays on screen while the total is being
+ * worked out. About three numbers a second — slow enough to read every one of them, quick enough
+ * that the ramp is over in a moment.
+ */
+export const COMPRESSION_CALCULATION_STEP_MS = 300;
+
+/**
+ * The most steps the ramp may take, which is what bounds it in wall-clock time
+ * (`COMPRESSION_CALCULATION_STEP_MS` × this ≈ 3 s). A long job strides in larger increments rather
+ * than taking longer to count up — the ramp must never become the wait it is describing.
+ */
+export const COMPRESSION_CALCULATION_MAX_STEPS = 10;
+
+/**
+ * And it may never spend more than this share of the predicted job counting up either, so a job
+ * that is over in two seconds does not spend most of it ramping.
+ */
+export const COMPRESSION_CALCULATION_MAX_ELAPSED_FRACTION = 0.4;
+/** A tracker for a compression starting now, seeded by its up-front [estimateSeconds]. */
+export const createCompressionProgressTracker = (estimateSeconds, nowMs) => {
+  const seconds = Math.max(1, Math.ceil(estimateSeconds));
+  // Step budget: capped both absolutely and as a share of the job, then divided into the estimate
+  // so that every step is the same size and the whole ramp is over within it.
+  const budgetMs = Math.min(COMPRESSION_CALCULATION_STEP_MS * COMPRESSION_CALCULATION_MAX_STEPS, seconds * 1000 * COMPRESSION_CALCULATION_MAX_ELAPSED_FRACTION);
+  const steps = Math.max(1, Math.floor(budgetMs / COMPRESSION_CALCULATION_STEP_MS));
+  const calculationStepSeconds = Math.max(1, Math.ceil(seconds / steps));
+  return {
+    startedAtMs: nowMs,
+    estimateSeconds: seconds,
+    progress: 0,
+    predictedTotalSeconds: seconds,
+    calculationStepSeconds,
+    calculationCeilingSeconds: calculationStepSeconds * Math.ceil(seconds / calculationStepSeconds)
+  };
+};
+
+/**
+ * Fold one measured progress report (0..1) into [tracker], re-deriving how long the whole
+ * compression will take from how long it has taken to get this far.
+ *
+ * `total = elapsed / fraction` is the entire idea: it is why the displayed figure can stretch as
+ * well as shrink, and therefore why it neither hits zero mid-compression nor lingers after the
+ * work is done. Out-of-order or repeated reports cannot walk the fraction backwards.
+ *
+ * Reports during the opening ramp are folded in exactly like any other: the ramp is a DISPLAY
+ * concern only, so nothing here has to be held back or paused for it. That is what makes the
+ * hand-over accurate — by the time the ramp meets the countdown, the figure it meets has already
+ * had every report so far folded into it.
+ */
+export const foldCompressionProgress = (tracker, progress, nowMs) => {
+  const clamped = Math.min(1, Math.max(0, progress));
+  const nextProgress = Math.max(tracker.progress, clamped);
+  const elapsedSeconds = Math.max(0, (nowMs - tracker.startedAtMs) / 1000);
+  if (nextProgress <= 0 || elapsedSeconds <= 0) {
+    return {
+      ...tracker,
+      progress: nextProgress
+    };
+  }
+  const measuredTotal = elapsedSeconds / nextProgress;
+  const trust = Math.min(1, nextProgress / MIN_TRUSTED_COMPRESSION_PROGRESS);
+  const blendedTotal = trust * measuredTotal + (1 - trust) * tracker.estimateSeconds;
+  return {
+    ...tracker,
+    progress: nextProgress,
+    predictedTotalSeconds: tracker.predictedTotalSeconds + COMPRESSION_PREDICTION_SMOOTHING * (blendedTotal - tracker.predictedTotalSeconds)
+  };
+};
+
+/** Seconds still to go by the current prediction — the figure the countdown proper reads. */
+const remainingSeconds = (tracker, nowMs) => tracker.predictedTotalSeconds - Math.max(0, (nowMs - tracker.startedAtMs) / 1000);
+/** Where the opening ramp has climbed to by [nowMs], in whole seconds. */
+const calculationValueSeconds = (tracker, nowMs) => {
+  const elapsedMs = Math.max(0, nowMs - tracker.startedAtMs);
+  const stepsTaken = Math.floor(elapsedMs / COMPRESSION_CALCULATION_STEP_MS);
+  return Math.min(tracker.calculationCeilingSeconds, tracker.calculationStepSeconds * (stepsTaken + 1));
+};
+
+/**
+ * The figure the opening ramp is showing right now, or `null` once it is over and the countdown
+ * proper owns the line.
+ *
+ * The ramp ends the moment its climbing figure REACHES the real remaining time, which is what
+ * makes the hand-over seamless: the last number it shows and the first number the countdown shows
+ * are the same one, arrived at from below. (`remaining` is falling in real time while the ramp
+ * climbs, so the two always meet — the ceiling is only a backstop for a prediction re-derived
+ * upward faster than the ramp can climb.)
+ */
+export const compressionCalculationSeconds = (tracker, nowMs) => {
+  if (tracker.calculationStepSeconds <= 0) return null;
+  const value = calculationValueSeconds(tracker, nowMs);
+  if (value >= tracker.calculationCeilingSeconds) return null;
+  if (value >= remainingSeconds(tracker, nowMs)) return null;
+  return value;
+};
+
+/**
+ * How long the screen should wait before re-reading the line.
+ *
+ * While the ramp is climbing this is the time to its NEXT step, so every number it shows gets the
+ * same {@link COMPRESSION_CALCULATION_STEP_MS} on screen — an even cadence rather than one
+ * quantised to a tick that does not divide it. Afterwards it is the ordinary countdown tick.
+ */
+export const compressionCountdownTickMs = (tracker, nowMs) => {
+  if (!tracker) return COMPRESSION_COUNTDOWN_TICK_MS;
+  if (compressionCalculationSeconds(tracker, nowMs) === null) {
+    return COMPRESSION_COUNTDOWN_TICK_MS;
+  }
+  const elapsedMs = Math.max(0, nowMs - tracker.startedAtMs);
+  return COMPRESSION_CALCULATION_STEP_MS - elapsedMs % COMPRESSION_CALCULATION_STEP_MS;
+};
+
+/**
+ * What the overlay's line should read right now.
+ *
+ * Four cases, in order:
+ *
+ *  1. **The encoder is done and the pass is in its tail** (progress at or above
+ *     {@link COMPRESSION_FINALIZING_PROGRESS}) — "Finalizing...", because flushing and muxing are
+ *     real work of unmeasurable length.
+ *  2. **The opening ramp is still climbing** — its figure, one readable step at a time, until it
+ *     meets the real remaining time (see {@link compressionCalculationSeconds}).
+ *  3. **The prediction is spent and nothing was ever measured** — "Finalizing..." as well: a
+ *     compressor that reports no progress leaves only the estimate, and counting through zero into
+ *     negative numbers would misrepresent what is happening.
+ *  4. **Otherwise** — `predicted total - elapsed`, floored at one second. The floor is reached only
+ *     within about a second of the end (it takes progress above `elapsed / (elapsed + 1)`), and
+ *     case 1 takes over from there.
+ */
+export const compressionCountdownLabel = (tracker, nowMs, t) => {
+  const finalizingLabel = () => {
+    const out = t?.('finalizingCompression');
+    return typeof out === 'string' && out.length > 0 ? out : COMPRESSION_FINALIZING_LABEL;
+  };
+  if (!tracker) {
+    const fallback = t?.('compressing');
+    return typeof fallback === 'string' && fallback.length > 0 ? fallback : COMPRESSION_FALLBACK_LABEL;
+  }
+  if (tracker.progress >= COMPRESSION_FINALIZING_PROGRESS) {
+    return finalizingLabel();
+  }
+  const calculating = compressionCalculationSeconds(tracker, nowMs);
+  if (calculating !== null) return formatCompressionCountdown(calculating, t);
+  const remaining = remainingSeconds(tracker, nowMs);
+  if (remaining < 1 && tracker.progress <= 0) return finalizingLabel();
+  return formatCompressionCountdown(Math.max(1, remaining), t);
+};
+
+// ── The level ladder and the sizes its rows quote ───────────────────────────────────────────
+// The rows the viewer's compression sheet lists, and the size band each of them promises. Both are
+// the native editor's own (MediaPreviewEditor.estimatedCompressedSize / proportionalTargetRange /
+// ImageExporter.estimateCompressedByteRange), reproduced here so the shell's sheet and the native
+// editor quote the SAME figures for the same file at the same level.
+
+/**
+ * The QUALITY levels the sheet offers, highest quality first — the percentage of the original to
+ * KEEP, which is exactly what the bridge takes (`compressVideo(uri, '45%')`). So the number a row
+ * displays is the number handed to the encoder: no inversion anywhere between the two.
+ *
+ * The native editor's ladder is the same rungs expressed the other way round (percent to SHAVE), so
+ * `95%` quality here is its `5% smaller` row and `5%` quality here is its `95% smaller` row.
+ */
+export const COMPRESSION_QUALITY_LEVELS = [95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5];
+
+/**
+ * How far under its ceiling a compression routinely lands, which is the bottom of every quoted band
+ * — for stills because the encoder's size search stops at the highest quality at or under the
+ * target (quality quantisation, a profile pre-cap, a fallback when the target is out of reach), and
+ * for clips because the same fraction is used so a video band and an image band open by the same
+ * amount. Shared verbatim with `ImageExporter.ESTIMATE_SIZE_UNDERSHOOT`.
+ */
+export const ESTIMATE_SIZE_UNDERSHOOT = 0.85;
+
+/**
+ * The quality floor, mirrored from `VideoRotationTranscoder.MIN_BITS_PER_PIXEL_AVC` — the fewest
+ * bits per pixel per frame the native encoder will spend on a full-size frame, however heavy the
+ * level asked for. Kotlin is the source of truth for the value; this copy exists so the sheet does
+ * not quote a size the pipeline deliberately refuses to produce.
+ *
+ * AVC's figure rather than HEVC's on purpose: it is the HIGHER of the two, and the shell cannot know
+ * which codec the device will pick, so assuming AVC keeps every quoted row at or above what will
+ * actually be written. A row that promises slightly less reduction than it delivers is a pleasant
+ * surprise; the other way round is a broken promise.
+ */
+export const MIN_BITS_PER_PIXEL_AVC = 0.065;
+
+/**
+ * How far the floor may push into the clip's own rate, mirroring
+ * `VideoRotationTranscoder.MAX_FLOOR_SOURCE_SHARE`. A clip that already sits below the floor is
+ * honestly cheap rather than under-encoded, so the floor gives way to half its own average rate:
+ * every clip can always be made about twice as small, and past that the picture is protected.
+ */
+export const MAX_FLOOR_SOURCE_SHARE = 0.5;
+
+/**
+ * Frames per second assumed when quoting the floor. The shell has no access to a clip's real frame
+ * rate (nothing on a `CameraAsset` carries it), and 30 is both the overwhelmingly common capture
+ * rate and native's own fallback (`VideoRotationTranscoder.DEFAULT_FRAME_RATE`).
+ */
+export const ASSUMED_VIDEO_FRAME_RATE = 30;
+
+/** The clip facts the quality floor is measured from. All optional: missing any of them drops it. */
+
+/**
+ * The smallest size a full-resolution re-encode of [frame] can honestly come out at, or 0 when the
+ * clip does not describe itself well enough to say.
+ *
+ * `bits-per-pixel × pixels × fps × duration`, capped at {@link MAX_FLOOR_SOURCE_SHARE} of the file's
+ * own average rate. An APPROXIMATION of native's figure rather than a byte-identical copy of it: the
+ * shell cannot read the track's frame rate, nor the split between the video track and the audio the
+ * transcoder copies through untouched. It is close enough for the one job it has — keeping a row from
+ * quoting a reduction the encoder will not perform.
+ */
+const qualityFloorBytes = (originalBytes, frame) => {
+  const width = frame?.width ?? 0;
+  const height = frame?.height ?? 0;
+  const seconds = durationToSeconds(frame?.duration);
+  if (width <= 0 || height <= 0 || seconds <= 0) return 0;
+  const floorBits = MIN_BITS_PER_PIXEL_AVC * width * height * ASSUMED_VIDEO_FRAME_RATE * seconds;
+  const floor = Math.floor(floorBits / 8);
+  if (floor <= 0) return 0;
+  return Math.min(floor, Math.floor(originalBytes * MAX_FLOOR_SOURCE_SHARE));
+};
+
+/** A quoted output-size band: [low]..[high], the pair a level row shows as "1.8 – 2.1 MB". */
+
+/**
+ * The CEILING a compression at [qualityPercent] is aiming at: [originalBytes] with the shaved share
+ * removed. The single figure a compressed clip is quoted at afterwards, and the top of the band a
+ * row promises beforehand.
+ *
+ * `shave = 100 - qualityPercent`, pinned to the same range the encoder pins it to — 1..99 for a
+ * clip, 1..95 for a still (`ImageExporter.compress`'s own clamp) — and the arithmetic is integer
+ * truncating, exactly as native's is, so the two agree to the byte.
+ *
+ * For a CLIP the result is then raised to the quality floor when [frame] describes the video well
+ * enough to measure one (see {@link qualityFloorBytes}): the native encoder will not take a
+ * full-size frame below that rate, so the heavy rungs all land on the same size and a row that went
+ * on quoting `1% of the original` would be promising a file that is never written. Omit [frame] and
+ * the figure stays purely proportional, as it was before the floor existed.
+ */
+export const compressedCeilingBytes = (originalBytes, qualityPercent, kind, frame) => {
+  if (!originalBytes || originalBytes <= 0) return 0;
+  const maxShave = kind === 'video' ? 99 : 95;
+  const shave = Math.min(maxShave, Math.max(1, Math.round(100 - qualityPercent)));
+  const proportional = Math.max(1, Math.floor(originalBytes * (100 - shave) / 100));
+  if (kind !== 'video') return proportional;
+  // Never above the original: a "compressed" row may not read as growth.
+  const floor = Math.min(originalBytes, qualityFloorBytes(originalBytes, frame));
+  return Math.max(proportional, floor);
+};
+
+/**
+ * The band of output sizes a compression at [qualityPercent] is expected to land in, or null when
+ * [originalBytes] is unknown — which drops the size from the row rather than inventing one.
+ *
+ * The top is {@link compressedCeilingBytes}; the bottom is that ceiling scaled by
+ * {@link ESTIMATE_SIZE_UNDERSHOOT}. Both media kinds share the shape deliberately: a still's band is
+ * the encoder's own target arithmetic, and a clip's is the display convention the native menu uses
+ * so a video row and an image row read alike at every rung. [frame] is the clip's own geometry and
+ * duration, which is what lets a video band respect the encoder's quality floor.
+ */
+export const compressedSizeBand = (originalBytes, qualityPercent, kind, frame) => {
+  const ceiling = compressedCeilingBytes(originalBytes, qualityPercent, kind, frame);
+  if (ceiling <= 0) return null;
+  const low = Math.min(ceiling, Math.max(1, Math.round(ceiling * ESTIMATE_SIZE_UNDERSHOOT)));
+  return {
+    low,
+    high: ceiling
+  };
+};
+
+/**
+ * The option string the bridge is called with for a quality level — the level itself, as a
+ * percentage. `compressVideo(uri, '45%')` keeps 45% of the quality.
+ */
+export const compressionOptionForQuality = qualityPercent => `${Math.round(qualityPercent)}%`;
+
+/**
+ * The sentinel option for "leave it alone". Native resolves any option starting with `Original`
+ * straight back to the input URI (quality ratio 1.0), and {@link parseCompressionPercent} reads it
+ * as 0, so it never starts a compression on either side. Never displayed — the row's label comes
+ * from the localized `originalVideo` / `originalImage` keys.
+ */
+export const originalCompressionOption = kind => kind === 'video' ? 'Original Video' : 'Original Image';
+
+/** True for the {@link originalCompressionOption} sentinels — the rows that compress nothing. */
+export const isOriginalCompressionOption = option => /^\s*Original\b/i.test(option);
+
+/**
+ * How much smaller a finished compression came out, as a whole percentage of the original — the
+ * `{1}` of the `compressedToSize` line. Returns null when there is nothing honest to claim (either
+ * size unknown, or an output that did not actually shrink), and the caller falls back to
+ * `compressedToSizeOnly`.
+ */
+export const compressionSavingPercent = (originalBytes, compressedBytes) => {
+  if (!originalBytes || originalBytes <= 0) return null;
+  if (!compressedBytes || compressedBytes <= 0) return null;
+  if (compressedBytes >= originalBytes) return null;
+  const saved = Math.round((1 - compressedBytes / originalBytes) * 100);
+  return saved >= 1 ? saved : null;
+};
+//# sourceMappingURL=compressionEstimate.js.map

package/lib/module/library/compressionEstimate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["COMPRESSION_SOURCE_MB_PER_SECOND","COMPRESSION_MEGAPIXELS_PER_SECOND","COMPRESSION_DOWNSCALE_QUALITY_CEILING","COMPRESSION_DOWNSCALED_LEVEL_FACTOR","MIN_COMPRESSION_COUNTDOWN_SECONDS","MAX_COMPRESSION_COUNTDOWN_SECONDS","IMAGE_COMPRESSION_MEGAPIXELS_PER_SECOND","MAX_IMAGE_COMPRESSION_COUNTDOWN_SECONDS","COMPRESSION_FINALIZING_LABEL","COMPRESSION_FALLBACK_LABEL","parseCompressionPercent","option","match","exec","percent","Number","isFinite","durationToSeconds","duration","estimateVideoCompressionSeconds","sizeBytes","width","height","megabytes","fromBytes","durationSeconds","megapixelsPerFrame","fromPixels","levelFactor","estimate","Math","max","min","ceil","estimateImageCompressionSeconds","megapixels","formatCompressionCountdown","secondsLeft","t","seconds","translated","length","MIN_TRUSTED_COMPRESSION_PROGRESS","COMPRESSION_FINALIZING_PROGRESS","COMPRESSION_PREDICTION_SMOOTHING","COMPRESSION_COUNTDOWN_TICK_MS","COMPRESSION_CALCULATION_STEP_MS","COMPRESSION_CALCULATION_MAX_STEPS","COMPRESSION_CALCULATION_MAX_ELAPSED_FRACTION","createCompressionProgressTracker","estimateSeconds","nowMs","budgetMs","steps","floor","calculationStepSeconds","startedAtMs","progress","predictedTotalSeconds","calculationCeilingSeconds","foldCompressionProgress","tracker","clamped","nextProgress","elapsedSeconds","measuredTotal","trust","blendedTotal","remainingSeconds","calculationValueSeconds","elapsedMs","stepsTaken","compressionCalculationSeconds","value","compressionCountdownTickMs","compressionCountdownLabel","finalizingLabel","out","fallback","calculating","remaining","COMPRESSION_QUALITY_LEVELS","ESTIMATE_SIZE_UNDERSHOOT","MIN_BITS_PER_PIXEL_AVC","MAX_FLOOR_SOURCE_SHARE","ASSUMED_VIDEO_FRAME_RATE","qualityFloorBytes","originalBytes","frame","floorBits","compressedCeilingBytes","qualityPercent","kind","maxShave","shave","round","proportional","compressedSizeBand","ceiling","low","high","compressionOptionForQuality","originalCompressionOption","isOriginalCompressionOption","test","compressionSavingPercent","compressedBytes","saved"],"sourceRoot":"..\\..\\..\\src","sources":["library/compressionEstimate.ts"],"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;;AAIA;AACA,OAAO,MAAMA,gCAAgC,GAAG,GAAG;;AAEnD;AACA,OAAO,MAAMC,iCAAiC,GAAG,GAAG;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,qCAAqC,GAAG,EAAE;AACvD,OAAO,MAAMC,mCAAmC,GAAG,CAAC;;AAEpD;AACA;AACA;AACA;AACA,OAAO,MAAMC,iCAAiC,GAAG,CAAC;;AAElD;AACA,OAAO,MAAMC,iCAAiC,GAAG,GAAG;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,uCAAuC,GAAG,GAAG;;AAE1D;AACA,OAAO,MAAMC,uCAAuC,GAAG,EAAE;;AAEzD;AACA,OAAO,MAAMC,4BAA4B,GAAG,eAAe;;AAE3D;AACA,OAAO,MAAMC,0BAA0B,GAAG,gBAAgB;;AAE1D;AACA;AACA;AACA;AACA,OAAO,MAAMC,uBAAuB,GAAIC,MAAc,IAAa;EACjE,MAAMC,KAAK,GAAG,6BAA6B,CAACC,IAAI,CAACF,MAAM,CAAC;EACxD,IAAI,CAACC,KAAK,EAAE,OAAO,CAAC;EACpB,MAAME,OAAO,GAAGC,MAAM,CAACH,KAAK,CAAC,CAAC,CAAC,CAAC;EAChC,OAAOG,MAAM,CAACC,QAAQ,CAACF,OAAO,CAAC,GAAGA,OAAO,GAAG,CAAC;AAC/C,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,MAAMG,iBAAiB,GAAIC,QAAiB,IAAa;EACvD,IAAI,CAACA,QAAQ,IAAIA,QAAQ,IAAI,CAAC,EAAE,OAAO,CAAC;EACxC,OAAOA,QAAQ,GAAG,IAAI,GAAGA,QAAQ,GAAG,IAAI,GAAGA,QAAQ;AACrD,CAAC;AAcD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,+BAA+B,GAAGA,CAAC;EAC9CC,SAAS;EACTF,QAAQ;EACRG,KAAK;EACLC,MAAM;EACNR;AAC6B,CAAC,KAAa;EAC3C,MAAMS,SAAS,GAAGH,SAAS,IAAIA,SAAS,GAAG,CAAC,GAAGA,SAAS,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC;EAC5E,MAAMI,SAAS,GACbD,SAAS,GAAG,CAAC,GAAGA,SAAS,GAAGvB,gCAAgC,GAAG,CAAC;EAElE,MAAMyB,eAAe,GAAGR,iBAAiB,CAACC,QAAQ,CAAC;EACnD,MAAMQ,kBAAkB,GACtBL,KAAK,IAAIC,MAAM,IAAID,KAAK,GAAG,CAAC,IAAIC,MAAM,GAAG,CAAC,GACrCD,KAAK,GAAGC,MAAM,GAAI,SAAS,GAC5B,CAAC;EACP,MAAMK,UAAU,GACdF,eAAe,GAAG,CAAC,IAAIC,kBAAkB,GAAG,CAAC,GACxCD,eAAe,GAAGC,kBAAkB,GAAIzB,iCAAiC,GAC1E,CAAC;EAEP,MAAM2B,WAAW,GACfd,OAAO,GAAGZ,qCAAqC,GAC3CC,mCAAmC,GACnC,CAAC;EACP,MAAM0B,QAAQ,GAAGC,IAAI,CAACC,GAAG,CAACP,SAAS,EAAEG,UAAU,CAAC,GAAGC,WAAW;EAE9D,OAAOE,IAAI,CAACE,GAAG,CACb3B,iCAAiC,EACjCyB,IAAI,CAACC,GAAG,CAAC3B,iCAAiC,EAAE0B,IAAI,CAACG,IAAI,CAACJ,QAAQ,CAAC,CACjE,CAAC;AACH,CAAC;AAQD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMK,+BAA+B,GAAGA,CAAC;EAC9Cb,KAAK;EACLC;AAC6B,CAAC,KAAa;EAC3C,MAAMa,UAAU,GACdd,KAAK,IAAIC,MAAM,IAAID,KAAK,GAAG,CAAC,IAAIC,MAAM,GAAG,CAAC,GACrCD,KAAK,GAAGC,MAAM,GAAI,SAAS,GAC5B,CAAC;EACP,OAAOQ,IAAI,CAACE,GAAG,CACbzB,uCAAuC,EACvCuB,IAAI,CAACC,GAAG,CACN3B,iCAAiC,EACjC0B,IAAI,CAACG,IAAI,CAACE,UAAU,GAAG7B,uCAAuC,CAChE,CACF,CAAC;AACH,CAAC;;AAED;AACA,OAAO,MAAM8B,0BAA0B,GAAGA,CACxCC,WAAmB,EACnBC,CAA6B,KAClB;EACX,MAAMC,OAAO,GAAGT,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACG,IAAI,CAACI,WAAW,CAAC,CAAC;EACnD,MAAMG,UAAU,GAAGF,CAAC,GAAG,wBAAwB,EAAEC,OAAO,CAAC;EACzD,OAAO,OAAOC,UAAU,KAAK,QAAQ,IAAIA,UAAU,CAACC,MAAM,GAAG,CAAC,GAC1DD,UAAU,GACV,gBAAgBD,OAAO,SAAS;AACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,gCAAgC,GAAG,IAAI;;AAEpD;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,+BAA+B,GAAG,KAAK;;AAEpD;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,gCAAgC,GAAG,GAAG;;AAEnD;AACA,OAAO,MAAMC,6BAA6B,GAAG,GAAG;;AAEhD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,+BAA+B,GAAG,GAAG;;AAElD;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,iCAAiC,GAAG,EAAE;;AAEnD;AACA;AACA;AACA;AACA,OAAO,MAAMC,4CAA4C,GAAG,GAAG;AA6B/D;AACA,OAAO,MAAMC,gCAAgC,GAAGA,CAC9CC,eAAuB,EACvBC,KAAa,KACkB;EAC/B,MAAMZ,OAAO,GAAGT,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACG,IAAI,CAACiB,eAAe,CAAC,CAAC;EACvD;EACA;EACA,MAAME,QAAQ,GAAGtB,IAAI,CAACE,GAAG,CACvBc,+BAA+B,GAAGC,iCAAiC,EACnER,OAAO,GAAG,IAAI,GAAGS,4CACnB,CAAC;EACD,MAAMK,KAAK,GAAGvB,IAAI,CAACC,GAAG,CACpB,CAAC,EACDD,IAAI,CAACwB,KAAK,CAACF,QAAQ,GAAGN,+BAA+B,CACvD,CAAC;EACD,MAAMS,sBAAsB,GAAGzB,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACG,IAAI,CAACM,OAAO,GAAGc,KAAK,CAAC,CAAC;EACtE,OAAO;IACLG,WAAW,EAAEL,KAAK;IAClBD,eAAe,EAAEX,OAAO;IACxBkB,QAAQ,EAAE,CAAC;IACXC,qBAAqB,EAAEnB,OAAO;IAC9BgB,sBAAsB;IACtBI,yBAAyB,EACvBJ,sBAAsB,GAAGzB,IAAI,CAACG,IAAI,CAACM,OAAO,GAAGgB,sBAAsB;EACvE,CAAC;AACH,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMK,uBAAuB,GAAGA,CACrCC,OAAmC,EACnCJ,QAAgB,EAChBN,KAAa,KACkB;EAC/B,MAAMW,OAAO,GAAGhC,IAAI,CAACE,GAAG,CAAC,CAAC,EAAEF,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE0B,QAAQ,CAAC,CAAC;EAClD,MAAMM,YAAY,GAAGjC,IAAI,CAACC,GAAG,CAAC8B,OAAO,CAACJ,QAAQ,EAAEK,OAAO,CAAC;EAExD,MAAME,cAAc,GAAGlC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE,CAACoB,KAAK,GAAGU,OAAO,CAACL,WAAW,IAAI,IAAI,CAAC;EACxE,IAAIO,YAAY,IAAI,CAAC,IAAIC,cAAc,IAAI,CAAC,EAAE;IAC5C,OAAO;MAAE,GAAGH,OAAO;MAAEJ,QAAQ,EAAEM;IAAa,CAAC;EAC/C;EAEA,MAAME,aAAa,GAAGD,cAAc,GAAGD,YAAY;EACnD,MAAMG,KAAK,GAAGpC,IAAI,CAACE,GAAG,CAAC,CAAC,EAAE+B,YAAY,GAAGrB,gCAAgC,CAAC;EAC1E,MAAMyB,YAAY,GAChBD,KAAK,GAAGD,aAAa,GAAG,CAAC,CAAC,GAAGC,KAAK,IAAIL,OAAO,CAACX,eAAe;EAC/D,OAAO;IACL,GAAGW,OAAO;IACVJ,QAAQ,EAAEM,YAAY;IACtBL,qBAAqB,EACnBG,OAAO,CAACH,qBAAqB,GAC7Bd,gCAAgC,IAC7BuB,YAAY,GAAGN,OAAO,CAACH,qBAAqB;EACnD,CAAC;AACH,CAAC;;AAED;AACA,MAAMU,gBAAgB,GAAGA,CACvBP,OAAmC,EACnCV,KAAa,KAEbU,OAAO,CAACH,qBAAqB,GAC7B5B,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE,CAACoB,KAAK,GAAGU,OAAO,CAACL,WAAW,IAAI,IAAI,CAAC;AACnD;AACA,MAAMa,uBAAuB,GAAGA,CAC9BR,OAAmC,EACnCV,KAAa,KACF;EACX,MAAMmB,SAAS,GAAGxC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEoB,KAAK,GAAGU,OAAO,CAACL,WAAW,CAAC;EAC1D,MAAMe,UAAU,GAAGzC,IAAI,CAACwB,KAAK,CAACgB,SAAS,GAAGxB,+BAA+B,CAAC;EAC1E,OAAOhB,IAAI,CAACE,GAAG,CACb6B,OAAO,CAACF,yBAAyB,EACjCE,OAAO,CAACN,sBAAsB,IAAIgB,UAAU,GAAG,CAAC,CAClD,CAAC;AACH,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,6BAA6B,GAAGA,CAC3CX,OAAmC,EACnCV,KAAa,KACK;EAClB,IAAIU,OAAO,CAACN,sBAAsB,IAAI,CAAC,EAAE,OAAO,IAAI;EACpD,MAAMkB,KAAK,GAAGJ,uBAAuB,CAACR,OAAO,EAAEV,KAAK,CAAC;EACrD,IAAIsB,KAAK,IAAIZ,OAAO,CAACF,yBAAyB,EAAE,OAAO,IAAI;EAC3D,IAAIc,KAAK,IAAIL,gBAAgB,CAACP,OAAO,EAAEV,KAAK,CAAC,EAAE,OAAO,IAAI;EAC1D,OAAOsB,KAAK;AACd,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,0BAA0B,GAAGA,CACxCb,OAA0C,EAC1CV,KAAa,KACF;EACX,IAAI,CAACU,OAAO,EAAE,OAAOhB,6BAA6B;EAClD,IAAI2B,6BAA6B,CAACX,OAAO,EAAEV,KAAK,CAAC,KAAK,IAAI,EAAE;IAC1D,OAAON,6BAA6B;EACtC;EACA,MAAMyB,SAAS,GAAGxC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEoB,KAAK,GAAGU,OAAO,CAACL,WAAW,CAAC;EAC1D,OACEV,+BAA+B,GAC9BwB,SAAS,GAAGxB,+BAAgC;AAEjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAM6B,yBAAyB,GAAGA,CACvCd,OAA0C,EAC1CV,KAAa,EACbb,CAA6B,KAClB;EACX,MAAMsC,eAAe,GAAGA,CAAA,KAAM;IAC5B,MAAMC,GAAG,GAAGvC,CAAC,GAAG,uBAAuB,CAAC;IACxC,OAAO,OAAOuC,GAAG,KAAK,QAAQ,IAAIA,GAAG,CAACpC,MAAM,GAAG,CAAC,GAC5CoC,GAAG,GACHrE,4BAA4B;EAClC,CAAC;EACD,IAAI,CAACqD,OAAO,EAAE;IACZ,MAAMiB,QAAQ,GAAGxC,CAAC,GAAG,aAAa,CAAC;IACnC,OAAO,OAAOwC,QAAQ,KAAK,QAAQ,IAAIA,QAAQ,CAACrC,MAAM,GAAG,CAAC,GACtDqC,QAAQ,GACRrE,0BAA0B;EAChC;EACA,IAAIoD,OAAO,CAACJ,QAAQ,IAAId,+BAA+B,EAAE;IACvD,OAAOiC,eAAe,CAAC,CAAC;EAC1B;EACA,MAAMG,WAAW,GAAGP,6BAA6B,CAACX,OAAO,EAAEV,KAAK,CAAC;EACjE,IAAI4B,WAAW,KAAK,IAAI,EAAE,OAAO3C,0BAA0B,CAAC2C,WAAW,EAAEzC,CAAC,CAAC;EAC3E,MAAM0C,SAAS,GAAGZ,gBAAgB,CAACP,OAAO,EAAEV,KAAK,CAAC;EAClD,IAAI6B,SAAS,GAAG,CAAC,IAAInB,OAAO,CAACJ,QAAQ,IAAI,CAAC,EAAE,OAAOmB,eAAe,CAAC,CAAC;EACpE,OAAOxC,0BAA0B,CAACN,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEiD,SAAS,CAAC,EAAE1C,CAAC,CAAC;AAC9D,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAM2C,0BAA6C,GAAG,CAC3D,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAC1E;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,wBAAwB,GAAG,IAAI;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAG,KAAK;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAG,GAAG;;AAEzC;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,wBAAwB,GAAG,EAAE;;AAE1C;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,iBAAiB,GAAGA,CACxBC,aAAqB,EACrBC,KAA2B,KAChB;EACX,MAAMnE,KAAK,GAAGmE,KAAK,EAAEnE,KAAK,IAAI,CAAC;EAC/B,MAAMC,MAAM,GAAGkE,KAAK,EAAElE,MAAM,IAAI,CAAC;EACjC,MAAMiB,OAAO,GAAGtB,iBAAiB,CAACuE,KAAK,EAAEtE,QAAQ,CAAC;EAClD,IAAIG,KAAK,IAAI,CAAC,IAAIC,MAAM,IAAI,CAAC,IAAIiB,OAAO,IAAI,CAAC,EAAE,OAAO,CAAC;EACvD,MAAMkD,SAAS,GACbN,sBAAsB,GAAG9D,KAAK,GAAGC,MAAM,GAAG+D,wBAAwB,GAAG9C,OAAO;EAC9E,MAAMe,KAAK,GAAGxB,IAAI,CAACwB,KAAK,CAACmC,SAAS,GAAG,CAAC,CAAC;EACvC,IAAInC,KAAK,IAAI,CAAC,EAAE,OAAO,CAAC;EACxB,OAAOxB,IAAI,CAACE,GAAG,CAACsB,KAAK,EAAExB,IAAI,CAACwB,KAAK,CAACiC,aAAa,GAAGH,sBAAsB,CAAC,CAAC;AAC5E,CAAC;;AAED;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMM,sBAAsB,GAAGA,CACpCH,aAAqB,EACrBI,cAAsB,EACtBC,IAAuB,EACvBJ,KAA2B,KAChB;EACX,IAAI,CAACD,aAAa,IAAIA,aAAa,IAAI,CAAC,EAAE,OAAO,CAAC;EAClD,MAAMM,QAAQ,GAAGD,IAAI,KAAK,OAAO,GAAG,EAAE,GAAG,EAAE;EAC3C,MAAME,KAAK,GAAGhE,IAAI,CAACE,GAAG,CAAC6D,QAAQ,EAAE/D,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACiE,KAAK,CAAC,GAAG,GAAGJ,cAAc,CAAC,CAAC,CAAC;EAC/E,MAAMK,YAAY,GAAGlE,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACwB,KAAK,CAAEiC,aAAa,IAAI,GAAG,GAAGO,KAAK,CAAC,GAAI,GAAG,CAAC,CAAC;EACnF,IAAIF,IAAI,KAAK,OAAO,EAAE,OAAOI,YAAY;EACzC;EACA,MAAM1C,KAAK,GAAGxB,IAAI,CAACE,GAAG,CAACuD,aAAa,EAAED,iBAAiB,CAACC,aAAa,EAAEC,KAAK,CAAC,CAAC;EAC9E,OAAO1D,IAAI,CAACC,GAAG,CAACiE,YAAY,EAAE1C,KAAK,CAAC;AACtC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAM2C,kBAAkB,GAAGA,CAChCV,aAAqB,EACrBI,cAAsB,EACtBC,IAAuB,EACvBJ,KAA2B,KACG;EAC9B,MAAMU,OAAO,GAAGR,sBAAsB,CAACH,aAAa,EAAEI,cAAc,EAAEC,IAAI,EAAEJ,KAAK,CAAC;EAClF,IAAIU,OAAO,IAAI,CAAC,EAAE,OAAO,IAAI;EAC7B,MAAMC,GAAG,GAAGrE,IAAI,CAACE,GAAG,CAClBkE,OAAO,EACPpE,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACiE,KAAK,CAACG,OAAO,GAAGhB,wBAAwB,CAAC,CAC5D,CAAC;EACD,OAAO;IAAEiB,GAAG;IAAEC,IAAI,EAAEF;EAAQ,CAAC;AAC/B,CAAC;;AAED;AACA;AACA;AACA;AACA,OAAO,MAAMG,2BAA2B,GAAIV,cAAsB,IAChE,GAAG7D,IAAI,CAACiE,KAAK,CAACJ,cAAc,CAAC,GAAG;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMW,yBAAyB,GAAIV,IAAuB,IAC/DA,IAAI,KAAK,OAAO,GAAG,gBAAgB,GAAG,gBAAgB;;AAExD;AACA,OAAO,MAAMW,2BAA2B,GAAI5F,MAAc,IACxD,iBAAiB,CAAC6F,IAAI,CAAC7F,MAAM,CAAC;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAM8F,wBAAwB,GAAGA,CACtClB,aAAqB,EACrBmB,eAAuB,KACL;EAClB,IAAI,CAACnB,aAAa,IAAIA,aAAa,IAAI,CAAC,EAAE,OAAO,IAAI;EACrD,IAAI,CAACmB,eAAe,IAAIA,eAAe,IAAI,CAAC,EAAE,OAAO,IAAI;EACzD,IAAIA,eAAe,IAAInB,aAAa,EAAE,OAAO,IAAI;EACjD,MAAMoB,KAAK,GAAG7E,IAAI,CAACiE,KAAK,CAAC,CAAC,CAAC,GAAGW,eAAe,GAAGnB,aAAa,IAAI,GAAG,CAAC;EACrE,OAAOoB,KAAK,IAAI,CAAC,GAAGA,KAAK,GAAG,IAAI;AAClC,CAAC","ignoreList":[]}