@replohq/sandbox-runtime 1.20.0 → 1.21.0

package/comments-overlay/vendor/bippy.js

@@ -0,0 +1,402 @@
+/*!
+ * Copyright (c) 2024-present Aiden Bai
+ * SPDX-License-Identifier: MIT
+ * https://github.com/aidenybai/bippy
+ */
+const FUNCTION_COMPONENT_TAG = 0;
+const CLASS_COMPONENT_TAG = 1;
+const HOST_ROOT_TAG = 3;
+const HOST_COMPONENT_TAG = 5;
+const FORWARD_REF_TAG = 11;
+const MEMO_COMPONENT_TAG = 14;
+const SIMPLE_MEMO_COMPONENT_TAG = 15;
+const HOST_HOISTABLE_TAG = 26;
+const HOST_SINGLETON_TAG = 27;
+const COMPOSITE_TAGS = /* @__PURE__ */ new Set([
+  FUNCTION_COMPONENT_TAG,
+  CLASS_COMPONENT_TAG,
+  FORWARD_REF_TAG,
+  MEMO_COMPONENT_TAG,
+  SIMPLE_MEMO_COMPONENT_TAG
+]);
+const HOST_TAGS = /* @__PURE__ */ new Set([
+  HOST_COMPONENT_TAG,
+  HOST_HOISTABLE_TAG,
+  HOST_SINGLETON_TAG
+]);
+const MAX_ROOT_CLIMB_DEPTH = 1e3;
+const MAX_CURRENT_TREE_SCAN = 5e4;
+const MAX_OWNED_CHILD_SCAN = 2e3;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFiber(value) {
+  return isObject(value) && typeof value.tag === "number" && "stateNode" in value;
+}
+function isCompositeFiber(fiber) {
+  return COMPOSITE_TAGS.has(fiber.tag);
+}
+function isHostFiber(fiber) {
+  return HOST_TAGS.has(fiber.tag) || typeof fiber.type === "string";
+}
+function getFiberFromHostInstance(element) {
+  for (const key of Object.keys(element)) {
+    if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+      const fiber = Reflect.get(element, key);
+      return isFiber(fiber) ? fiber : null;
+    }
+  }
+  return null;
+}
+function getDisplayName(type) {
+  if (typeof type === "function") {
+    const displayName = Reflect.get(type, "displayName");
+    if (typeof displayName === "string" && displayName) {
+      return displayName;
+    }
+    return type.name || null;
+  }
+  if (!isObject(type)) {
+    return null;
+  }
+  if (typeof type.displayName === "string" && type.displayName) {
+    return type.displayName;
+  }
+  if (typeof type.name === "string" && type.name) {
+    return type.name;
+  }
+  return getDisplayName(type.type ?? type.render);
+}
+function getLatestFiber(fiber) {
+  const alternate = fiber.alternate;
+  if (!alternate) {
+    return fiber;
+  }
+  let root = fiber;
+  for (let depth = 0; root.return && depth < MAX_ROOT_CLIMB_DEPTH; depth++) {
+    root = root.return;
+  }
+  const fiberRoot = root.tag === HOST_ROOT_TAG ? root.stateNode : null;
+  const current = isObject(fiberRoot) ? fiberRoot.current : null;
+  if (!isFiber(current)) {
+    return fiber;
+  }
+  const stack = [current];
+  for (let scanned = 0; stack.length > 0 && scanned < MAX_CURRENT_TREE_SCAN; scanned++) {
+    const node = stack.pop();
+    if (!node) {
+      continue;
+    }
+    if (node === fiber || node === alternate) {
+      return node;
+    }
+    if (node.sibling) {
+      stack.push(node.sibling);
+    }
+    if (node.child) {
+      stack.push(node.child);
+    }
+  }
+  return fiber;
+}
+const REACT_STACK_BOTTOM_FRAME_PATTERNS = [
+  "react_stack_bottom_frame",
+  "react-stack-bottom-frame"
+];
+const JSX_FACTORY_FRAME_COUNT = 1;
+const FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+const CHROME_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/;
+function extractLocation(urlLike) {
+  const isWrapped = urlLike.startsWith("(") && /:\d+\)$/.test(urlLike);
+  const location = isWrapped ? urlLike.slice(1, -1) : urlLike;
+  const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(location);
+  if (!parts?.[1]) {
+    return [location, void 0, void 0];
+  }
+  return [
+    parts[1],
+    parts[2] ? Number(parts[2]) : void 0,
+    parts[3] ? Number(parts[3]) : void 0
+  ];
+}
+function parseV8Line(line) {
+  if (!CHROME_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  let sanitized = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const locationMatch = sanitized.match(/ (\(.+\)$)/);
+  sanitized = locationMatch ? sanitized.replace(locationMatch[0], "") : sanitized;
+  const [fileName, lineNumber, columnNumber] = extractLocation(
+    locationMatch?.[1] ?? sanitized
+  );
+  return {
+    functionName: locationMatch && sanitized || void 0,
+    fileName: ["eval", "<anonymous>", "(native)"].includes(fileName) ? void 0 : fileName,
+    lineNumber,
+    columnNumber
+  };
+}
+function parseFirefoxSafariLine(line) {
+  if (!FIREFOX_SAFARI_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  const atIndex = line.lastIndexOf("@");
+  const functionName = atIndex > 0 ? line.slice(0, atIndex) : void 0;
+  const [fileName, lineNumber, columnNumber] = extractLocation(
+    line.slice(atIndex + 1)
+  );
+  return { functionName, fileName, lineNumber, columnNumber };
+}
+function parseStack(stackString) {
+  const frames = [];
+  for (const line of stackString.split("\n")) {
+    const frame = /^\s*at\s+/.test(line) ? parseV8Line(line) : parseFirefoxSafariLine(line);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+function readStackString(debugStack) {
+  if (typeof debugStack === "string") {
+    return debugStack;
+  }
+  if (isObject(debugStack) && typeof debugStack.stack === "string") {
+    return debugStack.stack;
+  }
+  return null;
+}
+function parseDebugStack(debugStack) {
+  const stackString = readStackString(debugStack);
+  if (!stackString) {
+    return { frames: [], isTrusted: false };
+  }
+  let bottomFrameIndex = -1;
+  for (const pattern of REACT_STACK_BOTTOM_FRAME_PATTERNS) {
+    bottomFrameIndex = stackString.indexOf(pattern);
+    if (bottomFrameIndex !== -1) {
+      break;
+    }
+  }
+  const trimmed = bottomFrameIndex === -1 ? stackString : stackString.slice(0, stackString.lastIndexOf("\n", bottomFrameIndex));
+  return {
+    frames: parseStack(trimmed).slice(JSX_FACTORY_FRAME_COUNT),
+    isTrusted: bottomFrameIndex !== -1
+  };
+}
+const INTERNAL_SCHEME_PREFIXES = [
+  "rsc://",
+  "file:///",
+  "webpack-internal://",
+  "webpack://",
+  "node:",
+  "turbopack://",
+  "metro://",
+  "/app-pages-browser/",
+  "/(app-pages-browser)/"
+];
+const ABOUT_REACT_PREFIX = "about://React/";
+const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+const QUERY_PARAMETER_PATTERN_REGEX = /^\?[\w~.-]+(?:=[^&#]*)?(?:&[\w~.-]+(?:=[^&#]*)?)*$/;
+function normalizeFileName(fileName) {
+  if (!fileName || fileName === "<anonymous>" || fileName === "eval") {
+    return "";
+  }
+  let normalized = fileName;
+  const isWindowsDrivePath = /^[a-zA-Z]:[\\/]/.test(normalized);
+  if (normalized.startsWith("http://") || normalized.startsWith("https://")) {
+    try {
+      normalized = new URL(normalized).pathname;
+    } catch {
+    }
+  }
+  if (normalized.startsWith(ABOUT_REACT_PREFIX)) {
+    const remainder = normalized.slice(ABOUT_REACT_PREFIX.length);
+    const slashIndex = remainder.indexOf("/");
+    const colonIndex = remainder.indexOf(":");
+    normalized = slashIndex !== -1 && (colonIndex === -1 || slashIndex < colonIndex) ? remainder.slice(slashIndex + 1) : remainder;
+  }
+  let didStripPrefix = true;
+  while (didStripPrefix) {
+    didStripPrefix = false;
+    for (const prefix of INTERNAL_SCHEME_PREFIXES) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+        if (prefix === "file:///") {
+          normalized = `/${normalized.replace(/^\/+/, "")}`;
+        }
+        didStripPrefix = true;
+        break;
+      }
+    }
+  }
+  if (!isWindowsDrivePath) {
+    const schemeMatch = normalized.match(SCHEME_REGEX);
+    if (schemeMatch) {
+      normalized = normalized.slice(schemeMatch[0].length);
+    }
+  }
+  if (normalized.startsWith("//")) {
+    const firstPathSlashIndex = normalized.indexOf("/", 2);
+    normalized = firstPathSlashIndex === -1 ? "" : normalized.slice(firstPathSlashIndex);
+  }
+  const queryIndex = normalized.indexOf("?");
+  if (queryIndex !== -1 && QUERY_PARAMETER_PATTERN_REGEX.test(normalized.slice(queryIndex))) {
+    normalized = normalized.slice(0, queryIndex);
+  }
+  return normalized;
+}
+function hasDebugSource(fiber) {
+  const debugSource = fiber._debugSource;
+  return isObject(debugSource) && typeof debugSource.fileName === "string" && debugSource.fileName !== "(native)" && typeof debugSource.lineNumber === "number";
+}
+function getUsageFrameFromDebugStack(fiber) {
+  const { frames, isTrusted } = parseDebugStack(fiber._debugStack);
+  if (!isTrusted) {
+    return null;
+  }
+  return frames.find((frame) => Boolean(frame.fileName)) ?? null;
+}
+function getDefinitionFrameFromOwnedChild(fiber) {
+  const stack = fiber.child ? [fiber.child] : [];
+  for (let scanned = 0; stack.length > 0 && scanned < MAX_OWNED_CHILD_SCAN; scanned++) {
+    const child = stack.pop();
+    if (!child) {
+      continue;
+    }
+    const owner = child._debugOwner;
+    if ((owner === fiber || fiber.alternate !== null && owner === fiber.alternate) && readStackString(child._debugStack)) {
+      const { frames, isTrusted } = parseDebugStack(child._debugStack);
+      if (!isTrusted) {
+        return null;
+      }
+      for (let index = frames.length - 1; index >= 0; index--) {
+        const frame = frames[index];
+        if (frame?.fileName) {
+          return frame;
+        }
+      }
+      return null;
+    }
+    if (child.sibling) {
+      stack.push(child.sibling);
+    }
+    if (child.child) {
+      stack.push(child.child);
+    }
+  }
+  return null;
+}
+function getDispatcherKey(ref) {
+  return "H" in ref ? "H" : "current";
+}
+function getRendererDispatcherRefs() {
+  const hook = typeof window === "undefined" ? void 0 : Reflect.get(window, "__REACT_DEVTOOLS_GLOBAL_HOOK__");
+  const renderers = isObject(hook) ? hook.renderers : void 0;
+  if (!(renderers instanceof Map)) {
+    return [];
+  }
+  const refs = [];
+  for (const renderer of renderers.values()) {
+    const ref = isObject(renderer) ? renderer.currentDispatcherRef : void 0;
+    if (isObject(ref) && !refs.includes(ref)) {
+      refs.push(ref);
+    }
+  }
+  return refs;
+}
+const componentFrameCache = /* @__PURE__ */ new WeakMap();
+let isDescribingComponent = false;
+function describeComponentFrame(component) {
+  if (typeof component !== "function" || isDescribingComponent) {
+    return null;
+  }
+  const cached = componentFrameCache.get(component);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const dispatcherRefs = getRendererDispatcherRefs();
+  if (dispatcherRefs.length === 0) {
+    return null;
+  }
+  const snapshots = dispatcherRefs.map((ref) => {
+    const key = getDispatcherKey(ref);
+    const value = ref[key];
+    ref[key] = null;
+    return { ref, key, value };
+  });
+  const previousConsoleError = console.error;
+  const previousConsoleWarn = console.warn;
+  console.error = () => {
+  };
+  console.warn = () => {
+  };
+  isDescribingComponent = true;
+  let frame = null;
+  try {
+    const runInRootFrame = {
+      DetermineComponentFrameRoot() {
+        try {
+          const result = Reflect.apply(component, void 0, [{}]);
+          if (isObject(result) && typeof result.catch === "function") {
+            Reflect.apply(result.catch, result, [() => void 0]);
+          }
+        } catch (sample) {
+          return readStackString(sample);
+        }
+        return null;
+      }
+    };
+    const sampleStack = runInRootFrame.DetermineComponentFrameRoot();
+    if (sampleStack) {
+      const frames = parseStack(sampleStack);
+      const rootIndex = frames.findIndex((candidate) => {
+        return Boolean(
+          candidate.functionName?.includes("DetermineComponentFrameRoot")
+        );
+      });
+      const componentFrame = rootIndex > 0 ? frames[rootIndex - 1] : null;
+      frame = componentFrame?.fileName ? componentFrame : null;
+    }
+  } finally {
+    isDescribingComponent = false;
+    console.error = previousConsoleError;
+    console.warn = previousConsoleWarn;
+    for (const { ref, key, value } of snapshots) {
+      ref[key] = value;
+    }
+  }
+  componentFrameCache.set(component, frame);
+  return frame;
+}
+function toDebugSource(frame) {
+  return frame?.fileName ? {
+    fileName: frame.fileName,
+    lineNumber: frame.lineNumber,
+    columnNumber: frame.columnNumber
+  } : null;
+}
+function getFiberSource(fiber) {
+  if (hasDebugSource(fiber)) {
+    return fiber._debugSource;
+  }
+  const debugStackSource = toDebugSource(
+    getUsageFrameFromDebugStack(fiber) ?? (isCompositeFiber(fiber) ? getDefinitionFrameFromOwnedChild(fiber) : null)
+  );
+  if (debugStackSource) {
+    return debugStackSource;
+  }
+  return isCompositeFiber(fiber) ? toDebugSource(describeComponentFrame(fiber.type)) : null;
+}
+export {
+  getDisplayName,
+  getFiberFromHostInstance,
+  getFiberSource,
+  getLatestFiber,
+  isCompositeFiber,
+  isFiber,
+  isHostFiber,
+  normalizeFileName,
+  parseDebugStack,
+  parseStack
+};

package/comments-overlay/vendor/elementAnchors.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) 2025 Aiden Bai
+ * SPDX-License-Identifier: MIT
+ * https://github.com/aidenybai/react-grab
+ */
+/** Records how to recover `element` after a DOM swap; cheap when nothing moved. */
+export declare function trackElementAnchor(element: Element): void;
+/** The live replacement of a tracked element that React swapped out, if any. */
+export declare function resolveLiveElement(element: Element): Element | null;

package/comments-overlay/vendor/elementAnchors.js

@@ -0,0 +1,144 @@
+/*!
+ * Copyright (c) 2025 Aiden Bai
+ * SPDX-License-Identifier: MIT
+ * https://github.com/aidenybai/react-grab
+ */
+import { getFiberFromHostInstance, getLatestFiber, isHostFiber } from "./bippy";
+const anchorByElement = /* @__PURE__ */ new WeakMap();
+function indexInParent(element) {
+  let index = 0;
+  let sibling = element.previousElementSibling;
+  while (sibling) {
+    index += 1;
+    sibling = sibling.previousElementSibling;
+  }
+  return index;
+}
+function isShadowRoot(node) {
+  return typeof ShadowRoot !== "undefined" && node instanceof ShadowRoot;
+}
+function findNearestHostElementWithTag(parentFiber, tagName) {
+  let fiber = parentFiber.child;
+  while (fiber) {
+    if (isHostFiber(fiber)) {
+      const node = fiber.stateNode;
+      if (node instanceof Element && node.isConnected && node.tagName === tagName) {
+        return node;
+      }
+    } else if (fiber.child) {
+      fiber = fiber.child;
+      continue;
+    }
+    while (fiber !== parentFiber && !fiber.sibling) {
+      fiber = fiber.return;
+      if (!fiber) {
+        return null;
+      }
+    }
+    if (fiber === parentFiber) {
+      return null;
+    }
+    fiber = fiber.sibling;
+  }
+  return null;
+}
+function resolveLiveAnchor(anchor) {
+  if (anchor.anchorElement.isConnected) {
+    return anchor.anchorElement;
+  }
+  const tagName = anchor.anchorElement.tagName;
+  const parentFiber = getLatestFiber(anchor.anchorParentFiber);
+  if (isHostFiber(parentFiber)) {
+    const parentNode = parentFiber.stateNode;
+    if (!(parentNode instanceof Element) || !parentNode.isConnected) {
+      return null;
+    }
+    const candidate = parentNode.children[anchor.anchorIndexInParent];
+    return candidate && candidate.tagName === tagName ? candidate : null;
+  }
+  return findNearestHostElementWithTag(parentFiber, tagName);
+}
+function followDomPath(root, domPath) {
+  let node = root;
+  for (const step of domPath) {
+    const children = step.isShadowChild ? node.shadowRoot?.children : node.children;
+    const child = children?.[step.childIndex];
+    if (!child) {
+      return null;
+    }
+    node = child;
+  }
+  return node;
+}
+function findAnchor(element) {
+  const domPath = [];
+  let anchorElement = element;
+  let anchorFiber = getFiberFromHostInstance(element);
+  while (anchorElement && !anchorFiber) {
+    const parentElement = anchorElement.parentElement;
+    if (parentElement) {
+      domPath.unshift({
+        childIndex: indexInParent(anchorElement),
+        isShadowChild: false
+      });
+      anchorElement = parentElement;
+    } else {
+      const rootNode = anchorElement.getRootNode();
+      if (!isShadowRoot(rootNode)) {
+        break;
+      }
+      domPath.unshift({
+        childIndex: indexInParent(anchorElement),
+        isShadowChild: true
+      });
+      anchorElement = rootNode.host;
+    }
+    anchorFiber = getFiberFromHostInstance(anchorElement);
+  }
+  const anchorParentFiber = anchorFiber?.return;
+  if (!anchorElement || !anchorParentFiber) {
+    return null;
+  }
+  return {
+    anchorElement,
+    anchorParentFiber,
+    anchorIndexInParent: indexInParent(anchorElement),
+    domPath,
+    targetTagName: element.tagName
+  };
+}
+function isAnchorFresh(anchor, element) {
+  return anchor.anchorElement.isConnected && anchor.anchorIndexInParent === indexInParent(anchor.anchorElement) && followDomPath(anchor.anchorElement, anchor.domPath) === element;
+}
+function trackElementAnchor(element) {
+  if (!element.isConnected) {
+    return;
+  }
+  const existing = anchorByElement.get(element);
+  if (existing && isAnchorFresh(existing, element)) {
+    return;
+  }
+  const anchor = findAnchor(element);
+  if (anchor) {
+    anchorByElement.set(element, anchor);
+  }
+}
+function resolveLiveElement(element) {
+  if (element.isConnected) {
+    return element;
+  }
+  const anchor = anchorByElement.get(element);
+  if (!anchor) {
+    return null;
+  }
+  const liveAnchor = resolveLiveAnchor(anchor);
+  if (!liveAnchor) {
+    return null;
+  }
+  const recovered = followDomPath(liveAnchor, anchor.domPath);
+  return recovered?.isConnected && recovered.tagName === anchor.targetTagName ? recovered : null;
+}
+export {
+  resolveLiveElement,
+  trackElementAnchor
+};

package/comments-overlay/vendor/fiberElement.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) 2025 Aiden Bai
+ * SPDX-License-Identifier: MIT
+ * https://github.com/aidenybai/react-grab
+ */
+import type { Fiber } from "./bippy";
+/** Climbs to the nearest host element React manages, crossing shadow roots. */
+export declare function findNearestFiberElement(element: Element): Element;
+export declare function getElementFiber(element: Element): Fiber | null;
+export declare function findNearestListItemKey(startingFiber: Fiber | null): string | null;
+export declare function isUsefulComponentName(name: string, isNextProject: boolean): boolean;
+export declare function isNextProjectRuntime(): boolean;
+export declare function normalizeFilePath(fileName: string): string;
+/**
+ * Useful component names on the owner stack of a host fiber, nearest first.
+ * Falls back to composite `return` ancestors when React recorded no owners
+ * (production builds).
+ */
+export declare function getComponentChain(fiber: Fiber): string[];
+/** The fiber whose source describes a host fiber: itself, else its owner. */
+export declare function getNearestOwnerFiber(fiber: Fiber): Fiber | null;