@sailfish-ai/recorder 1.12.4 → 1.12.6

package/dist/chunks/patch2d-PQxcaE6r.js

@@ -0,0 +1,886 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function closestSafe(t2, e2) {
+  if (!t2 || !e2) return false;
+  try {
+    return !!t2.closest(e2);
+  } catch {
+    return false;
+  }
+}
+function matchesSelectorSafe(t2, e2) {
+  if (!e2) return false;
+  try {
+    return t2.matches(e2);
+  } catch {
+    return false;
+  }
+}
+function buildMaskInputFn(t2) {
+  const { baseFn: e2, unmaskSelector: s2, maskInputSelector: a2, adminMaskInputOptions: i2 } = t2;
+  return s2 || a2 ? (t3, r2) => {
+    if ("hidden" === r2.type) return "";
+    if (closestSafe(r2, s2)) return t3;
+    const o2 = (r2.type || "").toLowerCase(), c2 = (r2.tagName || "").toLowerCase(), h2 = true === i2[o2] || true === i2[c2], l2 = matchesSelectorSafe(r2, a2);
+    return h2 || l2 ? e2(t3, r2) : t3;
+  } : e2;
+}
+function makeMaskTextFn(t2) {
+  return (e2, s2) => closestSafe(s2, t2) ? e2 : e2.replace(/\S/g, "*");
+}
+const t = /\d/, e = /\b\d{3}-\d{2}-\d{4}\b/, s = /\b(?:\d[ -]*?){13,16}\b/g, a = /\b\d{3}-\d{2}-\d{4}\b/g, i = /\b\d{1,2}[/\-.]\d{1,2}[/\-.]\d{2,4}\b/g;
+function passesLuhn(t2) {
+  let e2 = "";
+  for (let s3 = 0; s3 < t2.length; s3++) {
+    const a3 = t2.charCodeAt(s3);
+    a3 >= 48 && a3 <= 57 && (e2 += t2[s3]);
+  }
+  const s2 = e2.length;
+  if (s2 < 13 || s2 > 16) return false;
+  let a2 = 0, i2 = false;
+  for (let t3 = s2 - 1; t3 >= 0; t3--) {
+    let s3 = e2.charCodeAt(t3) - 48;
+    i2 && (s3 *= 2, s3 > 9 && (s3 -= 9)), a2 += s3, i2 = !i2;
+  }
+  return a2 % 10 == 0;
+}
+function looksLikeCreditCard(t2) {
+  if ("string" != typeof t2) return false;
+  let e2;
+  for (s.lastIndex = 0; null !== (e2 = s.exec(t2)); ) {
+    if (passesLuhn(e2[0])) return true;
+    e2.index === s.lastIndex && s.lastIndex++;
+  }
+  return false;
+}
+function looksLikeSsn(t2) {
+  return "string" == typeof t2 && e.test(t2);
+}
+function redactCreditCard(t2) {
+  return "**** **** **** " + t2.slice(-4);
+}
+function redactSsn(t2) {
+  return "***-**-" + t2.slice(-4);
+}
+function redactDob(t2) {
+  return "**/**/" + t2.slice(-4);
+}
+function redactSensitiveContent(e2, r2) {
+  if ("string" != typeof e2 || 0 === e2.length) return e2;
+  if (!t.test(e2)) return e2;
+  let o2 = e2;
+  return false === r2.recordCreditCardInfo && (s.lastIndex = 0, o2 = o2.replace(s, (t2) => passesLuhn(t2) ? redactCreditCard(t2) : t2)), false === r2.recordSsn && (a.lastIndex = 0, o2 = o2.replace(a, (t2) => redactSsn(t2))), false === r2.recordDob && (i.lastIndex = 0, o2 = o2.replace(i, (t2) => redactDob(t2))), o2;
+}
+function maskCanvasSelector(t2) {
+  return `.${t2.maskCanvasClass || "sailfishSanitize"}, [data-sf-mask]`;
+}
+function classifyCanvasPrivacy(t2, e2) {
+  return closestSafe(t2, e2.unmaskSelector) ? "normal" : closestSafe(t2, e2.blockSelector) || closestSafe(t2, maskCanvasSelector(e2)) ? "suppress" : e2.maskTextClass && closestSafe(t2, `.${e2.maskTextClass}`) || matchesSelectorSafe(t2, e2.maskTextSelector) || closestSafe(t2, e2.maskTextSelector) || true === e2.maskCanvasText || false !== e2.maskCanvasText && (function domTextMaskingConfigured(t3) {
+    return !(!t3.maskTextSelector && !t3.maskTextClass);
+  })(e2) ? "redact" : "normal";
+}
+function suppressReason(t2, e2) {
+  if (!closestSafe(t2, e2.unmaskSelector)) return closestSafe(t2, e2.blockSelector) ? "block" : closestSafe(t2, maskCanvasSelector(e2)) ? "mask" : void 0;
+}
+function maskAllText(t2) {
+  return t2.replace(/\S/g, "*");
+}
+function redactCanvasText(t2, e2, s2) {
+  return "string" != typeof t2 ? t2 : "redact" === e2 ? maskAllText(t2) : "normal" === e2 ? redactSensitiveContent(t2, s2) : t2;
+}
+const r = { text: "asterisks", shape: "color" }, o = "#1f2433";
+function resolveRedactStyle(t2, e2) {
+  const s2 = t2 ?? r;
+  return e2 ? { text: e2.text ?? s2.text, shape: e2.shape ?? s2.shape } : s2;
+}
+function transformedBox(t2, e2, s2, a2, i2, r2 = 1) {
+  if (![t2, e2, s2, a2, i2.a, i2.b, i2.c, i2.d, i2.e, i2.f].every(Number.isFinite)) return null;
+  const px = (t3, e3) => i2.a * t3 + i2.c * e3 + i2.e, py = (t3, e3) => i2.b * t3 + i2.d * e3 + i2.f, o2 = [px(t2, e2), px(s2, e2), px(s2, a2), px(t2, a2)], c2 = [py(t2, e2), py(s2, e2), py(s2, a2), py(t2, a2)], h2 = Math.min(...o2), l2 = Math.max(...o2), d2 = Math.min(...c2), u2 = Math.max(...c2);
+  return Number.isFinite(h2) && Number.isFinite(d2) ? { x: h2 - r2, y: d2 - r2, w: l2 - h2 + 2 * r2, h: u2 - d2 + 2 * r2 } : null;
+}
+function textLocalBox(t2) {
+  let e2 = t2.x;
+  const s2 = t2.align ?? "start";
+  "center" === s2 ? e2 = t2.x - t2.width / 2 : "right" !== s2 && "end" !== s2 || (e2 = t2.x - t2.width);
+  const a2 = e2 + t2.width, i2 = t2.ascent, r2 = t2.descent, o2 = i2 + r2;
+  let c2, h2;
+  switch (t2.baseline) {
+    case "top":
+    case "hanging":
+      c2 = t2.y, h2 = t2.y + o2;
+      break;
+    case "middle":
+      c2 = t2.y - o2 / 2, h2 = t2.y + o2 / 2;
+      break;
+    case "bottom":
+    case "ideographic":
+      c2 = t2.y - o2, h2 = t2.y;
+      break;
+    default:
+      c2 = t2.y - i2, h2 = t2.y + r2;
+  }
+  return { x0: e2, y0: c2, x1: a2, y1: h2 };
+}
+const c = new Map(["__frame", "__create", "__objcall", "arc", "arcTo", "beginPath", "bezierCurveTo", "clearRect", "clip", "closePath", "drawImage", "ellipse", "fill", "fillRect", "fillText", "lineTo", "moveTo", "putImageData", "quadraticCurveTo", "rect", "reset", "resetTransform", "restore", "rotate", "roundRect", "save", "scale", "setLineDash", "setTransform", "stroke", "strokeRect", "strokeText", "transform", "translate", "drawFocusIfNeeded", "fillStyle", "strokeStyle", "globalAlpha", "globalCompositeOperation", "lineWidth", "lineCap", "lineJoin", "miterLimit", "lineDashOffset", "font", "textAlign", "textBaseline", "direction", "shadowBlur", "shadowColor", "shadowOffsetX", "shadowOffsetY", "imageSmoothingEnabled", "imageSmoothingQuality", "filter", "letterSpacing", "wordSpacing", "useProgram", "bindBuffer", "bindTexture", "bindVertexArray", "bindFramebuffer", "bufferData", "bufferSubData", "uniform1f", "uniform1i", "uniform2f", "uniform3f", "uniform4f", "uniform1fv", "uniform2fv", "uniform3fv", "uniform4fv", "uniformMatrix3fv", "uniformMatrix4fv", "vertexAttribPointer", "enableVertexAttribArray", "drawArrays", "drawElements", "drawArraysInstanced", "drawElementsInstanced", "enable", "disable", "depthFunc", "depthMask", "blendFunc", "blendFuncSeparate", "blendEquation", "cullFace", "frontFace", "viewport", "scissor", "clearColor", "clearDepth", "clearStencil", "activeTexture", "texParameteri", "texImage2D", "texSubImage2D", "pixelStorei", "colorMask", "stencilFunc", "stencilOp", "stencilMask", "polygonOffset", "__site"].map((t2, e2) => [t2, e2]));
+class ByteWriter {
+  constructor() {
+    __publicField(this, "buf", new Uint8Array(65536));
+    __publicField(this, "len", 0);
+    __publicField(this, "view", new DataView(this.buf.buffer));
+  }
+  ensure(t2) {
+    if (this.len + t2 <= this.buf.length) return;
+    const e2 = new Uint8Array(Math.max(2 * this.buf.length, this.len + t2));
+    e2.set(this.buf.subarray(0, this.len)), this.buf = e2, this.view = new DataView(e2.buffer);
+  }
+  u8(t2) {
+    this.ensure(1), this.buf[this.len++] = 255 & t2;
+  }
+  varint(t2) {
+    let e2 = t2 < 0 ? 2 * -t2 - 1 : 2 * t2;
+    for (this.ensure(10); e2 >= 128; ) this.buf[this.len++] = 127 & e2 | 128, e2 = Math.floor(e2 / 128);
+    this.buf[this.len++] = e2;
+  }
+  f64(t2) {
+    this.ensure(8), this.view.setFloat64(this.len, t2, true), this.len += 8;
+  }
+  bytes(t2) {
+    this.ensure(t2.length), this.buf.set(t2, this.len), this.len += t2.length;
+  }
+  take() {
+    const t2 = this.buf.slice(0, this.len);
+    return this.len = 0, t2;
+  }
+  get size() {
+    return this.len;
+  }
+}
+const h = new TextEncoder();
+new TextDecoder();
+class CommandEncoder {
+  constructor() {
+    __publicField(this, "w", new ByteWriter());
+    __publicField(this, "strings", /* @__PURE__ */ new Map());
+    __publicField(this, "lastTUs", 0);
+    __publicField(this, "ops", 0);
+  }
+  encode(t2) {
+    const e2 = Math.round(1e3 * t2.t);
+    e2 !== this.lastTUs && (this.w.u8(c.get("__frame")), this.w.varint(e2 - this.lastTUs), this.lastTUs = e2), t2.sfId && (this.w.u8(c.get("__site")), this.str(t2.sfId));
+    const s2 = c.get(t2.op);
+    void 0 === s2 ? (this.w.u8(255), this.str(t2.op)) : this.w.u8(t2.setter ? 128 | s2 : s2), this.w.varint(t2.args.length);
+    for (const e3 of t2.args) this.arg(e3);
+    this.ops++;
+  }
+  str(t2) {
+    const e2 = this.strings.get(t2);
+    if (void 0 !== e2) return this.w.u8(3), void this.w.varint(e2);
+    const s2 = this.strings.size;
+    this.strings.set(t2, s2);
+    const a2 = h.encode(t2);
+    this.w.u8(2), this.w.varint(a2.length), this.w.bytes(a2);
+  }
+  arg(t2) {
+    if (null !== t2) {
+      switch (typeof t2) {
+        case "number":
+          return void (Number.isInteger(t2) && Math.abs(t2) < 2 ** 30 ? (this.w.u8(1), this.w.varint(t2)) : (this.w.u8(0), this.w.f64(t2)));
+        case "string":
+          return void this.str(t2);
+        case "boolean":
+          return void this.w.u8(t2 ? 4 : 5);
+      }
+      if ("$" in t2) switch (t2.$) {
+        case "asset":
+          return this.w.u8(7), void this.w.varint(t2.id);
+        case "obj":
+          return this.w.u8(8), void this.w.varint(t2.id);
+        case "imagedata":
+          return this.w.u8(10), void this.w.varint(t2.id);
+        case "arr":
+          this.w.u8(9), this.w.varint(t2.v.length);
+          for (const e2 of t2.v) this.w.f64(e2);
+          return;
+        case "ta":
+          return this.w.u8(12), this.w.u8(t2.k), this.w.varint(t2.b.length), void this.w.bytes(t2.b);
+        case "unsupported":
+          return this.w.u8(11), void this.str(t2.kind);
+      }
+      this.w.u8(6);
+    } else this.w.u8(6);
+  }
+  takeBatch() {
+    return this.ops = 0, this.strings.clear(), this.lastTUs = 0, this.w.take();
+  }
+}
+async function deflate(t2) {
+  return (async function pipeThrough(t3, e2) {
+    const s2 = new Uint8Array(e2.buffer.slice(e2.byteOffset, e2.byteOffset + e2.byteLength)), a2 = new Response(t3.readable).arrayBuffer(), i2 = t3.writable.getWriter();
+    return await i2.write(s2), await i2.close(), new Uint8Array(await a2);
+  })(new CompressionStream("deflate"), t2);
+}
+const l = /* @__PURE__ */ new WeakMap();
+function pushObjectCall(t2, e2, s2) {
+  t2 && (t2.calls.length >= 4096 ? t2.callsCapped = true : t2.calls.push({ method: e2, args: s2 }));
+}
+const d = ["createLinearGradient", "createRadialGradient", "createConicGradient", "createPattern"], u = ["addPath", "arc", "arcTo", "bezierCurveTo", "closePath", "ellipse", "lineTo", "moveTo", "quadraticCurveTo", "rect", "roundRect"];
+let f = null;
+const p = /* @__PURE__ */ new WeakSet();
+let g = false;
+function installFactoryLoggingOnProto(t2) {
+  if (p.has(t2)) return;
+  p.add(t2);
+  const e2 = t2;
+  for (const s2 of d) {
+    const a2 = Object.getOwnPropertyDescriptor(t2, s2);
+    if (!a2 || "function" != typeof a2.value) continue;
+    const i2 = a2.value;
+    e2[s2] = function(...t3) {
+      const e3 = i2.apply(this, t3);
+      return e3 && "object" == typeof e3 && l.set(e3, { factory: s2, args: t3, calls: [] }), e3;
+    };
+  }
+}
+function installSharedObjectLogging() {
+  if (!g) {
+    if (g = true, "undefined" != typeof CanvasGradient) {
+      const t2 = CanvasGradient.prototype.addColorStop;
+      CanvasGradient.prototype.addColorStop = function(...e2) {
+        return pushObjectCall(l.get(this), "addColorStop", e2), t2.apply(this, e2);
+      };
+    }
+    if ("undefined" != typeof Path2D && !f) {
+      f = Path2D;
+      for (const t3 of u) {
+        const e2 = Path2D.prototype[t3];
+        "function" == typeof e2 && (Path2D.prototype[t3] = function(...s2) {
+          return pushObjectCall(l.get(this), t3, s2), e2.apply(this, s2);
+        });
+      }
+      const t2 = f, Wrapped = function(e2) {
+        var _a;
+        const s2 = void 0 === e2 ? new t2() : new t2(e2);
+        return l.set(s2, { factory: "__path2d", args: ["string" == typeof e2 ? e2 : null], calls: e2 instanceof t2 ? [...((_a = l.get(e2)) == null ? void 0 : _a.calls) ?? []] : [] }), s2;
+      };
+      Wrapped.prototype = t2.prototype, globalThis.Path2D = Wrapped;
+    }
+  }
+}
+function installEarlyObjectLogging() {
+  "undefined" != typeof CanvasRenderingContext2D && installFactoryLoggingOnProto(CanvasRenderingContext2D.prototype), "undefined" != typeof OffscreenCanvasRenderingContext2D && installFactoryLoggingOnProto(OffscreenCanvasRenderingContext2D.prototype), installSharedObjectLogging();
+}
+const m = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+function serializeTypedArray(t2) {
+  var _a;
+  if (t2 instanceof ArrayBuffer) return { $: "ta", k: 1, b: new Uint8Array(t2.slice(0)) };
+  const e2 = m.findIndex((e3) => t2 instanceof e3);
+  if (e2 < 0) return { $: "unsupported", kind: ((_a = t2.constructor) == null ? void 0 : _a.name) ?? "view" };
+  return { $: "ta", k: e2, b: new Uint8Array(t2.buffer.slice(t2.byteOffset, t2.byteOffset + t2.byteLength)) };
+}
+class BufferSink {
+  constructor() {
+    __publicField(this, "ops", []);
+    __publicField(this, "assetEvents", []);
+    __publicField(this, "assetData", []);
+    __publicField(this, "notes", []);
+  }
+  onOp(t2) {
+    this.ops.push(t2);
+  }
+  onAssetBytes(t2, e2, s2) {
+    this.assetEvents.push({ id: t2, bytes: e2, t: s2 });
+  }
+  onAssetData(t2, e2) {
+    this.assetData.push({ info: t2, payload: e2 });
+  }
+  note(t2) {
+    this.notes.includes(t2) || this.notes.push(t2);
+  }
+}
+class DiscardSink {
+  constructor(t2) {
+    this.onDirty = t2;
+  }
+  onOp(t2) {
+    this.onDirty();
+  }
+  onAssetBytes(t2, e2, s2) {
+  }
+  note(t2) {
+  }
+}
+const y = { t: 0, op: "", args: [] }, k = new TextEncoder();
+new TextDecoder();
+const w = [83, 70, 67, 49];
+function buildFrame(t2, e2) {
+  const s2 = null == e2 ? new Uint8Array(0) : e2 instanceof ArrayBuffer ? new Uint8Array(e2) : e2, a2 = k.encode(JSON.stringify({ ...t2, pLen: s2.byteLength })), i2 = new ArrayBuffer(8 + a2.length + s2.byteLength), r2 = new Uint8Array(i2);
+  return r2[0] = w[0], r2[1] = w[1], r2[2] = w[2], r2[3] = w[3], new DataView(i2).setUint32(4, a2.length, true), r2.set(a2, 8), r2.set(s2, 8 + a2.length), i2;
+}
+function bytesToBase64(t2) {
+  const e2 = t2 instanceof Uint8Array ? t2 : new Uint8Array(t2);
+  let s2 = "";
+  for (let t3 = 0; t3 < e2.length; t3 += 32768) s2 += String.fromCharCode.apply(null, e2.subarray(t3, t3 + 32768));
+  return btoa(s2);
+}
+const b = ["fillStyle", "strokeStyle", "globalAlpha", "globalCompositeOperation", "lineWidth", "lineCap", "lineJoin", "miterLimit", "lineDashOffset", "font", "textAlign", "textBaseline", "direction", "shadowBlur", "shadowColor", "shadowOffsetX", "shadowOffsetY", "imageSmoothingEnabled", "imageSmoothingQuality", "filter", "letterSpacing", "wordSpacing"];
+let x = 1, S = 1;
+const C = /* @__PURE__ */ new WeakSet();
+let v = false;
+function notePreAttachMaskUsed(t2) {
+  t2 ? C.add(t2) : v = true;
+}
+function wasPreAttachMaskUsed(t2) {
+  return !!v || !!t2 && C.has(t2);
+}
+const M = /* @__PURE__ */ new Set(["beginPath", "closePath", "moveTo", "lineTo", "rect", "roundRect", "arc", "arcTo", "ellipse", "bezierCurveTo", "quadraticCurveTo"]), T = /* @__PURE__ */ new Set(["fill", "stroke", "fillRect", "strokeRect", "drawImage", "putImageData"]), R = /* @__PURE__ */ new Set(["setTransform", "transform", "translate", "scale", "rotate", "resetTransform"]);
+const A = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakSet();
+function ignore2DContext(t2) {
+  D.add(t2);
+}
+let I = null;
+function setUntracked2DContextNotifier(t2) {
+  I = t2;
+}
+function recorderForContext(t2) {
+  if (t2) return A.get(t2) ?? P.get(t2);
+}
+let O = null;
+function setContextCreatedNotifier(t2) {
+  O = t2;
+}
+let B = null;
+const P = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new WeakMap();
+function getContextInfo(t2) {
+  return L.get(t2);
+}
+function setAutoAttach(t2) {
+  B = t2, t2 && P.clear();
+}
+function releaseAutoRecorder(t2) {
+  const e2 = P.get(t2);
+  e2 && !e2.bound && (A.delete(e2.rawCtx), P.delete(t2));
+}
+function pruneUnboundRecorders() {
+  for (const [t2, e2] of P) e2.bound || (A.delete(e2.rawCtx), P.delete(t2));
+}
+class ContextRecorder {
+  constructor(t2, e2, s2, a2, i2, r2) {
+    __publicField(this, "assets", /* @__PURE__ */ new Map());
+    __publicField(this, "assetBySource", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "pendingEncodes", /* @__PURE__ */ new Set());
+    __publicField(this, "props", {});
+    __publicField(this, "stack", []);
+    __publicField(this, "cpuMs", 0);
+    __publicField(this, "bound", false);
+    __publicField(this, "retainAssets");
+    __publicField(this, "pendingSiteId");
+    __publicField(this, "textRedactor");
+    __publicField(this, "maskDepth", 0);
+    __publicField(this, "hasMaskedDraws", false);
+    __publicField(this, "redactStyle", r);
+    __publicField(this, "textOnlyMask", false);
+    __publicField(this, "maskedRegions", []);
+    __publicField(this, "keyframeUnsafe", false);
+    __publicField(this, "maskPathBounds", null);
+    __publicField(this, "objRefs", /* @__PURE__ */ new WeakMap());
+    this.ctx = t2, this.sink = e2, this.now = s2, this.assetMode = a2, this.encodeImage = i2, this.retainAssets = false !== (r2 == null ? void 0 : r2.retainAssets);
+  }
+  get rawCtx() {
+    return this.ctx;
+  }
+  swapSink(t2) {
+    var _a;
+    const e2 = this.sink;
+    if (this.sink = t2, this.bound = true, e2 instanceof BufferSink) {
+      for (const s2 of e2.ops) t2.onOp(s2);
+      for (const s2 of e2.assetEvents) t2.onAssetBytes(s2.id, s2.bytes, s2.t);
+      for (const s2 of e2.assetData) (_a = t2.onAssetData) == null ? void 0 : _a.call(t2, s2.info, s2.payload);
+      for (const s2 of e2.notes) t2.note(s2);
+    }
+  }
+  addAsset(t2, e2) {
+    if (this.assets.set(t2, e2), !this.retainAssets && this.assets.size > 2048) {
+      const t3 = this.assets.size - 2048;
+      let e3 = 0;
+      for (const s2 of this.assets.keys()) {
+        if (e3 >= t3) break;
+        this.assets.delete(s2), e3++;
+      }
+    }
+  }
+  takePendingSiteId() {
+    const t2 = this.pendingSiteId;
+    return this.pendingSiteId = void 0, t2;
+  }
+  recordCall(t2, e2) {
+    if (this.maskDepth > 0) return this.maskCall(t2, e2), void (this.pendingSiteId = void 0);
+    if (this.sink instanceof DiscardSink) return this.sink.onOp(y), void (this.pendingSiteId = void 0);
+    "clearRect" === t2 && this.maskedRegions.length > 0 && this.clipRegionsToClear(e2);
+    const s2 = performance.now(), a2 = this.now();
+    if (void 0 !== this.textRedactor && ("fillText" === t2 || "strokeText" === t2)) {
+      const t3 = e2[0];
+      if ("string" == typeof t3) {
+        const a3 = this.textRedactor(t3);
+        if (a3 !== t3) {
+          if (this.pushMaskRegion(this.textRegionFor(t3, e2)), "bar" === this.redactStyle.text) return this.emitRedactionBlock(this.textLocalRect(t3, e2)), void (this.cpuMs += performance.now() - s2);
+          (e2 = e2.slice())[0] = a3;
+        }
+      }
+    }
+    if ("save" === t2) this.stack.push({ props: { ...this.props }, transform: this.readTransform() });
+    else if ("restore" === t2) {
+      const t3 = this.stack.pop();
+      t3 && (this.props = t3.props);
+    }
+    const i2 = this.takePendingSiteId(), r2 = { t: a2, op: t2, args: this.serializeArgs(e2, a2) };
+    i2 && (r2.sfId = i2), this.sink.onOp(r2), this.cpuMs += performance.now() - s2;
+  }
+  serializeArgs(t2, e2) {
+    const s2 = t2.length, a2 = new Array(s2);
+    for (let i2 = 0; i2 < s2; i2++) {
+      const s3 = t2[i2];
+      switch (typeof s3) {
+        case "number":
+          a2[i2] = Number.isFinite(s3) ? s3 : 0;
+          break;
+        case "string":
+        case "boolean":
+          a2[i2] = s3;
+          break;
+        case "undefined":
+          a2[i2] = null;
+          break;
+        default:
+          a2[i2] = this.serializeArg(s3, e2);
+      }
+    }
+    return a2;
+  }
+  recordSet(t2, e2) {
+    if (this.maskDepth > 0 && !this.textOnlyMask) return this.hasMaskedDraws = true, void (this.pendingSiteId = void 0);
+    if (this.maskDepth > 0 && (this.hasMaskedDraws = true), this.sink instanceof DiscardSink) return this.sink.onOp(y), void (this.pendingSiteId = void 0);
+    const s2 = performance.now(), a2 = this.now(), i2 = this.serializeArg(e2, a2);
+    this.props[t2] = i2;
+    const r2 = this.takePendingSiteId(), o2 = { t: a2, op: t2, args: [i2], setter: true };
+    r2 && (o2.sfId = r2), this.sink.onOp(o2), this.cpuMs += performance.now() - s2;
+  }
+  maskCall(t2, e2) {
+    if (this.hasMaskedDraws = true, this.sink instanceof DiscardSink) return void this.sink.onOp(y);
+    const s2 = this.redactStyle, a2 = "fillText" === t2 || "strokeText" === t2;
+    if (!this.textOnlyMask || a2) if ("save" === t2 || "restore" === t2 || R.has(t2)) this.recordPassthrough(t2, e2);
+    else {
+      if (a2) {
+        const a3 = e2[0];
+        if ("string" != typeof a3) return;
+        if (this.pushMaskRegion(this.textRegionFor(a3, e2)), "asterisks" === s2.text) {
+          const s3 = e2.slice();
+          s3[0] = maskAllText(a3), this.emitSynthCall(t2, s3);
+        } else this.emitRedactionBlock(this.textLocalRect(a3, e2));
+        return;
+      }
+      if (M.has(t2)) return this.updatePathBounds(t2, e2), void ("color" === s2.shape && this.emitSynthCall(t2, e2));
+      if (T.has(t2)) {
+        this.pushMaskRegion(this.shapeRegion(t2, e2));
+        if (!("remove" === s2.shape || "putImageData" === t2)) if ("color" !== s2.shape || "fill" !== t2 && "stroke" !== t2 && "fillRect" !== t2 && "strokeRect" !== t2) this.emitRedactionBlock(this.shapeLocalRect(t2, e2));
+        else {
+          const s3 = "stroke" === t2 || "strokeRect" === t2 ? "strokeStyle" : "fillStyle";
+          this.emitSynthCall("save", []), this.emitSynthSetter(s3, o), this.emitSynthCall(t2, "fill" === t2 || "stroke" === t2 ? [] : e2), this.emitSynthCall("restore", []);
+        }
+        return void ("fill" !== t2 && "stroke" !== t2 || (this.maskPathBounds = null));
+      }
+    }
+    else this.recordPassthrough(t2, e2);
+  }
+  recordPassthrough(t2, e2) {
+    if (this.sink instanceof DiscardSink) return void this.sink.onOp(y);
+    const s2 = this.now();
+    if ("save" === t2) this.stack.push({ props: { ...this.props }, transform: this.readTransform() });
+    else if ("restore" === t2) {
+      const t3 = this.stack.pop();
+      t3 && (this.props = t3.props);
+    }
+    this.sink.onOp({ t: s2, op: t2, args: this.serializeArgs(e2, s2) });
+  }
+  pushRegion(t2) {
+    t2 && t2.w > 0 && t2.h > 0 && (this.maskedRegions.push(t2), this.maskedRegions.length > 4096 && this.coalesceRegions());
+  }
+  coalesceRegions() {
+    const t2 = this.canvasSize();
+    if (!t2) {
+      const t3 = (function unionRegion(t4) {
+        if (0 === t4.length) return null;
+        let e3 = 1 / 0, s3 = 1 / 0, a3 = -1 / 0, i3 = -1 / 0;
+        for (const r3 of t4) r3.x < e3 && (e3 = r3.x), r3.y < s3 && (s3 = r3.y), r3.x + r3.w > a3 && (a3 = r3.x + r3.w), r3.y + r3.h > i3 && (i3 = r3.y + r3.h);
+        return { x: e3, y: s3, w: a3 - e3, h: i3 - s3 };
+      })(this.maskedRegions);
+      return this.maskedRegions.length = 0, void (t3 && this.maskedRegions.push(t3));
+    }
+    let e2 = 64;
+    const fits = () => Math.ceil(t2.w / e2) * Math.ceil(t2.h / e2) <= 4096;
+    for (; !fits(); ) e2 *= 2;
+    const s2 = Math.max(1, Math.ceil(t2.w / e2)), a2 = s2 - 1, i2 = Math.max(0, Math.ceil(t2.h / e2) - 1), r2 = /* @__PURE__ */ new Map();
+    for (const o2 of this.maskedRegions) {
+      const c2 = Math.min(a2, Math.max(0, Math.floor(o2.x / e2))), h2 = Math.min(a2, Math.max(c2, Math.floor((o2.x + o2.w - 1) / e2))), l2 = Math.min(i2, Math.max(0, Math.floor(o2.y / e2))), d2 = Math.min(i2, Math.max(l2, Math.floor((o2.y + o2.h - 1) / e2)));
+      for (let a3 = l2; a3 <= d2; a3++) for (let i3 = c2; i3 <= h2; i3++) {
+        const o3 = a3 * s2 + i3;
+        if (!r2.has(o3)) {
+          const s3 = i3 * e2, c3 = a3 * e2;
+          r2.set(o3, { x: s3, y: c3, w: Math.min(e2, t2.w - s3), h: Math.min(e2, t2.h - c3) });
+        }
+      }
+    }
+    this.maskedRegions.length = 0;
+    for (const t3 of r2.values()) this.maskedRegions.push(t3);
+  }
+  pushMaskRegion(t2) {
+    t2 && t2.w > 0 && t2.h > 0 ? this.pushRegion(t2) : this.keyframeUnsafe = true;
+  }
+  resetMaskedRegions() {
+    this.maskedRegions.length = 0, this.maskPathBounds = null, this.keyframeUnsafe = false;
+  }
+  clipRegionsToClear(t2) {
+    if (0 === this.maskedRegions.length) return;
+    const e2 = this.getMat();
+    if (!e2) return;
+    if (!(0 === e2.b && 0 === e2.c || 0 === e2.a && 0 === e2.d)) return;
+    const n = (t3) => Number(t3) || 0, s2 = n(t2[0]), a2 = n(t2[1]), i2 = transformedBox(s2, a2, s2 + n(t2[2]), a2 + n(t2[3]), e2, 0);
+    if (!i2) return;
+    const r2 = i2.x + i2.w, o2 = i2.y + i2.h, c2 = this.maskedRegions.filter((t3) => !(t3.x >= i2.x && t3.y >= i2.y && t3.x + t3.w <= r2 && t3.y + t3.h <= o2));
+    if (c2.length !== this.maskedRegions.length) {
+      this.maskedRegions.length = 0;
+      for (const t3 of c2) this.maskedRegions.push(t3);
+    }
+  }
+  emitSynthCall(t2, e2) {
+    const s2 = this.now();
+    this.sink.onOp({ t: s2, op: t2, args: this.serializeArgs(e2, s2) });
+  }
+  emitSynthSetter(t2, e2) {
+    const s2 = this.now();
+    this.sink.onOp({ t: s2, op: t2, args: [e2], setter: true });
+  }
+  emitRedactionBlock(t2) {
+    t2 && 0 !== t2.w && 0 !== t2.h && (this.emitSynthCall("save", []), this.emitSynthSetter("fillStyle", o), this.emitSynthCall("fillRect", [t2.x, t2.y, t2.w, t2.h]), this.emitSynthCall("restore", []));
+  }
+  updatePathBounds(t2, e2) {
+    if ("beginPath" === t2) return void (this.maskPathBounds = null);
+    const n = (t3) => Number(t3) || 0, ext = (t3, e3) => {
+      if (!Number.isFinite(t3) || !Number.isFinite(e3)) return;
+      const s2 = this.maskPathBounds ?? { minX: t3, minY: e3, maxX: t3, maxY: e3 };
+      s2.minX = Math.min(s2.minX, t3), s2.minY = Math.min(s2.minY, e3), s2.maxX = Math.max(s2.maxX, t3), s2.maxY = Math.max(s2.maxY, e3), this.maskPathBounds = s2;
+    };
+    switch (t2) {
+      case "moveTo":
+      case "lineTo":
+        ext(n(e2[0]), n(e2[1]));
+        break;
+      case "rect":
+      case "roundRect":
+        ext(n(e2[0]), n(e2[1])), ext(n(e2[0]) + n(e2[2]), n(e2[1]) + n(e2[3]));
+        break;
+      case "arc": {
+        const t3 = n(e2[2]);
+        ext(n(e2[0]) - t3, n(e2[1]) - t3), ext(n(e2[0]) + t3, n(e2[1]) + t3);
+        break;
+      }
+      case "ellipse": {
+        const t3 = n(e2[2]), s2 = n(e2[3]);
+        ext(n(e2[0]) - t3, n(e2[1]) - s2), ext(n(e2[0]) + t3, n(e2[1]) + s2);
+        break;
+      }
+      case "arcTo":
+      case "quadraticCurveTo":
+        ext(n(e2[0]), n(e2[1])), ext(n(e2[2]), n(e2[3]));
+        break;
+      case "bezierCurveTo":
+        ext(n(e2[0]), n(e2[1])), ext(n(e2[2]), n(e2[3])), ext(n(e2[4]), n(e2[5]));
+    }
+  }
+  shapeLocalRect(t2, e2) {
+    const n = (t3) => Number(t3) || 0;
+    if ("fillRect" === t2 || "strokeRect" === t2) return { x: n(e2[0]), y: n(e2[1]), w: n(e2[2]), h: n(e2[3]) };
+    if ("fill" === t2 || "stroke" === t2) {
+      const t3 = this.maskPathBounds;
+      return t3 ? { x: t3.minX, y: t3.minY, w: t3.maxX - t3.minX, h: t3.maxY - t3.minY } : null;
+    }
+    return "drawImage" === t2 ? this.drawImageDest(e2) : null;
+  }
+  shapeRegion(t2, e2) {
+    const n = (t3) => Number(t3) || 0;
+    if ("putImageData" === t2) {
+      const t3 = e2[0], s3 = n(t3 == null ? void 0 : t3.width), a3 = n(t3 == null ? void 0 : t3.height);
+      return s3 > 0 && a3 > 0 ? { x: n(e2[1]), y: n(e2[2]), w: s3, h: a3 } : null;
+    }
+    const s2 = this.getMat(), a2 = this.shapeLocalRect(t2, e2);
+    return s2 && a2 ? (function rectRegion(t3, e3, s3, a3, i2) {
+      return transformedBox(t3, e3, t3 + s3, e3 + a3, i2);
+    })(a2.x, a2.y, a2.w, a2.h, s2) : null;
+  }
+  drawImageDest(t2) {
+    const n = (t3) => Number(t3) || 0;
+    if (t2.length >= 9) return { x: n(t2[5]), y: n(t2[6]), w: n(t2[7]), h: n(t2[8]) };
+    if (t2.length >= 5) return { x: n(t2[1]), y: n(t2[2]), w: n(t2[3]), h: n(t2[4]) };
+    if (t2.length >= 3) {
+      const e2 = t2[0];
+      return { x: n(t2[1]), y: n(t2[2]), w: n(e2 == null ? void 0 : e2.width), h: n(e2 == null ? void 0 : e2.height) };
+    }
+    return null;
+  }
+  textRegionFor(t2, e2) {
+    const s2 = this.getMat();
+    if (!s2) return null;
+    const a2 = Math.max(Math.hypot(s2.a, s2.b), Math.hypot(s2.c, s2.d)) || 1, i2 = this.fontSizePx(), r2 = Math.max(256, 0.5 * i2 * a2), o2 = Math.min(Math.max(2, 0.15 * i2 * a2), r2);
+    return (function textRegion(t3, e3, s3 = 1) {
+      const a3 = textLocalBox(t3);
+      return transformedBox(a3.x0, a3.y0, a3.x1, a3.y1, e3, s3);
+    })(this.textMetrics(t2, e2), s2, o2);
+  }
+  textLocalRect(t2, e2) {
+    const s2 = textLocalBox(this.textMetrics(t2, e2));
+    return { x: s2.x0, y: s2.y0, w: s2.x1 - s2.x0, h: s2.y1 - s2.y0 };
+  }
+  textMetrics(t2, e2) {
+    const s2 = Number(e2[1]) || 0, a2 = Number(e2[2]) || 0, i2 = this.ctx;
+    let r2, o2, c2 = NaN, h2 = NaN, l2 = NaN;
+    if ("function" == typeof i2.measureText) try {
+      const e3 = i2.measureText(t2);
+      c2 = e3.width, h2 = e3.actualBoundingBoxAscent, l2 = e3.actualBoundingBoxDescent, r2 = i2.textAlign, o2 = i2.textBaseline;
+    } catch {
+    }
+    const d2 = this.fontSizePx();
+    return Number.isFinite(c2) || (c2 = t2.length * d2 * 0.6), (!Number.isFinite(h2) || h2 <= 0) && (h2 = 0.8 * d2), (!Number.isFinite(l2) || l2 < 0) && (l2 = 0.2 * d2), void 0 === r2 && "string" == typeof this.props.textAlign && (r2 = this.props.textAlign), void 0 === o2 && "string" == typeof this.props.textBaseline && (o2 = this.props.textBaseline), { width: c2, ascent: h2, descent: l2, x: s2, y: a2, align: r2, baseline: o2 };
+  }
+  fontSizePx() {
+    const t2 = this.props.font;
+    if ("string" == typeof t2) {
+      const e2 = t2.match(/(\d+(?:\.\d+)?)px/);
+      if (e2) return parseFloat(e2[1]);
+    }
+    return 12;
+  }
+  canvasSize() {
+    const t2 = this.ctx.canvas;
+    return t2 && Number(t2.width) > 0 && Number(t2.height) > 0 ? { w: Number(t2.width), h: Number(t2.height) } : null;
+  }
+  getMat() {
+    try {
+      const t2 = this.ctx.getTransform();
+      return { a: t2.a, b: t2.b, c: t2.c, d: t2.d, e: t2.e, f: t2.f };
+    } catch {
+      return null;
+    }
+  }
+  snapshotState() {
+    return { stack: this.stack.map((t2) => ({ props: { ...t2.props }, transform: [...t2.transform] })), current: { props: { ...this.props }, transform: this.readTransform() } };
+  }
+  async settle() {
+    for (; this.pendingEncodes.size; ) await Promise.all([...this.pendingEncodes]);
+  }
+  pendingEncodeCount() {
+    return this.pendingEncodes.size;
+  }
+  trackEncode(t2) {
+    this.pendingEncodes.add(t2), t2.then(() => {
+    }, () => {
+    }).finally(() => this.pendingEncodes.delete(t2));
+  }
+  readTransform() {
+    const t2 = this.ctx.getTransform();
+    return [t2.a, t2.b, t2.c, t2.d, t2.e, t2.f];
+  }
+  serializeArg(t2, e2) {
+    var _a;
+    if (null === t2) return null;
+    switch (typeof t2) {
+      case "number":
+        return Number.isFinite(t2) ? t2 : 0;
+      case "string":
+      case "boolean":
+        return t2;
+      case "undefined":
+        return null;
+      case "object":
+        break;
+      default:
+        return { $: "unsupported", kind: typeof t2 };
+    }
+    const s2 = t2;
+    if (l.has(s2)) return this.serializeFactoryObject(s2, e2);
+    const a2 = /* @__PURE__ */ (function getNativePath2D() {
+      return f;
+    })();
+    return a2 && s2 instanceof a2 ? (this.sink.note("Path2D created before instrumentation — not serialized"), { $: "unsupported", kind: "Path2D" }) : Array.isArray(s2) ? { $: "arr", v: s2.map((t3) => Number(t3) || 0) } : s2 instanceof DOMMatrix || s2 instanceof DOMMatrixReadOnly ? { $: "arr", v: [s2.a, s2.b, s2.c, s2.d, s2.e, s2.f] } : s2 instanceof ImageData ? this.captureImageData(s2, e2) : (function isImageSource(t3) {
+      return "undefined" != typeof HTMLImageElement && t3 instanceof HTMLImageElement || "undefined" != typeof HTMLCanvasElement && t3 instanceof HTMLCanvasElement || "undefined" != typeof HTMLVideoElement && t3 instanceof HTMLVideoElement || "undefined" != typeof ImageBitmap && t3 instanceof ImageBitmap || "undefined" != typeof OffscreenCanvas && t3 instanceof OffscreenCanvas;
+    })(s2) ? this.captureImageSource(s2, e2) : { $: "unsupported", kind: ((_a = s2.constructor) == null ? void 0 : _a.name) ?? "object" };
+  }
+  serializeFactoryObject(t2, e2) {
+    const s2 = l.get(t2);
+    let a2 = this.objRefs.get(t2);
+    a2 || (a2 = { id: S++, emittedCalls: 0 }, this.objRefs.set(t2, a2), this.sink.onOp({ t: e2, op: "__create", create: true, args: [s2.factory, a2.id, ...s2.args.map((t3) => this.serializeArg(t3, e2))] }));
+    for (let t3 = a2.emittedCalls; t3 < s2.calls.length; t3++) {
+      const i2 = s2.calls[t3];
+      this.sink.onOp({ t: e2, op: "__objcall", objcall: true, args: [a2.id, i2.method, ...i2.args.map((t4) => this.serializeArg(t4, e2))] });
+    }
+    return a2.emittedCalls = s2.calls.length, { $: "obj", id: a2.id };
+  }
+  captureImageData(t2, e2) {
+    const s2 = x++, a2 = new ImageData(new Uint8ClampedArray(t2.data), t2.width, t2.height), i2 = { id: s2, kind: "imagedata", t: e2, bytes: 0, w: t2.width, h: t2.height };
+    return this.retainAssets && (i2.imageData = a2), this.addAsset(s2, i2), this.trackEncode(deflate(new Uint8Array(a2.data.buffer, a2.data.byteOffset, a2.data.byteLength)).then((a3) => {
+      var _a, _b;
+      i2.bytes = a3.length, this.sink.onAssetBytes(s2, a3.length, e2), (_b = (_a = this.sink).onAssetData) == null ? void 0 : _b.call(_a, { id: s2, format: "imagedata", w: t2.width, h: t2.height, t: e2 }, a3);
+    }).catch((t3) => this.sink.note(`imagedata deflate failed: ${t3.message}`))), { $: "imagedata", id: s2 };
+  }
+  captureImageSource(t2, e2) {
+    var _a, _b, _c, _d;
+    const s2 = "undefined" != typeof HTMLVideoElement && t2 instanceof HTMLVideoElement, a2 = s2 || "undefined" != typeof HTMLCanvasElement && t2 instanceof HTMLCanvasElement || "undefined" != typeof OffscreenCanvas && t2 instanceof OffscreenCanvas;
+    if (s2 && ((_b = (_a = this.sink).onVideoSource) == null ? void 0 : _b.call(_a, e2)), !a2 && this.assetBySource.has(t2)) return { $: "asset", id: this.assetBySource.get(t2) };
+    const i2 = x++;
+    a2 || this.assetBySource.set(t2, i2);
+    const r2 = { id: i2, kind: "image", t: e2, bytes: 0 };
+    if (this.addAsset(i2, r2), "dataurl" === this.assetMode) {
+      const s3 = performance.now();
+      try {
+        const { w: s4, h: a3 } = (function sourceSize(t3) {
+          if (t3 instanceof HTMLVideoElement) return { w: t3.videoWidth || 1, h: t3.videoHeight || 1 };
+          if (t3 instanceof HTMLImageElement) return { w: t3.naturalWidth || 1, h: t3.naturalHeight || 1 };
+          const e3 = t3;
+          return { w: Number(e3.width) || 1, h: Number(e3.height) || 1 };
+        })(t2), o2 = document.createElement("canvas");
+        o2.width = s4, o2.height = a3;
+        const c2 = o2.getContext("2d");
+        D.add(c2), c2.drawImage(t2, 0, 0);
+        const h2 = o2.toDataURL("image/png");
+        r2.bytes = h2.length, r2.w = s4, r2.h = a3, this.sink.onAssetBytes(i2, h2.length, e2), this.retainAssets && this.trackEncode(createImageBitmap(o2).then((t3) => {
+          r2.bitmap = t3;
+        }));
+      } catch (t3) {
+        this.sink.note(`asset capture failed: ${t3.message}`), isTaintError(t3) && ((_d = (_c = this.sink).onTaint) == null ? void 0 : _d.call(_c, e2));
+      }
+      this.cpuMs += performance.now() - s3;
+    } else {
+      const s3 = performance.now();
+      this.trackEncode(createImageBitmap(t2).then(async (t3) => {
+        var _a2, _b2;
+        const s4 = t3.width, a3 = t3.height;
+        let o2 = t3;
+        this.retainAssets && (r2.bitmap = t3, o2 = await createImageBitmap(t3));
+        const c2 = await this.encodeImage(o2);
+        r2.bytes = c2.size, r2.w = s4, r2.h = a3, this.sink.onAssetBytes(i2, c2.size, e2), c2.bytes && ((_b2 = (_a2 = this.sink).onAssetData) == null ? void 0 : _b2.call(_a2, { id: i2, format: "webp", w: s4, h: a3, t: e2 }, new Uint8Array(c2.bytes)));
+      }).catch((t3) => {
+        var _a2, _b2;
+        this.sink.note(`asset encode failed: ${t3.message}`), isTaintError(t3) && ((_b2 = (_a2 = this.sink).onTaint) == null ? void 0 : _b2.call(_a2, e2));
+      })), this.cpuMs += performance.now() - s3;
+    }
+    return { $: "asset", id: i2 };
+  }
+}
+function isTaintError(t2) {
+  if (!t2 || "object" != typeof t2) return false;
+  if ("SecurityError" === t2.name) return true;
+  const e2 = t2.message;
+  return "string" == typeof e2 && /tainted|cross-origin|insecure/i.test(e2);
+}
+let E = false;
+function patch2DProto(t2) {
+  const e2 = t2;
+  installFactoryLoggingOnProto(t2), installSharedObjectLogging();
+  for (const s2 of Object.getOwnPropertyNames(t2)) {
+    const a2 = Object.getOwnPropertyDescriptor(t2, s2);
+    if (a2) {
+      if ("function" == typeof a2.value && "constructor" !== s2) {
+        const t3 = a2.value;
+        d.includes(s2) || "getImageData" === s2 || "getTransform" === s2 || "isPointInPath" === s2 || "isPointInStroke" === s2 || "measureText" === s2 || "getLineDash" === s2 || "getContextAttributes" === s2 || "createImageData" === s2 || (e2[s2] = function(...e3) {
+          const a3 = A.get(this);
+          return a3 ? a3.recordCall(s2, e3) : I && !D.has(this) && I(this), t3.apply(this, e3);
+        });
+      } else if (a2.set && b.includes(s2)) {
+        const { get: e3, set: i2 } = a2;
+        Object.defineProperty(t2, s2, { configurable: true, get: e3, set(t3) {
+          const e4 = A.get(this);
+          e4 ? e4.recordSet(s2, t3) : I && !D.has(this) && I(this), i2.call(this, t3);
+        } });
+      }
+    }
+  }
+}
+function installCommandHooks() {
+  if (E) return;
+  E = true, patch2DProto(CanvasRenderingContext2D.prototype);
+  const t2 = HTMLCanvasElement.prototype.getContext;
+  HTMLCanvasElement.prototype.getContext = function(e2, s2) {
+    const a2 = t2.call(this, e2, s2);
+    if (a2 && !L.has(this) && L.set(this, { type: e2, attrs: s2 ?? void 0 }), "2d" === e2 && a2 && B && !A.has(a2)) {
+      const t3 = new ContextRecorder(a2, new BufferSink(), B.now, B.assetMode, B.encodeImage, { retainAssets: B.retainAssets });
+      A.set(a2, t3), P.set(this, t3);
+    }
+    return a2 && O && O(this, e2), a2;
+  };
+}
+function attachRecorderToContext(t2, e2, s2, a2, i2, r2) {
+  const o2 = new ContextRecorder(t2, e2, s2, a2, i2, r2);
+  return o2.bound = true, A.set(t2, o2), o2;
+}
+function attachRecorder(t2, e2, s2, a2, i2, r2) {
+  const o2 = P.get(t2);
+  if (o2) return o2.swapSink(e2), o2;
+  let c2 = null;
+  try {
+    c2 = t2.getContext("2d");
+  } catch {
+    return null;
+  }
+  if (!c2) return null;
+  const h2 = new ContextRecorder(c2, e2, s2, a2, i2, r2);
+  return h2.bound = true, A.set(c2, h2), h2;
+}
+function detachRecorderFromContext(t2) {
+  A.delete(t2);
+}
+function noteCtxPendingSiteId(t2, e2) {
+  const s2 = A.get(t2);
+  return !!s2 && (s2.pendingSiteId = e2, true);
+}
+export {
+  classifyCanvasPrivacy as A,
+  BufferSink as B,
+  CommandEncoder as C,
+  DiscardSink as D,
+  redactCanvasText as E,
+  releaseAutoRecorder as F,
+  getContextInfo as G,
+  bytesToBase64 as H,
+  wasPreAttachMaskUsed as I,
+  suppressReason as J,
+  buildFrame as K,
+  setContextCreatedNotifier as L,
+  setUntracked2DContextNotifier as M,
+  o as R,
+  m as T,
+  attachRecorderToContext as a,
+  buildMaskInputFn as b,
+  redactCreditCard as c,
+  deflate as d,
+  looksLikeSsn as e,
+  redactSsn as f,
+  redactDob as g,
+  recorderForContext as h,
+  resolveRedactStyle as i,
+  installEarlyObjectLogging as j,
+  ignore2DContext as k,
+  looksLikeCreditCard as l,
+  makeMaskTextFn as m,
+  notePreAttachMaskUsed as n,
+  isTaintError as o,
+  patch2DProto as p,
+  y as q,
+  redactSensitiveContent as r,
+  serializeTypedArray as s,
+  r as t,
+  installCommandHooks as u,
+  setAutoAttach as v,
+  noteCtxPendingSiteId as w,
+  pruneUnboundRecorders as x,
+  detachRecorderFromContext as y,
+  attachRecorder as z
+};