tempest-react-sdk 0.11.0 → 0.12.0

package/dist/vision.js

@@ -0,0 +1,1416 @@
+import * as H from "onnxruntime-web";
+class R extends Error {
+  constructor(t, e) {
+    super(t, e), this.name = new.target.name;
+  }
+}
+class Ft extends R {
+}
+class lt extends R {
+}
+class Wt extends R {
+}
+class $ extends R {
+}
+class J extends R {
+}
+class L {
+  constructor(t, e, s) {
+    if (this.data = t, this.width = e, this.height = s, t.length !== e * s * 3)
+      throw new $(
+        `RGBImage data length ${t.length} does not match width * height * 3 = ${e * s * 3}.`
+      );
+  }
+  data;
+  width;
+  height;
+}
+class gt {
+  constructor(t, e, s, n) {
+    this.x1 = t, this.y1 = e, this.x2 = s, this.y2 = n;
+  }
+  x1;
+  y1;
+  x2;
+  y2;
+  /** Box width in pixels (clamped to non-negative). */
+  get width() {
+    return Math.max(0, this.x2 - this.x1);
+  }
+  /** Box height in pixels (clamped to non-negative). */
+  get height() {
+    return Math.max(0, this.y2 - this.y1);
+  }
+  /** Box area in pixels squared. */
+  get area() {
+    return this.width * this.height;
+  }
+  /** The box as `[x1, y1, x2, y2]` in absolute pixels (Ultralytics-style). */
+  get xyxy() {
+    return [this.x1, this.y1, this.x2, this.y2];
+  }
+  /**
+   * The box as `[cx, cy, w, h]` with `(cx, cy)` at the center.
+   *
+   * Matches Ultralytics' `boxes.xywh` and YOLO's native head format. For the
+   * top-left `[x, y, w, h]` convention, use {@link asXywh}.
+   */
+  get xywh() {
+    return [(this.x1 + this.x2) / 2, (this.y1 + this.y2) / 2, this.width, this.height];
+  }
+  /**
+   * The box as `[x1, y1, x2, y2]` normalized to `[0, 1]`.
+   *
+   * @param origShape `[height, width]` of the source image, in pixels.
+   */
+  xyxyn(t) {
+    const [e, s] = t;
+    return s <= 0 || e <= 0 ? [0, 0, 0, 0] : [this.x1 / s, this.y1 / e, this.x2 / s, this.y2 / e];
+  }
+  /**
+   * The box as `[cx, cy, w, h]` normalized to `[0, 1]`.
+   *
+   * @param origShape `[height, width]` of the source image, in pixels.
+   */
+  xywhn(t) {
+    const [e, s] = t;
+    if (s <= 0 || e <= 0) return [0, 0, 0, 0];
+    const [n, r, a, i] = this.xywh;
+    return [n / s, r / e, a / s, i / e];
+  }
+  /** Returns `[x1, y1, x2, y2]`. */
+  asXyxy() {
+    return [this.x1, this.y1, this.x2, this.y2];
+  }
+  /**
+   * Returns `[x, y, width, height]` with `(x, y)` at the **top-left**.
+   *
+   * Note: this is the top-left convention. Ultralytics' `xywh` getter uses
+   * **center** coordinates — for that, read {@link xywh}.
+   */
+  asXywh() {
+    return [this.x1, this.y1, this.width, this.height];
+  }
+  /** Returns `[x1, y1, x2, y2]` truncated to integers, useful for slicing arrays. */
+  asIntXyxy() {
+    return [Math.trunc(this.x1), Math.trunc(this.y1), Math.trunc(this.x2), Math.trunc(this.y2)];
+  }
+}
+class B {
+  constructor(t, e, s) {
+    if (this.data = t, this.width = e, this.height = s, t.length !== e * s)
+      throw new $(
+        `Mask data length ${t.length} does not match width * height = ${e * s}.`
+      );
+  }
+  data;
+  width;
+  height;
+}
+class xt {
+  /**
+   * @param xyxy Flat array of length `4 * N` in `[x1, y1, x2, y2, ...]` order.
+   * @param cls One class index per box, length `N`.
+   * @param conf One confidence per box, length `N`.
+   * @param origShape `[height, width]` of the original image.
+   */
+  constructor(t, e, s, n) {
+    this.xyxy = t, this.cls = e, this.conf = s, this.origShape = n;
+  }
+  xyxy;
+  cls;
+  conf;
+  origShape;
+  /** Number of detected boxes. */
+  get length() {
+    return this.cls.length;
+  }
+  /** `[N, 4]` shape of the `xyxy` view. */
+  get shape() {
+    return [this.length, 4];
+  }
+  /** Boxes as `[N, 4]` `[cx, cy, w, h]` flat array in absolute pixels. */
+  get xywh() {
+    const t = new Float32Array(this.xyxy.length);
+    for (let e = 0; e < this.length; e++) {
+      const s = this.xyxy[e * 4], n = this.xyxy[e * 4 + 1], r = this.xyxy[e * 4 + 2], a = this.xyxy[e * 4 + 3];
+      t[e * 4] = (s + r) / 2, t[e * 4 + 1] = (n + a) / 2, t[e * 4 + 2] = r - s, t[e * 4 + 3] = a - n;
+    }
+    return t;
+  }
+  /** Boxes as `[N, 4]` `[x1, y1, x2, y2]` normalized to `[0, 1]`. */
+  get xyxyn() {
+    const [t, e] = this.origShape, s = new Float32Array(this.xyxy.length);
+    if (this.length === 0 || e <= 0 || t <= 0) return s;
+    for (let n = 0; n < this.length; n++)
+      s[n * 4] = this.xyxy[n * 4] / e, s[n * 4 + 1] = this.xyxy[n * 4 + 1] / t, s[n * 4 + 2] = this.xyxy[n * 4 + 2] / e, s[n * 4 + 3] = this.xyxy[n * 4 + 3] / t;
+    return s;
+  }
+  /** Boxes as `[N, 4]` `[cx, cy, w, h]` normalized to `[0, 1]`. */
+  get xywhn() {
+    const t = this.xywh, [e, s] = this.origShape;
+    if (this.length === 0 || s <= 0 || e <= 0) return t;
+    for (let n = 0; n < this.length; n++)
+      t[n * 4] = t[n * 4] / s, t[n * 4 + 1] = t[n * 4 + 1] / e, t[n * 4 + 2] = t[n * 4 + 2] / s, t[n * 4 + 3] = t[n * 4 + 3] / e;
+    return t;
+  }
+  /**
+   * Concatenated `[N, 6]` array of `[x1, y1, x2, y2, conf, cls]`.
+   *
+   * Matches Ultralytics' `boxes.data`.
+   */
+  get data() {
+    const t = new Float32Array(this.length * 6);
+    for (let e = 0; e < this.length; e++)
+      t[e * 6] = this.xyxy[e * 4], t[e * 6 + 1] = this.xyxy[e * 4 + 1], t[e * 6 + 2] = this.xyxy[e * 4 + 2], t[e * 6 + 3] = this.xyxy[e * 4 + 3], t[e * 6 + 4] = this.conf[e], t[e * 6 + 5] = this.cls[e];
+    return t;
+  }
+}
+class Nt {
+  /** @param data `[numClasses]` per-class probabilities, indexed by class id. */
+  constructor(t) {
+    this.data = t;
+  }
+  data;
+  /** Number of classes. */
+  get length() {
+    return this.data.length;
+  }
+  /** `[numClasses]` shape of the underlying vector. */
+  get shape() {
+    return [this.length];
+  }
+  /** Index of the most probable class. */
+  get top1() {
+    if (this.data.length === 0) return 0;
+    let t = 0, e = this.data[0];
+    for (let s = 1; s < this.data.length; s++) {
+      const n = this.data[s];
+      n > e && (t = s, e = n);
+    }
+    return t;
+  }
+  /** Probability of the top-1 class. */
+  get top1conf() {
+    return this.data.length === 0 ? 0 : this.data[this.top1];
+  }
+  /** Indices of the top-5 most probable classes, descending. */
+  get top5() {
+    return this._topK(5).indices;
+  }
+  /** Probabilities of the top-5 classes, descending. */
+  get top5conf() {
+    return this._topK(5).values;
+  }
+  _topK(t) {
+    const e = Math.min(t, this.data.length), s = [];
+    for (let a = 0; a < this.data.length; a++) s.push(a);
+    s.sort((a, i) => this.data[i] - this.data[a]);
+    const n = new Int32Array(e), r = new Float32Array(e);
+    for (let a = 0; a < e; a++)
+      n[a] = s[a], r[a] = this.data[s[a]];
+    return { indices: n, values: r };
+  }
+}
+class Ot {
+  /**
+   * @param data Per-instance binary masks (`Mask` objects from `types.ts`).
+   * @param xyxy Flat `[N, 4]` of bounding-box coordinates in original pixels.
+   * @param origShape `[height, width]` of the original image.
+   */
+  constructor(t, e, s) {
+    this.data = t, this.xyxy = e, this.origShape = s;
+  }
+  data;
+  xyxy;
+  origShape;
+  /** Number of instance masks. */
+  get length() {
+    return this.data.length;
+  }
+  /** `[N]` shape of the masks collection. */
+  get shape() {
+    return [this.length];
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+}
+class zt {
+  constructor(t, e, s, n, r, a = null, i = {}) {
+    this.boxes = t, this.detections = e, this.names = s, this.origImg = n, this.origShape = r, this.path = a, this.speed = i;
+  }
+  boxes;
+  detections;
+  names;
+  origImg;
+  origShape;
+  path;
+  speed;
+  /** Number of surviving detections. */
+  get length() {
+    return this.detections.length;
+  }
+  /** Index into the per-instance detections. */
+  get(t) {
+    return this.detections[t];
+  }
+  [Symbol.iterator]() {
+    return this.detections[Symbol.iterator]();
+  }
+}
+class Lt {
+  constructor(t, e, s, n, r, a = null, i = {}) {
+    this.probs = t, this.result = e, this.names = s, this.origImg = n, this.origShape = r, this.path = a, this.speed = i;
+  }
+  probs;
+  result;
+  names;
+  origImg;
+  origShape;
+  path;
+  speed;
+  /** Top-1 class index (Ultralytics-style alias). */
+  get cls() {
+    return this.probs.top1;
+  }
+  /** Top-1 confidence (Ultralytics-style alias). */
+  get conf() {
+    return this.probs.top1conf;
+  }
+  /** Top-1 class name. */
+  get name() {
+    return this.names[this.cls] ?? `class_${this.cls}`;
+  }
+  /** Per-class probability list, sorted descending (legacy field). */
+  get probabilities() {
+    return this.result.probabilities;
+  }
+}
+class Dt {
+  constructor(t, e, s, n, r, a, i = null, c = {}) {
+    this.boxes = t, this.masks = e, this.detections = s, this.names = n, this.origImg = r, this.origShape = a, this.path = i, this.speed = c;
+  }
+  boxes;
+  masks;
+  detections;
+  names;
+  origImg;
+  origShape;
+  path;
+  speed;
+  /** Number of surviving instances. */
+  get length() {
+    return this.detections.length;
+  }
+  /** Index into the per-instance results. */
+  get(t) {
+    return this.detections[t];
+  }
+  [Symbol.iterator]() {
+    return this.detections[Symbol.iterator]();
+  }
+}
+const Yt = Object.freeze([
+  "person",
+  "bicycle",
+  "car",
+  "motorcycle",
+  "airplane",
+  "bus",
+  "train",
+  "truck",
+  "boat",
+  "traffic light",
+  "fire hydrant",
+  "stop sign",
+  "parking meter",
+  "bench",
+  "bird",
+  "cat",
+  "dog",
+  "horse",
+  "sheep",
+  "cow",
+  "elephant",
+  "bear",
+  "zebra",
+  "giraffe",
+  "backpack",
+  "umbrella",
+  "handbag",
+  "tie",
+  "suitcase",
+  "frisbee",
+  "skis",
+  "snowboard",
+  "sports ball",
+  "kite",
+  "baseball bat",
+  "baseball glove",
+  "skateboard",
+  "surfboard",
+  "tennis racket",
+  "bottle",
+  "wine glass",
+  "cup",
+  "fork",
+  "knife",
+  "spoon",
+  "bowl",
+  "banana",
+  "apple",
+  "sandwich",
+  "orange",
+  "broccoli",
+  "carrot",
+  "hot dog",
+  "pizza",
+  "donut",
+  "cake",
+  "chair",
+  "couch",
+  "potted plant",
+  "bed",
+  "dining table",
+  "toilet",
+  "tv",
+  "laptop",
+  "mouse",
+  "remote",
+  "keyboard",
+  "cell phone",
+  "microwave",
+  "oven",
+  "toaster",
+  "sink",
+  "refrigerator",
+  "book",
+  "clock",
+  "vase",
+  "scissors",
+  "teddy bear",
+  "hair drier",
+  "toothbrush"
+]), dt = {
+  coco: Yt
+};
+function et(o, t = {}) {
+  const e = Ut(o, t.numClasses);
+  if (t.numClasses !== void 0 && e.length !== t.numClasses)
+    throw new J(
+      `Resolved ${e.length} labels but the model has ${t.numClasses} classes.`
+    );
+  return e;
+}
+function Ut(o, t) {
+  if (o == null) {
+    if (t === void 0)
+      throw new J(
+        "Cannot auto-generate labels without numClasses. Pass an explicit labels spec or numClasses."
+      );
+    return Array.from({ length: t }, (e, s) => `class_${s}`);
+  }
+  if (Array.isArray(o))
+    return [...o];
+  if (typeof o == "string") {
+    const e = dt[o];
+    if (e !== void 0)
+      return e;
+    throw new J(
+      `Unknown labels preset: ${JSON.stringify(o)}. Known presets: ${Object.keys(dt).join(", ")}.`
+    );
+  }
+  if (typeof o == "object") {
+    const e = o, s = Object.keys(e).map((r) => Number(r));
+    if (s.length === 0)
+      return [];
+    const n = Math.max(...s);
+    return Array.from({ length: n + 1 }, (r, a) => e[a] ?? `class_${a}`);
+  }
+  throw new J(`Unsupported labels spec type: ${typeof o}.`);
+}
+const ut = ["webgpu", "wasm"];
+function Bt(o) {
+  return o === void 0 ? [...ut] : o.length === 0 ? [...ut] : [...o];
+}
+class X {
+  constructor(t, e) {
+    this._session = t, this.providers = e;
+  }
+  _session;
+  providers;
+  /**
+   * Load an ONNX model into an ORT inference session.
+   *
+   * @param model Either a URL string fetched by ORT, or a `Uint8Array`/`ArrayBuffer` containing the model bytes.
+   * @param options Provider list and pass-through `SessionOptions`.
+   * @throws {@link ModelLoadError} if the model cannot be loaded.
+   */
+  static async create(t, e = {}) {
+    const s = Bt(e.providers), n = {
+      ...e.sessionOptions ?? {},
+      executionProviders: s
+    };
+    let r;
+    try {
+      typeof t == "string" ? r = await H.InferenceSession.create(t, n) : t instanceof Uint8Array ? r = await H.InferenceSession.create(t, n) : r = await H.InferenceSession.create(
+        t,
+        n
+      );
+    } catch (a) {
+      throw new Ft(`Failed to load ONNX model: ${a.message}`, {
+        cause: a
+      });
+    }
+    return new X(r, s);
+  }
+  /** Names of the model's inputs, in declaration order. */
+  get inputNames() {
+    return this._session.inputNames;
+  }
+  /** Name of the first (and usually only) input. */
+  get inputName() {
+    const t = this._session.inputNames[0];
+    if (t === void 0)
+      throw new lt("Model has no inputs.");
+    return t;
+  }
+  /** Names of the model's outputs, in declaration order. */
+  get outputNames() {
+    return this._session.outputNames;
+  }
+  /** The underlying `onnxruntime-web` session, for advanced use cases. */
+  get raw() {
+    return this._session;
+  }
+  /**
+   * Run inference and return all outputs.
+   *
+   * @param feeds Map of input name to `ort.Tensor`. Keys must match {@link inputNames}.
+   * @throws {@link InferenceError} if ORT raises any error during execution.
+   */
+  async run(t) {
+    try {
+      return await this._session.run(t);
+    } catch (e) {
+      throw new lt(`Inference failed: ${e.message}`, { cause: e });
+    }
+  }
+}
+function W(o, t) {
+  if (typeof OffscreenCanvas < "u")
+    return new OffscreenCanvas(o, t);
+  if (typeof document < "u") {
+    const e = document.createElement("canvas");
+    return e.width = o, e.height = t, e;
+  }
+  throw new $("No canvas implementation available in this environment.");
+}
+function tt(o) {
+  const t = o.getContext("2d");
+  if (t === null)
+    throw new $("Failed to obtain 2D rendering context.");
+  return t;
+}
+function nt(o) {
+  const { data: t, width: e, height: s } = o;
+  if (t.length !== e * s * 4)
+    throw new $(
+      `Unexpected ImageData length ${t.length} for ${e}x${s} (expected ${e * s * 4}).`
+    );
+  const n = new Uint8Array(e * s * 3);
+  for (let r = 0, a = 0; r < t.length; r += 4, a += 3)
+    n[a] = t[r], n[a + 1] = t[r + 1], n[a + 2] = t[r + 2];
+  return new L(n, e, s);
+}
+function Rt(o) {
+  const t = new Uint8ClampedArray(o.width * o.height * 4);
+  for (let e = 0, s = 0; e < o.data.length; e += 3, s += 4)
+    t[s] = o.data[e], t[s + 1] = o.data[e + 1], t[s + 2] = o.data[e + 2], t[s + 3] = 255;
+  return new ImageData(t, o.width, o.height);
+}
+async function st(o) {
+  if (o instanceof L)
+    return o;
+  if (typeof ImageData < "u" && o instanceof ImageData)
+    return nt(o);
+  if (typeof o == "string")
+    return Xt(o);
+  if (typeof Blob < "u" && o instanceof Blob)
+    return pt(o);
+  if (typeof HTMLImageElement < "u" && o instanceof HTMLImageElement)
+    return await Vt(o), U(o, o.naturalWidth, o.naturalHeight);
+  if (typeof HTMLCanvasElement < "u" && o instanceof HTMLCanvasElement || typeof OffscreenCanvas < "u" && o instanceof OffscreenCanvas || typeof ImageBitmap < "u" && o instanceof ImageBitmap)
+    return U(o, o.width, o.height);
+  throw new $(
+    `Unsupported image source type: ${Object.prototype.toString.call(o)}`
+  );
+}
+async function Xt(o) {
+  let t;
+  try {
+    t = await fetch(o);
+  } catch (s) {
+    throw new $(`Failed to fetch image from ${o}: ${s.message}`, {
+      cause: s
+    });
+  }
+  if (!t.ok)
+    throw new $(
+      `Failed to fetch image from ${o}: HTTP ${t.status} ${t.statusText}`
+    );
+  const e = await t.blob();
+  return pt(e);
+}
+async function pt(o) {
+  let t;
+  try {
+    t = await createImageBitmap(o);
+  } catch (e) {
+    throw new $(`Failed to decode image blob: ${e.message}`, {
+      cause: e
+    });
+  }
+  try {
+    return U(t, t.width, t.height);
+  } finally {
+    t.close();
+  }
+}
+function Vt(o) {
+  return o.complete && o.naturalWidth > 0 ? Promise.resolve() : new Promise((t, e) => {
+    const s = () => {
+      r(), t();
+    }, n = () => {
+      r(), e(new $("Failed to load HTMLImageElement (load event errored)"));
+    }, r = () => {
+      o.removeEventListener("load", s), o.removeEventListener("error", n);
+    };
+    o.addEventListener("load", s, { once: !0 }), o.addEventListener("error", n, { once: !0 });
+  });
+}
+function U(o, t, e) {
+  if (t === 0 || e === 0)
+    throw new $(`Cannot load image with zero dimension (${t}x${e}).`);
+  const s = W(t, e), n = tt(s);
+  n.drawImage(o, 0, 0);
+  const r = n.getImageData(0, 0, t, e);
+  return nt(r);
+}
+function bt(o, t, e) {
+  if (t <= 0 || e <= 0)
+    throw new Error(`Invalid resize target ${t}x${e}.`);
+  if (t === o.width && e === o.height)
+    return o;
+  const s = W(o.width, o.height);
+  tt(s).putImageData(Rt(o), 0, 0);
+  const r = W(t, e), a = tt(r);
+  a.imageSmoothingEnabled = !0, a.imageSmoothingQuality = "high", a.drawImage(s, 0, 0, t, e);
+  const i = a.getImageData(0, 0, t, e);
+  return nt(i);
+}
+function jt(o, t, e, s = 1 / 255) {
+  const n = new Float32Array(o.data.length), r = o.data, a = t[0], i = t[1], c = t[2], f = e[0], y = e[1], h = e[2];
+  for (let l = 0; l < r.length; l += 3)
+    n[l] = (r[l] * s - a) / f, n[l + 1] = (r[l + 1] * s - i) / y, n[l + 2] = (r[l + 2] * s - c) / h;
+  return n;
+}
+function ot(o, t = 1 / 255) {
+  const e = new Float32Array(o.data.length), s = o.data;
+  for (let n = 0; n < s.length; n++)
+    e[n] = s[n] * t;
+  return e;
+}
+function Q(o, t, e, s = 3) {
+  const n = t * e * s;
+  if (o.length !== n)
+    throw new Error(
+      `toCHW: expected length ${n} for ${t}x${e}x${s}, got ${o.length}.`
+    );
+  const r = new Float32Array(n), a = t * e;
+  for (let i = 0; i < e; i++)
+    for (let c = 0; c < t; c++) {
+      const f = (i * t + c) * s, y = i * t + c;
+      for (let h = 0; h < s; h++)
+        r[h * a + y] = o[f + h];
+    }
+  return r;
+}
+function rt(o, t) {
+  return new H.Tensor("float32", o, t);
+}
+function te(o) {
+  const t = ot(o);
+  return Q(t, o.width, o.height, 3);
+}
+function ee(o, t, e) {
+  if (o.length !== t * e * 3)
+    throw new Error(
+      `fromCv2: data length ${o.length} does not match width * height * 3 = ${t * e * 3}.`
+    );
+  const s = new Uint8Array(o.length);
+  for (let n = 0; n < o.length; n += 3)
+    s[n] = o[n + 2], s[n + 1] = o[n + 1], s[n + 2] = o[n];
+  return new L(s, t, e);
+}
+function ne(o) {
+  const t = o.data, e = new Uint8Array(t.length);
+  for (let s = 0; s < t.length; s += 3)
+    e[s] = t[s + 2], e[s + 1] = t[s + 1], e[s + 2] = t[s];
+  return e;
+}
+function _t(o, t, e, s = [114, 114, 114]) {
+  const n = Math.min(t / o.width, e / o.height), r = Math.round(o.width * n), a = Math.round(o.height * n), i = bt(o, r, a), c = new Uint8Array(t * e * 3), f = s[0], y = s[1], h = s[2];
+  for (let d = 0; d < c.length; d += 3)
+    c[d] = f, c[d + 1] = y, c[d + 2] = h;
+  const l = Math.floor((t - r) / 2), w = Math.floor((e - a) / 2), x = r * 3;
+  for (let d = 0; d < a; d++) {
+    const u = d * x, p = ((w + d) * t + l) * 3;
+    c.set(i.data.subarray(u, u + x), p);
+  }
+  return {
+    image: new L(c, t, e),
+    scale: n,
+    padLeft: l,
+    padTop: w
+  };
+}
+function Pt(o) {
+  const t = o.length, e = new Float32Array(t);
+  let s = -1 / 0;
+  for (let r = 0; r < t; r++) {
+    const a = o[r];
+    a > s && (s = a);
+  }
+  let n = 0;
+  for (let r = 0; r < t; r++) {
+    const a = Math.exp(o[r] - s);
+    e[r] = a, n += a;
+  }
+  for (let r = 0; r < t; r++)
+    e[r] = e[r] / n;
+  return e;
+}
+function Kt(o, t) {
+  const e = o.length, s = t === null ? e : Math.min(Math.max(0, t), e), n = new Array(e);
+  for (let i = 0; i < e; i++) n[i] = i;
+  n.sort((i, c) => o[c] - o[i]);
+  const r = new Int32Array(s), a = new Float32Array(s);
+  for (let i = 0; i < s; i++) {
+    const c = n[i];
+    r[i] = c, a[i] = o[c];
+  }
+  return { indices: r, values: a };
+}
+function Gt(o, t, e) {
+  const s = t.length;
+  if (s === 0) return new Int32Array(0);
+  const n = new Float32Array(s);
+  for (let c = 0; c < s; c++) {
+    const f = o[c * 4], y = o[c * 4 + 1], h = o[c * 4 + 2], l = o[c * 4 + 3];
+    n[c] = Math.max(0, h - f) * Math.max(0, l - y);
+  }
+  const r = new Array(s);
+  for (let c = 0; c < s; c++) r[c] = c;
+  r.sort((c, f) => t[f] - t[c]);
+  const a = new Uint8Array(s), i = [];
+  for (let c = 0; c < r.length; c++) {
+    const f = r[c];
+    if (a[f]) continue;
+    i.push(f);
+    const y = o[f * 4], h = o[f * 4 + 1], l = o[f * 4 + 2], w = o[f * 4 + 3], x = n[f];
+    for (let d = c + 1; d < r.length; d++) {
+      const u = r[d];
+      if (a[u]) continue;
+      const p = o[u * 4], _ = o[u * 4 + 1], g = o[u * 4 + 2], S = o[u * 4 + 3], I = Math.max(y, p), v = Math.max(h, _), M = Math.min(l, g), C = Math.min(w, S), E = Math.max(0, M - I), m = Math.max(0, C - v), b = E * m, A = x + n[u] - b;
+      (A > 0 ? b / A : 0) > e && (a[u] = 1);
+    }
+  }
+  return Int32Array.from(i);
+}
+function Ht(o, t, e, s) {
+  if (t.length === 0) return new Int32Array(0);
+  const n = /* @__PURE__ */ new Map();
+  for (let a = 0; a < e.length; a++) {
+    const i = e[a], c = n.get(i);
+    c === void 0 ? n.set(i, [a]) : c.push(a);
+  }
+  const r = [];
+  for (const a of n.values()) {
+    const i = a.length, c = new Float32Array(i * 4), f = new Float32Array(i);
+    for (let h = 0; h < i; h++) {
+      const l = a[h];
+      c[h * 4] = o[l * 4], c[h * 4 + 1] = o[l * 4 + 1], c[h * 4 + 2] = o[l * 4 + 2], c[h * 4 + 3] = o[l * 4 + 3], f[h] = t[l];
+    }
+    const y = Gt(c, f, s);
+    for (let h = 0; h < y.length; h++)
+      r.push(a[y[h]]);
+  }
+  return r.sort((a, i) => t[i] - t[a]), Int32Array.from(r);
+}
+function at(o, t, e) {
+  let s = t;
+  if (s.length === 3) {
+    if (s[0] !== 1)
+      throw new Error(`decodeYoloAnchors: expected batch size 1, got ${s[0]}.`);
+    s = [s[1], s[2]];
+  }
+  if (s.length !== 2)
+    throw new Error(
+      `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(t)}.`
+    );
+  const n = s[0], r = s[1], {
+    numClasses: a,
+    originalWidth: i,
+    originalHeight: c,
+    padLeft: f,
+    padTop: y,
+    scale: h,
+    confThreshold: l,
+    iouThreshold: w,
+    maxDetections: x
+  } = e;
+  if (a < 1 || a + 4 > n)
+    throw new Error(
+      `decodeYoloAnchors: invalid numClasses=${a} for channels=${n}.`
+    );
+  if (o.length !== n * r)
+    throw new Error(
+      `decodeYoloAnchors: data length ${o.length} does not match channels*numAnchors=${n * r}.`
+    );
+  const d = [];
+  for (let m = 0; m < r; m++) {
+    let b = 0, A = -1 / 0;
+    for (let Y = 0; Y < a; Y++) {
+      const z = o[(4 + Y) * r + m];
+      z !== void 0 && z > A && (A = z, b = Y);
+    }
+    if (A < l) continue;
+    const T = o[m], V = o[r + m], j = o[2 * r + m], P = o[3 * r + m];
+    let D = T - j / 2, k = V - P / 2, F = T + j / 2, O = V + P / 2;
+    D = (D - f) / h, k = (k - y) / h, F = (F - f) / h, O = (O - y) / h, D = Math.max(0, Math.min(i, D)), k = Math.max(0, Math.min(c, k)), F = Math.max(0, Math.min(i, F)), O = Math.max(0, Math.min(c, O)), d.push({ anchorIdx: m, x1: D, y1: k, x2: F, y2: O, classId: b, confidence: A });
+  }
+  if (d.length === 0) return ft();
+  const u = new Float32Array(d.length * 4), p = new Float32Array(d.length), _ = new Int32Array(d.length);
+  for (let m = 0; m < d.length; m++) {
+    const b = d[m];
+    u[m * 4] = b.x1, u[m * 4 + 1] = b.y1, u[m * 4 + 2] = b.x2, u[m * 4 + 3] = b.y2, p[m] = b.confidence, _[m] = b.classId;
+  }
+  const g = Ht(u, p, _, w);
+  if (g.length === 0) return ft();
+  const S = Array.from(g).slice(0, x), I = S.length, v = new Int32Array(I), M = new Float32Array(I * 4), C = new Int32Array(I), E = new Float32Array(I);
+  for (let m = 0; m < I; m++) {
+    const b = d[S[m]];
+    v[m] = b.anchorIdx, M[m * 4] = b.x1, M[m * 4 + 1] = b.y1, M[m * 4 + 2] = b.x2, M[m * 4 + 3] = b.y2, C[m] = b.classId, E[m] = b.confidence;
+  }
+  return { anchorIndices: v, boxesXyxy: M, classIds: C, confidences: E };
+}
+function ft() {
+  return {
+    anchorIndices: new Int32Array(0),
+    boxesXyxy: new Float32Array(0),
+    classIds: new Int32Array(0),
+    confidences: new Float32Array(0)
+  };
+}
+function Mt(o, t, e) {
+  const s = t.length === 3 ? t[1] : t[0];
+  if (s === void 0 || s < 5)
+    throw new Error(`decodeYolo: invalid output channel count ${s} (expected >= 5).`);
+  const n = s - 4, r = at(o, t, {
+    numClasses: n,
+    ...e
+  }), a = [];
+  for (let i = 0; i < r.classIds.length; i++)
+    a.push({
+      bbox: new gt(
+        r.boxesXyxy[i * 4],
+        r.boxesXyxy[i * 4 + 1],
+        r.boxesXyxy[i * 4 + 2],
+        r.boxesXyxy[i * 4 + 3]
+      ),
+      classId: r.classIds[i],
+      confidence: r.confidences[i]
+    });
+  return a;
+}
+let yt = !1, mt = !1;
+function se(o, t, e) {
+  return yt || (yt = !0, console.warn(
+    "[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. The alias will be removed in 0.3.0."
+  )), Mt(o, t, e);
+}
+function oe(o, t, e) {
+  return mt || (mt = !0, console.warn(
+    "[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. The alias will be removed in 0.3.0."
+  )), at(o, t, e);
+}
+function vt(o, t, e, s, n) {
+  let r = s;
+  if (r.length === 4) {
+    if (r[0] !== 1)
+      throw new Error(`decodeYoloSeg: expected batch size 1 in prototypes, got ${r[0]}.`);
+    r = [r[1], r[2], r[3]];
+  }
+  if (r.length !== 3)
+    throw new Error(
+      `decodeYoloSeg: expected 3-D prototypes after batch removal, got dims=${JSON.stringify(s)}.`
+    );
+  const a = r[0], i = r[1], c = r[2], f = t.length === 3 ? t[1] : t[0], y = t.length === 3 ? t[2] : t[1];
+  if (f === void 0 || y === void 0)
+    throw new Error(
+      `decodeYoloSeg: cannot read channels/numAnchors from dims=${JSON.stringify(t)}.`
+    );
+  const h = 4 + n.numClasses + a;
+  if (f !== h)
+    throw new Error(
+      `decodeYoloSeg: channels=${f} does not match 4 + numClasses(${n.numClasses}) + numMaskCoefs(${a}) = ${h}.`
+    );
+  if (e.length !== a * i * c)
+    throw new Error(
+      `decodeYoloSeg: prototype length ${e.length} does not match dims=${JSON.stringify(s)}.`
+    );
+  const l = at(o, t, {
+    numClasses: n.numClasses,
+    originalWidth: n.originalWidth,
+    originalHeight: n.originalHeight,
+    padLeft: n.padLeft,
+    padTop: n.padTop,
+    scale: n.scale,
+    confThreshold: n.confThreshold,
+    iouThreshold: n.iouThreshold,
+    maxDetections: n.maxDetections
+  });
+  if (l.anchorIndices.length === 0) return [];
+  const w = n.maskThreshold ?? 0.5, x = c / n.inputWidth, d = i / n.inputHeight, u = i * c, p = (4 + n.numClasses) * y, _ = [];
+  for (let g = 0; g < l.anchorIndices.length; g++) {
+    const S = l.anchorIndices[g], I = l.boxesXyxy[g * 4], v = l.boxesXyxy[g * 4 + 1], M = l.boxesXyxy[g * 4 + 2], C = l.boxesXyxy[g * 4 + 3], E = new gt(I, v, M, C), m = l.classIds[g], b = l.confidences[g], A = Math.max(0, Math.trunc(M) - Math.trunc(I)), T = Math.max(0, Math.trunc(C) - Math.trunc(v));
+    if (A === 0 || T === 0) {
+      _.push({ bbox: E, classId: m, confidence: b, mask: new B(new Uint8Array(0), 0, 0) });
+      continue;
+    }
+    const V = I * n.scale + n.padLeft, j = v * n.scale + n.padTop, P = M * n.scale + n.padLeft, D = C * n.scale + n.padTop, k = Math.max(0, Math.floor(V * x)), F = Math.max(0, Math.floor(j * d)), O = Math.min(c, Math.ceil(P * x)), Y = Math.min(i, Math.ceil(D * d));
+    if (O <= k || Y <= F) {
+      _.push({
+        bbox: E,
+        classId: m,
+        confidence: b,
+        mask: new B(new Uint8Array(A * T), A, T)
+      });
+      continue;
+    }
+    const z = O - k, Z = Y - F, ct = new Float32Array(z * Z);
+    for (let N = 0; N < Z; N++) {
+      const $t = F + N;
+      for (let K = 0; K < z; K++) {
+        const Ct = k + K;
+        let ht = 0;
+        for (let G = 0; G < a; G++) {
+          const Et = o[p + G * y + S], kt = e[G * u + $t * c + Ct];
+          ht += Et * kt;
+        }
+        ct[N * z + K] = Jt(ht);
+      }
+    }
+    const Tt = Qt(ct, z, Z, A, T), q = new Uint8Array(A * T);
+    for (let N = 0; N < q.length; N++)
+      q[N] = Tt[N] >= w ? 255 : 0;
+    _.push({ bbox: E, classId: m, confidence: b, mask: new B(q, A, T) });
+  }
+  return _;
+}
+function Jt(o) {
+  if (o >= 0)
+    return 1 / (1 + Math.exp(-o));
+  const t = Math.exp(o);
+  return t / (1 + t);
+}
+let wt = !1;
+function re(o, t, e, s, n) {
+  return wt || (wt = !0, console.warn(
+    "[@ort-vision-sdk/web] decodeYoloV8Seg is deprecated since 0.2.0; use decodeYoloSeg. The alias will be removed in 0.3.0."
+  )), vt(o, t, e, s, n);
+}
+function Qt(o, t, e, s, n) {
+  const r = new Float32Array(s * n);
+  if (s === 0 || n === 0 || t === 0 || e === 0)
+    return r;
+  if (s === t && n === e)
+    return r.set(o), r;
+  const a = t / s, i = e / n;
+  for (let c = 0; c < n; c++) {
+    const f = (c + 0.5) * i - 0.5, y = Math.max(0, Math.floor(f)), h = Math.min(e - 1, y + 1), l = Math.max(0, Math.min(1, f - y));
+    for (let w = 0; w < s; w++) {
+      const x = (w + 0.5) * a - 0.5, d = Math.max(0, Math.floor(x)), u = Math.min(t - 1, d + 1), p = Math.max(0, Math.min(1, x - d)), _ = o[y * t + d], g = o[y * t + u], S = o[h * t + d], I = o[h * t + u], v = _ * (1 - p) + g * p, M = S * (1 - p) + I * p;
+      r[c * s + w] = v * (1 - l) + M * l;
+    }
+  }
+  return r;
+}
+class it {
+  constructor(t) {
+    this._session = t;
+  }
+  _session;
+  /** The underlying {@link OrtSession} used to run inference. */
+  get session() {
+    return this._session;
+  }
+}
+const Zt = [0.485, 0.456, 0.406], qt = [0.229, 0.224, 0.225];
+class It extends it {
+  constructor(t, e, s, n, r, a, i) {
+    super(t), this._labels = e, this._names = s, this._inputSize = n, this._mean = r, this._std = a, this._applySoftmax = i;
+  }
+  _labels;
+  _names;
+  _inputSize;
+  _mean;
+  _std;
+  _applySoftmax;
+  /** Load the model and resolve labels. */
+  static async create(t, e) {
+    const s = await X.create(t, e), n = et(e.labels, { numClasses: e.numClasses }), r = {};
+    for (let a = 0; a < n.length; a++)
+      r[a] = n[a];
+    return new It(
+      s,
+      n,
+      r,
+      e.inputSize ?? [224, 224],
+      e.mean ?? Zt,
+      e.std ?? qt,
+      e.applySoftmax ?? !0
+    );
+  }
+  /** Class labels indexed by class id. */
+  get labels() {
+    return this._labels;
+  }
+  /** Class id → class name dict (matches Ultralytics' `model.names`). */
+  get names() {
+    return this._names;
+  }
+  /** Number of classes the model can predict. */
+  get numClasses() {
+    return this._labels.length;
+  }
+  /** Alias for {@link predict} (parity with PyTorch `nn.Module.__call__`). */
+  async call(t, e = {}) {
+    return this.predict(t, e);
+  }
+  /** Run classification on a single image. */
+  async predict(t, e = {}) {
+    const s = typeof t == "string" ? t : null, n = await st(t), r = this._preprocess(n), a = await this._session.run({ [this._session.inputName]: r }), i = this._session.outputNames[0];
+    if (i === void 0)
+      throw new Error("Classifier model has no outputs.");
+    const c = a[i];
+    if (c === void 0)
+      throw new Error(
+        `Classifier model output ${i} missing from run() result.`
+      );
+    const f = this._postprocess(c.data), { indices: y, values: h } = Kt(f, e.topK ?? null), l = [];
+    for (let u = 0; u < y.length; u++) {
+      const p = y[u], _ = this._labels[p] ?? `class_${p}`;
+      l.push({
+        classId: p,
+        className: _,
+        probability: h[u],
+        cls: p,
+        name: _,
+        conf: h[u]
+      });
+    }
+    if (l.length === 0)
+      throw new Error("Classifier produced no probabilities (empty output).");
+    const w = l[0], x = {
+      classId: w.classId,
+      className: w.className,
+      confidence: w.probability,
+      cls: w.classId,
+      name: w.className,
+      conf: w.probability,
+      image: n,
+      probabilities: l
+    }, d = [n.height, n.width];
+    return [
+      new Lt(
+        new Nt(f),
+        x,
+        this._names,
+        n,
+        d,
+        s
+      )
+    ];
+  }
+  _preprocess(t) {
+    const [e, s] = this._inputSize, n = bt(t, e, s), r = jt(n, this._mean, this._std), a = Q(r, n.width, n.height, 3);
+    return rt(a, [1, 3, n.height, n.width]);
+  }
+  _postprocess(t) {
+    return this._applySoftmax ? Pt(t) : new Float32Array(t);
+  }
+}
+class At extends it {
+  constructor(t, e, s, n, r, a, i, c) {
+    super(t), this._head = e, this._labels = s, this._names = n, this._inputSize = r, this._confThreshold = a, this._iouThreshold = i, this._maxDetections = c;
+  }
+  _head;
+  _labels;
+  _names;
+  _inputSize;
+  _confThreshold;
+  _iouThreshold;
+  _maxDetections;
+  /** Load the model and resolve labels. */
+  static async create(t, e = {}) {
+    const s = e.head ?? "yolo";
+    if (s !== "yolo")
+      throw new Error(`Unsupported detector head '${s}'. Supported: 'yolo'.`);
+    const n = await X.create(t, e), r = et(e.labels ?? "coco", {
+      numClasses: e.numClasses
+    }), a = {};
+    for (let i = 0; i < r.length; i++)
+      a[i] = r[i];
+    return new At(
+      n,
+      s,
+      r,
+      a,
+      e.inputSize ?? [640, 640],
+      e.confThreshold ?? 0.25,
+      e.iouThreshold ?? 0.45,
+      e.maxDetections ?? 300
+    );
+  }
+  /** The decoder family used to interpret the model's output. */
+  get head() {
+    return this._head;
+  }
+  /** Class labels indexed by class id. */
+  get labels() {
+    return this._labels;
+  }
+  /** Class id → class name dict (matches Ultralytics' `model.names`). */
+  get names() {
+    return this._names;
+  }
+  /** Number of classes the model predicts. */
+  get numClasses() {
+    return this._labels.length;
+  }
+  /**
+   * Alias for {@link predict} — call the detector like a torch `nn.Module`.
+   *
+   * Use as `det.call(img)` since JavaScript class instances are not callable;
+   * for direct invocation, prefer `det.predict(img)`. The full
+   * {@link DetectorPredictOptions} (including `classes`) is supported.
+   */
+  async call(t, e = {}) {
+    return this.predict(t, e);
+  }
+  /** Run detection on a single image. */
+  async predict(t, e = {}) {
+    const s = typeof t == "string" ? t : null, n = await st(t), { tensor: r, scale: a, padLeft: i, padTop: c } = this._preprocess(n), f = await this._session.run({ [this._session.inputName]: r }), y = this._session.outputNames[0];
+    if (y === void 0)
+      throw new Error("Detector model has no outputs.");
+    const h = f[y];
+    if (h === void 0)
+      throw new Error(`Detector model output ${y} missing from run() result.`);
+    const l = Mt(h.data, h.dims, {
+      originalWidth: n.width,
+      originalHeight: n.height,
+      padLeft: i,
+      padTop: c,
+      scale: a,
+      confThreshold: e.confThreshold ?? this._confThreshold,
+      iouThreshold: e.iouThreshold ?? this._iouThreshold,
+      maxDetections: this._maxDetections
+    }), x = (e.classes !== void 0 ? (() => {
+      const u = new Set(e.classes);
+      return l.filter((p) => u.has(p.classId));
+    })() : l).map(
+      (u) => this._buildResult(n, u.bbox, u.classId, u.confidence)
+    ), d = [n.height, n.width];
+    return [
+      new zt(
+        this._buildBoxes(x, d),
+        x,
+        this._names,
+        n,
+        d,
+        s
+      )
+    ];
+  }
+  _preprocess(t) {
+    const [e, s] = this._inputSize, n = _t(t, e, s), r = ot(n.image), a = Q(r, n.image.width, n.image.height, 3);
+    return {
+      tensor: rt(a, [1, 3, n.image.height, n.image.width]),
+      scale: n.scale,
+      padLeft: n.padLeft,
+      padTop: n.padTop
+    };
+  }
+  _buildResult(t, e, s, n) {
+    const [r, a, i, c] = e.asIntXyxy(), f = Math.max(0, r), y = Math.max(0, a), h = Math.min(t.width, i), l = Math.min(t.height, c);
+    let w;
+    if (h > f && l > y) {
+      const d = h - f, u = l - y, p = new Uint8Array(d * u * 3);
+      for (let _ = 0; _ < u; _++) {
+        const g = ((y + _) * t.width + f) * 3;
+        p.set(t.data.subarray(g, g + d * 3), _ * d * 3);
+      }
+      w = new L(p, d, u);
+    } else
+      w = new L(new Uint8Array(0), 0, 0);
+    const x = this._names[s] ?? `class_${s}`;
+    return {
+      classId: s,
+      className: x,
+      confidence: n,
+      bbox: e,
+      cls: s,
+      name: x,
+      conf: n,
+      box: e,
+      croppedImage: w
+    };
+  }
+  _buildBoxes(t, e) {
+    const s = t.length, n = new Float32Array(s * 4), r = new Int32Array(s), a = new Float32Array(s);
+    for (let i = 0; i < s; i++) {
+      const c = t[i];
+      n[i * 4] = c.bbox.x1, n[i * 4 + 1] = c.bbox.y1, n[i * 4 + 2] = c.bbox.x2, n[i * 4 + 3] = c.bbox.y2, r[i] = c.classId, a[i] = c.confidence;
+    }
+    return new xt(n, r, a, e);
+  }
+}
+class St extends it {
+  constructor(t, e, s, n, r, a, i, c, f) {
+    super(t), this._head = e, this._labels = s, this._names = n, this._inputSize = r, this._confThreshold = a, this._iouThreshold = i, this._maxDetections = c, this._maskThreshold = f;
+  }
+  _head;
+  _labels;
+  _names;
+  _inputSize;
+  _confThreshold;
+  _iouThreshold;
+  _maxDetections;
+  _maskThreshold;
+  /** Load the model and resolve labels. */
+  static async create(t, e = {}) {
+    const s = e.head ?? "yolo-seg";
+    if (s !== "yolo-seg")
+      throw new Error(`Unsupported segmenter head '${s}'. Supported: 'yolo-seg'.`);
+    const n = await X.create(t, e), r = et(e.labels ?? "coco", {
+      numClasses: e.numClasses
+    }), a = {};
+    for (let i = 0; i < r.length; i++)
+      a[i] = r[i];
+    return new St(
+      n,
+      s,
+      r,
+      a,
+      e.inputSize ?? [640, 640],
+      e.confThreshold ?? 0.25,
+      e.iouThreshold ?? 0.45,
+      e.maxDetections ?? 300,
+      e.maskThreshold ?? 0.5
+    );
+  }
+  /** The decoder family used to interpret the model's output. */
+  get head() {
+    return this._head;
+  }
+  /** Class labels indexed by class id. */
+  get labels() {
+    return this._labels;
+  }
+  /** Class id → class name dict (matches Ultralytics' `model.names`). */
+  get names() {
+    return this._names;
+  }
+  /** Number of classes the model predicts. */
+  get numClasses() {
+    return this._labels.length;
+  }
+  /** Alias for {@link predict} (parity with PyTorch `nn.Module.__call__`). */
+  async call(t, e = {}) {
+    return this.predict(t, e);
+  }
+  /** Run instance segmentation on a single image. */
+  async predict(t, e = {}) {
+    const s = typeof t == "string" ? t : null, n = await st(t), { tensor: r, scale: a, padLeft: i, padTop: c } = this._preprocess(n), f = await this._session.run({ [this._session.inputName]: r }), { perAnchor: y, prototypes: h } = this._splitOutputs(f), l = vt(
+      y.data,
+      y.dims,
+      h.data,
+      h.dims,
+      {
+        numClasses: this._labels.length,
+        inputWidth: this._inputSize[0],
+        inputHeight: this._inputSize[1],
+        originalWidth: n.width,
+        originalHeight: n.height,
+        padLeft: i,
+        padTop: c,
+        scale: a,
+        confThreshold: e.confThreshold ?? this._confThreshold,
+        iouThreshold: e.iouThreshold ?? this._iouThreshold,
+        maxDetections: this._maxDetections,
+        maskThreshold: this._maskThreshold
+      }
+    ), x = (e.classes !== void 0 ? (() => {
+      const u = new Set(e.classes);
+      return l.filter((p) => u.has(p.classId));
+    })() : l).map(
+      (u) => this._buildResult(n, u.bbox, u.classId, u.confidence, u.mask)
+    ), d = [n.height, n.width];
+    return [
+      new Dt(
+        this._buildBoxes(x, d),
+        this._buildMasks(x, d),
+        x,
+        this._names,
+        n,
+        d,
+        s
+      )
+    ];
+  }
+  _preprocess(t) {
+    const [e, s] = this._inputSize, n = _t(t, e, s), r = ot(n.image), a = Q(r, n.image.width, n.image.height, 3);
+    return {
+      tensor: rt(a, [1, 3, n.image.height, n.image.width]),
+      scale: n.scale,
+      padLeft: n.padLeft,
+      padTop: n.padTop
+    };
+  }
+  _splitOutputs(t) {
+    let e, s;
+    for (const n of this._session.outputNames) {
+      const r = t[n];
+      r !== void 0 && (r.dims.length === 3 && e === void 0 ? e = r : r.dims.length === 4 && s === void 0 && (s = r));
+    }
+    if (e === void 0 || s === void 0) {
+      const n = this._session.outputNames.map(
+        (r) => `${r}: ${JSON.stringify(t[r]?.dims ?? [])}`
+      );
+      throw new Error(
+        `Segmenter expected one 3-D and one 4-D output, got [${n.join(", ")}].`
+      );
+    }
+    return { perAnchor: e, prototypes: s };
+  }
+  _buildResult(t, e, s, n, r) {
+    const [a, i, c, f] = e.asIntXyxy(), y = Math.max(0, a), h = Math.max(0, i), l = Math.min(t.width, c), w = Math.min(t.height, f);
+    let x, d = r;
+    if (l > y && w > h && r.data.length > 0) {
+      const p = l - y, _ = w - h, g = Math.min(r.width, p), S = Math.min(r.height, _), I = new Uint8Array(g * S * 3);
+      for (let v = 0; v < S; v++) {
+        const M = ((h + v) * t.width + y) * 3, C = v * g * 3, E = v * r.width;
+        for (let m = 0; m < g; m++)
+          if (r.data[E + m] !== 0) {
+            const A = M + m * 3, T = C + m * 3;
+            I[T] = t.data[A], I[T + 1] = t.data[A + 1], I[T + 2] = t.data[A + 2];
+          }
+      }
+      if (x = new L(I, g, S), g !== r.width || S !== r.height) {
+        const v = new Uint8Array(g * S);
+        for (let M = 0; M < S; M++)
+          v.set(
+            r.data.subarray(M * r.width, M * r.width + g),
+            M * g
+          );
+        d = new B(v, g, S);
+      }
+    } else
+      d = new B(new Uint8Array(0), 0, 0), x = new L(new Uint8Array(0), 0, 0);
+    const u = this._names[s] ?? `class_${s}`;
+    return {
+      classId: s,
+      className: u,
+      confidence: n,
+      bbox: e,
+      cls: s,
+      name: u,
+      conf: n,
+      box: e,
+      mask: d,
+      segmentedImage: x
+    };
+  }
+  _buildBoxes(t, e) {
+    const s = t.length, n = new Float32Array(s * 4), r = new Int32Array(s), a = new Float32Array(s);
+    for (let i = 0; i < s; i++) {
+      const c = t[i];
+      n[i * 4] = c.bbox.x1, n[i * 4 + 1] = c.bbox.y1, n[i * 4 + 2] = c.bbox.x2, n[i * 4 + 3] = c.bbox.y2, r[i] = c.classId, a[i] = c.confidence;
+    }
+    return new xt(n, r, a, e);
+  }
+  _buildMasks(t, e) {
+    const s = new Float32Array(t.length * 4);
+    for (let n = 0; n < t.length; n++) {
+      const r = t[n];
+      s[n * 4] = r.bbox.x1, s[n * 4 + 1] = r.bbox.y1, s[n * 4 + 2] = r.bbox.x2, s[n * 4 + 3] = r.bbox.y2;
+    }
+    return new Ot(
+      t.map((n) => n.mask),
+      s,
+      e
+    );
+  }
+}
+const ae = "0.2.1";
+export {
+  gt as BoundingBox,
+  xt as Boxes,
+  Yt as COCO_CLASSES,
+  Lt as ClassificationResults,
+  It as Classifier,
+  ut as DEFAULT_PROVIDERS,
+  zt as DetectionResults,
+  At as Detector,
+  $ as ImageLoadError,
+  lt as InferenceError,
+  J as LabelMapError,
+  B as Mask,
+  Ot as Masks,
+  Ft as ModelLoadError,
+  X as OrtSession,
+  R as OrtVisionError,
+  Nt as Probs,
+  Wt as ProviderNotAvailableError,
+  L as RGBImage,
+  Dt as SegmentationResults,
+  St as Segmenter,
+  ae as VERSION,
+  it as VisionTask,
+  Ht as batchedNms,
+  Mt as decodeYolo,
+  at as decodeYoloAnchors,
+  vt as decodeYoloSeg,
+  se as decodeYoloV8,
+  oe as decodeYoloV8Anchors,
+  re as decodeYoloV8Seg,
+  ee as fromCv2,
+  _t as letterbox,
+  st as loadImage,
+  Gt as nms,
+  jt as normalize,
+  bt as resize,
+  et as resolveLabels,
+  Bt as resolveProviders,
+  Pt as softmax,
+  Q as toCHW,
+  ne as toCv2,
+  ot as toFloat32,
+  rt as toFloat32Tensor,
+  te as toTensor,
+  Kt as topK
+};
+//# sourceMappingURL=vision.js.map