issue-sticker 0.8.0 → 0.9.0

package/dist/{mouse-pointer-2-BR00y3ir.js → three-B7nbYqGK.js}

@@ -2,6 +2,772 @@ import * as React from "react";
 import { useLayoutEffect, forwardRef, createElement } from "react";
 import { jsx } from "react/jsx-runtime";
 import * as ReactDOM from "react-dom";
+function forEachElementDeep(root2, callback) {
+  if (root2 instanceof Element) {
+    callback(root2);
+    if (root2.shadowRoot) {
+      forEachElementDeep(root2.shadowRoot, callback);
+    }
+  }
+  Array.from(root2.children).forEach((child) => {
+    forEachElementDeep(child, callback);
+  });
+}
+const SESSION_REPLAY_BLOCK_CLASS = "rr-block";
+const SESSION_REPLAY_MASK_CLASS = "rr-mask";
+const SESSION_REPLAY_UNMASK_CLASS = "rr-unmask";
+const FOREIGN_BLOCK_SELECTORS = [
+  // FullStory
+  ".fs-exclude",
+  ".fs-block",
+  // Sentry — ignore 는 의미가 "입력 이벤트를 기록하지 않는다"라 차단과 어긋나지만,
+  // 빼면 이미 그것에 기대고 있는 고객에게 회귀다. 과잉 마스킹은 안전한 방향이라 둔다.
+  ".sentry-block",
+  ".sentry-ignore",
+  "[data-sentry-block]",
+  // PostHog
+  ".ph-no-capture",
+  // Hotjar
+  "[data-hj-suppress]",
+  // OpenReplay
+  "[data-openreplay-hidden]",
+  // Highlight.io
+  ".highlight-block",
+  ".highlight-ignore",
+  // Heap
+  "[data-heap-ignore]",
+  ".heap-ignore"
+];
+const FOREIGN_MASK_SELECTORS = [
+  // FullStory
+  ".fs-mask",
+  // Sentry
+  ".sentry-mask",
+  "[data-sentry-mask]",
+  // LogRocket
+  "[data-private]",
+  // Microsoft Clarity
+  "[data-clarity-mask]",
+  // Hotjar
+  "[data-hj-masked]",
+  // OpenReplay
+  "[data-openreplay-obscured]",
+  // Highlight.io
+  ".highlight-mask",
+  // ContentSquare
+  "[data-cs-mask]",
+  "[data-cs-encrypt]",
+  // Heap
+  "[data-heap-redact-text]",
+  "[data-heap-redact-attributes]",
+  // Amplitude
+  "[data-amp-mask]",
+  // Matomo
+  "[data-matomo-mask]"
+];
+const FOREIGN_UNMASK_SELECTORS = [
+  ".fs-unmask",
+  ".sentry-unmask",
+  "[data-clarity-unmask]",
+  "[data-amp-unmask]",
+  "[data-cs-capture]"
+];
+const SESSION_REPLAY_FULL_MASK_SELECTOR = [
+  `.${SESSION_REPLAY_MASK_CLASS}`,
+  ...FOREIGN_MASK_SELECTORS
+].join(",");
+const SESSION_REPLAY_BLOCK_SELECTOR = [
+  `.${SESSION_REPLAY_BLOCK_CLASS}`,
+  ...FOREIGN_BLOCK_SELECTORS
+].join(",");
+const SESSION_REPLAY_UNMASK_SELECTOR = [
+  `.${SESSION_REPLAY_UNMASK_CLASS}`,
+  ...FOREIGN_UNMASK_SELECTORS
+].join(",");
+function isElementFullyMasked(element, maskSelector = SESSION_REPLAY_FULL_MASK_SELECTOR, unmaskSelector = SESSION_REPLAY_UNMASK_SELECTOR) {
+  if (!element) return false;
+  try {
+    const nearest = element.closest(`${maskSelector},${unmaskSelector}`);
+    return nearest !== null && nearest.matches(maskSelector);
+  } catch {
+    return true;
+  }
+}
+const DEFAULT_PRIVACY_CONFIG_V2 = {
+  version: "v2",
+  maskAllInputs: true,
+  maskTextSelector: "*",
+  fullMaskSelector: SESSION_REPLAY_FULL_MASK_SELECTOR,
+  unmaskSelector: SESSION_REPLAY_UNMASK_SELECTOR,
+  blockSelector: SESSION_REPLAY_BLOCK_SELECTOR,
+  allowCanvasRecording: false
+};
+function resolvePrivacyConfig(override) {
+  if (!override) return DEFAULT_PRIVACY_CONFIG_V2;
+  return { ...DEFAULT_PRIVACY_CONFIG_V2, ...override };
+}
+const REDACTED_HEADER_VALUE = "[redacted]";
+const SENSITIVE_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "api-key",
+  "apikey",
+  "x-auth-token",
+  "x-access-token",
+  "x-refresh-token",
+  "x-session-token",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-amz-security-token",
+  "x-goog-api-key"
+]);
+function isSensitiveHeaderName(headerName) {
+  return SENSITIVE_HEADER_NAMES.has(headerName.toLowerCase());
+}
+function redactSensitiveHeaders(headers) {
+  if (!headers) return headers;
+  let changed = false;
+  const redacted = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (value && isSensitiveHeaderName(name)) {
+      redacted[name] = REDACTED_HEADER_VALUE;
+      changed = true;
+    } else {
+      redacted[name] = value;
+    }
+  }
+  return changed ? redacted : headers;
+}
+const REDACTED_BODY_VALUE = "[redacted]";
+const SENSITIVE_KEY_MARKERS = [
+  "password",
+  "passwd",
+  "pwd",
+  "secret",
+  "token",
+  "apikey",
+  "privatekey",
+  "credential",
+  // 결제·본인확인 계열. 토스페이먼츠 공식 문서의 필드명을 그대로 딴다.
+  // cardNumber / customerIdentityNumber / businessNumber / accountNumber(가상계좌)
+  "cardnumber",
+  "identitynumber",
+  "businessnumber",
+  "registrationnumber",
+  "accountnumber"
+];
+const SENSITIVE_KEY_EXACT = /* @__PURE__ */ new Set([
+  "otp",
+  "auth",
+  "authorization",
+  "bearer",
+  // 토스페이먼츠. billingKey + customerKey 조합이면 결제를 낼 수 있고, authKey 는 일회성
+  // 인증 키다(우리 admin 결제 성공 URL 의 쿼리 파라미터로 실제로 실린다).
+  // paymentKey 는 넣지 않는다 — 시크릿 키 없이는 아무것도 못 하는 식별자이고, 결제 장애
+  // 진단의 출발점이라 가리면 로그가 쓸모를 잃는다.
+  "billingkey",
+  "customerkey",
+  "authkey"
+]);
+const MAX_WALK_DEPTH = 20;
+function isSensitiveFieldName(name) {
+  const normalized = name.toLowerCase().replace(/[-_\s]/g, "");
+  if (SENSITIVE_KEY_EXACT.has(normalized)) {
+    return true;
+  }
+  return SENSITIVE_KEY_MARKERS.some((marker) => normalized.includes(marker));
+}
+function redactJsonValue(value, depth) {
+  if (typeof value === "string") {
+    const redacted = redactSensitiveValues(value);
+    return { value: redacted, changed: redacted !== value };
+  }
+  if (depth > MAX_WALK_DEPTH || value === null || typeof value !== "object") {
+    return { value, changed: false };
+  }
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const next2 = value.map((item) => {
+      const result2 = redactJsonValue(item, depth + 1);
+      changed2 || (changed2 = result2.changed);
+      return result2.value;
+    });
+    return changed2 ? { value: next2, changed: changed2 } : { value, changed: changed2 };
+  }
+  let changed = false;
+  const next = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== "" && item != null && typeof item !== "boolean" && isSensitiveFieldName(key)) {
+      next[key] = REDACTED_BODY_VALUE;
+      changed = true;
+      continue;
+    }
+    const result2 = redactJsonValue(item, depth + 1);
+    changed || (changed = result2.changed);
+    next[key] = result2.value;
+  }
+  return changed ? { value: next, changed } : { value, changed };
+}
+function redactKeyValuePairs(body) {
+  let changed = false;
+  const redacted = body.split("&").map((pair) => {
+    const separator = pair.indexOf("=");
+    if (separator <= 0) {
+      return pair;
+    }
+    const rawKey = pair.slice(0, separator);
+    const rawValue = pair.slice(separator + 1);
+    if (!rawValue) {
+      return pair;
+    }
+    if (isSensitiveFieldName(decodeURIComponent(rawKey))) {
+      changed = true;
+      return `${rawKey}=${encodeURIComponent(REDACTED_BODY_VALUE)}`;
+    }
+    const redactedValue = redactSensitiveValues(decodeURIComponent(rawValue));
+    if (redactedValue === decodeURIComponent(rawValue)) {
+      return pair;
+    }
+    changed = true;
+    return `${rawKey}=${encodeURIComponent(redactedValue)}`;
+  }).join("&");
+  return changed ? redacted : body;
+}
+function looksLikeFormUrlEncoded(body) {
+  return /^[^=&\s]+=[^&]*(&[^=&\s]+=[^&]*)*$/.test(body);
+}
+function redactSensitiveBody(body) {
+  if (!body) return body;
+  const trimmed = body.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const { value, changed } = redactJsonValue(parsed, 0);
+      return changed ? JSON.stringify(value) : body;
+    } catch {
+    }
+  }
+  if (looksLikeFormUrlEncoded(trimmed)) {
+    const redacted = redactKeyValuePairs(trimmed);
+    return redacted === trimmed ? body : redacted;
+  }
+  return body;
+}
+const JWT_PATTERN = /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]*/g;
+const BEARER_PATTERN = /(Bearer\s+)[A-Za-z0-9._~+/-]{12,}=*/gi;
+const CARD_CANDIDATE_PATTERN = /\b[2-6](?:[ -]?\d){13,18}\b/g;
+const RRN_CANDIDATE_PATTERN = /\b(\d{2})(\d{2})(\d{2})-?([1-8])(\d{6})\b/g;
+const BRN_CANDIDATE_PATTERN = /\b(\d{3})-?(\d{2})-?(\d{5})\b/g;
+const BRN_WEIGHTS = [1, 3, 7, 1, 3, 7, 1, 3, 5];
+const KR_MOBILE_PATTERN = /\b01[016789]-?\d{3,4}-?\d{4}\b/g;
+const EMAIL_PATTERN = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g;
+function redactEmails(text) {
+  if (!text) return text;
+  const out = text.replace(EMAIL_PATTERN, REDACTED_BODY_VALUE);
+  return out === text ? text : out;
+}
+function passesBrnChecksum(digits) {
+  let sum = 0;
+  for (let i2 = 0; i2 < 9; i2 += 1) {
+    sum += (digits.charCodeAt(i2) - 48) * BRN_WEIGHTS[i2];
+  }
+  sum += Math.floor((digits.charCodeAt(8) - 48) * 5 / 10);
+  return (10 - sum % 10) % 10 === digits.charCodeAt(9) - 48;
+}
+function passesLuhn(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i2 = digits.length - 1; i2 >= 0; i2 -= 1) {
+    let digit = digits.charCodeAt(i2) - 48;
+    if (double) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function looksLikeBirthDate(month, day) {
+  const monthValue = Number(month);
+  const dayValue = Number(day);
+  return monthValue >= 1 && monthValue <= 12 && dayValue >= 1 && dayValue <= 31;
+}
+function redactSensitiveValues(text) {
+  if (!text) return text;
+  let out = text;
+  out = out.replace(JWT_PATTERN, REDACTED_BODY_VALUE);
+  out = out.replace(BEARER_PATTERN, `$1${REDACTED_BODY_VALUE}`);
+  out = out.replace(CARD_CANDIDATE_PATTERN, (match) => {
+    const digits = match.replace(/[ -]/g, "");
+    return digits.length >= 14 && digits.length <= 19 && passesLuhn(digits) ? REDACTED_BODY_VALUE : match;
+  });
+  out = out.replace(
+    RRN_CANDIDATE_PATTERN,
+    (match, _year, month, day) => looksLikeBirthDate(month, day) ? REDACTED_BODY_VALUE : match
+  );
+  out = out.replace(BRN_CANDIDATE_PATTERN, (match) => {
+    const digits = match.replace(/-/g, "");
+    return passesBrnChecksum(digits) ? REDACTED_BODY_VALUE : match;
+  });
+  out = out.replace(KR_MOBILE_PATTERN, REDACTED_BODY_VALUE);
+  return out === text ? text : out;
+}
+function redactUrlSecrets(url) {
+  if (!url) return url;
+  const queryStart = url.indexOf("?");
+  const fragmentStart = url.indexOf("#");
+  if (queryStart < 0 && fragmentStart < 0) {
+    return redactSensitiveValues(url);
+  }
+  const hasQuery = queryStart >= 0 && (fragmentStart < 0 || queryStart < fragmentStart);
+  const base = url.slice(0, hasQuery ? queryStart : fragmentStart);
+  const query = hasQuery ? url.slice(queryStart + 1, fragmentStart >= 0 ? fragmentStart : void 0) : "";
+  const fragment = fragmentStart >= 0 ? url.slice(fragmentStart + 1) : "";
+  const redactedQuery = redactKeyValuePairs(query);
+  const redactedFragment = fragment.includes("=") ? redactKeyValuePairs(fragment) : fragment;
+  const redactedBase = redactSensitiveValues(base);
+  if (redactedBase === base && redactedQuery === query && redactedFragment === fragment) {
+    return url;
+  }
+  return redactedBase + (hasQuery ? `?${redactedQuery}` : "") + (fragmentStart >= 0 ? `#${redactedFragment}` : "");
+}
+function redactSensitiveText(text) {
+  if (!text) return text;
+  return redactSensitiveValues(redactUrlSecrets(redactSensitiveBody(text)));
+}
+const SCREENSHOT_FULL_MASK_SELECTOR = SESSION_REPLAY_FULL_MASK_SELECTOR;
+const SCREENSHOT_BLOCK_SELECTOR = SESSION_REPLAY_BLOCK_SELECTOR;
+const SCREENSHOT_MASK_BACKGROUND = "rgba(148, 148, 148, 0.28)";
+const SCREENSHOT_BLOCK_BACKGROUND = "rgba(148, 148, 148, 0.85)";
+const MASK_LABEL_WIDTH = 44;
+const MASK_LABEL_HEIGHT = 16;
+const MASK_LABEL_IMAGE = `url("data:image/svg+xml;charset=utf-8,${encodeURIComponent(
+  `<svg xmlns="http://www.w3.org/2000/svg" width="${MASK_LABEL_WIDTH}" height="${MASK_LABEL_HEIGHT}" viewBox="0 0 ${MASK_LABEL_WIDTH} ${MASK_LABEL_HEIGHT}"><text x="${MASK_LABEL_WIDTH / 2}" y="12" text-anchor="middle" font-family="sans-serif" font-size="11" font-weight="600" fill="#262626">가려짐</text></svg>`
+)}")`;
+const MASK_LABEL_MIN_WIDTH = MASK_LABEL_WIDTH + 8;
+const MASK_LABEL_MIN_HEIGHT = MASK_LABEL_HEIGHT + 8;
+const TEXT_HIDING_PROPERTIES = [
+  ["color", "transparent"],
+  ["-webkit-text-fill-color", "transparent"],
+  ["text-shadow", "none"],
+  ["fill", "transparent"]
+];
+const REPLACED_MEDIA_SELECTOR = "img, svg, video, canvas, picture, iframe, object, embed";
+const VALUE_ELEMENT_SELECTOR = "input, textarea, select";
+const SENSITIVE_AUTOCOMPLETE_TOKENS = /* @__PURE__ */ new Set([
+  // 자격증명
+  "current-password",
+  "new-password",
+  "one-time-code",
+  // 결제
+  "cc-number",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year",
+  "cc-csc",
+  "cc-name",
+  "cc-type",
+  "cc-given-name",
+  "cc-additional-name",
+  "cc-family-name",
+  // 신원
+  "name",
+  "given-name",
+  "additional-name",
+  "family-name",
+  "honorific-prefix",
+  "honorific-suffix",
+  "nickname",
+  "bday",
+  "bday-day",
+  "bday-month",
+  "bday-year",
+  "sex",
+  // 주소
+  "street-address",
+  "address-line1",
+  "address-line2",
+  "address-line3",
+  "postal-code",
+  // 연락처
+  "tel",
+  "tel-national",
+  "tel-local",
+  "tel-area-code",
+  "email",
+  "impp"
+]);
+function redactScreenshotText(text) {
+  return redactEmails(redactSensitiveValues(text));
+}
+function matchesSafely(element, selector) {
+  try {
+    return element.matches(selector);
+  } catch {
+    return false;
+  }
+}
+function closestSafely(element, selector) {
+  if (!element) return null;
+  try {
+    return element.closest(selector);
+  } catch {
+    return null;
+  }
+}
+function hasSensitiveValueHint(element) {
+  var _a2;
+  if (((_a2 = element.getAttribute("type")) == null ? void 0 : _a2.toLowerCase()) === "password") {
+    return true;
+  }
+  const autocomplete = element.getAttribute("autocomplete");
+  if (!autocomplete) return false;
+  return autocomplete.toLowerCase().split(/\s+/).some((token) => SENSITIVE_AUTOCOMPLETE_TOKENS.has(token));
+}
+const overwriteProperty = (element, name, value) => {
+  const style = element.style;
+  style == null ? void 0 : style.setProperty(name, value, "important");
+};
+function coverMaskedRegion(region, setProperty) {
+  setProperty(region, "background-color", SCREENSHOT_MASK_BACKGROUND);
+  forEachElementDeep(region, (node2) => {
+    if (!isElementFullyMasked(node2)) return;
+    TEXT_HIDING_PROPERTIES.forEach(([name, value]) => setProperty(node2, name, value));
+    if (matchesSafely(node2, REPLACED_MEDIA_SELECTOR)) {
+      setProperty(node2, "visibility", "hidden");
+    }
+  });
+}
+function parsePixels(value) {
+  const parsed = Number.parseFloat(value ?? "");
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function fitsMaskLabel(region) {
+  const rect = region.getBoundingClientRect();
+  const style = region.style;
+  const width = rect.width || parsePixels(style == null ? void 0 : style.width);
+  const height = rect.height || parsePixels(style == null ? void 0 : style.height);
+  return width >= MASK_LABEL_MIN_WIDTH && height >= MASK_LABEL_MIN_HEIGHT;
+}
+function coverBlockedRegion(region, setProperty) {
+  const labeled = fitsMaskLabel(region);
+  setProperty(region, "visibility", "visible");
+  setProperty(region, "background-color", SCREENSHOT_BLOCK_BACKGROUND);
+  setProperty(region, "background-image", labeled ? MASK_LABEL_IMAGE : "none");
+  if (labeled) {
+    setProperty(region, "background-repeat", "no-repeat");
+    setProperty(region, "background-position", "center");
+    setProperty(region, "background-size", "auto");
+  }
+  TEXT_HIDING_PROPERTIES.forEach(([name, value]) => setProperty(region, name, value));
+  setProperty(region, "pointer-events", "none");
+  forEachElementDeep(region, (descendant) => {
+    if (descendant !== region) {
+      setProperty(descendant, "visibility", "hidden");
+    }
+  });
+}
+function coverPrivateRegions(root2, setProperty) {
+  const blocked = [];
+  const masked = [];
+  forEachElementDeep(root2, (element) => {
+    if (matchesSafely(element, SCREENSHOT_BLOCK_SELECTOR)) {
+      blocked.push(element);
+      return;
+    }
+    if (matchesSafely(element, SCREENSHOT_FULL_MASK_SELECTOR) && isElementFullyMasked(element)) {
+      masked.push(element);
+    }
+  });
+  masked.forEach((region) => coverMaskedRegion(region, setProperty));
+  blocked.forEach((region) => coverBlockedRegion(region, setProperty));
+}
+function applyScreenshotPrivacyMask(clonedRoot) {
+  coverPrivateRegions(clonedRoot, overwriteProperty);
+  const walker = clonedRoot.ownerDocument.createTreeWalker(clonedRoot, NodeFilter.SHOW_TEXT);
+  for (let node2 = walker.nextNode(); node2; node2 = walker.nextNode()) {
+    const text = node2.nodeValue;
+    if (!text) continue;
+    node2.nodeValue = redactScreenshotText(text);
+  }
+  clonedRoot.querySelectorAll(VALUE_ELEMENT_SELECTOR).forEach((element) => {
+    const value = element.getAttribute("value");
+    if (!value) return;
+    const hidden = closestSafely(element, SCREENSHOT_BLOCK_SELECTOR) !== null || isElementFullyMasked(element) || hasSensitiveValueHint(element);
+    element.setAttribute("value", hidden ? "" : redactScreenshotText(value));
+  });
+}
+const FRAME_GRAB_TIMEOUT_MS = 300;
+const PROBE_SIZE = 8;
+function matchesSelfOrAncestor(element, selector) {
+  try {
+    return element.closest(selector) !== null;
+  } catch {
+    return false;
+  }
+}
+function shouldOverlayCanvas(canvas, excludeSelectors) {
+  const rect = canvas.getBoundingClientRect();
+  if (rect.width < 1 || rect.height < 1) {
+    return false;
+  }
+  if (matchesSelfOrAncestor(canvas, SCREENSHOT_BLOCK_SELECTOR) || matchesSelfOrAncestor(canvas, SCREENSHOT_FULL_MASK_SELECTOR)) {
+    return false;
+  }
+  return !excludeSelectors.some((selector) => matchesSelfOrAncestor(canvas, selector));
+}
+function rendersBlank(canvas) {
+  const probe = document.createElement("canvas");
+  probe.width = PROBE_SIZE;
+  probe.height = PROBE_SIZE;
+  const context = probe.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    return false;
+  }
+  try {
+    context.drawImage(canvas, 0, 0, PROBE_SIZE, PROBE_SIZE);
+    const { data } = context.getImageData(0, 0, PROBE_SIZE, PROBE_SIZE);
+    for (let offset2 = 4; offset2 < data.length; offset2 += 4) {
+      if (data[offset2] !== data[0] || data[offset2 + 1] !== data[1] || data[offset2 + 2] !== data[2] || data[offset2 + 3] !== data[3]) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function grabFrame(canvas) {
+  const FrameGrabber = globalThis.ImageCapture;
+  if (!FrameGrabber || typeof canvas.captureStream !== "function") {
+    return null;
+  }
+  let track;
+  try {
+    track = canvas.captureStream().getVideoTracks()[0];
+    if (!track) {
+      return null;
+    }
+    return await Promise.race([
+      new FrameGrabber(track).grabFrame(),
+      new Promise((resolve) => {
+        setTimeout(() => resolve(null), FRAME_GRAB_TIMEOUT_MS);
+      })
+    ]);
+  } catch {
+    return null;
+  } finally {
+    track == null ? void 0 : track.stop();
+  }
+}
+const threeHandles = /* @__PURE__ */ new Map();
+const registrationListeners = /* @__PURE__ */ new Set();
+function onThreeRendererRegistered(listener) {
+  registrationListeners.add(listener);
+  return () => {
+    registrationListeners.delete(listener);
+  };
+}
+function registerThreeRenderer(handle) {
+  var _a2;
+  const canvas = (_a2 = handle == null ? void 0 : handle.renderer) == null ? void 0 : _a2.domElement;
+  if (!(canvas instanceof HTMLCanvasElement)) {
+    return () => void 0;
+  }
+  const isNew = !threeHandles.has(canvas);
+  threeHandles.set(canvas, handle);
+  if (isNew) {
+    registrationListeners.forEach((listener) => {
+      try {
+        listener(canvas);
+      } catch {
+      }
+    });
+  }
+  return () => {
+    threeHandles.delete(canvas);
+  };
+}
+function getThreeHandle(canvas) {
+  return threeHandles.get(canvas);
+}
+async function renderAndGrab(handle) {
+  try {
+    handle.renderer.render(handle.scene, handle.camera);
+    return await createImageBitmap(handle.renderer.domElement);
+  } catch {
+    return null;
+  }
+}
+async function grabCanvasFrames(root2, excludeSelectors) {
+  const targets = [];
+  forEachElementDeep(root2, (element) => {
+    if (!(element instanceof HTMLCanvasElement) || !shouldOverlayCanvas(element, excludeSelectors)) {
+      return;
+    }
+    if (threeHandles.has(element) || rendersBlank(element)) {
+      targets.push(element);
+    }
+  });
+  if (targets.length === 0) {
+    return [];
+  }
+  const frames = await Promise.all(
+    targets.map(async (canvas) => {
+      const handle = threeHandles.get(canvas);
+      const bitmap = (handle ? await renderAndGrab(handle) : null) ?? await grabFrame(canvas);
+      return bitmap ? { bitmap, rect: canvas.getBoundingClientRect() } : null;
+    })
+  );
+  return frames.filter((frame) => frame !== null);
+}
+function installThreeAutoDetect() {
+  if (typeof window === "undefined") {
+    return () => void 0;
+  }
+  const holder = window;
+  const restorePatches = [];
+  const observe = (event) => {
+    const detail = event.detail;
+    if ((detail == null ? void 0 : detail.isWebGLRenderer) === true) {
+      observeRenderer(detail, restorePatches);
+    }
+  };
+  const wrap = (hook) => {
+    if (!hook) {
+      return {
+        dispatchEvent(event) {
+          observe(event);
+          return true;
+        }
+      };
+    }
+    const original = hook.dispatchEvent;
+    if (typeof original !== "function" || original.__probed === true) {
+      return hook;
+    }
+    const patched = function(event) {
+      observe(event);
+      return original.call(this, event);
+    };
+    patched.__probed = true;
+    hook.dispatchEvent = patched;
+    restorePatches.push(() => {
+      hook.dispatchEvent = original;
+    });
+    return hook;
+  };
+  const previousDescriptor = Object.getOwnPropertyDescriptor(window, "__THREE_DEVTOOLS__");
+  let current = wrap(holder.__THREE_DEVTOOLS__);
+  Object.defineProperty(window, "__THREE_DEVTOOLS__", {
+    configurable: true,
+    enumerable: true,
+    get: () => current,
+    set: (next) => {
+      current = wrap(next);
+    }
+  });
+  return () => {
+    restorePatches.forEach((restore) => restore());
+    restorePatches.length = 0;
+    const survivor = current;
+    delete window.__THREE_DEVTOOLS__;
+    if (previousDescriptor) {
+      Object.defineProperty(window, "__THREE_DEVTOOLS__", previousDescriptor);
+      return;
+    }
+    if (survivor && !holder.__THREE_DEVTOOLS__) {
+      const isOurs = Object.keys(survivor).length === 1 && "dispatchEvent" in survivor;
+      if (!isOurs) {
+        holder.__THREE_DEVTOOLS__ = survivor;
+      }
+    }
+  };
+}
+function isSceneLike(value) {
+  return (value == null ? void 0 : value.isScene) === true;
+}
+const lastDrawn = /* @__PURE__ */ new WeakMap();
+function observeRenderer(renderer, restorePatches) {
+  queueMicrotask(() => {
+    const owner = Object.prototype.hasOwnProperty.call(renderer, "render") ? renderer : Object.getPrototypeOf(renderer);
+    const original = owner.render;
+    if (typeof original !== "function") {
+      return;
+    }
+    owner.render = function(scene, camera) {
+      const canvas = (this == null ? void 0 : this.domElement) ?? renderer.domElement;
+      if (canvas instanceof HTMLCanvasElement) {
+        lastDrawn.set(canvas, [scene, camera]);
+        if (isSceneLike(scene)) {
+          const existing = threeHandles.get(canvas);
+          if (existing) {
+            existing.scene = scene;
+            existing.camera = camera;
+          } else {
+            registerThreeRenderer({
+              // 강제 렌더는 **앱이 마지막으로 그린 그대로** 다시 그린다. 후처리를 쓰면 화면을
+              // 그리는 것은 풀스크린 쿼드 패스라, 앱의 씬으로 그리면 후처리가 빠진다.
+              // 원본을 부른다 — 우리 래퍼를 다시 타지 않게 한다.
+              renderer: {
+                domElement: canvas,
+                render: (s2, c2) => {
+                  const last = lastDrawn.get(canvas);
+                  return last ? original.call(this, last[0], last[1]) : original.call(this, s2, c2);
+                }
+              },
+              scene,
+              camera
+            });
+          }
+        }
+      }
+      return original.call(this, scene, camera);
+    };
+    restorePatches.push(() => {
+      owner.render = original;
+    });
+  });
+}
+function frameDestRect(rect, origin, scale) {
+  return [
+    (rect.left - origin.x) * scale,
+    (rect.top - origin.y) * scale,
+    rect.width * scale,
+    rect.height * scale
+  ];
+}
+async function overlayCanvasFrames(capture, frames, origin, cssWidth, quality) {
+  let captured = null;
+  try {
+    captured = await createImageBitmap(capture);
+    const output = document.createElement("canvas");
+    output.width = captured.width;
+    output.height = captured.height;
+    const context = output.getContext("2d");
+    if (!context) {
+      return capture;
+    }
+    context.drawImage(captured, 0, 0);
+    const scale = cssWidth > 0 ? captured.width / cssWidth : 1;
+    frames.forEach(({ bitmap, rect }) => {
+      context.drawImage(bitmap, ...frameDestRect(rect, origin, scale));
+    });
+    const blob2 = await new Promise((resolve) => {
+      output.toBlob(resolve, capture.type || "image/webp", quality);
+    });
+    return blob2 ?? capture;
+  } catch {
+    return capture;
+  } finally {
+    captured == null ? void 0 : captured.close();
+  }
+}
+const CANVAS_INTERACTION_TAG = "issue-sticker:canvas-interaction";
 /*! pako 2.2.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 const Z_FIXED$1 = 4;
 const Z_BINARY = 0;
@@ -15433,6 +16199,42 @@ function inDom(n2) {
   if (!doc) return false;
   return index$2.contains(doc, n2) || shadowHostInDom(n2);
 }
+const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  StyleSheetMirror,
+  get _mirror() {
+    return _mirror;
+  },
+  closestElementOfNode,
+  getBaseDimension,
+  getNestedRule,
+  getPositionsAndIndex,
+  getRootShadowHost,
+  getShadowHost,
+  getWindowHeight,
+  getWindowScroll,
+  getWindowWidth,
+  hasShadowRoot,
+  hookSetter,
+  inDom,
+  isAncestorRemoved,
+  isBlocked,
+  isIgnored,
+  isSerialized,
+  isSerializedIframe,
+  isSerializedStylesheet,
+  iterateResolveTree,
+  legacy_isTouchEvent,
+  get nowTimestamp() {
+    return nowTimestamp;
+  },
+  on,
+  polyfill: polyfill$1,
+  queueToResolveTrees,
+  shadowHostInDom,
+  throttle,
+  uniqueTextMutations
+}, Symbol.toStringTag, { value: "Module" }));
 var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2[EventType2["DomContentLoaded"] = 0] = "DomContentLoaded";
   EventType2[EventType2["Load"] = 1] = "Load";
@@ -21615,6 +22417,23 @@ class Replayer {
 const { addCustomEvent } = record;
 const { freezePage } = record;
 const { takeFullSnapshot } = record;
+const rrweb = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EventType,
+  IncrementalSource,
+  MouseInteractions,
+  Replayer,
+  ReplayerEvents,
+  addCustomEvent,
+  canvasMutation,
+  freezePage,
+  get mirror() {
+    return _mirror;
+  },
+  record,
+  takeFullSnapshot,
+  utils
+}, Symbol.toStringTag, { value: "Module" }));
 const OVERLAY_LAYER_INDEX = {
   // 익스텐션·SDK 위젯의 shadow host. isolation:isolate 로 stacking context 를 만들기 때문에
   // 아래 레이어 값들은 호스트 내부 순서만 정한다. 호스트 페이지의 오버레이와 겨루는 것은
@@ -27397,17 +28216,41 @@ const MousePointer2 = createLucideIcon("MousePointer2", [
     }
   ]
 ]);
+function registerThree(handle) {
+  return registerThreeRenderer(handle);
+}
+installThreeAutoDetect();
 export {
-  Anchor as A,
-  Content as C,
+  createSlottable as $,
+  record as A,
+  resolvePrivacyConfig as B,
+  CANVAS_INTERACTION_TAG as C,
   DismissableLayer as D,
+  isElementFullyMasked as E,
+  grabCanvasFrames as F,
+  applyScreenshotPrivacyMask as G,
+  overlayCanvasFrames as H,
+  forEachElementDeep as I,
+  redactSensitiveText as J,
+  REDACTED_BODY_VALUE as K,
+  isSensitiveFieldName as L,
   MousePointer2 as M,
+  redactSensitiveHeaders as N,
   OVERLAY_LAYER_INDEX as O,
   Presence as P,
+  redactSensitiveBody as Q,
   Replayer as R,
-  Slot as S,
-  VISUALLY_HIDDEN_STYLES as V,
+  Content as S,
+  createPopperScope as T,
+  Root2 as U,
+  Anchor as V,
+  Arrow as W,
+  VISUALLY_HIDDEN_STYLES as X,
+  clsx as Y,
+  Slot as Z,
+  Root as _,
   cn as a,
+  rrweb as a0,
   usePortalContainer as b,
   createLucideIcon as c,
   OVERLAY_LAYER as d,
@@ -27423,14 +28266,14 @@ export {
   useLayoutEffect2 as n,
   useCallbackRef as o,
   PortalContainerProvider as p,
-  gzip_1 as q,
-  record as r,
+  onThreeRendererRegistered as q,
+  registerThree as r,
   stopEscapePropagation as s,
-  createPopperScope as t,
+  shouldOverlayCanvas as t,
   ungzip_1 as u,
-  Root2 as v,
-  Arrow as w,
-  clsx as x,
-  Root as y,
-  createSlottable as z
+  getThreeHandle as v,
+  rendersBlank as w,
+  gzip_1 as x,
+  redactUrlSecrets as y,
+  redactSensitiveValues as z
 };