@lvce-editor/static-server 0.113.21 → 0.113.22

package/static/f0797cf/packages/renderer-process/dist/sessionReplayWorkerMain.js

@@ -0,0 +1,1164 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../session-replay-worker/src/api/transfer.ts
+var getTransferrables = (value) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = /* @__PURE__ */ new Set();
+  const visit = (item) => {
+    if (!item || typeof item !== "object" || seen.has(item)) return;
+    seen.add(item);
+    if (Object.prototype.toString.call(item) === "[object ArrayBuffer]") result.add(item);
+    else if (ArrayBuffer.isView(item)) visit(item.buffer);
+    else if (["MessagePort", "OffscreenCanvas", "ImageBitmap", "AudioData", "VideoFrame", "ReadableStream", "WritableStream", "TransformStream"].some(
+      (name) => typeof globalThis[name] === "function" && item instanceof globalThis[name]
+    ))
+      result.add(item);
+    else if (Object.prototype.toString.call(item) === "[object Map]") {
+      for (const [key, entry] of item) {
+        visit(key);
+        visit(entry);
+      }
+    } else if (Object.prototype.toString.call(item) === "[object Set]") {
+      for (const entry of item) visit(entry);
+    } else for (const entry of Object.values(item)) visit(entry);
+  };
+  visit(value);
+  return [...result];
+};
+
+// ../../node_modules/@lvce-editor/constants/dist/parts/ElementTagMap/ElementTagMap.js
+var ElementTagMap_exports = {};
+__export(ElementTagMap_exports, {
+  getElementTag: () => getElementTag
+});
+
+// ../../node_modules/@lvce-editor/constants/dist/parts/ElementTags/ElementTags.js
+var Audio = "audio";
+var Button = "button";
+var Col = "col";
+var ColGroup = "colgroup";
+var Del = "del";
+var Div = "div";
+var H1 = "h1";
+var H2 = "h2";
+var H3 = "h3";
+var H4 = "h4";
+var H5 = "h5";
+var H6 = "h6";
+var I = "i";
+var Img = "img";
+var Input = "input";
+var Ins = "ins";
+var Kbd = "kbd";
+var Span = "span";
+var Table = "table";
+var TBody = "tbody";
+var Td = "td";
+var Th = "th";
+var THead = "thead";
+var Tr = "tr";
+var Article = "article";
+var Aside = "aside";
+var Footer = "footer";
+var Header = "header";
+var Nav = "nav";
+var Section = "section";
+var Search = "search";
+var Dd = "dd";
+var Dl = "dl";
+var Figcaption = "figcaption";
+var Figure = "figure";
+var Hr = "hr";
+var Li = "li";
+var Ol = "ol";
+var P = "p";
+var Pre = "pre";
+var A = "a";
+var Br = "br";
+var Cite = "cite";
+var Data = "data";
+var Time = "time";
+var Tfoot = "tfoot";
+var Ul = "ul";
+var Video = "video";
+var TextArea = "textarea";
+var Select = "select";
+var Option = "option";
+var Code = "code";
+var Label = "label";
+var Dt = "dt";
+var Iframe = "iframe";
+var Main = "main";
+var Em = "em";
+var Strong = "strong";
+var Style = "style";
+var Html = "html";
+var Head = "head";
+var Title = "title";
+var Meta = "meta";
+var Canvas = "canvas";
+var Circle = "circle";
+var Form = "form";
+var Defs = "defs";
+var Ellipse = "ellipse";
+var G = "g";
+var Line = "line";
+var Path = "path";
+var Polygon = "polygon";
+var Polyline = "polyline";
+var Quote = "quote";
+var BlockQuote = "blockquote";
+var Rect = "rect";
+var Svg = "svg";
+var Use = "use";
+
+// ../../node_modules/@lvce-editor/constants/dist/parts/VirtualDomElements/VirtualDomElements.js
+var VirtualDomElements_exports = {};
+__export(VirtualDomElements_exports, {
+  A: () => A2,
+  Abbr: () => Abbr,
+  Article: () => Article2,
+  Aside: () => Aside2,
+  Audio: () => Audio2,
+  BlockQuote: () => BlockQuote2,
+  Br: () => Br2,
+  Button: () => Button2,
+  Canvas: () => Canvas2,
+  Circle: () => Circle2,
+  Cite: () => Cite2,
+  Code: () => Code2,
+  Col: () => Col2,
+  ColGroup: () => ColGroup2,
+  Data: () => Data2,
+  Dd: () => Dd2,
+  Defs: () => Defs2,
+  Del: () => Del2,
+  Div: () => Div2,
+  Dl: () => Dl2,
+  Dt: () => Dt2,
+  Ellipse: () => Ellipse2,
+  Em: () => Em2,
+  Figcaption: () => Figcaption2,
+  Figure: () => Figure2,
+  Footer: () => Footer2,
+  Form: () => Form2,
+  G: () => G2,
+  H1: () => H12,
+  H2: () => H22,
+  H3: () => H32,
+  H4: () => H42,
+  H5: () => H52,
+  H6: () => H62,
+  Head: () => Head2,
+  Header: () => Header2,
+  Hr: () => Hr2,
+  Html: () => Html2,
+  I: () => I2,
+  Iframe: () => Iframe2,
+  Img: () => Img2,
+  Input: () => Input2,
+  Ins: () => Ins2,
+  Kbd: () => Kbd2,
+  Label: () => Label2,
+  Li: () => Li2,
+  Line: () => Line2,
+  Main: () => Main2,
+  Meta: () => Meta2,
+  Nav: () => Nav2,
+  Ol: () => Ol2,
+  Option: () => Option2,
+  P: () => P2,
+  Path: () => Path2,
+  Polygon: () => Polygon2,
+  Polyline: () => Polyline2,
+  Pre: () => Pre2,
+  Quote: () => Quote2,
+  Rect: () => Rect2,
+  Reference: () => Reference,
+  Root: () => Root,
+  Search: () => Search2,
+  Section: () => Section2,
+  Select: () => Select2,
+  Span: () => Span2,
+  Strong: () => Strong2,
+  Style: () => Style2,
+  Svg: () => Svg2,
+  TBody: () => TBody2,
+  THead: () => THead2,
+  Table: () => Table2,
+  Td: () => Td2,
+  Text: () => Text,
+  TextArea: () => TextArea2,
+  Tfoot: () => Tfoot2,
+  Th: () => Th2,
+  Time: () => Time2,
+  Title: () => Title2,
+  Tr: () => Tr2,
+  Ul: () => Ul2,
+  Use: () => Use2,
+  Video: () => Video2
+});
+var Audio2 = 0;
+var Button2 = 1;
+var Col2 = 2;
+var ColGroup2 = 3;
+var Div2 = 4;
+var H12 = 5;
+var Input2 = 6;
+var Kbd2 = 7;
+var Span2 = 8;
+var Table2 = 9;
+var TBody2 = 10;
+var Td2 = 11;
+var Text = 12;
+var Th2 = 13;
+var THead2 = 14;
+var Tr2 = 15;
+var I2 = 16;
+var Img2 = 17;
+var Root = 0;
+var Ins2 = 20;
+var Del2 = 21;
+var H22 = 22;
+var H32 = 23;
+var H42 = 24;
+var H52 = 25;
+var H62 = 26;
+var Article2 = 27;
+var Aside2 = 28;
+var Footer2 = 29;
+var Header2 = 30;
+var Nav2 = 40;
+var Section2 = 41;
+var Search2 = 42;
+var Dd2 = 43;
+var Dl2 = 44;
+var Figcaption2 = 45;
+var Figure2 = 46;
+var Hr2 = 47;
+var Li2 = 48;
+var Ol2 = 49;
+var P2 = 50;
+var Pre2 = 51;
+var A2 = 53;
+var Abbr = 54;
+var Br2 = 55;
+var Cite2 = 56;
+var Data2 = 57;
+var Time2 = 58;
+var Tfoot2 = 59;
+var Ul2 = 60;
+var Video2 = 61;
+var TextArea2 = 62;
+var Select2 = 63;
+var Option2 = 64;
+var Code2 = 65;
+var Label2 = 66;
+var Dt2 = 67;
+var Iframe2 = 68;
+var Main2 = 69;
+var Strong2 = 70;
+var Em2 = 71;
+var Style2 = 72;
+var Html2 = 73;
+var Head2 = 74;
+var Title2 = 75;
+var Meta2 = 76;
+var Canvas2 = 77;
+var Form2 = 78;
+var BlockQuote2 = 79;
+var Quote2 = 80;
+var Circle2 = 81;
+var Defs2 = 82;
+var Ellipse2 = 83;
+var G2 = 84;
+var Line2 = 85;
+var Path2 = 86;
+var Polygon2 = 87;
+var Polyline2 = 88;
+var Rect2 = 89;
+var Svg2 = 90;
+var Use2 = 91;
+var Reference = 100;
+
+// ../../node_modules/@lvce-editor/constants/dist/parts/ElementTagMap/ElementTagMap.js
+var elementTagMap = {
+  [A2]: A,
+  [Article2]: Article,
+  [Aside2]: Aside,
+  [Audio2]: Audio,
+  [BlockQuote2]: BlockQuote,
+  [Br2]: Br,
+  [Button2]: Button,
+  [Canvas2]: Canvas,
+  [Circle2]: Circle,
+  [Cite2]: Cite,
+  [Code2]: Code,
+  [Col2]: Col,
+  [ColGroup2]: ColGroup,
+  [Data2]: Data,
+  [Dd2]: Dd,
+  [Defs2]: Defs,
+  [Del2]: Del,
+  [Div2]: Div,
+  [Dl2]: Dl,
+  [Dt2]: Dt,
+  [Ellipse2]: Ellipse,
+  [Em2]: Em,
+  [Figcaption2]: Figcaption,
+  [Figure2]: Figure,
+  [Footer2]: Footer,
+  [Form2]: Form,
+  [G2]: G,
+  [H12]: H1,
+  [H22]: H2,
+  [H32]: H3,
+  [H42]: H4,
+  [H52]: H5,
+  [H62]: H6,
+  [Head2]: Head,
+  [Header2]: Header,
+  [Hr2]: Hr,
+  [Html2]: Html,
+  [I2]: I,
+  [Iframe2]: Iframe,
+  [Img2]: Img,
+  [Input2]: Input,
+  [Ins2]: Ins,
+  [Kbd2]: Kbd,
+  [Label2]: Label,
+  [Li2]: Li,
+  [Line2]: Line,
+  [Main2]: Main,
+  [Meta2]: Meta,
+  [Nav2]: Nav,
+  [Ol2]: Ol,
+  [Option2]: Option,
+  [P2]: P,
+  [Path2]: Path,
+  [Polygon2]: Polygon,
+  [Polyline2]: Polyline,
+  [Pre2]: Pre,
+  [Quote2]: Quote,
+  [Rect2]: Rect,
+  [Search2]: Search,
+  [Section2]: Section,
+  [Select2]: Select,
+  [Span2]: Span,
+  [Strong2]: Strong,
+  [Style2]: Style,
+  [Svg2]: Svg,
+  [Table2]: Table,
+  [TBody2]: TBody,
+  [Td2]: Td,
+  [TextArea2]: TextArea,
+  [Tfoot2]: Tfoot,
+  [Th2]: Th,
+  [THead2]: THead,
+  [Time2]: Time,
+  [Title2]: Title,
+  [Tr2]: Tr,
+  [Ul2]: Ul,
+  [Use2]: Use,
+  [Video2]: Video
+};
+var getElementTag = (type) => {
+  const elementTag = elementTagMap[type];
+  if (elementTag) {
+    return elementTag;
+  }
+  throw new Error(`element tag not found ${type}`);
+};
+
+// ../session-replay-worker/src/visualDom.ts
+var element = (tag = "div") => ({ attrs: {}, children: [], tag });
+var styleKeys = /* @__PURE__ */ new Set(["width", "height", "top", "left", "marginTop", "paddingLeft", "paddingRight"]);
+var attributes = { className: "class", htmlFor: "for", inputType: "type" };
+var setStyle = (node, key, value) => {
+  node.attrs ||= {};
+  const declarations = (node.attrs.style || "").split(";").filter((entry) => entry.trim() && entry.split(":", 1)[0].trim() !== key);
+  if (value !== void 0 && value !== "") declarations.push(`${key}:${typeof value === "number" || typeof value === "string" ? value : ""}`);
+  node.attrs.style = declarations.join(";");
+};
+var property = (node, key, value) => {
+  if (!node || /^on/i.test(key) || ["type", "childCount", "uid"].includes(key)) return;
+  switch (key) {
+    case "checked":
+      node.checked = Boolean(value);
+      return;
+    case "scrollLeft":
+    case "scrollTop": {
+      node.scroll ||= [0, 0];
+      node.scroll[key === "scrollTop" ? 1 : 0] = Number(value) || 0;
+      return;
+    }
+    case "value":
+      node.value = typeof value === "string" ? value : "";
+      return;
+    default:
+      break;
+  }
+  if (styleKeys.has(key)) {
+    setStyle(
+      node,
+      key.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`),
+      typeof value === "number" ? `${value}px` : value
+    );
+    return;
+  }
+  const attribute = attributes[key] || (key.startsWith("aria") ? `aria-${key.slice(4).toLowerCase()}` : key);
+  node.attrs ||= {};
+  if ([void 0, null, false].includes(value)) delete node.attrs[attribute];
+  else node.attrs[attribute] = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : "";
+};
+var matches = (node, selector) => {
+  if (selector.startsWith(".")) return (node.attrs?.class || "").split(" ").includes(selector.slice(1));
+  if (selector.startsWith("#")) return node.attrs?.id === selector.slice(1);
+  const name = /^\[name="([^"]+)"\]$/.exec(selector);
+  return name ? node.attrs?.name === name[1] : node.tag === selector;
+};
+var find = (node, selector) => {
+  if (matches(node, selector)) return node;
+  const children = node.children || [];
+  for (const child of children) {
+    const result = find(child, selector);
+    if (result) return result;
+  }
+  return void 0;
+};
+var createVisualDom = () => {
+  const views = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new WeakMap();
+  const owners = /* @__PURE__ */ new WeakMap();
+  let nodeCount = 0;
+  const detach = (node) => {
+    const parent = parents.get(node);
+    if (parent) parent.children.splice(parent.children.indexOf(node), 1);
+    parents.delete(node);
+  };
+  const clear = (node) => {
+    while (node.children?.length) detach(node.children.at(0));
+  };
+  const append = (parent, node, index) => {
+    let depth = 0;
+    for (let ancestor = parent; ancestor; ancestor = parents.get(ancestor)) {
+      if (ancestor === node || ++depth > 150) throw new Error("Invalid replay DOM reference or depth");
+    }
+    const oldParent = parents.get(node);
+    const oldIndex = oldParent?.children?.indexOf(node);
+    if (oldParent === parent && index !== void 0 && oldIndex !== void 0 && oldIndex < index) index--;
+    detach(node);
+    parent.children ||= [];
+    parent.children.splice(index ?? parent.children.length, 0, node);
+    parents.set(node, parent);
+  };
+  const replace = (node, next) => {
+    if (node === next) return next;
+    const parent = parents.get(node);
+    const index = parent?.children.indexOf(node);
+    detach(node);
+    if (parent) append(parent, next, index);
+    const uid = owners.get(node);
+    if (uid !== void 0) {
+      views.set(uid, next);
+      owners.set(next, uid);
+    }
+    return next;
+  };
+  const renderNode = (value) => {
+    let node;
+    if (value.type === VirtualDomElements_exports.Reference) node = views.get(value.uid) || { text: "Reference node not found" };
+    else if (value.type === VirtualDomElements_exports.Text) node = { text: value.text };
+    else {
+      node = element(ElementTagMap_exports.getElementTag(value.type));
+      for (const [key, entry] of Object.entries(value)) property(node, key, entry);
+    }
+    return node;
+  };
+  const render = (nodes) => {
+    const roots = [];
+    const stack = [];
+    for (const value of nodes) {
+      if (++nodeCount > 2e6) throw new Error("Session replay DOM operation limit reached");
+      while (stack.at(-1)?.remaining === 0) stack.pop();
+      const node = renderNode(value);
+      const parent = stack.at(-1);
+      if (parent) {
+        append(parent.node, node);
+        parent.remaining--;
+      } else roots.push(node);
+      const childCount = value.childCount || 0;
+      if (!Number.isSafeInteger(childCount) || childCount < 0 || stack.length > 150) throw new Error("Invalid virtual DOM child count or depth");
+      if (childCount) stack.push({ node, remaining: childCount });
+    }
+    if (stack.some((entry) => entry.remaining !== 0)) throw new Error("Incomplete replay virtual DOM");
+    return roots;
+  };
+  const patch = (uid, patches) => {
+    let current = views.get(uid);
+    if (!current) return;
+    owners.set(current, uid);
+    const mutations = {
+      1: (node, value) => {
+        node.text = String(value.value);
+        return node;
+      },
+      10: (node, value) => parents.get(node)?.children?.[value.index],
+      11: (node, value) => {
+        const next = views.get(value.uid);
+        return next ? replace(node, next) : node;
+      },
+      2: (node, value) => {
+        const next = render(value.nodes)[0];
+        if (next) return replace(node, next);
+        detach(node);
+        return node;
+      },
+      3: (node, value) => {
+        property(node, value.key, value.value);
+        return node;
+      },
+      4: (node, value) => {
+        property(node, value.key, void 0);
+        return node;
+      },
+      6: (node, value) => {
+        const children = render(value.nodes);
+        for (const child of children) append(node, child);
+        return node;
+      },
+      7: (node, value) => node.children?.[value.index],
+      8: (node) => parents.get(node),
+      9: (node, value) => {
+        if (node.children?.[value.index]) detach(node.children[value.index]);
+        return node;
+      }
+    };
+    for (let index = 0; index < patches.length; index++) {
+      const value = patches[index];
+      if (value.type === 7 && value.index === current.children?.length && patches[index + 1]?.type === 2) append(current, element());
+      if (!mutations[value.type]) continue;
+      current = mutations[value.type](current, value);
+      if (!current) return;
+    }
+  };
+  return { append, clear, detach, element, find, patch, property, render, replace, views };
+};
+
+// ../session-replay-worker/src/visualState.ts
+var createVisualState = (initial) => {
+  const frame = structuredClone(initial);
+  const dom = createVisualDom();
+  const { append, clear, detach, element: element2, find: find2, patch, property: property2, render, replace, views } = dom;
+  const sheets = new Map((frame.styles || []).map((text, index) => [`initial-${index}`, text]));
+  const calls = /* @__PURE__ */ new Map();
+  const batches = /* @__PURE__ */ new Map();
+  const setDom = (uid, nodes) => {
+    const view = views.get(uid);
+    if (!view) return;
+    const next = render(nodes)[0];
+    if (next) {
+      replace(view, next);
+      views.set(uid, next);
+    }
+  };
+  const apply = (method, params = []) => {
+    if (method && Object.hasOwn(handlers, method)) handlers[method](...params);
+  };
+  const execute = (commands2) => {
+    for (const [method, ...params] of commands2) apply(method, params);
+  };
+  const commit = (uid, transaction) => {
+    const batch = batches.get(transaction);
+    if (!batch || batch.uid !== uid) return;
+    batch.committed = true;
+    for (const [key, pending2] of batches) {
+      if (pending2.uid !== uid) continue;
+      if (!pending2.committed) return;
+      execute(pending2.commands);
+      batches.delete(key);
+    }
+  };
+  const appendView = (uid, childId, references) => {
+    const view = views.get(uid);
+    const child = views.get(childId);
+    if (!view || !child) return;
+    const nextReferences = references?.slice(references.indexOf(childId) + 1) || [];
+    const next = nextReferences.map((id) => views.get(id)).find((node) => node && view.children?.includes(node));
+    append(view, child, next ? view.children.indexOf(next) : void 0);
+  };
+  const setProperty = (uid, selector, key, value) => {
+    const view = views.get(uid);
+    const node = view && find2(view, selector);
+    if (!node) return;
+    if (key === "textContent") {
+      clear(node);
+      append(node, { text: String(value) });
+    } else property2(node, key, value);
+  };
+  const setBounds = (uid, left, top, width, height) => {
+    const view = views.get(uid);
+    const bounds = Object.entries({ height, left, top, width });
+    for (const [key, value] of bounds) property2(view, key, value);
+  };
+  const setCss = (uid, text) => {
+    sheets.set(uid, text);
+  };
+  const create = (_id, uid = Number(_id)) => {
+    views.set(uid, element2());
+  };
+  const handlers = {
+    "Css.addCssStyleSheet": setCss,
+    "Css.removeCssStyleSheet": (uid) => {
+      sheets.delete(uid);
+    },
+    "Viewlet.addCss": setCss,
+    "Viewlet.append": appendView,
+    "Viewlet.appendToBody": (uid) => {
+      const view = views.get(uid);
+      if (view) append(frame.dom, view);
+    },
+    "Viewlet.appendToRoot": (uid, root) => {
+      const view = views.get(uid);
+      const parent = find2(frame.dom, `#${root}`);
+      if (view && parent) append(parent, view);
+    },
+    "Viewlet.commitPending": commit,
+    "Viewlet.create": create,
+    "Viewlet.createFunctionalRoot": create,
+    "Viewlet.createPlaceholder": (uid, parentId, top, left, width, height) => {
+      views.set(uid, element2());
+      property2(views.get(uid), "className", `Viewlet ${uid}`);
+      setBounds(uid, left, top, width, height);
+      appendView(parentId, uid);
+    },
+    "Viewlet.dispose": (uid) => {
+      const view = views.get(uid);
+      if (view) detach(view);
+      views.delete(uid);
+      sheets.delete(uid);
+    },
+    "Viewlet.executeCommands": execute,
+    "Viewlet.patchCss": (uid, start, count, replacement) => {
+      const text = sheets.get(uid);
+      if (typeof text === "string") sheets.set(uid, text.slice(0, start) + replacement + text.slice(start + count));
+    },
+    "Viewlet.replaceChildren": (uid, children) => {
+      const view = views.get(uid);
+      if (!view) return;
+      clear(view);
+      for (const id of children) {
+        const child = views.get(id);
+        if (child) append(view, child);
+      }
+    },
+    "Viewlet.scrollSelectorBy": (uid, selector, delta) => {
+      const view = views.get(uid);
+      const node = view && find2(view, selector);
+      if (node) property2(node, "scrollLeft", (node.scroll?.[0] || 0) + delta);
+    },
+    "Viewlet.sendMultiple": execute,
+    "Viewlet.setBounds": setBounds,
+    "Viewlet.setCheckBoxValue": (uid, name, value) => setProperty(uid, `[name="${name}"]`, "checked", value),
+    "Viewlet.setComponentDom": setDom,
+    "Viewlet.setCss": setCss,
+    "Viewlet.setDom": (uid, nodes) => {
+      const view = views.get(uid);
+      if (!view) return;
+      clear(view);
+      const children = render(nodes);
+      for (const child of children) append(view, child);
+    },
+    "Viewlet.setDom2": setDom,
+    "Viewlet.setInputValues": (uid, items) => {
+      for (const { name, value } of items) setProperty(uid, `[name="${name}"]`, "value", value);
+    },
+    "Viewlet.setPatches": (uid, patches) => {
+      if (patches.length === 1 && patches[0].type === 6) setDom(uid, patches[0].nodes);
+      else patch(uid, patches);
+    },
+    "Viewlet.setProperty": setProperty,
+    "Viewlet.setTreePatches": patch,
+    "Viewlet.setValueByName": (uid, name, value) => setProperty(uid, `[name="${name}"]`, "value", value),
+    "Viewlet.show": (uid) => {
+      const view = views.get(uid);
+      if (view) append(find2(frame.dom, "#Workbench") || frame.dom, view);
+    }
+  };
+  return {
+    accept(data) {
+      if (!data?.renderer || !data.message || typeof data.message !== "object") return;
+      const { connection, direction, message } = data;
+      const key = `${connection}:${message.id}`;
+      if (direction === "to-renderer") {
+        if (message.method === "Viewlet.queueCommands") calls.set(key, message.params);
+        else apply(message.method, message.params);
+      } else if (calls.has(key)) {
+        const [uid, commands2] = calls.get(key);
+        calls.delete(key);
+        if (Number.isSafeInteger(message.result)) batches.set(message.result, { commands: commands2, committed: false, uid });
+      }
+    },
+    frame() {
+      return { ...frame, styles: [...sheets.values()] };
+    }
+  };
+};
+
+// ../session-replay-worker/src/protocol.ts
+var version = 1;
+var maxEventBytes = 75e4;
+var maxSessionBytes = 64 * 1024 * 1024;
+var bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+var validateSession = (value) => {
+  const session = value;
+  if (session?.version !== version || !Array.isArray(session.events) || session.events.length > 2e5 || bytes(session) > maxSessionBytes) {
+    throw new Error("Unsupported or oversized session replay");
+  }
+  let time = 0;
+  for (const [sequence, event] of session.events.entries()) {
+    if (!event || event.sequence !== sequence || !Number.isFinite(event.timestamp) || event.timestamp < time || !["frame", "message"].includes(event.type)) {
+      throw new Error("Invalid session replay event sequence");
+    }
+    if (bytes(event) > maxEventBytes) throw new Error("Session replay event is too large");
+    time = event.timestamp;
+  }
+  return session;
+};
+var loadContent = (value) => {
+  const session = validateSession(value);
+  const frames = session.events.filter((event) => event.type === "frame");
+  if (frames.length === 0) throw new Error("This session has no visual frames");
+  const duration = session.events.at(-1)?.timestamp || 0;
+  let visual = createVisualState(frames[0].data);
+  let eventIndex = 0;
+  let lastPosition = -1;
+  const seek = (timestamp) => {
+    const position = Math.max(0, Math.min(duration, timestamp || 0));
+    if (frames[0].data.commandReplay) {
+      if (position < lastPosition) {
+        visual = createVisualState(frames[0].data);
+        eventIndex = 0;
+      }
+      while (eventIndex < session.events.length && session.events[eventIndex].timestamp <= position) {
+        const event = session.events[eventIndex++];
+        if (event.type === "message") visual.accept(event.data);
+      }
+      lastPosition = position;
+      return { duration, frame: structuredClone(visual.frame()), position };
+    }
+    let low = 0;
+    let high = frames.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (frames[middle].timestamp <= position) low = middle + 1;
+      else high = middle;
+    }
+    return { duration, frame: frames[Math.max(0, low - 1)].data, position };
+  };
+  return { duration, seek };
+};
+
+// ../session-replay-worker/src/proxy.ts
+var wrapPorts = (value, replacePort, seen = /* @__PURE__ */ new Map()) => {
+  if (!value || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof MessagePort) {
+    const replacement = replacePort(value);
+    seen.set(value, replacement);
+    return replacement;
+  }
+  seen.set(value, value);
+  if (value instanceof Map) {
+    const entries = [...value];
+    value.clear();
+    for (const [key, entry] of entries) value.set(wrapPorts(key, replacePort, seen), wrapPorts(entry, replacePort, seen));
+  } else if (value instanceof Set) {
+    const entries = [...value];
+    value.clear();
+    for (const entry of entries) value.add(wrapPorts(entry, replacePort, seen));
+  } else if (Array.isArray(value) || Object.prototype.toString.call(value) === "[object Object]") {
+    const object = value;
+    for (const key of Object.keys(object)) object[key] = wrapPorts(object[key], replacePort, seen);
+  }
+  return value;
+};
+var createProxyRegistry = ({
+  record,
+  report: report2 = () => {
+  }
+}) => {
+  const connections = /* @__PURE__ */ new Set();
+  let nextId = 0;
+  const createNestedPort = (connection, renderer, port) => create(port, `${connection}/port`, renderer);
+  const create = (port, label = "renderer", renderer = true) => {
+    const channel = new MessageChannel();
+    const peer = channel.port1;
+    const connection = ++nextId;
+    const close = () => {
+      for (const endpoint of [port, peer]) {
+        endpoint.removeEventListener("close", close);
+        endpoint.onmessage = null;
+        endpoint.onmessageerror = null;
+        endpoint.close();
+      }
+      connections.delete(close);
+    };
+    connections.add(close);
+    const ignoredReplies = { "from-renderer": /* @__PURE__ */ new Set(), "to-renderer": /* @__PURE__ */ new Set() };
+    const forward = (source, target, direction) => {
+      source.onmessage = ({ data }) => {
+        const opposite = direction === "to-renderer" ? "from-renderer" : "to-renderer";
+        const ignored = typeof data?.method === "string" && data.method.startsWith("SessionReplay.");
+        if (ignored && data.id !== void 0) ignoredReplies[opposite].add(data.id);
+        const ignoredReply = !data?.method && ignoredReplies[direction].delete(data?.id);
+        if (!ignored && !ignoredReply) {
+          try {
+            record({ connection, direction, label, message: data, renderer });
+          } catch (error) {
+            report2(error);
+          }
+        }
+        const directRenderer = renderer && data?.method === "HandleMessagePort.handleMessagePort";
+        const message = wrapPorts(data, createNestedPort.bind(null, connection, directRenderer));
+        target.postMessage(message, getTransferrables(message));
+        if (data?.method === "Exit.exit") close();
+      };
+      source.onmessageerror = () => report2(new Error(`Cannot decode session replay proxy message (${connection})`));
+      source.addEventListener("close", close);
+      source.start();
+    };
+    forward(port, peer, "to-renderer");
+    forward(peer, port, "from-renderer");
+    return channel.port2;
+  };
+  return {
+    create,
+    dispose() {
+      for (const close of connections) close();
+    }
+  };
+};
+
+// ../session-replay-worker/src/recorder.ts
+var createRecorder = ({
+  fetch: request = globalThis.fetch,
+  now = () => performance.now(),
+  storage: storage2
+}) => {
+  let metadata;
+  let options;
+  const events = [];
+  const pending2 = [];
+  let size = 0;
+  let origin = 0;
+  let remote;
+  let uploadPromise;
+  let lastError = "";
+  let saved = 0;
+  let uploaded = 0;
+  const start = async (config) => {
+    if (metadata) throw new Error("A session is already recording");
+    options = config;
+    origin = now();
+    metadata = { createdAt: (/* @__PURE__ */ new Date()).toISOString(), id: crypto.randomUUID(), version };
+    if (options.local) await storage2.save(metadata, []);
+    return metadata.id;
+  };
+  const record = async (...[type, data]) => {
+    if (!metadata) return;
+    const event = { data, sequence: events.length, timestamp: Math.max(events.at(-1)?.timestamp || 0, now() - origin), type };
+    const eventSize = bytes(event);
+    if (eventSize > maxEventBytes || size + eventSize > maxSessionBytes)
+      throw new Error("Session replay storage limit reached; download this session and start a new one");
+    size += eventSize;
+    events.push(event);
+    if (options.upload) pending2.push(event);
+    if (options.local) {
+      await storage2.save(metadata, [event]);
+      saved++;
+    }
+  };
+  const doUpload = async () => {
+    if (!options?.upload || pending2.length === 0) return;
+    const endpoint = new URL(options.endpoint);
+    if (!["https:", "http:"].includes(endpoint.protocol)) throw new Error("Invalid session replay backend URL");
+    const headers = { "Content-Type": "application/json", ...options.token && { Authorization: `Bearer ${options.token}` } };
+    const send = async (url, body) => {
+      const response = await request(url, {
+        body: JSON.stringify(body),
+        credentials: "include",
+        headers,
+        method: "POST",
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) throw new Error(`Session replay upload failed (${response.status})`);
+      return response.json();
+    };
+    if (!remote) remote = await send(endpoint, { createdAt: metadata.createdAt, version });
+    while (pending2.length > 0) {
+      const batch = [];
+      let batchBytes = 0;
+      for (const event of pending2) {
+        const length = bytes(event);
+        if (batch.length > 0 && (batchBytes + length > 8e5 || batch.length >= 250)) break;
+        batch.push(event);
+        batchBytes += length;
+      }
+      const url = new URL(endpoint);
+      url.pathname = `${url.pathname.replace(/\/$/, "")}/${encodeURIComponent(remote.id)}/events`;
+      await send(url, { events: batch, uploadToken: remote.uploadToken });
+      pending2.splice(0, batch.length);
+      uploaded += batch.length;
+    }
+  };
+  const flush = () => {
+    uploadPromise ||= doUpload().then(
+      () => {
+        lastError = "";
+      },
+      (error) => {
+        lastError = error.message;
+        throw error;
+      }
+    ).finally(() => {
+      uploadPromise = void 0;
+    });
+    return uploadPromise;
+  };
+  return {
+    export: () => ({ ...metadata, events }),
+    flush,
+    record,
+    start,
+    status: () => ({
+      bytes: size,
+      error: lastError,
+      events: events.length,
+      id: metadata?.id,
+      pending: pending2.length,
+      saved,
+      uploaded
+    })
+  };
+};
+
+// ../session-replay-worker/src/api/capture.ts
+var serializeMessage = (message) => {
+  const ancestors = [];
+  let count = 0;
+  return JSON.parse(
+    JSON.stringify(message, function(key, value) {
+      if (++count > 2e5) throw new Error("Session replay message is too complex");
+      if (/password|token|secret|authorization|cookie/i.test(key)) return "[redacted]";
+      if (typeof value === "bigint") return String(value);
+      if (typeof value !== "object" || value === null) return value;
+      while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop();
+      if (ancestors.includes(value)) return "[circular]";
+      ancestors.push(value);
+      if (value instanceof Error) return { message: value.message, name: value.name, stack: value.stack };
+      if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return { byteLength: value.byteLength, type: value.constructor.name };
+      if (value.constructor?.name === "MessagePort") return { type: "MessagePort" };
+      return value;
+    })
+  );
+};
+
+// ../session-replay-worker/src/serializeProxyMessage.ts
+var redacted = "[redacted]";
+var isMasked = (node) => node.inputType === "password" || Object.hasOwn(node, "data-session-replay-mask") || Object.hasOwn(node, "data-session-replay-ignore");
+var structuralKeys = /* @__PURE__ */ new Set(["type", "childCount", "uid"]);
+var redactNode = (node) => {
+  for (const key of Object.keys(node)) {
+    if (structuralKeys.has(key)) continue;
+    if (["text", "value", "textContent"].includes(key)) node[key] = redacted;
+    else if (key === "inputType" && node[key] === "password") continue;
+    else if (["data-session-replay-mask", "data-session-replay-ignore"].includes(key)) node[key] = "";
+    else delete node[key];
+  }
+};
+var redactUpdates = (method, params) => {
+  if (method === "Viewlet.setValueByName") params[2] = redacted;
+  else if (method === "Viewlet.setProperty") params[3] = redacted;
+  const updates = params[1];
+  if (!Array.isArray(updates)) return;
+  if (method === "Viewlet.setInputValues") for (const item of updates) item.value = redacted;
+  if (!["Viewlet.setPatches", "Viewlet.setTreePatches"].includes(method)) return;
+  for (const patch of updates) {
+    if ([1, 3].includes(patch.type)) patch.value = redacted;
+  }
+};
+var createMessageSerializer = () => {
+  const maskedViews = /* @__PURE__ */ new Set();
+  const sanitizeCommand = (method, params, masked) => {
+    if (!method.startsWith("Viewlet.") || typeof params[0] !== "number") return;
+    const uid = params[0];
+    const patches = params[1];
+    const masksInput = Array.isArray(patches) && patches.some((patch) => patch?.key === "inputType" && patch.value === "password");
+    if (masked || masksInput) maskedViews.add(uid);
+    if (maskedViews.has(uid)) redactUpdates(method, params);
+  };
+  const sanitizeArray = (array) => {
+    let remaining = 0;
+    let masked = false;
+    for (const entry of array) {
+      if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+        const node = entry;
+        if (remaining > 0 || isMasked(node)) {
+          remaining = Math.max(0, remaining - 1) + (typeof node.childCount === "number" ? node.childCount : 0);
+          redactNode(node);
+          masked = true;
+        }
+      }
+      masked = sanitize(entry) || masked;
+    }
+    if (typeof array[0] === "string" && array[0].startsWith("Viewlet.")) {
+      const params = array.slice(1);
+      sanitizeCommand(array[0], params, masked);
+      array.splice(1, array.length - 1, ...params);
+    }
+    return masked;
+  };
+  const sanitize = (value) => {
+    if (!value || typeof value !== "object") return false;
+    if (Array.isArray(value)) return sanitizeArray(value);
+    const object = value;
+    let masked = isMasked(object);
+    if (masked) redactNode(object);
+    for (const child of Object.values(object)) masked = sanitize(child) || masked;
+    if (typeof object.method === "string" && Array.isArray(object.params)) sanitizeCommand(object.method, object.params, masked);
+    return masked;
+  };
+  return (message) => {
+    const result = serializeMessage(message);
+    sanitize(result);
+    return result;
+  };
+};
+
+// ../session-replay-worker/src/storage.ts
+var withoutSessionId = ({ sessionId, ...event }) => event;
+var open = () => new Promise((resolve, reject) => {
+  const request = indexedDB.open("lvce-session-replays", 1);
+  request.onupgradeneeded = () => {
+    request.result.createObjectStore("sessions", { keyPath: "id" });
+    request.result.createObjectStore("events", { keyPath: ["sessionId", "sequence"] });
+  };
+  request.onsuccess = () => resolve(request.result);
+  request.onerror = () => reject(request.error || new Error("Replay storage open failed"));
+});
+var createStorage = async () => {
+  const db = await open();
+  const transaction = (stores, action) => new Promise((resolve, reject) => {
+    const tx = db.transaction(stores, "readwrite");
+    action(tx);
+    tx.oncomplete = () => resolve();
+    tx.onerror = tx.onabort = () => reject(tx.error || new Error("Replay storage transaction aborted"));
+  });
+  return {
+    close: () => db.close(),
+    read: (id) => new Promise((resolve, reject) => {
+      const tx = db.transaction(["sessions", "events"]);
+      const metadata = tx.objectStore("sessions").get(id);
+      const events = tx.objectStore("events").getAll(IDBKeyRange.bound([id, 0], [id, Number.MAX_SAFE_INTEGER]));
+      tx.oncomplete = () => metadata.result ? resolve({ ...metadata.result, events: events.result.map(withoutSessionId) }) : reject(new Error("Session replay not found"));
+      tx.onerror = () => reject(tx.error || new Error("Replay storage read failed"));
+    }),
+    save: (session, events) => transaction(["sessions", "events"], (tx) => {
+      tx.objectStore("sessions").put(session);
+      for (const event of events) tx.objectStore("events").put({ ...event, sessionId: session.id });
+    })
+  };
+};
+
+// ../session-replay-worker/src/worker.ts
+var storage;
+var recorder;
+var content;
+var queue = Promise.resolve();
+var timer;
+var getStorage = async () => storage ||= await createStorage();
+var recording = false;
+var captureError = "";
+var pending = 0;
+var writes = Promise.resolve();
+var report = (error) => {
+  captureError = error instanceof Error ? error.message : String(error);
+  recording = false;
+};
+var serializeMessage2 = createMessageSerializer();
+var proxies = createProxyRegistry({
+  record(message) {
+    if (!recording) return;
+    if (pending >= 500) {
+      report(new Error("Recording cannot keep up with worker messages"));
+      return;
+    }
+    const data = serializeMessage2(message);
+    pending++;
+    const write = recorder.record("message", data).catch(report).finally(() => {
+      pending--;
+    });
+    writes = Promise.all([writes, write]).then(() => {
+    });
+  },
+  report
+});
+var commands = {
+  export: async () => {
+    await writes;
+    return recorder.export();
+  },
+  flush: () => recorder.flush(),
+  async load(source) {
+    let session;
+    if ("localId" in source) {
+      const localStorage = await getStorage();
+      session = await localStorage.read(source.localId);
+    } else if ("url" in source) {
+      const response = await fetch(source.url, { credentials: "include", headers: { Accept: "application/json" } });
+      if (!response.ok) throw new Error(`Cannot load session replay (${response.status})`);
+      session = await response.json();
+    } else ({ session } = source);
+    content = loadContent(session);
+    return content.seek(0);
+  },
+  proxy: (port) => proxies.create(port),
+  record: (...params) => recorder.record(...params),
+  seek: (timestamp) => content.seek(timestamp),
+  async start(options, initialFrame) {
+    if (recorder) throw new Error("Reload the window to start a new command recording");
+    recorder = createRecorder({ storage: options.local ? await getStorage() : void 0 });
+    const id = await recorder.start(options);
+    if (initialFrame) await recorder.record("frame", { ...initialFrame, commandReplay: true });
+    recording = true;
+    clearInterval(timer);
+    timer = setInterval(() => {
+      void recorder.flush().catch(() => {
+      });
+    }, 2e3);
+    return id;
+  },
+  status: () => ({ ...recorder.status(), error: captureError || recorder.status().error }),
+  async stop() {
+    clearInterval(timer);
+    recording = false;
+    await writes;
+    await recorder?.flush();
+  }
+};
+globalThis.onmessage = ({ data: { id, method, params = [] } }) => {
+  queue = queue.then(async () => {
+    try {
+      if (!Object.hasOwn(commands, method)) throw new Error("Unknown session replay command");
+      const result = await commands[method](...params);
+      globalThis.postMessage({ id, result }, { transfer: getTransferrables(result) });
+    } catch (error) {
+      globalThis.postMessage({ error: error instanceof Error ? error.message : String(error), id });
+    }
+  });
+};