@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/FaceRetouch-CLoTfrcs.js

@@ -0,0 +1,1071 @@
+import { F as v, a as q, b as B, c as N, d as J, e as d, f as R } from "./renderPasses-B6l8IpJv.js";
+import * as S from "three";
+import { jsx as _, jsxs as ge } from "react/jsx-runtime";
+import { useMemo as M, useEffect as Q } from "react";
+import { X as fe } from "./index-CIe7eCMH.js";
+import { u as be } from "./landmarks-bftdwq6Z.js";
+import { F as ve, r as Se, a as ye } from "./renderState-CJNmj5jz.js";
+import { useThree as ke, useFrame as xe } from "@react-three/fiber";
+import { c as Ee } from "./selectors-DmNaKIwE.js";
+import { f as Me } from "./FaceSurface-DmP9AEeC.js";
+import { c as Re, d as we } from "./landmarkMask-BFDyBnKM.js";
+const ht = [
+  { label: "Wireframe", value: v.wireframe },
+  { label: "Basic", value: v.basic },
+  { label: "Standard", value: v.standard },
+  { label: "Physical", value: v.physical },
+  { label: "Toon", value: v.toon },
+  { label: "Normal", value: v.normal },
+  { label: "Matcap", value: v.matcap },
+  { label: "Shader", value: v.shader }
+], gt = [
+  { label: "Original Face", value: q.originalFace },
+  { label: "Composite", value: q.composite }
+], ft = [
+  { label: "Front", value: B.front },
+  { label: "Back", value: B.back },
+  { label: "Double", value: B.double }
+], bt = [
+  { label: "None", value: N.none },
+  { label: "UV Map 1", value: N.canonical },
+  { label: "UV Map 2", value: N.style2 }
+], vt = [
+  { label: "None", value: J.none },
+  { label: "Default Mask", value: J.canonical }
+], St = [
+  { label: "Solid", value: R.solid },
+  { label: "Gradient", value: R.gradient },
+  { label: "Image URL", value: R.imageUrl },
+  { label: "Media URL", value: R.mediaUrl }
+], yt = [
+  { label: "Normal", value: d.normal },
+  { label: "Add", value: d.add },
+  { label: "Subtract", value: d.subtract },
+  { label: "Multiply", value: d.multiply },
+  { label: "Screen", value: d.screen },
+  { label: "Overlay", value: d.overlay },
+  { label: "Soft Light", value: d.softLight },
+  { label: "Hard Light", value: d.hardLight },
+  { label: "Lighten", value: d.lighten },
+  { label: "Darken", value: d.darken },
+  { label: "Difference", value: d.difference },
+  { label: "Exclusion", value: d.exclusion }
+], Ae = ["both", "left", "right"], Fe = ["shader", "image"], Ce = {
+  eye: "both",
+  mode: "shader",
+  color: "#4fa3ff",
+  textureUrl: "",
+  tintImage: !1,
+  scale: 1,
+  opacity: 0.85,
+  targetFps: 0,
+  smoothing: 0,
+  leadMs: 80,
+  mirrored: !1,
+  faceIndex: 0,
+  holdMs: 250
+}, kt = [
+  {
+    key: "eye",
+    label: "Eye",
+    type: "select",
+    options: Ae.map((e) => ({ label: e, value: e }))
+  },
+  {
+    key: "mode",
+    label: "Material",
+    type: "select",
+    options: Fe.map((e) => ({ label: e, value: e }))
+  },
+  { key: "color", label: "Color / tint", type: "color" },
+  { key: "textureUrl", label: "Image URL (image mode)", type: "text" },
+  { key: "tintImage", label: "Tint image with color", type: "boolean" },
+  { key: "scale", label: "Scale (× iris radius)", type: "number", min: 0.2, max: 4, step: 0.05 },
+  { key: "opacity", label: "Opacity", type: "number", min: 0, max: 1, step: 0.05 },
+  { key: "targetFps", label: "Face FPS (0 = session)", type: "number", min: 0, max: 60, step: 1 },
+  { key: "smoothing", label: "Smoothing (0 = raw)", type: "number", min: 0, max: 60, step: 1 },
+  { key: "leadMs", label: "Lead between samples (ms)", type: "number", min: 0, max: 200, step: 10 },
+  { key: "mirrored", label: "Mirror material", type: "boolean" },
+  { key: "faceIndex", label: "Face index", type: "number", min: 0, max: 3, step: 1 },
+  { key: "holdMs", label: "Hold (ms)", type: "number", min: 0, max: 1e3, step: 10 }
+], xt = (e) => ({
+  ...Ce,
+  ...e
+}), Et = (e, t) => ({ ...e, ...t }), Mt = [
+  "lips",
+  "contour",
+  "blush",
+  "highlighter",
+  "eyeshadow",
+  "eyeliner",
+  "brows"
+], z = [
+  "matte",
+  "satin",
+  "gloss",
+  "shimmer",
+  "metallic",
+  "glitter"
+], Rt = ["both", "left", "right"], _e = [
+  "lips",
+  "blush",
+  "contour",
+  "highlighter",
+  "brows"
+], G = {
+  matte: { shine: 0, sparkleDensity: 0, sparkleSize: 0.25 },
+  satin: { shine: 0.3, sparkleDensity: 0, sparkleSize: 0.25 },
+  gloss: { shine: 0.8, sparkleDensity: 0, sparkleSize: 0.25 },
+  shimmer: { shine: 0.5, sparkleDensity: 0.6, sparkleSize: 0.25 },
+  metallic: { shine: 0.7, sparkleDensity: 0, sparkleSize: 0.25 },
+  glitter: { shine: 0.7, sparkleDensity: 0.35, sparkleSize: 0.8 }
+}, Te = ["shine", "sparkleDensity", "sparkleSize"], Y = [0.1, 1.5], I = {
+  lips: {
+    nude: "#b9826f",
+    rosewood: "#9e5a5a",
+    mauve: "#a0606e",
+    softPink: "#d88a95",
+    coral: "#e0645a",
+    peach: "#e8907a",
+    classicRed: "#a3202d",
+    brick: "#8e3b2c",
+    berry: "#7b2846",
+    plum: "#5e2a45",
+    wine: "#5a1a28",
+    chocolate: "#5b3a2e"
+  },
+  contour: {
+    fair: "#c9a08a",
+    light: "#b48a72",
+    medium: "#98705a",
+    tan: "#7f5a45",
+    deep: "#5e4032",
+    rich: "#432c22",
+    bronzeLight: "#b9805a",
+    bronzeDeep: "#8a5532"
+  },
+  blush: {
+    softPink: "#e8a0a8",
+    rose: "#d97a85",
+    peach: "#f0a07c",
+    coral: "#ec7b67",
+    apricot: "#f2a86b",
+    mauve: "#c0828f",
+    berry: "#b04a68",
+    brick: "#b4574a",
+    terracotta: "#c4694c",
+    plum: "#8f4a68"
+  },
+  highlighter: {
+    pearl: "#f6eee6",
+    champagne: "#f2dcc0",
+    gold: "#e9c27a",
+    roseGold: "#eab3a0",
+    bronzeGlow: "#d29a66",
+    lilacPearl: "#e6d6ef"
+  },
+  eyeshadow: {
+    ivory: "#f3e6d3",
+    champagne: "#e9d2b0",
+    sand: "#d2b48c",
+    taupe: "#8f7a6e",
+    warmBrown: "#8b5a3c",
+    coolBrown: "#6e5a50",
+    espresso: "#3e2a22",
+    charcoal: "#3a3a3c",
+    black: "#141414",
+    bronze: "#a8743f",
+    copper: "#b5653a",
+    gold: "#d4ae5a",
+    roseGold: "#d49a8a",
+    plum: "#6b3a5a",
+    burgundy: "#6e2433",
+    olive: "#6f6a3a",
+    navy: "#23314f",
+    emerald: "#1f6b52",
+    teal: "#1f6f73",
+    lilac: "#b8a0cf",
+    silver: "#c5c7cb"
+  },
+  eyeliner: {
+    black: "#0d0d0d",
+    brownBlack: "#231a16",
+    brown: "#4a3226",
+    charcoal: "#33343a",
+    navy: "#1c2848",
+    plum: "#4f2442",
+    emerald: "#145a44",
+    bronze: "#8a5a2e",
+    gold: "#c9a14e",
+    white: "#f5f3ef"
+  },
+  brows: {
+    blonde: "#a88a62",
+    taupe: "#7c6a5c",
+    softBrown: "#6b4f3c",
+    mediumBrown: "#57402f",
+    darkBrown: "#3d2c22",
+    softBlack: "#252020",
+    auburn: "#7a4030",
+    grey: "#8a8580"
+  }
+}, k = (e) => Object.keys(I[e]), Le = {
+  lips: k("lips"),
+  contour: k("contour"),
+  blush: k("blush"),
+  highlighter: k("highlighter"),
+  eyeshadow: k("eyeshadow"),
+  eyeliner: k("eyeliner"),
+  brows: k("brows")
+}, K = (e) => _e.includes(e), oe = (e, t) => typeof t == "string" && Object.prototype.hasOwnProperty.call(I[e], t), ee = (e, t) => t === "custom" || t === "auto" && K(e) || oe(e, t);
+function Oe(e, t) {
+  return t === "auto" ? K(e) ? "auto" : void 0 : oe(e, t) ? I[e][t] : void 0;
+}
+const T = (e) => {
+  const t = e.trim().toLowerCase(), o = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/.exec(t);
+  return o ? `#${o[1]}${o[1]}${o[2]}${o[2]}${o[3]}${o[3]}` : t;
+}, Pe = (e, t) => Object.values(I[e]).some(
+  (o) => T(o) === t
+), Ie = (e, t, o, s, l) => {
+  const a = ee(e, t), r = a ? t : ee(e, s) ? s : "custom", i = typeof o == "string" && o.trim() ? o.trim() : void 0;
+  if (r === "custom") return { shade: r, color: i ?? l };
+  const c = r === "auto" ? l : Oe(e, r) ?? l;
+  if (i !== void 0) {
+    const n = T(i), f = a && (Pe(e, n) || n === T(l));
+    if (n !== T(c) && !f) return { shade: "custom", color: i };
+  }
+  return { shade: r, color: c };
+}, se = (e) => {
+  const t = e.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return t[0].toUpperCase() + t.slice(1);
+}, Ue = (e) => [
+  { label: "Custom color", value: "custom" },
+  ...K(e) ? [{ label: "Auto (own color)", value: "auto" }] : [],
+  ...Le[e].map((t) => ({ label: se(t), value: t }))
+], re = [
+  "lipstick",
+  "gloss",
+  "matte",
+  "tint",
+  "metallic",
+  "gradient",
+  "shimmer",
+  "glitter"
+], De = ["texture", "solid"], Be = ["outward", "vertical", "horizontal"], Ne = {
+  enabled: !0,
+  preset: "custom",
+  shade: "custom",
+  maskMode: "outer-and-inner-lips",
+  colorMode: "texture",
+  color: "#e85d75",
+  opacity: 0.8,
+  coverage: 0.8,
+  finish: "satin",
+  ...G.satin,
+  sparkleColor: "",
+  intensity: 1,
+  shading: 1,
+  gloss: 0.35,
+  roughness: 0.5,
+  highlightColor: "#ffffff",
+  gradientColor: "#ffd6de",
+  gradientAmount: 0,
+  gradientDirection: "outward",
+  edgeSoftness: 0.12,
+  innerLipColor: "#7a1f36",
+  innerLipAmount: 0,
+  innerLipWidth: 0.35,
+  splitLips: !1,
+  lowerLipColor: "#e85d75",
+  lowerLipOpacity: 0.8,
+  textureScaleX: 1,
+  textureScaleY: 1,
+  textureOffsetX: 0,
+  textureOffsetY: 0,
+  textureRotation: 0,
+  textureFlipX: !1,
+  textureFlipY: !1
+}, le = {
+  lipstick: {
+    finish: "satin",
+    coverage: 0.85,
+    color: "#c0304f",
+    opacity: 0.85,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.35,
+    roughness: 0.5,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  gloss: {
+    finish: "gloss",
+    coverage: 0.45,
+    color: "#e05a7a",
+    opacity: 0.7,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.95,
+    roughness: 0.12,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  matte: {
+    finish: "matte",
+    coverage: 0.95,
+    color: "#a8323e",
+    opacity: 0.92,
+    intensity: 1,
+    shading: 1,
+    gloss: 0,
+    roughness: 1,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  tint: {
+    finish: "matte",
+    coverage: 0.3,
+    color: "#ff6b81",
+    opacity: 0.4,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.1,
+    roughness: 0.7,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  metallic: {
+    finish: "metallic",
+    coverage: 0.9,
+    color: "#b5485a",
+    opacity: 0.9,
+    intensity: 1,
+    shading: 1,
+    gloss: 1,
+    roughness: 0.3,
+    highlightColor: "#f3c46b",
+    gradientAmount: 0
+  },
+  gradient: {
+    finish: "satin",
+    coverage: 0.8,
+    color: "#d6336c",
+    opacity: 0.8,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.3,
+    roughness: 0.5,
+    highlightColor: "#ffffff",
+    gradientColor: "#f9c2cf",
+    gradientAmount: 0.85,
+    gradientDirection: "outward"
+  },
+  shimmer: {
+    finish: "shimmer",
+    coverage: 0.7,
+    color: "#c8577a",
+    opacity: 0.8,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.4,
+    roughness: 0.45,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  glitter: {
+    finish: "glitter",
+    coverage: 0.5,
+    color: "#b8406a",
+    opacity: 0.8,
+    intensity: 1,
+    shading: 1,
+    gloss: 0.5,
+    roughness: 0.35,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  }
+}, ie = (e) => typeof e == "string" && re.includes(e), m = (e, t, o, s) => typeof e == "number" && Number.isFinite(e) ? Math.min(o, Math.max(t, e)) : s, Xe = (e, t) => typeof e == "number" && Number.isFinite(e) ? e : t, w = (e, t) => typeof e == "string" && e.trim() ? e : t, He = (e, t) => typeof e == "string" ? e.trim() : t, A = (e, t) => typeof e == "boolean" ? e : t, X = (e, t, o) => typeof t == "string" && e.includes(t) ? t : o, Ye = (e) => Object.fromEntries(
+  Object.entries(e).filter(([, t]) => t !== void 0)
+), ze = (e = {}) => {
+  const t = ie(e.preset) ? e.preset : "custom", o = Ye(e), s = {
+    ...Ne,
+    ...t === "custom" ? {} : le[t]
+  }, l = X(z, o.finish, s.finish), a = { ...s, ...G[l] }, r = { ...a, ...o }, { shade: i, color: c } = Ie(
+    "lips",
+    o.shade,
+    o.color,
+    a.shade,
+    a.color
+  );
+  return {
+    enabled: A(r.enabled, a.enabled),
+    preset: t,
+    shade: i,
+    maskMode: r.maskMode === "outer-lips" ? "outer-lips" : "outer-and-inner-lips",
+    colorMode: X(De, r.colorMode, a.colorMode),
+    color: c,
+    opacity: m(r.opacity, 0, 1, a.opacity),
+    coverage: m(r.coverage, 0, 1, a.coverage),
+    finish: l,
+    shine: m(r.shine, 0, 1, a.shine),
+    sparkleDensity: m(r.sparkleDensity, 0, 1, a.sparkleDensity),
+    sparkleSize: m(r.sparkleSize, ...Y, a.sparkleSize),
+    sparkleColor: He(r.sparkleColor, a.sparkleColor),
+    intensity: m(r.intensity, 0, 1, a.intensity),
+    shading: m(r.shading, 0, 1, a.shading),
+    gloss: m(r.gloss, 0, 1, a.gloss),
+    roughness: m(r.roughness, 0, 1, a.roughness),
+    highlightColor: w(r.highlightColor, a.highlightColor),
+    gradientColor: w(r.gradientColor, a.gradientColor),
+    gradientAmount: m(r.gradientAmount, 0, 1, a.gradientAmount),
+    gradientDirection: X(
+      Be,
+      r.gradientDirection,
+      a.gradientDirection
+    ),
+    edgeSoftness: m(r.edgeSoftness, 0, 1, a.edgeSoftness),
+    innerLipColor: w(r.innerLipColor, a.innerLipColor),
+    innerLipAmount: m(r.innerLipAmount, 0, 1, a.innerLipAmount),
+    innerLipWidth: m(r.innerLipWidth, 0, 1, a.innerLipWidth),
+    splitLips: A(r.splitLips, a.splitLips),
+    lowerLipColor: w(r.lowerLipColor, a.lowerLipColor),
+    lowerLipOpacity: m(r.lowerLipOpacity, 0, 1, a.lowerLipOpacity),
+    textureScaleX: m(r.textureScaleX, 0.05, 20, a.textureScaleX),
+    textureScaleY: m(r.textureScaleY, 0.05, 20, a.textureScaleY),
+    textureOffsetX: m(r.textureOffsetX, -2, 2, a.textureOffsetX),
+    textureOffsetY: m(r.textureOffsetY, -2, 2, a.textureOffsetY),
+    textureRotation: Xe(r.textureRotation, a.textureRotation),
+    textureFlipX: A(r.textureFlipX, a.textureFlipX),
+    textureFlipY: A(r.textureFlipY, a.textureFlipY)
+  };
+}, wt = (e, t) => {
+  const o = Object.keys(e).some(
+    (a) => t[a] === void 0
+  ), s = Object.fromEntries(
+    Object.entries(t).filter(
+      ([a, r]) => r !== void 0 && (o || r !== e[a])
+    )
+  ), l = { ...e };
+  if (s.preset !== e.preset && ie(s.preset) && Object.assign(l, le[s.preset]), Object.assign(l, s), l.finish !== e.finish && z.includes(l.finish)) {
+    Object.assign(l, G[l.finish]);
+    for (const a of Te)
+      s[a] !== void 0 && (l[a] = s[a]);
+  }
+  return s.color === void 0 ? l.shade !== "custom" && delete l.color : s.shade === void 0 && s.color !== e.color && (l.shade = "custom"), ze(l);
+}, p = { min: 0, max: 1, step: 0.01 }, At = [
+  { key: "enabled", label: "On", type: "boolean" },
+  {
+    key: "preset",
+    label: "Preset",
+    type: "select",
+    options: [
+      { label: "Custom", value: "custom" },
+      ...re.map((e) => ({
+        label: e[0].toUpperCase() + e.slice(1),
+        value: e
+      }))
+    ]
+  },
+  { key: "shade", label: "Shade", type: "select", options: Ue("lips") },
+  {
+    key: "maskMode",
+    label: "Mask mode",
+    type: "select",
+    options: [
+      { label: "Outer + inner lips (mouth cut out)", value: "outer-and-inner-lips" },
+      { label: "Outer lips (mouth included)", value: "outer-lips" }
+    ]
+  },
+  {
+    key: "colorMode",
+    label: "Color mode",
+    type: "select",
+    options: [
+      { label: "Design texture", value: "texture" },
+      { label: "Procedural (solid / gradient)", value: "solid" }
+    ]
+  },
+  { key: "color", label: "Tint color", type: "color" },
+  { key: "opacity", label: "Opacity", type: "number", ...p },
+  { key: "coverage", label: "Coverage (sheer → opaque)", type: "number", ...p },
+  {
+    key: "finish",
+    label: "Finish",
+    type: "select",
+    options: z.map((e) => ({ label: se(e), value: e }))
+  },
+  { key: "shine", label: "Shine", type: "number", ...p },
+  { key: "sparkleColor", label: "Sparkle color (blank = from shade)", type: "text" },
+  { key: "sparkleDensity", label: "Sparkle density", type: "number", ...p },
+  {
+    key: "sparkleSize",
+    label: "Sparkle size (mm)",
+    type: "number",
+    min: Y[0],
+    max: Y[1],
+    step: 0.05
+  },
+  { key: "intensity", label: "Tint intensity", type: "number", ...p },
+  { key: "shading", label: "Follow light (0 = flat)", type: "number", ...p },
+  { key: "gloss", label: "Gloss", type: "number", ...p },
+  { key: "roughness", label: "Roughness", type: "number", ...p },
+  { key: "highlightColor", label: "Highlight color", type: "color" },
+  { key: "gradientColor", label: "Gradient color", type: "color" },
+  { key: "gradientAmount", label: "Gradient amount", type: "number", ...p },
+  {
+    key: "gradientDirection",
+    label: "Gradient direction",
+    type: "select",
+    options: [
+      { label: "Mouth line → outer edge", value: "outward" },
+      { label: "Bottom → top", value: "vertical" },
+      { label: "Person's right → left corner", value: "horizontal" }
+    ]
+  },
+  { key: "edgeSoftness", label: "Edge softness", type: "number", ...p },
+  { key: "innerLipColor", label: "Inner lip color", type: "color" },
+  { key: "innerLipAmount", label: "Inner lip amount", type: "number", ...p },
+  { key: "innerLipWidth", label: "Inner lip width", type: "number", ...p },
+  { key: "splitLips", label: "Separate lower lip", type: "boolean" },
+  { key: "lowerLipColor", label: "Lower lip color", type: "color" },
+  { key: "lowerLipOpacity", label: "Lower lip opacity", type: "number", ...p },
+  { key: "textureScaleX", label: "Texture scale X", type: "number", min: 0.1, max: 10, step: 0.05 },
+  { key: "textureScaleY", label: "Texture scale Y", type: "number", min: 0.1, max: 10, step: 0.05 },
+  { key: "textureOffsetX", label: "Texture offset X", type: "number", min: -1, max: 1, step: 0.01 },
+  { key: "textureOffsetY", label: "Texture offset Y", type: "number", min: -1, max: 1, step: 0.01 },
+  {
+    key: "textureRotation",
+    label: "Texture rotation°",
+    type: "number",
+    min: -180,
+    max: 180,
+    step: 1
+  },
+  { key: "textureFlipX", label: "Flip horizontal", type: "boolean" },
+  { key: "textureFlipY", label: "Flip vertical", type: "boolean" }
+], Ft = (e, t, o = new S.Matrix3()) => {
+  const s = (t.minU + t.maxU) / 2, l = (t.minV + t.maxV) / 2, a = t.maxU - t.minU, r = t.maxV - t.minV, i = -S.MathUtils.degToRad(e.textureRotation), c = Math.cos(i), n = Math.sin(i), f = (e.textureFlipX ? -1 : 1) / Math.max(e.textureScaleX, 1e-3), h = (e.textureFlipY ? -1 : 1) / Math.max(e.textureScaleY, 1e-3), g = f * c, y = -f * n, u = h * n, x = h * c, E = s + e.textureOffsetX * a, U = l + e.textureOffsetY * r, $ = s - (g * E + y * U), D = l - (u * E + x * U);
+  return o.set(g, y, $, u, x, D, 0, 0, 1);
+}, Ct = [
+  "eachOther",
+  "photo",
+  "canonicalTexture",
+  "faceTexture"
+], ne = ["natural", "keepColors", "raw"], L = {
+  preset: "natural",
+  matchSkinTone: 1,
+  matchLighting: 1,
+  edgeMatch: 1,
+  edgeSoftness: 1.2,
+  edgeInset: 0.3,
+  ownEyes: !0,
+  ownMouth: !0,
+  featureSoftness: 0.25,
+  detail: 1,
+  smoothing: 0.35,
+  amount: 1
+}, j = {
+  natural: {
+    matchSkinTone: 1,
+    matchLighting: 1,
+    edgeMatch: 1,
+    edgeSoftness: 1.2,
+    ownEyes: !0,
+    ownMouth: !0,
+    detail: 1
+  },
+  keepColors: { matchSkinTone: 0, matchLighting: 0.7, edgeMatch: 1, edgeSoftness: 1 },
+  raw: { matchSkinTone: 0, matchLighting: 0, edgeMatch: 0, edgeSoftness: 0.4 }
+}, ce = (e) => typeof e == "string" && ne.includes(e), Ge = (e) => ue(e) ? "keepColors" : "natural", ue = (e) => {
+  var t;
+  return (e == null ? void 0 : e.kind) === "canonicalTexture" || (e == null ? void 0 : e.kind) === "faceTexture" && ((t = e.face) == null ? void 0 : t.kind) === "canonical";
+}, Ke = 0.1, me = (e, t, o, s) => typeof e == "number" && Number.isFinite(e) ? Math.min(o, Math.max(t, e)) : s, te = (e, t) => typeof e == "boolean" ? e : t, je = (e, t, o) => typeof t == "string" && e.includes(t) ? t : o, W = (e) => Object.fromEntries(
+  Object.entries(e).filter(([, t]) => t !== void 0)
+), P = {
+  matchSkinTone: [0, 1],
+  matchLighting: [0, 1],
+  edgeMatch: [0, 1],
+  edgeSoftness: [0.3, 3],
+  edgeInset: [0, 1.5],
+  featureSoftness: [0.1, 0.6],
+  detail: [0, 1],
+  smoothing: [0, 1],
+  amount: [0, 1]
+}, pe = (e, t) => Object.entries(j[t]).every(
+  ([o, s]) => e[o] === s
+), ae = (e = {}, t = {}) => {
+  const o = e.preset ?? Ge(t.source), s = ce(o) ? o : "custom", l = {
+    ...L,
+    ...ue(t.source) ? { featureSoftness: Ke } : {},
+    ...s === "custom" ? {} : j[s]
+  }, a = { ...l, ...W(e) }, r = P, i = (n) => me(a[n], r[n][0], r[n][1], l[n]), c = {
+    preset: s,
+    matchSkinTone: i("matchSkinTone"),
+    matchLighting: i("matchLighting"),
+    edgeMatch: i("edgeMatch"),
+    edgeSoftness: i("edgeSoftness"),
+    edgeInset: i("edgeInset"),
+    ownEyes: te(a.ownEyes, l.ownEyes),
+    ownMouth: te(a.ownMouth, l.ownMouth),
+    featureSoftness: i("featureSoftness"),
+    detail: i("detail"),
+    smoothing: i("smoothing"),
+    amount: i("amount")
+  };
+  return s !== "custom" && !pe(c, s) && (c.preset = "custom"), c;
+}, _t = (e, t) => {
+  const o = Object.fromEntries(
+    Object.entries(t).filter(
+      ([l, a]) => l !== "preset" && a !== void 0 && a !== e[l]
+    )
+  ), s = t.preset;
+  return ce(s) && (s !== e.preset || !pe(e, s)) ? ae({
+    ...e,
+    ...j[s],
+    ...o,
+    preset: s
+  }) : ae({
+    ...e,
+    ...o,
+    preset: s === "custom" ? "custom" : e.preset
+  });
+}, b = { min: 0, max: 1, step: 0.01 }, O = (e, t) => ({
+  min: P[e][0],
+  max: P[e][1],
+  step: t
+}), We = {
+  natural: "Natural",
+  keepColors: "Keep colors",
+  raw: "Raw"
+}, Tt = [
+  {
+    key: "preset",
+    label: "Preset",
+    type: "select",
+    options: [
+      { label: "Custom", value: "custom" },
+      ...ne.map((e) => ({ label: We[e], value: e }))
+    ]
+  },
+  { key: "matchSkinTone", label: "Match skin tone", type: "number", ...b },
+  { key: "matchLighting", label: "Match lighting", type: "number", ...b },
+  { key: "edgeMatch", label: "Match at the edge", type: "number", ...b },
+  {
+    key: "edgeSoftness",
+    label: "Edge softness (cm)",
+    type: "number",
+    ...O("edgeSoftness", 0.05)
+  },
+  { key: "edgeInset", label: "Edge inset (cm)", type: "number", ...O("edgeInset", 0.05) },
+  { key: "ownEyes", label: "Keep own eyes", type: "boolean" },
+  { key: "ownMouth", label: "Keep own mouth", type: "boolean" },
+  {
+    key: "featureSoftness",
+    label: "Eye and mouth rim (cm)",
+    type: "number",
+    ...O("featureSoftness", 0.01)
+  },
+  { key: "detail", label: "Detail", type: "number", ...b },
+  { key: "smoothing", label: "Smoothing", type: "number", ...b },
+  { key: "amount", label: "Amount", type: "number", ...b }
+], V = [
+  "leftLeft",
+  "rightRight",
+  "flip",
+  "upsideDown"
+], Ve = {
+  leftLeft: "your left half twice",
+  rightRight: "your right half twice",
+  flip: "left and right swapped",
+  upsideDown: "eyes and mouth upside down"
+}, Lt = (e) => typeof e == "string" && V.includes(e), $e = {
+  variant: "leftLeft",
+  matchLighting: 1,
+  edgeSoftness: 1.2,
+  smoothing: 0.35,
+  amount: 1
+}, Ze = (e = {}) => {
+  const t = $e, o = { ...t, ...W(e) }, s = P, l = (a) => me(o[a], s[a][0], s[a][1], t[a]);
+  return {
+    variant: je(V, o.variant, t.variant),
+    matchLighting: l("matchLighting"),
+    edgeSoftness: l("edgeSoftness"),
+    smoothing: l("smoothing"),
+    amount: l("amount")
+  };
+}, Ot = (e, t) => Ze({ ...e, ...W(t) }), Pt = [
+  {
+    key: "variant",
+    label: "Variant",
+    type: "select",
+    options: V.map((e) => ({
+      label: Ve[e],
+      value: e
+    }))
+  },
+  { key: "matchLighting", label: "Match lighting", type: "number", ...b },
+  {
+    key: "edgeSoftness",
+    label: "Edge softness (cm)",
+    type: "number",
+    ...O("edgeSoftness", 0.05)
+  },
+  { key: "smoothing", label: "Smoothing", type: "number", ...b },
+  { key: "amount", label: "Amount", type: "number", ...b }
+], It = (e) => ({
+  matchSkinTone: 0,
+  matchLighting: e.matchLighting,
+  edgeMatch: e.matchLighting,
+  edgeSoftness: e.edgeSoftness,
+  edgeInset: L.edgeInset,
+  ownEyes: !1,
+  ownMouth: !1,
+  featureSoftness: L.featureSoftness,
+  detail: L.detail,
+  smoothing: e.smoothing,
+  amount: e.amount
+}), qe = Object.freeze({
+  ...Me,
+  transparent: !1,
+  depthTest: !0,
+  depthWrite: !1,
+  toneMapped: !1
+}), Je = `
+  varying vec2 vUv;
+
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, Qe = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D retouchMaskTexture;
+  uniform vec2 texelSize;
+  uniform float retouchAmount;
+  uniform float blurRadius;
+  uniform float detailPreservation;
+  uniform float blemishReduction;
+  uniform float blemishRadius;
+  uniform float previewMask;
+  uniform float protectLandmarks;
+  uniform float clipMinX;
+  uniform float clipMaxX;
+  varying vec2 vUv;
+
+  vec3 sampleCamera(vec2 uv) {
+    return texture2D(cameraTexture, clamp(uv, vec2(0.0), vec2(1.0))).rgb;
+  }
+
+  vec3 readRetouchMask(vec2 uv) {
+    vec4 mask = texture2D(retouchMaskTexture, uv);
+    float faceRegion = clamp(mask.b, 0.0, 1.0);
+    float softFaceRegion = min(mask.r, faceRegion);
+    float protectedRegion = min(mask.g, faceRegion) * protectLandmarks;
+    float hardProtectedRegion = step(0.08, protectedRegion);
+    float softRetouchRegion = softFaceRegion * (1.0 - protectedRegion);
+    float hardRetouchRegion = step(0.5, faceRegion) * (1.0 - hardProtectedRegion);
+
+    return vec3(
+      clamp(softRetouchRegion, 0.0, 1.0),
+      clamp(protectedRegion, 0.0, 1.0),
+      clamp(hardRetouchRegion, 0.0, 1.0)
+    );
+  }
+
+  float retouchCoverage(vec2 uv) {
+    return step(0.001, readRetouchMask(uv).x);
+  }
+
+  void addMaskedBlurSample(inout vec3 color, inout float weightSum, vec2 centerUv, vec2 sampleUv, float weight) {
+    float coverage = retouchCoverage(sampleUv);
+    vec3 sampleColor = mix(sampleCamera(centerUv), sampleCamera(sampleUv), coverage);
+    color += sampleColor * weight;
+    weightSum += weight;
+  }
+
+  vec3 maskedBlurCamera(vec2 uv, float radius) {
+    vec2 r = texelSize * radius;
+    vec3 color = sampleCamera(uv) * 0.2;
+    float weightSum = 0.2;
+
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv - r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, -r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(-r.x, r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + r * 2.0, 0.05);
+    addMaskedBlurSample(color, weightSum, uv, uv - r * 2.0, 0.05);
+
+    return color / max(weightSum, 0.001);
+  }
+
+  float retouchLuminance(vec3 color) {
+    return dot(color, vec3(0.299, 0.587, 0.114));
+  }
+
+  vec3 reduceBlemishes(vec3 current, vec3 source, vec3 localAverage, vec3 skinBase, float skinMask) {
+    float originalLum = retouchLuminance(source);
+    float localLum = retouchLuminance(localAverage);
+    float redness = max(source.r - max(source.g, source.b), 0.0);
+    float localRedness = max(localAverage.r - max(localAverage.g, localAverage.b), 0.0);
+    float excessRedness = max(redness - localRedness * 0.72, 0.0);
+    float darkSpot = max(localLum - originalLum, 0.0);
+    float contrast = length(source - localAverage);
+    float candidate =
+      smoothstep(0.012, 0.09, excessRedness) +
+      smoothstep(0.018, 0.13, darkSpot) +
+      smoothstep(0.03, 0.16, contrast);
+    float blemishMask = clamp(candidate * 0.72, 0.0, 1.0) * skinMask * blemishReduction;
+
+    vec3 chromaReduced = vec3(
+      mix(current.r, min(current.r, localAverage.r * 1.04), blemishMask),
+      mix(current.g, max(current.g, localAverage.g * 0.98), 0.35 * blemishMask),
+      mix(current.b, max(current.b, localAverage.b * 0.98), 0.35 * blemishMask)
+    );
+    vec3 texture = source - localAverage;
+    vec3 repaired = clamp(skinBase + texture * detailPreservation * 0.18, 0.0, 1.0);
+
+    return mix(chromaReduced, repaired, min(blemishMask * 1.15, 1.0));
+  }
+
+  void main() {
+    if (vUv.x < clipMinX || vUv.x > clipMaxX) discard;
+
+    vec3 original = sampleCamera(vUv);
+    vec3 masks = readRetouchMask(vUv);
+    float faceAlpha = max(max(masks.x, masks.y), masks.z);
+
+    if (previewMask > 0.5) {
+      float sharpPreview = 1.0 - step(0.001, retouchAmount + blurRadius);
+      float retouchPreview = mix(masks.x, masks.z, sharpPreview);
+      float protectedPreview = mix(masks.y, step(0.08, masks.y), sharpPreview);
+      vec3 facePreview = vec3(retouchPreview, 0.08, 0.08);
+      vec3 featurePreview = vec3(0.05, protectedPreview, 0.1);
+      vec3 maskPreview = max(facePreview, featurePreview);
+      vec3 debugColor = mix(original * 0.18, maskPreview, max(retouchPreview, protectedPreview));
+      gl_FragColor = vec4(debugColor, faceAlpha);
+      #include <colorspace_fragment>
+      return;
+    }
+
+    float effectiveBlurRadius = min(blurRadius, 12.0);
+    vec3 smallBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius * 0.45));
+    vec3 largeBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius));
+    vec3 detail = original - smallBlur;
+    float detailAmount = mix(detailPreservation, 0.9, masks.y);
+    vec3 smoothed = clamp(largeBlur + detail * detailAmount, 0.0, 1.0);
+    vec3 color = mix(original, smoothed, min(retouchAmount, 0.72) * masks.x);
+    vec3 blemishAverage = maskedBlurCamera(vUv, max(1.0, blemishRadius));
+    color = reduceBlemishes(color, original, blemishAverage, smoothed, masks.x);
+    gl_FragColor = vec4(color, faceAlpha);
+    #include <colorspace_fragment>
+  }
+`, et = ({
+  retouchMask: e,
+  retouchAmount: t,
+  blurRadius: o,
+  detailPreservation: s = 0.62,
+  blemishReduction: l = 0.35,
+  blemishRadius: a = 3,
+  previewMask: r,
+  protectLandmarks: i,
+  clipMinX: c = 0,
+  clipMaxX: n = 1,
+  renderOrder: f = ve
+}) => {
+  const { camera: h, size: g } = ke(), y = Ee(), u = M(
+    () => ({
+      cameraTexture: { value: null },
+      retouchMaskTexture: { value: null },
+      texelSize: { value: new S.Vector2(1 / 1280, 1 / 720) },
+      retouchAmount: { value: 0 },
+      blurRadius: { value: 0 },
+      detailPreservation: { value: 0 },
+      blemishReduction: { value: 0 },
+      blemishRadius: { value: 0 },
+      previewMask: { value: 0 },
+      protectLandmarks: { value: 1 },
+      clipMinX: { value: 0 },
+      clipMaxX: { value: 1 }
+    }),
+    []
+  ), x = M(() => {
+    if (!h.isPerspectiveCamera)
+      return [10, 10];
+    const E = h, D = (E.position.z || 5) - -1, he = S.MathUtils.degToRad(E.fov), Z = 2 * Math.tan(he / 2) * D;
+    return [Z * (g.width / g.height), Z];
+  }, [h, g]);
+  return xe(() => {
+    u.cameraTexture.value = y ?? null, u.retouchMaskTexture.value = e, u.texelSize.value.set(1 / Math.max(g.width, 1), 1 / Math.max(g.height, 1)), u.retouchAmount.value = t, u.blurRadius.value = o, u.detailPreservation.value = s, u.blemishReduction.value = l, u.blemishRadius.value = a, u.previewMask.value = r ? 1 : 0, u.protectLandmarks.value = i ? 1 : 0, u.clipMinX.value = c, u.clipMaxX.value = n;
+  }), y ? /* @__PURE__ */ _("group", { position: [0, 0, -1], children: /* @__PURE__ */ ge("mesh", { renderOrder: f, children: [
+    /* @__PURE__ */ _("planeGeometry", { args: x }),
+    /* @__PURE__ */ _(
+      "shaderMaterial",
+      {
+        uniforms: u,
+        vertexShader: Je,
+        fragmentShader: Qe,
+        ...qe
+      }
+    )
+  ] }) }) : null;
+}, tt = (e) => {
+  const t = document.createElement("canvas");
+  t.width = e, t.height = e;
+  const o = t.getContext("2d", { willReadFrequently: !1 });
+  if (!o) throw new Error("Unable to create face retouch mask context");
+  const s = new S.CanvasTexture(t);
+  return s.colorSpace = S.NoColorSpace, s.minFilter = S.LinearFilter, s.magFilter = S.LinearFilter, s.generateMipmaps = !1, s.needsUpdate = !0, { canvas: t, context: o, texture: s };
+}, at = (e, t = Re, o = {}, s = 0) => {
+  const l = M(() => tt(t), [t]);
+  return Q(() => {
+    let a = 0;
+    const r = () => {
+      var c, n;
+      a = requestAnimationFrame(r);
+      const i = (n = (c = e == null ? void 0 : e.detectionResults) == null ? void 0 : c.faceLandmarks) == null ? void 0 : n[s];
+      we(l.context, i, t, o), l.texture.needsUpdate = !0;
+    };
+    return r(), () => {
+      cancelAnimationFrame(a);
+    };
+  }, [s, e, l.context, l.texture, o, t]), Q(() => () => {
+    l.texture.dispose();
+  }, [l.texture]), { canvas: l.canvas, texture: l.texture };
+}, Ut = [
+  { key: "skinSmoothing", label: "Skin smoothing", type: "number", min: 0, max: 1, step: 0.01 },
+  { key: "skinRealism", label: "Skin realism", type: "number", min: 0, max: 1, step: 0.01 },
+  {
+    key: "blemishReduction",
+    label: "Blemish reduction",
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01
+  },
+  { key: "previewMask", label: "Preview mask", type: "boolean" }
+], F = {
+  skinSmoothing: 0.55,
+  skinRealism: 0.62,
+  blemishReduction: 0.35,
+  previewMask: !1
+}, C = {
+  blurRadius: 8,
+  blemishRadius: 3,
+  protectLandmarks: !0,
+  foreheadCoverage: !0
+}, H = (e, t) => {
+  const o = Number(e);
+  return Number.isFinite(o) ? Math.min(1, Math.max(0, o)) : t;
+}, de = (e = {}) => ({
+  skinSmoothing: H(e.skinSmoothing, F.skinSmoothing),
+  skinRealism: H(e.skinRealism, F.skinRealism),
+  blemishReduction: H(e.blemishReduction, F.blemishReduction),
+  previewMask: typeof e.previewMask == "boolean" ? e.previewMask : F.previewMask
+}), Dt = (e, t) => de({ ...e, ...t }), Bt = ({
+  faceIndex: e,
+  numFaces: t,
+  skinSmoothing: o,
+  skinRealism: s,
+  blemishReduction: l,
+  previewMask: a,
+  clipMinX: r = 0,
+  clipMaxX: i = 1,
+  renderOrder: c
+}) => {
+  const n = ye(e), f = Se(n, t), h = de({
+    skinSmoothing: o,
+    skinRealism: s,
+    blemishReduction: l,
+    previewMask: a
+  }), g = M(() => ({ numFaces: f }), [f]), { node: y } = be(
+    fe.FACE_TRACKER,
+    g
+  ), u = M(
+    () => ({ foreheadCoverage: C.foreheadCoverage }),
+    []
+  ), x = at(y, void 0, u, n);
+  return /* @__PURE__ */ _(
+    et,
+    {
+      retouchMask: x.texture,
+      retouchAmount: h.skinSmoothing,
+      blurRadius: C.blurRadius,
+      detailPreservation: h.skinRealism,
+      blemishReduction: h.blemishReduction,
+      blemishRadius: C.blemishRadius,
+      previewMask: h.previewMask,
+      protectLandmarks: C.protectLandmarks,
+      clipMinX: r,
+      clipMaxX: i,
+      renderOrder: c
+    }
+  );
+};
+export {
+  V as $,
+  Ue as A,
+  se as B,
+  Mt as C,
+  Ne as D,
+  Le as E,
+  Ut as F,
+  L as G,
+  P as H,
+  kt as I,
+  Ze as J,
+  It as K,
+  At as L,
+  G as M,
+  j as N,
+  Ce as O,
+  Ae as P,
+  Fe as Q,
+  De as R,
+  ie as S,
+  _e as T,
+  oe as U,
+  Oe as V,
+  K as W,
+  F as X,
+  Bt as Y,
+  $e as Z,
+  Pt as _,
+  ae as a,
+  Ve as a0,
+  Ke as a1,
+  ne as a2,
+  Ct as a3,
+  Ge as a4,
+  Lt as a5,
+  ce as a6,
+  Ot as a7,
+  Tt as b,
+  _t as c,
+  xt as d,
+  Et as e,
+  ze as f,
+  wt as g,
+  ht as h,
+  ft as i,
+  vt as j,
+  yt as k,
+  Be as l,
+  St as m,
+  Ft as n,
+  le as o,
+  Dt as p,
+  re as q,
+  de as r,
+  gt as s,
+  bt as t,
+  I as u,
+  z as v,
+  Te as w,
+  Y as x,
+  Rt as y,
+  Ie as z
+};