@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/setEnableStyledLineCache-BpskngSJ.js

@@ -0,0 +1,2 @@
+import '@visulima/string';
+export { c as clearStringWidthCache, a as clearStyledLineCache, m as default, i as inkCharacterWidth, k as measureStyledLine, s as setEnableStyledLineCache, b as setStringWidthFunction, l as splitStyledLineByNewline, d as styledLineWidth, t as toStyledLine } from './measure-text-DItZYotK.js';

package/dist/packem_shared/squashTextNodesWithMap-iqm6OMMT.js

@@ -0,0 +1,100 @@
+import { h as hasAnsiControlCharacters, t as tokenizeAnsi } from './ansi-tokenizer-LHq2LUWA.js';
+
+const sgrParametersRegex = /^[\d:;]*$/;
+const sanitizeAnsi = (text) => {
+  if (!hasAnsiControlCharacters(text)) {
+    return text;
+  }
+  let output = "";
+  for (const token of tokenizeAnsi(text)) {
+    if (token.type === "text" || token.type === "osc") {
+      output += token.value;
+      continue;
+    }
+    if (token.type === "csi" && token.finalCharacter === "m" && token.intermediateString === "" && sgrParametersRegex.test(token.parameterString)) {
+      output += token.value;
+    }
+  }
+  return output;
+};
+
+const squashTextNodes = (node) => {
+  let text = "";
+  for (let index = 0; index < node.childNodes.length; index++) {
+    const childNode = node.childNodes[index];
+    if (childNode === void 0) {
+      continue;
+    }
+    let nodeText = "";
+    if (childNode.nodeName === "#text") {
+      nodeText = childNode.nodeValue;
+    } else {
+      if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") {
+        nodeText = squashTextNodes(childNode);
+      }
+      if (nodeText.length > 0 && typeof childNode.internal_transform === "function") {
+        nodeText = childNode.internal_transform(nodeText, index);
+      }
+    }
+    text += nodeText;
+  }
+  return sanitizeAnsi(text);
+};
+const squashTextNodesWithMap = (node, map, offsetRef) => {
+  if (node.internal_textCache) {
+    const { map: cachedMap, text: text2 } = node.internal_textCache;
+    for (const [k, v] of cachedMap.entries()) {
+      map.set(k, {
+        end: v.end + offsetRef.current,
+        start: v.start + offsetRef.current
+      });
+    }
+    offsetRef.current += text2.length;
+    return text2;
+  }
+  let text = "";
+  const localMap = /* @__PURE__ */ new Map();
+  const localOffsetRef = { current: 0 };
+  for (let index = 0; index < node.childNodes.length; index++) {
+    const childNode = node.childNodes[index];
+    if (childNode === void 0) {
+      continue;
+    }
+    let nodeText = "";
+    const startOffset = localOffsetRef.current;
+    if (childNode.nodeName === "#text") {
+      nodeText = childNode.nodeValue;
+      localMap.set(childNode, {
+        end: startOffset + nodeText.length,
+        start: startOffset
+      });
+      localOffsetRef.current += nodeText.length;
+    } else {
+      if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") {
+        nodeText = squashTextNodesWithMap(childNode, localMap, localOffsetRef);
+        localMap.set(childNode, {
+          end: localOffsetRef.current,
+          start: startOffset
+        });
+      }
+      if (nodeText.length > 0 && typeof childNode.internal_transform === "function") {
+        nodeText = childNode.internal_transform(nodeText, index);
+      }
+    }
+    text += nodeText;
+  }
+  node.internal_textCache = {
+    map: localMap,
+    text
+  };
+  for (const [k, v] of localMap.entries()) {
+    map.set(k, {
+      end: v.end + offsetRef.current,
+      start: v.start + offsetRef.current
+    });
+  }
+  offsetRef.current += text.length;
+  return text;
+};
+
+export { squashTextNodes as default, squashTextNodesWithMap };

package/dist/packem_shared/text-width-DhuarWcB.js

@@ -0,0 +1,42 @@
+import { getStringWidth as getStringWidth$1 } from '@visulima/string';
+
+const WIDTH_OPTIONS = { ambiguousIsNarrow: true, emojiWidth: 1 };
+function getCodePointWidth(char) {
+  return Math.max(1, getStringWidth$1(char, WIDTH_OPTIONS));
+}
+function getStringWidth(text) {
+  return getStringWidth$1(text, WIDTH_OPTIONS);
+}
+function countWrappedRowsForLine(line, width) {
+  if (width <= 0) {
+    return 0;
+  }
+  if (line.length === 0) {
+    return 1;
+  }
+  let rows = 1;
+  let col = 0;
+  for (const char of line) {
+    const charWidth = Math.min(getCodePointWidth(char), width);
+    if (col + charWidth > width) {
+      rows++;
+      col = 0;
+    }
+    col += charWidth;
+  }
+  return rows;
+}
+function measureTextBlock(text, wrapWidth) {
+  const lines = text.split("\n");
+  let maxLineWidth = 0;
+  let wrappedRows = 0;
+  for (const line of lines) {
+    const lineWidth = getStringWidth(line);
+    if (lineWidth > maxLineWidth)
+      maxLineWidth = lineWidth;
+    wrappedRows += wrapWidth > 0 ? countWrappedRowsForLine(line, wrapWidth) : 0;
+  }
+  return { maxLineWidth, wrappedRows };
+}
+
+export { getCodePointWidth as a, getStringWidth as g, measureTextBlock as m };

package/dist/packem_shared/token-to-elements-BRFl_rzw.js

@@ -0,0 +1,249 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import Box from './Box-D_pSJ9Jp.js';
+import Text from './Text-DvAUdZcK.js';
+
+const LANGUAGE_IMPORT_MAP = {
+  bash: () => import('@shikijs/langs/bash'),
+  c: () => import('@shikijs/langs/c'),
+  clojure: () => import('@shikijs/langs/clojure'),
+  cpp: () => import('@shikijs/langs/cpp'),
+  csharp: () => import('@shikijs/langs/csharp'),
+  css: () => import('@shikijs/langs/css'),
+  dart: () => import('@shikijs/langs/dart'),
+  diff: () => import('@shikijs/langs/diff'),
+  dockerfile: () => import('@shikijs/langs/dockerfile'),
+  elixir: () => import('@shikijs/langs/elixir'),
+  erlang: () => import('@shikijs/langs/erlang'),
+  go: () => import('@shikijs/langs/go'),
+  graphql: () => import('@shikijs/langs/graphql'),
+  groovy: () => import('@shikijs/langs/groovy'),
+  haskell: () => import('@shikijs/langs/haskell'),
+  html: () => import('@shikijs/langs/html'),
+  java: () => import('@shikijs/langs/java'),
+  javascript: () => import('@shikijs/langs/javascript'),
+  json: () => import('@shikijs/langs/json'),
+  jsonc: () => import('@shikijs/langs/jsonc'),
+  jsx: () => import('@shikijs/langs/jsx'),
+  kotlin: () => import('@shikijs/langs/kotlin'),
+  less: () => import('@shikijs/langs/less'),
+  lua: () => import('@shikijs/langs/lua'),
+  makefile: () => import('@shikijs/langs/makefile'),
+  markdown: () => import('@shikijs/langs/markdown'),
+  mdx: () => import('@shikijs/langs/mdx'),
+  nginx: () => import('@shikijs/langs/nginx'),
+  objc: () => import('@shikijs/langs/objc'),
+  perl: () => import('@shikijs/langs/perl'),
+  php: () => import('@shikijs/langs/php'),
+  powershell: () => import('@shikijs/langs/powershell'),
+  prisma: () => import('@shikijs/langs/prisma'),
+  python: () => import('@shikijs/langs/python'),
+  r: () => import('@shikijs/langs/r'),
+  ruby: () => import('@shikijs/langs/ruby'),
+  rust: () => import('@shikijs/langs/rust'),
+  scala: () => import('@shikijs/langs/scala'),
+  scss: () => import('@shikijs/langs/scss'),
+  shell: () => import('@shikijs/langs/shell'),
+  sql: () => import('@shikijs/langs/sql'),
+  svelte: () => import('@shikijs/langs/svelte'),
+  swift: () => import('@shikijs/langs/swift'),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  text: () => Promise.resolve({ name: "text", patterns: [], repository: {}, scopeName: "source.text" }),
+  toml: () => import('@shikijs/langs/toml'),
+  tsx: () => import('@shikijs/langs/tsx'),
+  typescript: () => import('@shikijs/langs/typescript'),
+  vue: () => import('@shikijs/langs/vue'),
+  xml: () => import('@shikijs/langs/xml'),
+  yaml: () => import('@shikijs/langs/yaml'),
+  zig: () => import('@shikijs/langs/zig')
+};
+const LANGUAGE_ALIASES = {
+  "c#": "csharp",
+  "c++": "cpp",
+  docker: "dockerfile",
+  gql: "graphql",
+  hs: "haskell",
+  js: "javascript",
+  kt: "kotlin",
+  md: "markdown",
+  "objective-c": "objc",
+  ps1: "powershell",
+  py: "python",
+  rb: "ruby",
+  rs: "rust",
+  sh: "bash",
+  ts: "typescript",
+  yml: "yaml",
+  zsh: "bash"
+};
+const THEME_IMPORT_MAP = {
+  "catppuccin-frappe": () => import('@shikijs/themes/catppuccin-frappe'),
+  "catppuccin-latte": () => import('@shikijs/themes/catppuccin-latte'),
+  "catppuccin-macchiato": () => import('@shikijs/themes/catppuccin-macchiato'),
+  "catppuccin-mocha": () => import('@shikijs/themes/catppuccin-mocha'),
+  "dark-plus": () => import('@shikijs/themes/dark-plus'),
+  dracula: () => import('@shikijs/themes/dracula'),
+  "github-dark": () => import('@shikijs/themes/github-dark'),
+  "github-dark-default": () => import('@shikijs/themes/github-dark-default'),
+  "github-dark-dimmed": () => import('@shikijs/themes/github-dark-dimmed'),
+  "github-light": () => import('@shikijs/themes/github-light'),
+  "github-light-default": () => import('@shikijs/themes/github-light-default'),
+  "light-plus": () => import('@shikijs/themes/light-plus'),
+  "min-dark": () => import('@shikijs/themes/min-dark'),
+  "min-light": () => import('@shikijs/themes/min-light'),
+  monokai: () => import('@shikijs/themes/monokai'),
+  nord: () => import('@shikijs/themes/nord'),
+  "one-dark-pro": () => import('@shikijs/themes/one-dark-pro'),
+  "one-light": () => import('@shikijs/themes/one-light'),
+  poimandres: () => import('@shikijs/themes/poimandres'),
+  "rose-pine": () => import('@shikijs/themes/rose-pine'),
+  "rose-pine-dawn": () => import('@shikijs/themes/rose-pine-dawn'),
+  "rose-pine-moon": () => import('@shikijs/themes/rose-pine-moon'),
+  "slack-dark": () => import('@shikijs/themes/slack-dark'),
+  "slack-ochin": () => import('@shikijs/themes/slack-ochin'),
+  "solarized-dark": () => import('@shikijs/themes/solarized-dark'),
+  "solarized-light": () => import('@shikijs/themes/solarized-light'),
+  "tokyo-night": () => import('@shikijs/themes/tokyo-night'),
+  "vitesse-dark": () => import('@shikijs/themes/vitesse-dark'),
+  "vitesse-light": () => import('@shikijs/themes/vitesse-light')
+};
+let highlighterPromise;
+const languageLoadPromises = /* @__PURE__ */ new Map();
+const themeLoadPromises = /* @__PURE__ */ new Map();
+const TOKEN_CACHE_MAX = 50;
+const tokenCache = /* @__PURE__ */ new Map();
+const makeTokenCacheKey = (code, lang, theme) => `${code.length}:${code}\0${lang}\0${theme}`;
+const getCachedTokens = (highlighter, code, lang, theme) => {
+  const key = makeTokenCacheKey(code, lang, theme);
+  if (tokenCache.has(key)) {
+    const value = tokenCache.get(key);
+    tokenCache.delete(key);
+    tokenCache.set(key, value);
+    return value;
+  }
+  const result = highlighter.codeToTokens(code, { lang, theme });
+  tokenCache.set(key, result);
+  if (tokenCache.size > TOKEN_CACHE_MAX) {
+    const firstKey = tokenCache.keys().next().value;
+    if (firstKey !== void 0) {
+      tokenCache.delete(firstKey);
+    }
+  }
+  return result;
+};
+const createSingletonHighlighter = async () => {
+  const [coreModule, engineModule] = await Promise.all([import('shiki/core'), import('shiki/engine/javascript')]);
+  const { createHighlighterCore } = coreModule;
+  const { createJavaScriptRegexEngine } = engineModule;
+  const highlighter = await createHighlighterCore({
+    engine: createJavaScriptRegexEngine(),
+    langs: [],
+    themes: [import('@shikijs/themes/github-dark-default')]
+  });
+  return highlighter;
+};
+const resolveLanguage = (lang) => {
+  const lower = lang.toLowerCase();
+  return LANGUAGE_ALIASES[lower] ?? lower;
+};
+const isLanguageSupported = (lang) => {
+  const resolved = resolveLanguage(lang);
+  return resolved in LANGUAGE_IMPORT_MAP;
+};
+const ensureLanguageLoaded = async (highlighter, langName) => {
+  const resolved = resolveLanguage(langName);
+  if (resolved === "text") {
+    return;
+  }
+  const loadedLanguages = highlighter.getLoadedLanguages?.() ?? [];
+  if (loadedLanguages.includes(resolved)) {
+    return;
+  }
+  if (!languageLoadPromises.has(resolved)) {
+    const promise = (async () => {
+      try {
+        const importer = LANGUAGE_IMPORT_MAP[resolved];
+        if (importer) {
+          await highlighter.loadLanguage(await importer());
+        }
+      } catch (error) {
+        languageLoadPromises.delete(resolved);
+        throw error;
+      }
+    })();
+    languageLoadPromises.set(resolved, promise);
+  }
+  await languageLoadPromises.get(resolved);
+};
+const ensureThemeLoaded = async (highlighter, themeName) => {
+  const loadedThemes = highlighter.getLoadedThemes?.() ?? [];
+  if (loadedThemes.includes(themeName)) {
+    return;
+  }
+  const importer = THEME_IMPORT_MAP[themeName];
+  if (!importer) {
+    return;
+  }
+  if (!themeLoadPromises.has(themeName)) {
+    const promise = (async () => {
+      try {
+        await highlighter.loadTheme(await importer());
+      } catch (error) {
+        themeLoadPromises.delete(themeName);
+        throw error;
+      }
+    })();
+    themeLoadPromises.set(themeName, promise);
+  }
+  await themeLoadPromises.get(themeName);
+};
+const getHighlighter = async (languages = [], theme) => {
+  if (!highlighterPromise) {
+    highlighterPromise = createSingletonHighlighter();
+  }
+  const highlighter = await highlighterPromise;
+  const loadPromises = languages.map((lang) => ensureLanguageLoaded(highlighter, lang));
+  if (theme && theme !== "github-dark-default") {
+    loadPromises.push(ensureThemeLoaded(highlighter, theme));
+  }
+  await Promise.all(loadPromises);
+  return highlighter;
+};
+
+const FONT_STYLE_ITALIC = 1;
+const FONT_STYLE_BOLD = 2;
+const FONT_STYLE_UNDERLINE = 4;
+const FONT_STYLE_STRIKETHROUGH = 8;
+const renderToken = (token, key) => {
+  const fontStyle = token.fontStyle ?? 0;
+  return jsx(
+    Text,
+    {
+      backgroundColor: token.bgColor,
+      bold: (fontStyle & FONT_STYLE_BOLD) !== 0,
+      color: token.color,
+      italic: (fontStyle & FONT_STYLE_ITALIC) !== 0,
+      strikethrough: (fontStyle & FONT_STYLE_STRIKETHROUGH) !== 0,
+      underline: (fontStyle & FONT_STYLE_UNDERLINE) !== 0,
+      children: token.content
+    },
+    key
+  );
+};
+const renderTokenLine = (tokens) => jsx(Fragment, { children: tokens.map((token, index) => renderToken(token, index)) });
+const tokenLinesToElements = (lines, options = {}) => {
+  const { highlightLines, showLineNumbers = false, startLine = 1 } = options;
+  const gutterWidth = showLineNumbers ? String(startLine + lines.length - 1).length : 0;
+  return jsx(Box, { flexDirection: "column", children: lines.map((line, lineIndex) => {
+    const lineNumber = startLine + lineIndex;
+    const isHighlighted = highlightLines?.has(lineNumber) ?? false;
+    return jsxs(Box, { children: [
+      showLineNumbers ? jsxs(Text, { color: isHighlighted ? "yellow" : void 0, dimColor: !isHighlighted, children: [
+        String(lineNumber).padStart(gutterWidth),
+        " "
+      ] }) : void 0,
+      jsx(Text, { backgroundColor: isHighlighted ? "#3a3a00" : void 0, children: line.length > 0 ? line.map((token, tokenIndex) => renderToken(token, tokenIndex)) : "" })
+    ] }, lineIndex);
+  }) });
+};
+
+export { getCachedTokens as a, renderTokenLine as b, getHighlighter as g, isLanguageSupported as i, resolveLanguage as r, tokenLinesToElements as t };

package/dist/packem_shared/treeViewTheme-BpSw9TMf.js

@@ -0,0 +1,52 @@
+const theme = {
+  styles: {
+    container: () => {
+      return {
+        flexDirection: "column"
+      };
+    },
+    expandIndicator: (_props) => {
+      return {
+        color: "gray"
+      };
+    },
+    focusIndicator: () => {
+      return {
+        color: "blue"
+      };
+    },
+    indent: ({ depth }) => {
+      return {
+        width: (depth ?? 0) * 2
+      };
+    },
+    label: ({ isFocused, isSelected }) => {
+      let color;
+      if (isSelected) {
+        color = "green";
+      }
+      if (isFocused) {
+        color = "blue";
+      }
+      return { color };
+    },
+    loadingIndicator: () => {
+      return {
+        color: "yellow"
+      };
+    },
+    node: ({ isFocused }) => {
+      return {
+        gap: 1,
+        paddingLeft: isFocused ? 0 : 2
+      };
+    },
+    selectedIndicator: () => {
+      return {
+        color: "green"
+      };
+    }
+  }
+};
+
+export { theme };

package/dist/packem_shared/useAnimation-kj31sA-T.js

@@ -0,0 +1,62 @@
+import { useContext, useState, useRef, useCallback, useLayoutEffect } from 'react';
+import { a as animationContext } from './AnimationContext-BcJg8Jr6.js';
+
+const defaultAnimationInterval = 100;
+const maximumTimerInterval = 2147483647;
+const zeroAnimState = { delta: 0, frame: 0, time: 0 };
+function useAnimation(options) {
+  const { interval = defaultAnimationInterval, isActive = true } = options ?? {};
+  const safeInterval = normalizeAnimationInterval(interval);
+  const { renderThrottleMs, subscribe } = useContext(animationContext);
+  const [resetKey, setResetKey] = useState(0);
+  const [animState, setAnimState] = useState(zeroAnimState);
+  const nextRenderTimeRef = useRef(0);
+  const lastRenderTimeRef = useRef(0);
+  const previousOptionsRef = useRef({ isActive, resetKey, safeInterval });
+  const previousOptions = previousOptionsRef.current;
+  const shouldReset = isActive && (safeInterval !== previousOptions.safeInterval || !previousOptions.isActive || resetKey !== previousOptions.resetKey);
+  const reset = useCallback(() => {
+    setResetKey((k) => k + 1);
+  }, []);
+  useLayoutEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    setAnimState(zeroAnimState);
+    let startTime = 0;
+    const { startTime: subscriberStartTime, unsubscribe } = subscribe((currentTime) => {
+      const isThrottled = renderThrottleMs > 0 && currentTime < nextRenderTimeRef.current;
+      if (isThrottled) {
+        return;
+      }
+      const elapsed = currentTime - startTime;
+      const nextDelta = currentTime - lastRenderTimeRef.current;
+      lastRenderTimeRef.current = currentTime;
+      nextRenderTimeRef.current = currentTime + renderThrottleMs;
+      setAnimState({
+        delta: nextDelta,
+        frame: Math.floor(elapsed / safeInterval),
+        time: elapsed
+      });
+    }, safeInterval);
+    startTime = subscriberStartTime;
+    lastRenderTimeRef.current = subscriberStartTime;
+    nextRenderTimeRef.current = startTime + renderThrottleMs;
+    return unsubscribe;
+  }, [safeInterval, isActive, subscribe, renderThrottleMs, resetKey]);
+  useLayoutEffect(() => {
+    previousOptionsRef.current = { isActive, resetKey, safeInterval };
+  }, [isActive, safeInterval, resetKey]);
+  if (shouldReset) {
+    return { ...zeroAnimState, reset };
+  }
+  return { ...animState, reset };
+}
+function normalizeAnimationInterval(interval) {
+  if (!Number.isFinite(interval)) {
+    return defaultAnimationInterval;
+  }
+  return Math.min(maximumTimerInterval, Math.max(1, interval));
+}
+
+export { useAnimation as default };

package/dist/packem_shared/useApp-DPQlRzi5.js

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+import { A as AppContext } from './AppContext-CP0U6H7O.js';
+
+const useApp = () => useContext(AppContext);
+
+export { useApp as default };

package/dist/packem_shared/useBoxMetrics-rBjKc-g4.js

@@ -0,0 +1,54 @@
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { a as addLayoutListener } from './dom-DvzhsAez.js';
+import useStdout from './useStdout-DyF6DSH0.js';
+
+const emptyMetrics = {
+  height: 0,
+  left: 0,
+  top: 0,
+  width: 0
+};
+const findRootNode = (node) => {
+  if (!node) {
+    return void 0;
+  }
+  if (!node.parentNode) {
+    return node.nodeName === "ink-root" ? node : void 0;
+  }
+  return findRootNode(node.parentNode);
+};
+const useBoxMetrics = (ref) => {
+  const [metrics, setMetrics] = useState(emptyMetrics);
+  const [hasMeasured, setHasMeasured] = useState(false);
+  const { stdout } = useStdout();
+  const updateMetrics = useCallback(() => {
+    const layout = ref.current?.yogaNode?.getComputedLayout() ?? emptyMetrics;
+    setMetrics((previousMetrics) => {
+      const hasChanged = previousMetrics.width !== layout.width || previousMetrics.height !== layout.height || previousMetrics.left !== layout.left || previousMetrics.top !== layout.top;
+      return hasChanged ? layout : previousMetrics;
+    });
+    setHasMeasured(Boolean(ref.current));
+  }, [ref]);
+  useEffect(updateMetrics);
+  useEffect(() => {
+    const rootNode = findRootNode(ref.current);
+    if (!rootNode) {
+      return;
+    }
+    return addLayoutListener(rootNode, updateMetrics);
+  });
+  useEffect(() => {
+    stdout.on("resize", updateMetrics);
+    return () => {
+      stdout.off("resize", updateMetrics);
+    };
+  }, [stdout, updateMetrics]);
+  return useMemo(() => {
+    return {
+      ...metrics,
+      hasMeasured
+    };
+  }, [metrics, hasMeasured]);
+};
+
+export { useBoxMetrics as default };

package/dist/packem_shared/useClipboard-B_9-adw1.js

@@ -0,0 +1,23 @@
+import { useMemo, useCallback } from 'react';
+import { isOsc52Supported, writeOsc52 } from './isOsc52Supported-G0k4sXJx.js';
+import useStdout from './useStdout-DyF6DSH0.js';
+
+const useClipboard = (options = {}) => {
+  const { target = "c" } = options;
+  const { stdout } = useStdout();
+  const isSupported = useMemo(() => isOsc52Supported(), []);
+  const copy = useCallback(
+    (text) => {
+      if (!isSupported || !stdout) {
+        return;
+      }
+      writeOsc52(stdout, text, target);
+    },
+    [isSupported, stdout, target]
+  );
+  return useMemo(() => {
+    return { copy, isSupported };
+  }, [copy, isSupported]);
+};
+
+export { useClipboard as default };

package/dist/packem_shared/useColorBlindness-D_sTIhcb.js

@@ -0,0 +1,30 @@
+import { useMemo, useCallback } from 'react';
+import { IDENTITY_MATRIX, COLOR_BLINDNESS_COMPENSATION, COLOR_BLINDNESS_SIMULATION, transformHexColor } from './COLOR_BLINDNESS_SIMULATION-BsMy5Ewl.js';
+
+const useColorBlindness = (options = {}) => {
+  const { compensate = false, mode = "none" } = options;
+  const matrix = useMemo(() => {
+    if (mode === "none") {
+      return IDENTITY_MATRIX;
+    }
+    if (compensate && mode !== "achromatopsia") {
+      return COLOR_BLINDNESS_COMPENSATION[mode];
+    }
+    return COLOR_BLINDNESS_SIMULATION[mode];
+  }, [mode, compensate]);
+  const isActive = mode !== "none";
+  const transformColor = useCallback(
+    (hex) => {
+      if (!isActive) {
+        return hex;
+      }
+      return transformHexColor(hex, matrix);
+    },
+    [isActive, matrix]
+  );
+  return useMemo(() => {
+    return { isActive, matrix, transformColor };
+  }, [isActive, matrix, transformColor]);
+};
+
+export { useColorBlindness as default };

package/dist/packem_shared/useConsoleCapture-Dvt7G1W1.js

@@ -0,0 +1,61 @@
+import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+
+const ALL_LEVELS = ["log", "info", "warn", "error", "debug"];
+const useConsoleCapture = (options = {}) => {
+  const { filter = ALL_LEVELS, isActive = true, maxEntries = 200 } = options;
+  const [entries, setEntries] = useState([]);
+  const idRef = useRef(0);
+  const filterKey = Array.isArray(filter) ? filter.toSorted().join(",") : "";
+  const stableFilter = useMemo(() => filter, [filterKey]);
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const originals = {};
+    const filterSet = new Set(stableFilter);
+    for (const level of ALL_LEVELS) {
+      if (!filterSet.has(level)) {
+        continue;
+      }
+      originals[level] = console[level];
+      console[level] = (...args) => {
+        originals[level]?.apply(console, args);
+        const message = args.map((a) => {
+          if (typeof a === "string") {
+            return a;
+          }
+          try {
+            return JSON.stringify(a);
+          } catch {
+            return String(a);
+          }
+        }).join(" ");
+        setEntries((previous) => {
+          const entry = {
+            id: ++idRef.current,
+            level,
+            message,
+            timestamp: Date.now()
+          };
+          const next = [...previous, entry];
+          return next.length > maxEntries ? next.slice(-maxEntries) : next;
+        });
+      };
+    }
+    return () => {
+      for (const level of ALL_LEVELS) {
+        if (originals[level]) {
+          console[level] = originals[level];
+        }
+      }
+    };
+  }, [isActive, maxEntries, stableFilter]);
+  const clear = useCallback(() => {
+    setEntries([]);
+  }, []);
+  return useMemo(() => {
+    return { clear, entries };
+  }, [clear, entries]);
+};
+
+export { useConsoleCapture as default };