fromsrc 0.0.0 → 0.0.2

package/dist/hooks/toggle.d.ts

@@ -0,0 +1,13 @@
+type ToggleResult = [
+    open: boolean,
+    toggle: () => void,
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>
+];
+/**
+ * Hook for managing toggle state
+ * @param defaultOpen - Initial open state (default: false)
+ * @returns Tuple of [open, toggle, setOpen]
+ */
+declare function useToggle(defaultOpen?: boolean): ToggleResult;
+
+export { type ToggleResult, useToggle };

package/dist/hooks/toggle.js

@@ -0,0 +1,10 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useToggle(defaultOpen = false) {
+  const [open, setOpen] = useState(defaultOpen);
+  const toggle = useCallback(() => setOpen((prev) => !prev), []);
+  return [open, toggle, setOpen];
+}
+
+export { useToggle };

package/dist/hooks/undoredo.d.ts

@@ -0,0 +1,12 @@
+interface UndoRedoResult<T> {
+    state: T;
+    set: (value: T) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    reset: (value: T) => void;
+}
+declare function useUndoRedo<T>(initial: T): UndoRedoResult<T>;
+
+export { type UndoRedoResult, useUndoRedo };

package/dist/hooks/undoredo.js

@@ -0,0 +1,50 @@
+"use client";
+import { useState, useRef, useCallback } from 'react';
+
+function useUndoRedo(initial) {
+  const [state, setState] = useState(initial);
+  const pastRef = useRef([]);
+  const futureRef = useRef([]);
+  const set = useCallback(
+    (value) => {
+      pastRef.current = [...pastRef.current, state];
+      futureRef.current = [];
+      setState(value);
+    },
+    [state]
+  );
+  const undo = useCallback(() => {
+    const past = pastRef.current;
+    if (past.length === 0) return;
+    const prev = past[past.length - 1];
+    if (prev === void 0) return;
+    pastRef.current = past.slice(0, -1);
+    futureRef.current = [state, ...futureRef.current];
+    setState(prev);
+  }, [state]);
+  const redo = useCallback(() => {
+    const future = futureRef.current;
+    if (future.length === 0) return;
+    const next = future[0];
+    if (next === void 0) return;
+    futureRef.current = future.slice(1);
+    pastRef.current = [...pastRef.current, state];
+    setState(next);
+  }, [state]);
+  const reset = useCallback((value) => {
+    pastRef.current = [];
+    futureRef.current = [];
+    setState(value);
+  }, []);
+  return {
+    state,
+    set,
+    undo,
+    redo,
+    canUndo: pastRef.current.length > 0,
+    canRedo: futureRef.current.length > 0,
+    reset
+  };
+}
+
+export { useUndoRedo };

package/dist/hooks/vibrate.d.ts

@@ -0,0 +1,7 @@
+interface VibrateResult {
+    supported: boolean;
+    vibrate: (pattern?: number | number[]) => void;
+}
+declare function useVibrate(): VibrateResult;
+
+export { type VibrateResult, useVibrate };

package/dist/hooks/vibrate.js

@@ -0,0 +1,15 @@
+"use client";
+import { useCallback } from 'react';
+
+function useVibrate() {
+  const supported = typeof navigator !== "undefined" && "vibrate" in navigator;
+  const vibrate = useCallback(
+    (pattern = 200) => {
+      if (supported) navigator.vibrate(pattern);
+    },
+    [supported]
+  );
+  return { supported, vibrate };
+}
+
+export { useVibrate };

package/dist/hooks/viewtransition.d.ts

@@ -0,0 +1,9 @@
+interface ViewTransitionResult {
+    startTransition: (callback: () => void) => void;
+    isTransitioning: boolean;
+    supported: boolean;
+}
+declare function useViewTransition(): ViewTransitionResult;
+declare function usePageTransition(): void;
+
+export { type ViewTransitionResult, usePageTransition, useViewTransition };

package/dist/hooks/viewtransition.js

@@ -0,0 +1,38 @@
+"use client";
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { usePathname } from 'next/navigation';
+
+function useViewTransition() {
+  const [isTransitioning, setIsTransitioning] = useState(false);
+  const supported = typeof document !== "undefined" && typeof document.startViewTransition === "function";
+  const startTransition = useCallback(
+    (callback) => {
+      if (!supported) {
+        callback();
+        return;
+      }
+      setIsTransitioning(true);
+      const transition = document.startViewTransition?.(callback);
+      if (!transition) {
+        setIsTransitioning(false);
+        return;
+      }
+      transition.finished.finally(() => setIsTransitioning(false));
+    },
+    [supported]
+  );
+  return { startTransition, isTransitioning, supported };
+}
+function usePageTransition() {
+  const pathname = usePathname();
+  const previous = useRef(pathname);
+  const supported = typeof document !== "undefined" && typeof document.startViewTransition === "function";
+  useEffect(() => {
+    if (!supported || pathname === previous.current) return;
+    previous.current = pathname;
+    document.startViewTransition?.(() => {
+    });
+  }, [pathname, supported]);
+}
+
+export { usePageTransition, useViewTransition };

package/dist/hooks/wakelock.d.ts

@@ -0,0 +1,9 @@
+interface WakeLockResult {
+    active: boolean;
+    supported: boolean;
+    request: () => Promise<void>;
+    release: () => Promise<void>;
+}
+declare function useWakeLock(): WakeLockResult;
+
+export { type WakeLockResult, useWakeLock };

package/dist/hooks/wakelock.js

@@ -0,0 +1,32 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useWakeLock() {
+  const [active, setActive] = useState(false);
+  const supported = typeof navigator !== "undefined" && "wakeLock" in navigator;
+  const sentinelRef = useRef(null);
+  const request = useCallback(async () => {
+    if (!supported) return;
+    try {
+      const lock = navigator.wakeLock;
+      if (!lock) return;
+      sentinelRef.current = await lock.request("screen");
+      sentinelRef.current.addEventListener("release", () => setActive(false));
+      setActive(true);
+    } catch {
+    }
+  }, [supported]);
+  const release = useCallback(async () => {
+    await sentinelRef.current?.release();
+    sentinelRef.current = null;
+    setActive(false);
+  }, []);
+  useEffect(() => {
+    return () => {
+      sentinelRef.current?.release();
+    };
+  }, []);
+  return { active, supported, request, release };
+}
+
+export { useWakeLock };

package/dist/hooks/websocket.d.ts

@@ -0,0 +1,10 @@
+type WebSocketStatus = "connecting" | "open" | "closing" | "closed";
+interface WebSocketResult {
+    status: WebSocketStatus;
+    lastMessage: string | null;
+    send: (data: string) => void;
+    close: () => void;
+}
+declare function useWebSocket(url: string | null): WebSocketResult;
+
+export { type WebSocketResult, type WebSocketStatus, useWebSocket };

package/dist/hooks/websocket.js

@@ -0,0 +1,30 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useWebSocket(url) {
+  const [status, setStatus] = useState("closed");
+  const [lastMessage, setLastMessage] = useState(null);
+  const wsRef = useRef(null);
+  const send = useCallback((data) => {
+    wsRef.current?.send(data);
+  }, []);
+  const close = useCallback(() => {
+    wsRef.current?.close();
+  }, []);
+  useEffect(() => {
+    if (!url) return;
+    setStatus("connecting");
+    const ws = new WebSocket(url);
+    wsRef.current = ws;
+    ws.onopen = () => setStatus("open");
+    ws.onclose = () => setStatus("closed");
+    ws.onmessage = (e) => setLastMessage(e.data);
+    ws.onerror = () => setStatus("closed");
+    return () => {
+      ws.close();
+    };
+  }, [url]);
+  return { status, lastMessage, send, close };
+}
+
+export { useWebSocket };

package/dist/hooks/windowsize.d.ts

@@ -0,0 +1,7 @@
+interface WindowSize {
+    width: number;
+    height: number;
+}
+declare function useWindowSize(): WindowSize;
+
+export { type WindowSize, useWindowSize };

package/dist/hooks/windowsize.js

@@ -0,0 +1,17 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useWindowSize() {
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useEffect(() => {
+    function update() {
+      setSize({ width: window.innerWidth, height: window.innerHeight });
+    }
+    update();
+    window.addEventListener("resize", update, { passive: true });
+    return () => window.removeEventListener("resize", update);
+  }, []);
+  return size;
+}
+
+export { useWindowSize };

package/dist/i18n.d.ts

@@ -0,0 +1,30 @@
+interface I18nConfig {
+    defaultLocale: string;
+    locales: string[];
+    pathPrefix?: boolean;
+}
+interface LocalizedPath {
+    locale: string;
+    path: string;
+    originalPath: string;
+}
+interface I18nResult {
+    locale: string;
+    path: string;
+    alternates: {
+        locale: string;
+        path: string;
+    }[];
+}
+declare function detectLocale(acceptLanguage: string, locales: string[], fallback: string): string;
+declare function localizePath(path: string, locale: string, config: I18nConfig): string;
+declare function delocalizePath(path: string, config: I18nConfig): LocalizedPath;
+declare function resolveContent(path: string, locale: string, config: I18nConfig): string[];
+declare function generateAlternates(path: string, config: I18nConfig): I18nResult;
+declare function createI18n(config: I18nConfig): {
+    resolve: (path: string, locale: string) => string[];
+    localize: (path: string, locale: string) => string;
+    delocalize: (path: string) => LocalizedPath;
+};
+
+export { type I18nConfig, type I18nResult, type LocalizedPath, createI18n, delocalizePath, detectLocale, generateAlternates, localizePath, resolveContent };

package/dist/i18n.js

@@ -0,0 +1,73 @@
+function detectLocale(acceptLanguage, locales, fallback) {
+  if (!acceptLanguage) return fallback;
+  const set = new Set(locales);
+  const entries = acceptLanguage.split(",").map((part) => {
+    const [lang, ...params] = part.trim().split(";");
+    const qp = params.find((p) => p.trim().startsWith("q="));
+    const q = qp ? Number.parseFloat(qp.trim().slice(2)) : 1;
+    return { lang: (lang ?? "").trim().toLowerCase(), q: Number.isNaN(q) ? 0 : q };
+  }).sort((a, b) => b.q - a.q);
+  for (const { lang } of entries) {
+    if (set.has(lang)) return lang;
+    const base = lang.split("-")[0];
+    if (!base) continue;
+    if (set.has(base)) return base;
+  }
+  return fallback;
+}
+function localizePath(path, locale, config) {
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  if (locale === config.defaultLocale && !config.pathPrefix) return clean;
+  return `/${locale}${clean === "/" ? "" : clean}`;
+}
+function delocalizePath(path, config) {
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  const segments = clean.replace(/^\//, "").split("/");
+  const first = segments[0];
+  if (first && config.locales.includes(first)) {
+    const rest = segments.slice(1).join("/");
+    return {
+      locale: first,
+      path: `/${rest}` || "/",
+      originalPath: clean
+    };
+  }
+  return {
+    locale: config.defaultLocale,
+    path: clean,
+    originalPath: clean
+  };
+}
+function resolveContent(path, locale, config) {
+  const clean = path.startsWith("/") ? path.slice(1) : path;
+  const paths = [];
+  if (locale !== config.defaultLocale) {
+    paths.push(`${locale}/${clean}`);
+  }
+  paths.push(clean);
+  if (locale !== config.defaultLocale) {
+    paths.push(`${config.defaultLocale}/${clean}`);
+  }
+  return paths;
+}
+function generateAlternates(path, config) {
+  const { locale, path: stripped } = delocalizePath(path, config);
+  const alternates = config.locales.filter((l) => l !== locale).map((l) => ({
+    locale: l,
+    path: localizePath(stripped, l, config)
+  }));
+  return {
+    locale,
+    path: localizePath(stripped, locale, config),
+    alternates
+  };
+}
+function createI18n(config) {
+  return {
+    resolve: (path, locale) => resolveContent(path, locale, config),
+    localize: (path, locale) => localizePath(path, locale, config),
+    delocalize: (path) => delocalizePath(path, config)
+  };
+}
+
+export { createI18n, delocalizePath, detectLocale, generateAlternates, localizePath, resolveContent };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+export { calcReadTime } from './readtime.js';
+export { ReadTime } from './components/readtime.js';
+export { ContentConfig, Doc, DocMeta, Heading, SearchDoc, clearContentCache, defineContent, extractHeadings, getAllDocs, getDoc, getNavigation, getSearchDocs } from './content.js';
+export { FrontmatterError, FrontmatterResult, parseFrontmatter, validateAllFrontmatter } from './frontmatter.js';
+export { MetaFile, PageTreeItem, clearMetaCache, loadMeta, sortByMeta } from './meta.js';
+export { InferSchema, baseSchema, defineSchema, extendSchema } from './schema.js';
+export { SearchAdapter, SearchResult, createSearchAdapter, localSearch } from './search.js';
+export { lastModified, lastModifiedAll } from './lastmodified.js';
+export { LlmsConfig, generateLlmsFull, generateLlmsIndex } from './llms.js';
+export { ContentSource, RemoteSourceConfig, createRemoteSource } from './source.js';
+export { GithubSourceConfig, createGithubSource } from './github.js';
+export { McpConfig, createMcpHandler, generateMcpManifest } from './mcp.js';
+export { default as rehypeAnchors } from './rehype.js';
+export { rehypeInlineCode } from './rehypeinline.js';
+export { RehypeLinksOptions, rehypeExternalLinks } from './rehypelinks.js';
+export { default as remarkAlerts } from './remark.js';
+export { remarkTs2Js } from './remarkts2js.js';
+export { RemarkImageOptions, remarkImage } from './remarkimage.js';
+export { LinkIssue, ValidateOptions, validateLinks } from './validate.js';
+export { preloadConfig, preloadPage, preloadSearch } from './preload.js';
+export { transformerCollapse } from './collapse.js';
+export { transformerAnsi } from './ansi.js';
+export { DocManifest, ManifestPage, generateManifest, generateManifestJson } from './manifest.js';
+export { exportCsv, exportJson, exportMarkdown } from './export.js';
+export { IndexConfig, SearchDocument, SearchIndex, addDocument, createIndex, deserializeIndex, removeDocument, search, serializeIndex, tokenize } from './searchindex.js';
+export { TypeDefinition, TypeProperty, parseTypeFile, parseTypes } from './autotype.js';
+export { parseOpenApi } from './openapi.js';
+export { remarkInstall } from './remarkinstall.js';
+export { IncludeOptions, remarkInclude } from './remarkinclude.js';
+export { TocHeading, TocNode, buildTocTree, remarkStructure } from './remarkstructure.js';
+export { I18nConfig, I18nResult, LocalizedPath, createI18n, delocalizePath, detectLocale, generateAlternates, localizePath, resolveContent } from './i18n.js';
+export { remarkMath } from './remarkmath.js';
+export { remarkSteps } from './remarksteps.js';
+export { generateSlug, rehypeSlug } from './rehypeslug.js';
+export { WatchEvent, WatchHandler, WatcherConfig, clearAllCaches, createWatcher } from './watcher.js';
+export { SitemapConfig, SitemapEntry, docsToEntries, entriesToRss, generateSitemap, generateSitemapIndex } from './sitemap.js';
+export { remarkGfm } from './remarkgfm.js';
+export { DocVersion, VersionConfig, VersionedPage, compareVersions, createVersionSwitcher, getLatestVersion, isVersionedPath, parseVersion, resolveVersion, sortVersions } from './versioning.js';
+export { Redirect, RedirectConfig, createRedirects, parseRedirectsFile } from './redirects.js';
+export { rehypeCode } from './rehypecode.js';
+export { ChangelogConfig, ChangelogEntry, ChangelogItem, filterByType, generateChangelogRss, hasBreaking, latestVersion, parseChangelog } from './changelog.js';
+export { AnalyticsConfig, AnalyticsEvent, aggregateEvents, createAnalytics, generateScript } from './analytics.js';
+export { PageSeo, SeoConfig, createSeo } from './seo.js';
+export { defineCollection, defineCollections } from './collections.js';
+export { RehypeTocOptions, TocEntry, rehypeToc } from './rehypetoc.js';
+export { Pipeline, PipelineContext, Transform, composeTransforms, conditionalTransform, createPipeline, mapContent, mapFrontmatter } from './pipeline.js';
+export { NavNode, NavTreeConfig, buildNavTree, findNavNode, flattenNavTree, getNavBreadcrumbs, getPrevNext } from './navtree.js';
+export { Snippet, SnippetConfig, extractFileSnippet, extractSnippets, generateSnippetMap, getSnippet } from './snippets.js';
+export { TypegenConfig, generateTypes, inferType, writeTypes } from './typegen.js';
+export { LinkCheckConfig, LinkCheckReport, LinkCheckResult, checkInternalLinks, extractLinks, formatReport, isInternalLink, resolveLink } from './linkcheck.js';
+export { OgImageConfig, OgImageMeta, defaultTemplate, generateOgMeta, ogImageUrl, socialMeta } from './ogimage.js';
+export { WorkspaceConfig, WorkspaceNavItem, WorkspacePackage, WorkspaceResult, buildWorkspaceNav, discoverPackages, mergeNavigation, resolveWorkspacePath } from './workspace.js';
+export { MigrateConfig, MigrateResult, MigrateSource, MigrateTransform, migrate, migrateDocusaurus, migrateMintlify, migrateNextra } from './migrate.js';
+export { DraftConfig, DraftFilter, DraftInfo, createDraftMode, filterDrafts, isDraft, scheduledDraft } from './draft.js';
+export { AuditConfig, AuditIssue, AuditResult, audit, formatAudit } from './audit.js';
+export { TestCase, TestResult, TestSuite, assertFrontmatter, assertHeadings, assertLength, assertLinks, createTestSuite, formatTestSuite } from './testing.js';
+export { DiffLine, DiffOptions, DiffResult, diffFrontmatter, diffLines, formatDiff, summarizeDiff } from './diff.js';
+export { BatchConfig, BatchError, BatchResult, batch, batchFiles, forEachDoc, mapFiles } from './batch.js';
+export { CodeLanguage, CodeSample, CodeSampleConfig, generateSample, generateSamples } from './codesample.js';
+export { DocsStats, PageStats, analyzeDocs, analyzePage, compareStats, formatStats } from './stats.js';
+export { Changes, ContentHash, HashManifest, detectChanges, generateHashManifest, hashContent, hashFile, hashFrontmatter } from './hash.js';
+export { ShortcodeConfig, ShortcodeDefinition, builtinShortcodes, parseAttrs, processShortcodes, registerShortcode } from './shortcodes.js';
+export { remarkTabs } from './remarktabs.js';
+export { remarkCallout } from './remarkcallout.js';
+export { ApiError, ApiResponse, CorsConfig, cache, cors, error, json, rateLimiter, withCors } from './api.js';
+export { ThemeColors, ThemeConfig, ThemePreset, contrastRatio, cssVariables, generateCss, mergeTheme, presets } from './themeutil.js';
+export { FromsrcConfig, ResolvedConfig, defineConfig, loadConfig, mergeConfig, resolveConfig } from './config.js';
+export { CliCommand, CliConfig, createCli, formatHelp, parseArgs, spinner } from './cli.js';
+export { OembedData, OembedProvider, extractUrls, providers, resolve, resolveMany } from './oembed.js';
+export { HighlightResult, SnippetOptions, fuzzyHighlight, generateSnippet, highlightHtml, highlightMatches, tokenize as highlightTokenize } from './highlight.js';
+export { TocItem, TocOptions, extractToc, generateTocMarkdown, injectToc, removeToc } from './mdtoc.js';
+export { RankOptions, RankResult, RankableItem, bm25, boostRecent, rank } from './ranking.js';
+export { AccessConfig, AccessResult, AccessRule, createAccess, matchPattern, mergeRoles } from './access.js';
+export { WebhookConfig, WebhookEvent, WebhookResult, createEventFromChange, createWebhook, filterEvents, verifySignature } from './webhook.js';
+export { ChangelogData, ChangelogEntry as ChangelogUtilEntry, formatChangelog, getLatestVersion as getLatestChangelog, getVersionsBetween, groupByType, parseChangelog as parseChangelogFile } from './changelogutil.js';
+export { CacheConfig, CacheEntry, CacheStats, createCache } from './contentcache.js';
+export { GitFile, GitSourceConfig, createGitSource, getFileHash, gitExec, getLastModified as gitLastModified, listFiles as gitListFiles, readFile as gitReadFile } from './gitsource.js';
+export { remarkAdmonition } from './remarkadmonition.js';
+export { NavConfig, NavItem, NavTree, breadcrumbFromPath, findNavItem, flattenNav, generateNav, navToSidebar, sortNav } from './navgen.js';
+export { AutolinkOptions, rehypeAutolink } from './rehypeautolink.js';
+export { CodeMeta, parseMeta, remarkMeta } from './remarkmeta.js';
+export { remarkCaption } from './remarkcaption.js';
+export { MdxComponent, MdxScope, MdxScopeConfig, createScope, filterScope, listComponents, mergeScopes, scopeFromImports, withDefaults } from './mdxscope.js';
+export { remarkEmbed } from './remarkembed.js';
+export { ValidationIssue, ValidationResult, ValidationRule, ValidatorConfig, builtinRules, createRule, validate, validateAll } from './validator.js';
+export { Contributor, ContributorConfig, formatContributors, getContributors, getEditHistory, getLastAuthor } from './contributors.js';
+export { remarkHeadingId } from './remarkheadingid.js';
+export { ReadingTimeOptions, countWords, remarkReadingTime } from './remarkreadingtime.js';
+export { Environment, FeatureFlags, getBaseUrl, getEnv, getFeatureFlags, isDev, isPreview, isProd, optionalEnv, requireEnv } from './env.js';
+export { TableWrapOptions, rehypeTableWrap } from './rehypetablewrap.js';
+export { rehypeCopy } from './rehypecopy.js';
+export { TwoslashAnnotation, TwoslashResult, parseannotations, remarkTwoslash, serialize as serializeTwoslash } from './remarktwoslash.js';
+export { DirectiveType, remarkDirective } from './remarkdirective.js';
+export { remarkFileTree } from './remarkfiletree.js';
+export { rehypeRaw } from './rehyperaw.js';
+export { Annotation, remarkAnnotation } from './remarkannotation.js';
+export { RemarkVideoOptions, remarkVideo } from './remarkvideo.js';
+export { remarkMermaid } from './remarkmermaid.js';
+export { remarkBlockMath } from './remarkblockmath.js';
+export { remarkCodeTitle } from './remarkcodetitle.js';
+export { ContentChange, ContentDiff, contentFromDocs, diffContent, formatChangelog as formatContentDiff } from './contentdiff.js';
+export { remarkLinkCard } from './remarklinkcard.js';
+export { remarkDetails } from './remarkdetails.js';
+export { remarkToc } from './remarktoc.js';
+export { remarkFootnote } from './remarkfootnote.js';
+export { remarkBadge } from './remarkbadge.js';
+export { remarkColumns } from './remarkcolumns.js';
+export { OpenApiEndpoint, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiSchema, OpenApiSpec, OpenApiTag, generateEndpointSlug } from './openapiutil.js';
+export { z } from 'zod';
+import 'react';
+import './searchscore.js';
+import 'hast';
+import 'unified';
+import 'mdast';
+import '@shikijs/types';

package/dist/index.js

@@ -0,0 +1,107 @@
+export { calcReadTime } from './readtime';
+export { ReadTime } from './components/readtime';
+export { clearContentCache, defineContent, extractHeadings, getAllDocs, getDoc, getNavigation, getSearchDocs } from './content';
+export { parseFrontmatter, validateAllFrontmatter } from './frontmatter';
+export { clearMetaCache, loadMeta, sortByMeta } from './meta';
+export { baseSchema, defineSchema, extendSchema, z } from './schema';
+export { createSearchAdapter, localSearch } from './search';
+export { lastModified, lastModifiedAll } from './lastmodified';
+export { generateLlmsFull, generateLlmsIndex } from './llms';
+export { createRemoteSource } from './source';
+export { createGithubSource } from './github';
+export { createMcpHandler, generateMcpManifest } from './mcp';
+export { rehypeAnchors } from './rehype';
+export { rehypeInlineCode } from './rehypeinline';
+export { rehypeExternalLinks } from './rehypelinks';
+export { remarkAlerts } from './remark';
+export { remarkTs2Js } from './remarkts2js';
+export { remarkImage } from './remarkimage';
+export { validateLinks } from './validate';
+export { preloadConfig, preloadPage, preloadSearch } from './preload';
+export { transformerCollapse } from './collapse';
+export { transformerAnsi } from './ansi';
+export { generateManifest, generateManifestJson } from './manifest';
+export { exportCsv, exportJson, exportMarkdown } from './export';
+export { addDocument, createIndex, deserializeIndex, removeDocument, search, serializeIndex, tokenize } from './searchindex';
+export { parseTypeFile, parseTypes } from './autotype';
+export { generateEndpointSlug, parseOpenApi } from './openapi';
+export { remarkInstall } from './remarkinstall';
+export { remarkInclude } from './remarkinclude';
+export { buildTocTree, remarkStructure } from './remarkstructure';
+export { createI18n, delocalizePath, detectLocale, generateAlternates, localizePath, resolveContent } from './i18n';
+export { remarkMath } from './remarkmath';
+export { remarkSteps } from './remarksteps';
+export { generateSlug, rehypeSlug } from './rehypeslug';
+export { clearAllCaches, createWatcher } from './watcher';
+export { docsToEntries, entriesToRss, generateSitemap, generateSitemapIndex } from './sitemap';
+export { remarkGfm } from './remarkgfm';
+export { compareVersions, createVersionSwitcher, getLatestVersion, isVersionedPath, parseVersion, resolveVersion, sortVersions } from './versioning';
+export { createRedirects, parseRedirectsFile } from './redirects';
+export { rehypeCode } from './rehypecode';
+export { filterByType, generateChangelogRss, hasBreaking, latestVersion, parseChangelog } from './changelog';
+export { aggregateEvents, createAnalytics, generateScript } from './analytics';
+export { createSeo } from './seo';
+export { defineCollection, defineCollections } from './collections';
+export { rehypeToc } from './rehypetoc';
+export { composeTransforms, conditionalTransform, createPipeline, mapContent, mapFrontmatter } from './pipeline';
+export { buildNavTree, findNavNode, flattenNavTree, getNavBreadcrumbs, getPrevNext } from './navtree';
+export { extractFileSnippet, extractSnippets, generateSnippetMap, getSnippet } from './snippets';
+export { generateTypes, inferType, writeTypes } from './typegen';
+export { checkInternalLinks, extractLinks, formatReport, isInternalLink, resolveLink } from './linkcheck';
+export { defaultTemplate, generateOgMeta, ogImageUrl, socialMeta } from './ogimage';
+export { buildWorkspaceNav, discoverPackages, mergeNavigation, resolveWorkspacePath } from './workspace';
+export { migrate, migrateDocusaurus, migrateMintlify, migrateNextra } from './migrate';
+export { createDraftMode, filterDrafts, isDraft, scheduledDraft } from './draft';
+export { audit, formatAudit } from './audit';
+export { assertFrontmatter, assertHeadings, assertLength, assertLinks, createTestSuite, formatTestSuite } from './testing';
+export { diffFrontmatter, diffLines, formatDiff, summarizeDiff } from './diff';
+export { batch, batchFiles, forEachDoc, mapFiles } from './batch';
+export { generateSample, generateSamples } from './codesample';
+export { analyzeDocs, analyzePage, compareStats, formatStats } from './stats';
+export { detectChanges, generateHashManifest, hashContent, hashFile, hashFrontmatter } from './hash';
+export { builtinShortcodes, parseAttrs, processShortcodes, registerShortcode } from './shortcodes';
+export { remarkTabs } from './remarktabs';
+export { remarkCallout } from './remarkcallout';
+export { cache, cors, error, json, rateLimiter, withCors } from './api';
+export { contrastRatio, cssVariables, generateCss, mergeTheme, presets } from './themeutil';
+export { defineConfig, loadConfig, mergeConfig, resolveConfig } from './config';
+export { createCli, formatHelp, parseArgs, spinner } from './cli';
+export { extractUrls, providers, resolve, resolveMany } from './oembed';
+export { fuzzyHighlight, generateSnippet, highlightHtml, highlightMatches, tokenize as highlightTokenize } from './highlight';
+export { extractToc, generateTocMarkdown, injectToc, removeToc } from './mdtoc';
+export { bm25, boostRecent, rank } from './ranking';
+export { createAccess, matchPattern, mergeRoles } from './access';
+export { createEventFromChange, createWebhook, filterEvents, verifySignature } from './webhook';
+export { formatChangelog, getLatestVersion as getLatestChangelog, getVersionsBetween, groupByType, parseChangelog as parseChangelogFile } from './changelogutil';
+export { createCache } from './contentcache';
+export { createGitSource, getFileHash, gitExec, getLastModified as gitLastModified, listFiles as gitListFiles, readFile as gitReadFile } from './gitsource';
+export { remarkAdmonition } from './remarkadmonition';
+export { breadcrumbFromPath, findNavItem, flattenNav, generateNav, navToSidebar, sortNav } from './navgen';
+export { rehypeAutolink } from './rehypeautolink';
+export { parseMeta, remarkMeta } from './remarkmeta';
+export { remarkCaption } from './remarkcaption';
+export { createScope, filterScope, listComponents, mergeScopes, scopeFromImports, withDefaults } from './mdxscope';
+export { remarkEmbed } from './remarkembed';
+export { builtinRules, createRule, validate, validateAll } from './validator';
+export { formatContributors, getContributors, getEditHistory, getLastAuthor } from './contributors';
+export { remarkHeadingId } from './remarkheadingid';
+export { countWords, remarkReadingTime } from './remarkreadingtime';
+export { getBaseUrl, getEnv, getFeatureFlags, isDev, isPreview, isProd, optionalEnv, requireEnv } from './env';
+export { rehypeTableWrap } from './rehypetablewrap';
+export { rehypeCopy } from './rehypecopy';
+export { parseannotations, remarkTwoslash, serialize as serializeTwoslash } from './remarktwoslash';
+export { remarkDirective } from './remarkdirective';
+export { remarkFileTree } from './remarkfiletree';
+export { rehypeRaw } from './rehyperaw';
+export { remarkAnnotation } from './remarkannotation';
+export { remarkVideo } from './remarkvideo';
+export { remarkMermaid } from './remarkmermaid';
+export { remarkBlockMath } from './remarkblockmath';
+export { remarkCodeTitle } from './remarkcodetitle';
+export { contentFromDocs, diffContent, formatChangelog as formatContentDiff } from './contentdiff';
+export { remarkLinkCard } from './remarklinkcard';
+export { remarkDetails } from './remarkdetails';
+export { remarkToc } from './remarktoc';
+export { remarkFootnote } from './remarkfootnote';
+export { remarkBadge } from './remarkbadge';
+export { remarkColumns } from './remarkcolumns';

package/dist/lastmodified.d.ts

@@ -0,0 +1,4 @@
+declare function lastModified(filepath: string): Date | null;
+declare function lastModifiedAll(filepaths: string[]): Map<string, Date | null>;
+
+export { lastModified, lastModifiedAll };

package/dist/lastmodified.js

@@ -0,0 +1,24 @@
+import { execFileSync } from 'node:child_process';
+
+function lastModified(filepath) {
+  try {
+    const result = execFileSync("git", ["log", "-1", "--format=%cI", filepath], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!result) return null;
+    const value = new Date(result);
+    return Number.isNaN(value.getTime()) ? null : value;
+  } catch {
+    return null;
+  }
+}
+function lastModifiedAll(filepaths) {
+  const results = /* @__PURE__ */ new Map();
+  for (const filepath of filepaths) {
+    results.set(filepath, lastModified(filepath));
+  }
+  return results;
+}
+
+export { lastModified, lastModifiedAll };