libretto 0.6.11 → 0.6.12

package/dist/shared/snapshot/render-snapshot.js

@@ -0,0 +1,651 @@
+import { scopeSnapshotToRef } from "./capture-snapshot.js";
+const MAX_CHILDREN_PER_PARENT = 4;
+const MAX_LABEL_CHARS = 140;
+const MAX_SUMMARY_TEXT_CHARS = 80;
+const MAX_HREF_CHARS = 96;
+const MAX_ACTIONS_IN_SUMMARY = 3;
+const MAX_ACTION_LABEL_CHARS = 80;
+const PRESERVE_CHILDREN_BY_ROLE = /* @__PURE__ */ new Set([
+  "document",
+  "main",
+  "navigation",
+  "banner",
+  "contentinfo",
+  "form",
+  "search",
+  "list",
+  "table",
+  "tabpanel"
+]);
+const FLATTEN_ROLES = /* @__PURE__ */ new Set([
+  "none",
+  "presentation",
+  "LayoutTable",
+  "LayoutTableRow",
+  "LayoutTableCell"
+]);
+const SKIP_ROLES = /* @__PURE__ */ new Set(["InlineTextBox", "ListMarker"]);
+const ACTION_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "combobox",
+  "listbox",
+  "menuitem",
+  "tab",
+  "slider"
+]);
+const ACTION_STATE_ATTRS = /* @__PURE__ */ new Set([
+  "checked",
+  "disabled",
+  "expanded",
+  "pressed",
+  "selected",
+  "value",
+  "placeholder"
+]);
+const TEXT_ACTION_ROLES = /* @__PURE__ */ new Set(["button", "link", "menuitem", "tab"]);
+const KEEP_ROLES = /* @__PURE__ */ new Set([
+  "document",
+  "main",
+  "navigation",
+  "banner",
+  "contentinfo",
+  "form",
+  "search",
+  "list",
+  "listitem",
+  "button",
+  "link",
+  "image",
+  "textbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "combobox",
+  "listbox",
+  "menu",
+  "menuitem",
+  "option",
+  "tab",
+  "slider"
+]);
+const BLOCK_FLATTEN_ROLES = /* @__PURE__ */ new Set([
+  "paragraph",
+  "section",
+  "article",
+  "region",
+  "group",
+  "figure"
+]);
+const RENDERED_STATE_PROPERTIES = [
+  "disabled",
+  "checked",
+  "expanded",
+  "selected",
+  "pressed",
+  "required",
+  "invalid",
+  "readonly",
+  "multiline",
+  "autocomplete",
+  "haspopup",
+  "value"
+];
+function renderSnapshot(snapshot, refId) {
+  const snapshotTree = refId ? scopeSnapshotToRef(snapshot, refId) : snapshot;
+  const lines = [renderPageOpen(snapshotTree, "")];
+  for (const frame of renderSnapshotFrames(snapshotTree)) {
+    renderFrame(frame, 1, lines);
+  }
+  lines.push("</page>");
+  return lines.join("\n");
+}
+function renderSnapshotFrames(snapshot) {
+  return snapshot.frames.map(toRenderedFrame).filter(hasRenderedFrameContent);
+}
+function renderPageOpen(snapshot, prefix, selfClosing = false) {
+  return `${prefix}${formatTag(
+    "page",
+    [
+      ["title", firstNonEmpty(snapshot.title, snapshot.url) ?? ""],
+      ["url", snapshot.url]
+    ],
+    !selfClosing
+  )}`;
+}
+function renderFrameLine(frame, depth, prefix, selfClosing) {
+  const attrs = [
+    ["index", String(frame.index)],
+    ["url", normalizeText(frame.url, MAX_LABEL_CHARS)]
+  ];
+  if (frame.name)
+    attrs.push(["name", normalizeText(frame.name, MAX_LABEL_CHARS)]);
+  if (frame.parentId) attrs.push(["parent", frame.parentId]);
+  if (frame.status === "unavailable") {
+    attrs.push(["error", normalizeText(frame.error, 180)]);
+  }
+  return `${prefix}${indent(depth)}${formatTag("frame", attrs, !selfClosing)}`;
+}
+function renderTextNode(node, depth, prefix) {
+  return `${prefix}${indent(depth)}${escapeText(node.text)}`;
+}
+function indent(depth) {
+  return "	".repeat(depth);
+}
+function formatTag(tagName, attributes, hasChildren) {
+  const attrs = attributes.filter(([, value]) => value !== "").map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
+  return hasChildren ? `<${tagName}${attrs}>` : `<${tagName}${attrs} />`;
+}
+function renderChildrenTruncationNotice(children) {
+  const count = children.length;
+  const summaryActions = actionSummariesForChildren(children);
+  const textSnippet = previewForChildren(children, summaryActions.labels);
+  const elementLabel = count === 1 ? "element" : "elements";
+  const textSnippetPart = textSnippet ? `. Text snippet: ${JSON.stringify(textSnippet)}` : "";
+  const interactiveText = summaryActions.actions.length ? `. Interactive elements: ${summaryActions.actions.map((action) => action.markup).join(", ")}${summaryActions.hasMore ? ", ..." : ""}` : "";
+  return `[Truncated ${count} more ${elementLabel}${textSnippetPart}${interactiveText}]`;
+}
+function toRenderedFrame(frame) {
+  if (frame.status === "unavailable") return frame;
+  return {
+    status: "ok",
+    id: frame.id,
+    index: frame.index,
+    url: frame.url,
+    name: frame.name,
+    parentId: frame.parentId,
+    roots: frame.roots.flatMap((root) => toRenderedNodes(root, null))
+  };
+}
+function hasRenderedFrameContent(frame) {
+  if (frame.status === "unavailable") return true;
+  return frame.roots.length > 0;
+}
+function toRenderedNodes(node, parent) {
+  return toRenderedChildren(node, parent).filter(isRenderedNode);
+}
+function toRenderedChildren(node, parent) {
+  if (shouldSkipNode(node, parent)) return [];
+  if (isTextRole(node.role)) {
+    const text2 = firstNonEmpty(
+      node.name,
+      node.description,
+      primitiveToString(node.value)
+    );
+    if (text2 && text2 !== parent?.name && text2 !== nodeTextValue(parent)) {
+      return [{ kind: "text", text: text2 }];
+    }
+    return [];
+  }
+  const children = renderableChildren(node);
+  const role = tagNameForRole(node.role);
+  if (role === "heading") return renderHeading(node, children);
+  const compactRole = roleForNode(node, role, children);
+  if (compactRole === "image" && !hasNonEmptyAttribute(node, "src"))
+    return [];
+  if (compactRole === "link" && !hasNonEmptyAttribute(node, "href")) {
+    return flattenedChildren(node, children).filter(
+      hasVisibleTextOrInteractive
+    );
+  }
+  if (node.ignored || FLATTEN_ROLES.has(node.role) || !KEEP_ROLES.has(compactRole)) {
+    return flattenedChildren(node, children).filter(
+      hasVisibleTextOrInteractive
+    );
+  }
+  const text = normalizedText(children);
+  const suppressName = text.includes(normalizeRawText(node.name ?? "")) ? node.name : null;
+  const attrs = nodeAttributes(node, suppressName);
+  const content = nameAttributeAsContent(attrs, children);
+  const renderedChildren = removeDuplicateNestedActions(
+    compactRole,
+    content.attrs,
+    content.children
+  ).filter(hasVisibleTextOrInteractive);
+  if (!ACTION_ROLES.has(compactRole) && !renderedChildren.some(hasVisibleTextOrInteractive)) {
+    return [];
+  }
+  const rendered = {
+    kind: "node",
+    key: node.nodeId || node.ref || `${compactRole}:${content.attrs.map(([name, value]) => `${name}=${value}`).join(";")}`,
+    role: compactRole,
+    attrs: content.attrs,
+    children: renderedChildren
+  };
+  return [rendered];
+}
+function renderableChildren(node) {
+  const children = [];
+  for (const child of node.children)
+    children.push(...toRenderedChildren(child, node));
+  return mergeAdjacentText(children).filter(hasVisibleTextOrInteractive);
+}
+function renderHeading(node, children) {
+  const text = firstNonEmpty(node.name, normalizedText(children));
+  if (!text) return [];
+  return [
+    {
+      kind: "text",
+      text: `${"#".repeat(headingLevel(node))} ${text}`,
+      block: true
+    }
+  ];
+}
+function headingLevel(node) {
+  const rawLevel = node.properties.level;
+  const level = typeof rawLevel === "number" ? rawLevel : Number(rawLevel);
+  if (!Number.isFinite(level)) return 2;
+  return Math.min(6, Math.max(1, Math.round(level)));
+}
+function roleForNode(node, role, children) {
+  if (isPointerButtonCandidate(node, role, children)) return "button";
+  return role;
+}
+function isPointerButtonCandidate(node, role, children) {
+  if (KEEP_ROLES.has(role) && role !== "document") return false;
+  if (children.some(hasInteractiveNode)) return false;
+  if (!hasClickableHint(node)) return false;
+  return Boolean(firstNonEmpty(node.name, normalizedText(children)));
+}
+function hasClickableHint(node) {
+  if (node.attributes.cursor === "pointer") return true;
+  if (Object.hasOwn(node.attributes, "onclick")) return true;
+  const tabindex = node.attributes.tabindex;
+  return tabindex !== void 0 && Number(tabindex) >= 0;
+}
+function hasInteractiveNode(child) {
+  if (child.kind === "text") return false;
+  if (ACTION_ROLES.has(child.role)) return true;
+  return child.children.some(hasInteractiveNode);
+}
+function flattenedChildren(node, children) {
+  const fallbackText = fallbackTextForFlattenedNode(node);
+  const flattened = children.length > 0 || !fallbackText ? children : [{ kind: "text", text: fallbackText }];
+  if (!BLOCK_FLATTEN_ROLES.has(tagNameForRole(node.role))) return flattened;
+  return flattened.map(
+    (child) => child.kind === "text" ? { ...child, block: true } : child
+  );
+}
+function fallbackTextForFlattenedNode(node) {
+  const name = firstNonEmpty(node.name, primitiveToString(node.value));
+  if (!name) return null;
+  if (attributeMatchesName(node, "aria-label", name)) return null;
+  if (attributeMatchesName(node, "title", name)) return null;
+  if (attributeMatchesName(node, "alt", name)) return null;
+  return name;
+}
+function attributeMatchesName(node, attributeName, name) {
+  return normalizeRawText(node.attributes[attributeName] ?? "") === name;
+}
+function hasNonEmptyAttribute(node, attributeName) {
+  return normalizeRawText(node.attributes[attributeName] ?? "") !== "";
+}
+function removeDuplicateNestedActions(role, attrs, children) {
+  if (!ACTION_ROLES.has(role)) return children;
+  const label = firstNonEmpty(
+    attrFromAttrs(attrs, "name"),
+    normalizedText(children)
+  );
+  if (!label) return children;
+  return children.flatMap((child) => {
+    if (child.kind === "text") return [child];
+    if (!ACTION_ROLES.has(child.role)) return [child];
+    const childLabel = firstNonEmpty(
+      attrValue(child, "name"),
+      singleTextChild(child),
+      normalizedText(child.children)
+    );
+    return childLabel === label ? child.children : [child];
+  });
+}
+function nameAttributeAsContent(attrs, children) {
+  const name = attrFromAttrs(attrs, "name");
+  if (!name) return { attrs, children };
+  const attrsWithoutName = attrs.filter(([attr]) => attr !== "name");
+  if (normalizedText(children).includes(normalizeRawText(name))) {
+    return { attrs: attrsWithoutName, children };
+  }
+  return {
+    attrs: attrsWithoutName,
+    children: [{ kind: "text", text: name }, ...children]
+  };
+}
+function renderFrame(frame, depth, lines, prefix = "") {
+  if (frame.status === "unavailable") {
+    lines.push(renderFrameLine(frame, depth, prefix, true));
+    return;
+  }
+  lines.push(renderFrameLine(frame, depth, prefix, false));
+  for (const root of frame.roots) renderNode(root, depth + 1, lines, prefix);
+  lines.push(`${prefix}${indent(depth)}</frame>`);
+}
+function renderNode(node, depth, lines, prefix = "") {
+  if (renderFoldedSingleChildChain(node, depth, lines, prefix)) return;
+  if (node.children.length === 0) {
+    lines.push(
+      `${prefix}${indent(depth)}${formatTag(node.role, node.attrs, false)}`
+    );
+    return;
+  }
+  const singleText = singleTextChild(node);
+  if (singleText !== null) {
+    if (shouldRenderBareText(node)) {
+      lines.push(`${prefix}${indent(depth)}${escapeText(singleText)}`);
+      return;
+    }
+    lines.push(
+      `${prefix}${indent(depth)}${formatTag(node.role, node.attrs, true)}${escapeText(singleText)}</${node.role}>`
+    );
+    return;
+  }
+  lines.push(
+    `${prefix}${indent(depth)}${formatTag(node.role, node.attrs, true)}`
+  );
+  renderChildren(node.children, depth + 1, lines, prefix);
+  lines.push(`${prefix}${indent(depth)}</${node.role}>`);
+}
+function renderChildren(children, depth, lines, prefix) {
+  const renderedChildren = children.slice(0, MAX_CHILDREN_PER_PARENT);
+  for (const child of renderedChildren) {
+    if (child.kind === "text") {
+      lines.push(`${prefix}${indent(depth)}${escapeText(child.text)}`);
+      continue;
+    }
+    renderNode(child, depth, lines, prefix);
+  }
+  if (children.length > MAX_CHILDREN_PER_PARENT) {
+    const truncated = children.slice(MAX_CHILDREN_PER_PARENT);
+    lines.push(
+      `${prefix}${indent(depth)}${renderChildrenTruncationNotice(
+        truncated
+      )}`
+    );
+  }
+}
+function renderFoldedSingleChildChain(node, depth, lines, prefix) {
+  const chain = singleChildChain(node);
+  if (chain.length <= 1) return false;
+  const keptIndexes = chain.map((chainNode, index) => ({ chainNode, index })).filter(
+    ({ chainNode, index }) => shouldKeepFoldedChainNode(chainNode, index)
+  ).map(({ index }) => index);
+  if (keptIndexes.length === chain.length) return false;
+  renderFoldedChainNode(chain, keptIndexes, 0, depth, lines, prefix);
+  return true;
+}
+function shouldKeepFoldedChainNode(node, index) {
+  return index === 0 || node.role === "list";
+}
+function renderFoldedChainNode(chain, keptIndexes, keptIndexPosition, depth, lines, prefix) {
+  const currentIndex = keptIndexes[keptIndexPosition];
+  const current = chain[currentIndex];
+  lines.push(
+    `${prefix}${indent(depth)}${formatTag(current.role, current.attrs, true)}`
+  );
+  renderFoldedChainNodeOwnContent(current, depth + 1, lines, prefix);
+  const nextKeptIndex = keptIndexes[keptIndexPosition + 1];
+  if (nextKeptIndex !== void 0) {
+    if (nextKeptIndex > currentIndex + 1)
+      lines.push(`${prefix}${indent(depth + 1)}...`);
+    renderFoldedChainNode(
+      chain,
+      keptIndexes,
+      keptIndexPosition + 1,
+      depth + 1,
+      lines,
+      prefix
+    );
+  } else {
+    const terminal = chain[chain.length - 1];
+    if (chain.length - 1 > currentIndex)
+      lines.push(`${prefix}${indent(depth + 1)}...`);
+    renderChildren(terminal.children, depth + 1, lines, prefix);
+  }
+  lines.push(`${prefix}${indent(depth)}</${current.role}>`);
+}
+function renderFoldedChainNodeOwnContent(node, depth, lines, prefix) {
+  for (const child of node.children) {
+    if (child.kind === "text")
+      lines.push(`${prefix}${indent(depth)}${escapeText(child.text)}`);
+  }
+}
+function singleChildChain(node) {
+  const chain = [node];
+  let current = node;
+  while (isDeprioritizedSingleChildParent(current)) {
+    const child = singleElementChild(current);
+    if (!child) break;
+    if (ACTION_ROLES.has(child.role)) break;
+    chain.push(child);
+    current = child;
+  }
+  return chain;
+}
+function isDeprioritizedSingleChildParent(node) {
+  if (node.role === "document") return false;
+  if (ACTION_ROLES.has(node.role)) return false;
+  return singleElementChild(node) !== null;
+}
+function singleElementChild(node) {
+  let result = null;
+  for (const child of node.children) {
+    if (child.kind === "text") continue;
+    if (result) return null;
+    result = child;
+  }
+  return result;
+}
+function shouldRenderBareText(node) {
+  if (ACTION_ROLES.has(node.role)) return false;
+  if (attrValue(node, "ref")) return false;
+  if (PRESERVE_CHILDREN_BY_ROLE.has(node.role)) return false;
+  return true;
+}
+function nodeAttributes(node, suppressName) {
+  const attributes = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const push = (name, value) => {
+    if (value === void 0 || value === null || value === "") return;
+    if (value === false || value === "false") return;
+    const normalizedName = uniqueAttributeName(
+      sanitizeAttributeName(name),
+      usedNames
+    );
+    attributes.push([
+      normalizedName,
+      normalizeAttributeValue(normalizedName, value)
+    ]);
+    usedNames.add(normalizedName);
+  };
+  push("ref", node.ref);
+  if (node.name !== suppressName) push("name", node.name);
+  const hasStateValue = node.properties.value !== void 0 && node.properties.value !== null && node.properties.value !== "";
+  for (const name of RENDERED_STATE_PROPERTIES) {
+    const value = node.properties[name];
+    if (value === true) push(name, "true");
+    else push(name, value);
+  }
+  if (!hasStateValue) push("value", node.value);
+  push("href", node.attributes.href);
+  push("placeholder", node.attributes.placeholder);
+  return attributes;
+}
+function normalizeAttributeValue(name, value) {
+  const normalized = normalizeRawText(String(value));
+  return name === "href" ? truncate(normalized, MAX_HREF_CHARS) : normalized;
+}
+function singleTextChild(node) {
+  if (node.children.length !== 1) return null;
+  const child = node.children[0];
+  return child.kind === "text" && !child.block ? child.text : null;
+}
+function mergeAdjacentText(children) {
+  const result = [];
+  for (const child of children) {
+    const previous = result[result.length - 1];
+    if (child.kind === "text" && previous?.kind === "text" && !child.block && !previous.block) {
+      previous.text = normalizeRawText(`${previous.text} ${child.text}`);
+    } else {
+      result.push(child);
+    }
+  }
+  return result;
+}
+function normalizedText(children) {
+  return children.map(
+    (child) => child.kind === "text" ? child.text : normalizedText(child.children)
+  ).join(" ");
+}
+function previewForChildren(children, excludedText) {
+  const labels = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(child, insideInteractive) {
+    if (child.kind === "text") {
+      if (!insideInteractive) pushLabel(child.text);
+      return;
+    }
+    const nextInsideInteractive = insideInteractive || ACTION_ROLES.has(child.role);
+    if (labels.join(" \xB7 ").length > MAX_SUMMARY_TEXT_CHARS) return;
+    for (const grandchild of child.children)
+      visit(grandchild, nextInsideInteractive);
+  }
+  function pushLabel(value) {
+    const normalized = normalizeRawText(value ?? "");
+    if (!normalized || normalized === "no visible text" || seen.has(normalized) || excludedText.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    labels.push(normalized);
+  }
+  for (const child of children) visit(child, false);
+  const preview = labels.join(" \xB7 ");
+  return preview ? truncate(preview, MAX_SUMMARY_TEXT_CHARS) : "";
+}
+function actionSummariesForChildren(children) {
+  const actions = [];
+  const labels = /* @__PURE__ */ new Set();
+  const seenRefs = /* @__PURE__ */ new Set();
+  let hasMore = false;
+  function visit(child) {
+    if (child.kind === "text") return;
+    const ref = attrValue(child, "ref");
+    if (ref && ACTION_ROLES.has(child.role) && !seenRefs.has(ref)) {
+      seenRefs.add(ref);
+      const label = actionLabel(child);
+      if (label) labels.add(label);
+      if (actions.length < MAX_ACTIONS_IN_SUMMARY) {
+        actions.push({ markup: renderActionSummary(child, ref), label });
+      } else {
+        hasMore = true;
+      }
+    }
+    for (const grandchild of child.children) visit(grandchild);
+  }
+  for (const child of children) visit(child);
+  return { actions, labels, hasMore };
+}
+function renderActionSummary(node, ref) {
+  const label = actionLabel(node);
+  const attrs = [["ref", ref]];
+  for (const [name, value] of node.attrs) {
+    if (name === "ref" || !ACTION_STATE_ATTRS.has(name)) continue;
+    attrs.push([name, normalizeText(value, MAX_ACTION_LABEL_CHARS)]);
+  }
+  if (!label || !TEXT_ACTION_ROLES.has(node.role)) {
+    const name = attrValue(node, "name");
+    if (name) attrs.push(["name", normalizeText(name, MAX_ACTION_LABEL_CHARS)]);
+    return formatTag(node.role, attrs, false);
+  }
+  return `${formatTag(node.role, attrs, true)}${escapeText(
+    normalizeText(label, MAX_ACTION_LABEL_CHARS)
+  )}</${node.role}>`;
+}
+function actionLabel(node) {
+  return firstNonEmpty(
+    singleTextChild(node),
+    attrValue(node, "name"),
+    attrValue(node, "value"),
+    attrValue(node, "placeholder")
+  );
+}
+function attrValue(node, name) {
+  return node.attrs.find(([attr]) => attr === name)?.[1] ?? null;
+}
+function attrFromAttrs(attrs, name) {
+  return attrs.find(([attr]) => attr === name)?.[1] ?? null;
+}
+function shouldSkipNode(node, parent) {
+  if (SKIP_ROLES.has(node.role)) return true;
+  if (node.role !== "StaticText") return false;
+  return Boolean(parent?.name && node.name && parent.name === node.name);
+}
+function isTextRole(role) {
+  return role === "StaticText" || role === "InlineTextBox";
+}
+function isRenderedNode(child) {
+  return child.kind === "node";
+}
+function hasVisibleTextOrInteractive(child) {
+  if (child.kind === "text") return normalizeRawText(child.text) !== "";
+  if (ACTION_ROLES.has(child.role)) return true;
+  return child.children.some(hasVisibleTextOrInteractive);
+}
+function tagNameForRole(role) {
+  const normalized = normalizeRole(role).replace(/[^a-zA-Z0-9_.:-]/g, "-");
+  return /^[a-zA-Z_:]/.test(normalized) ? normalized : "node";
+}
+function normalizeRole(role) {
+  if (role === "RootWebArea") return "document";
+  if (role === "textField") return "textbox";
+  return role || "node";
+}
+function primitiveToString(value) {
+  return value === null ? null : String(value);
+}
+function nodeTextValue(node) {
+  if (!node) return null;
+  const value = primitiveToString(node.properties.value ?? node.value);
+  return value ? normalizeRawText(value) : null;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const normalized = normalizeRawText(value ?? "");
+    if (normalized) return truncate(normalized, MAX_LABEL_CHARS);
+  }
+  return null;
+}
+function normalizeText(value, maxChars) {
+  return truncate(value.replace(/\s+/g, " ").trim(), maxChars);
+}
+function normalizeRawText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncate(value, maxChars) {
+  return value.length > maxChars ? `${value.slice(0, maxChars - 1)}\u2026` : value;
+}
+function uniqueAttributeName(name, usedNames) {
+  if (!usedNames.has(name)) return name;
+  let index = 2;
+  while (usedNames.has(`${name}-${index}`)) index += 1;
+  return `${name}-${index}`;
+}
+function sanitizeAttributeName(name) {
+  const sanitized = name.replace(/[^a-zA-Z0-9_.:-]/g, "-");
+  return /^[a-zA-Z_:]/.test(sanitized) ? sanitized : `attr-${sanitized}`;
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export {
+  renderChildrenTruncationNotice,
+  renderFrame,
+  renderNode,
+  renderSnapshot,
+  renderSnapshotFrames
+};

package/dist/shared/snapshot/snapshot.spec.d.ts

@@ -0,0 +1,2 @@
+
+export {  }