@mechane-ai/ui 0.2.2 → 0.3.0

package/dist/packages/core/src/selection-styles.d.ts

@@ -0,0 +1,110 @@
+import * as stylex from '@stylexjs/stylex';
+import { conditions } from './tokens.stylex.ts';
+export declare const selectionStyles: Readonly<{
+    readonly trigger: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "inline-flex">;
+        readonly boxSizing: stylex.StyleXClassNameFor<"boxSizing", "border-box">;
+        readonly alignItems: stylex.StyleXClassNameFor<"alignItems", "center">;
+        readonly justifyContent: stylex.StyleXClassNameFor<"justifyContent", "space-between">;
+        readonly gap: stylex.StyleXClassNameFor<"gap", string>;
+        readonly minHeight: stylex.StyleXClassNameFor<"minHeight", string>;
+        readonly paddingBlock: stylex.StyleXClassNameFor<"paddingBlock", 0>;
+        readonly paddingInline: stylex.StyleXClassNameFor<"paddingInline", string>;
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", 0>;
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 1>;
+        readonly borderStyle: stylex.StyleXClassNameFor<"borderStyle", "solid">;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+        readonly WebkitFontSmoothing: stylex.StyleXClassNameFor<"WebkitFontSmoothing", "antialiased">;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+        readonly textAlign: stylex.StyleXClassNameFor<"textAlign", "left">;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly cursor: stylex.StyleXClassNameFor<"cursor", "pointer">;
+        readonly ':hover:not([data-disabled])': stylex.StyleXClassNameFor<":hover:not([data-disabled])", {
+            readonly backgroundColor: {
+                readonly [conditions.hoverPointer]: stylex.StyleXVar<string>;
+            };
+        }>;
+        readonly ':is([data-disabled])': stylex.StyleXClassNameFor<":is([data-disabled])", {
+            readonly opacity: stylex.StyleXVar<string>;
+            readonly cursor: "default";
+        }>;
+        readonly ':is([data-invalid])': stylex.StyleXClassNameFor<":is([data-invalid])", {
+            readonly borderColor: stylex.StyleXVar<string>;
+        }>;
+        readonly ':focus-visible': stylex.StyleXClassNameFor<":focus-visible", {
+            readonly outlineWidth: stylex.StyleXVar<string>;
+            readonly outlineStyle: "solid";
+            readonly outlineColor: stylex.StyleXVar<string>;
+            readonly outlineOffset: `calc(0px - ${stylex.StyleXVar<string>})`;
+        }>;
+    }>;
+    readonly outlined: Readonly<{
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", string>;
+        readonly borderColor: stylex.StyleXClassNameFor<"borderColor", string>;
+    }>;
+    readonly ghost: Readonly<{
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", "transparent">;
+        readonly borderColor: stylex.StyleXClassNameFor<"borderColor", "transparent">;
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 0>;
+    }>;
+    readonly value: Readonly<{
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", 0>;
+        readonly flex: stylex.StyleXClassNameFor<"flex", 1>;
+        readonly overflow: stylex.StyleXClassNameFor<"overflow", "hidden">;
+        readonly textOverflow: stylex.StyleXClassNameFor<"textOverflow", "ellipsis">;
+        readonly whiteSpace: stylex.StyleXClassNameFor<"whiteSpace", "nowrap">;
+    }>;
+    readonly icon: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "inline-flex">;
+        readonly flexShrink: stylex.StyleXClassNameFor<"flexShrink", 0>;
+        readonly alignItems: stylex.StyleXClassNameFor<"alignItems", "center">;
+    }>;
+    readonly positioner: Readonly<{
+        readonly zIndex: stylex.StyleXClassNameFor<"zIndex", string>;
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", "var(--anchor-width)">;
+        readonly maxWidth: stylex.StyleXClassNameFor<"maxWidth", "calc(100vw - 16px)">;
+    }>;
+    readonly popup: Readonly<{
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 1>;
+        readonly borderStyle: stylex.StyleXClassNameFor<"borderStyle", "solid">;
+        readonly borderColor: stylex.StyleXClassNameFor<"borderColor", string>;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly padding: stylex.StyleXClassNameFor<"padding", string>;
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", string>;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+        readonly WebkitFontSmoothing: stylex.StyleXClassNameFor<"WebkitFontSmoothing", "antialiased">;
+        readonly boxShadow: stylex.StyleXClassNameFor<"boxShadow", string>;
+        readonly maxHeight: stylex.StyleXClassNameFor<"maxHeight", "var(--available-height)">;
+        readonly overflowY: stylex.StyleXClassNameFor<"overflowY", "auto">;
+        readonly overscrollBehavior: stylex.StyleXClassNameFor<"overscrollBehavior", "contain">;
+    }>;
+    readonly option: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "flex">;
+        readonly alignItems: stylex.StyleXClassNameFor<"alignItems", "center">;
+        readonly gap: stylex.StyleXClassNameFor<"gap", string>;
+        readonly minHeight: stylex.StyleXClassNameFor<"minHeight", string>;
+        readonly paddingInline: stylex.StyleXClassNameFor<"paddingInline", string>;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+        readonly WebkitFontSmoothing: stylex.StyleXClassNameFor<"WebkitFontSmoothing", "antialiased">;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+        readonly cursor: stylex.StyleXClassNameFor<"cursor", "pointer">;
+        readonly outlineWidth: stylex.StyleXClassNameFor<"outlineWidth", 0>;
+        readonly ':is([data-highlighted])': stylex.StyleXClassNameFor<":is([data-highlighted])", {
+            readonly backgroundColor: stylex.StyleXVar<string>;
+        }>;
+        readonly ':is([data-disabled])': stylex.StyleXClassNameFor<":is([data-disabled])", {
+            readonly color: stylex.StyleXVar<string>;
+            readonly cursor: "default";
+        }>;
+    }>;
+    readonly optionText: Readonly<{
+        readonly flex: stylex.StyleXClassNameFor<"flex", 1>;
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", 0>;
+        readonly overflowWrap: stylex.StyleXClassNameFor<"overflowWrap", "anywhere">;
+    }>;
+}>;

package/dist/packages/core/src/selection.d.ts

@@ -0,0 +1,57 @@
+import { Checkbox as BaseCheckbox } from '@base-ui/react/checkbox';
+import { Radio as BaseRadio } from '@base-ui/react/radio';
+import { RadioGroup as BaseRadioGroup } from '@base-ui/react/radio-group';
+import { Switch as BaseSwitch } from '@base-ui/react/switch';
+import { Toggle as BaseToggle } from '@base-ui/react/toggle';
+import { ToggleGroup as BaseToggleGroup } from '@base-ui/react/toggle-group';
+import type { ComponentProps, ReactNode } from 'react';
+import type { CheckedStateProperties, ReadOnlyValueProperties, ValueStateProperties } from './control-state.ts';
+import type { PlacementStyle } from './style-composition.ts';
+type CheckboxRootProps = Omit<ComponentProps<typeof BaseCheckbox.Root>, 'checked' | 'defaultChecked' | 'onCheckedChange' | 'readOnly'> & CheckedStateProperties<NonNullable<BaseCheckbox.Root.Props['onCheckedChange']>> & {
+    readonly xstyle?: PlacementStyle;
+};
+type CheckboxIndicatorProps = ComponentProps<typeof BaseCheckbox.Indicator>;
+type RadioGroupRootProps<Value> = Omit<BaseRadioGroup.Props<Value>, 'value' | 'defaultValue' | 'onValueChange'> & (ValueStateProperties<Value, NonNullable<BaseRadioGroup.Props<Value>['onValueChange']>> | ReadOnlyValueProperties<Value, NonNullable<BaseRadioGroup.Props<Value>['onValueChange']>>) & {
+    readonly xstyle?: PlacementStyle;
+};
+type RadioItemProps<Value> = BaseRadio.Root.Props<Value> & {
+    readonly xstyle?: PlacementStyle;
+};
+type RadioIndicatorProps = ComponentProps<typeof BaseRadio.Indicator>;
+type SwitchRootProps = Omit<ComponentProps<typeof BaseSwitch.Root>, 'checked' | 'defaultChecked' | 'onCheckedChange' | 'readOnly'> & CheckedStateProperties<NonNullable<BaseSwitch.Root.Props['onCheckedChange']>> & {
+    readonly xstyle?: PlacementStyle;
+};
+type SwitchThumbProps = ComponentProps<typeof BaseSwitch.Thumb>;
+type ToggleGroupRootProps<Value extends string> = Omit<BaseToggleGroup.Props<Value>, 'value' | 'defaultValue' | 'onValueChange'> & ValueStateProperties<ReadonlyArray<Value>, NonNullable<BaseToggleGroup.Props<Value>['onValueChange']>> & {
+    readonly xstyle?: PlacementStyle;
+};
+type ToggleItemProps<Value extends string> = Omit<BaseToggle.Props<Value>, 'value' | 'pressed' | 'defaultPressed' | 'onPressedChange'> & {
+    readonly value: Value;
+};
+declare function CheckboxRoot({ className, style, xstyle, ...props }: CheckboxRootProps): ReactNode;
+declare function CheckboxIndicator({ children, className, style, ...props }: CheckboxIndicatorProps): ReactNode;
+declare function RadioGroupRoot<Value>({ className, style, xstyle, ...props }: RadioGroupRootProps<Value>): ReactNode;
+declare function RadioItem<Value>({ className, style, xstyle, ...props }: RadioItemProps<Value>): ReactNode;
+declare function RadioIndicator({ className, style, ...props }: RadioIndicatorProps): ReactNode;
+declare function SwitchRoot({ className, style, xstyle, ...props }: SwitchRootProps): ReactNode;
+declare function SwitchThumb({ className, style, ...props }: SwitchThumbProps): ReactNode;
+declare function ToggleGroupRoot<Value extends string>({ className, style, xstyle, ...props }: ToggleGroupRootProps<Value>): ReactNode;
+declare function ToggleItem<Value extends string>({ className, style, ...props }: ToggleItemProps<Value>): ReactNode;
+export declare const Checkbox: {
+    Root: typeof CheckboxRoot;
+    Indicator: typeof CheckboxIndicator;
+};
+export declare const RadioGroup: {
+    Root: typeof RadioGroupRoot;
+    Item: typeof RadioItem;
+    Indicator: typeof RadioIndicator;
+};
+export declare const Switch: {
+    Root: typeof SwitchRoot;
+    Thumb: typeof SwitchThumb;
+};
+export declare const ToggleGroup: {
+    Root: typeof ToggleGroupRoot;
+    Item: typeof ToggleItem;
+};
+export {};

package/dist/packages/core/src/skeleton.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+type SkeletonShape = 'rectangle' | 'circle';
+export type SkeletonProps = {
+    readonly width?: number | `${number}%`;
+    readonly height?: number;
+    readonly shape?: SkeletonShape;
+};
+export type SkeletonTextProps = {
+    readonly lines?: number;
+};
+export type SpinnerProps = {
+    readonly label: string;
+    readonly showLabel?: boolean;
+};
+export declare function Skeleton({ width, height, shape }: SkeletonProps): ReactNode;
+export declare function SkeletonText({ lines }: SkeletonTextProps): ReactNode;
+export declare function Spinner({ label, showLabel }: SpinnerProps): ReactNode;
+export {};

package/dist/packages/core/src/theme.d.ts

@@ -0,0 +1,16 @@
+export declare const themeProps: {
+    readonly light: Readonly<{
+        className?: string;
+        'data-style-src'?: string;
+        style?: Readonly<{
+            [$$Key$$: string]: string | number;
+        }>;
+    }>;
+    readonly dark: Readonly<{
+        className?: string;
+        'data-style-src'?: string;
+        style?: Readonly<{
+            [$$Key$$: string]: string | number;
+        }>;
+    }>;
+};

package/dist/packages/core/src/toast.d.ts

@@ -0,0 +1,28 @@
+import { Toast as BaseToast } from '@base-ui/react/toast';
+import type { ComponentProps, ReactNode } from 'react';
+type ToastViewportProps = ComponentProps<typeof BaseToast.Viewport>;
+type ToastRootProps = ComponentProps<typeof BaseToast.Root>;
+type ToastContentProps = ComponentProps<typeof BaseToast.Content>;
+type ToastTitleProps = ComponentProps<typeof BaseToast.Title>;
+type ToastDescriptionProps = ComponentProps<typeof BaseToast.Description>;
+type ToastCloseProps = ComponentProps<typeof BaseToast.Close>;
+declare function ToastViewport({ className, style, ...props }: ToastViewportProps): ReactNode;
+declare function ToastRoot({ className, style, ...props }: ToastRootProps): ReactNode;
+declare function ToastContent({ className, style, ...props }: ToastContentProps): ReactNode;
+declare function ToastTitle({ className, style, ...props }: ToastTitleProps): ReactNode;
+declare function ToastDescription({ className, style, ...props }: ToastDescriptionProps): ReactNode;
+declare function ToastClose(props: ToastCloseProps): ReactNode;
+export declare const Toast: {
+    Provider: import("react").FC<import("@base-ui/react").ToastProviderProps>;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ToastPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Viewport: typeof ToastViewport;
+    Root: typeof ToastRoot;
+    Content: typeof ToastContent;
+    Title: typeof ToastTitle;
+    Description: typeof ToastDescription;
+    Close: typeof ToastClose;
+    Action: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ToastActionProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    useManager: typeof BaseToast.useToastManager;
+    createManager: typeof BaseToast.createToastManager;
+};
+export {};

package/dist/{tokens.stylex.d.ts → packages/core/src/tokens.stylex.d.ts}

@@ -18,6 +18,61 @@ export declare const colors: stylex.VarGroup<Readonly<{
     dangerSoft: string;
     overlay: string;
 }>, symbol>;
+export declare const darkColors: {
+    canvas: string;
+    surface: string;
+    ink: string;
+    inkHover: string;
+    inverse: string;
+    muted: string;
+    faint: string;
+    line: string;
+    focus: string;
+    accent: string;
+    accentSoft: string;
+    warning: string;
+    warningSoft: string;
+    danger: string;
+    dangerHover: string;
+    dangerSoft: string;
+    overlay: string;
+};
+export declare const chartColors: stylex.VarGroup<Readonly<{
+    series1: string;
+    series2: string;
+    series3: string;
+    series4: string;
+    series5: string;
+    series6: string;
+    negative: string;
+    positive: string;
+    missing: string;
+}>, symbol>;
+export declare const darkChartColors: {
+    series1: string;
+    series2: string;
+    series3: string;
+    series4: string;
+    series5: string;
+    series6: string;
+    negative: string;
+    positive: string;
+    missing: string;
+};
+export declare const syntaxColors: stylex.VarGroup<Readonly<{
+    keyword: string;
+    string: string;
+    comment: string;
+    number: string;
+    type: string;
+}>, symbol>;
+export declare const darkSyntaxColors: {
+    keyword: string;
+    string: string;
+    comment: string;
+    number: string;
+    type: string;
+};
 export declare const spacing: stylex.VarGroup<Readonly<{
     xxs: string;
     xs: string;
@@ -32,6 +87,7 @@ export declare const typography: stylex.VarGroup<Readonly<{
     monoFamily: string;
     bodySize: string;
     bodyLineHeight: string;
+    multilineLineHeight: string;
     captionSize: string;
     captionLineHeight: string;
     inputSize: string;
@@ -50,6 +106,7 @@ export declare const controls: stylex.VarGroup<Readonly<{
     coarseTarget: string;
     iconSize: string;
     paddingInline: string;
+    paddingBlock: string;
     gap: string;
     focusWidth: string;
     disabledOpacity: string;
@@ -67,6 +124,9 @@ export declare const motion: stylex.VarGroup<Readonly<{
 export declare const shadows: stylex.VarGroup<Readonly<{
     popup: string;
 }>, symbol>;
+export declare const darkShadows: {
+    popup: string;
+};
 export declare const layers: {
     backdrop: string;
     dialog: string;

package/dist/packages/core/src/trace.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+export type TraceStatus = 'pending' | 'running' | 'complete' | 'failed' | 'skipped' | 'unknown';
+export type TraceRootProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+};
+export type TraceGroupProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+};
+type TraceSelection = {
+    readonly selected: boolean;
+    readonly onSelect: (id: string) => void;
+} | {
+    readonly selected?: never;
+    readonly onSelect?: never;
+};
+export type TraceItemProps = TraceSelection & {
+    readonly id: string;
+    readonly label: string;
+    readonly status: TraceStatus;
+    readonly statusLabel: string;
+    readonly description?: string;
+    readonly detail?: ReactNode;
+    readonly children?: ReactNode;
+};
+declare function TraceRoot({ label, children }: TraceRootProps): ReactNode;
+declare function TraceGroup({ label, children }: TraceGroupProps): ReactNode;
+declare function TraceItem({ id, label, status, statusLabel, description, detail, selected, onSelect, children, }: TraceItemProps): ReactNode;
+export declare const Trace: {
+    Root: typeof TraceRoot;
+    Item: typeof TraceItem;
+    Group: typeof TraceGroup;
+};
+export {};

package/dist/{layout → packages/layout/src}/index.d.ts

@@ -2,3 +2,5 @@ export { AppShell } from './app-shell.tsx';
 export { PageToolbar, ToolbarAction } from './page-toolbar.tsx';
 export { DetailPage } from './detail-page.tsx';
 export { Navigation, NavigationItem, NavigationLink, SidebarLabel, SidebarFooter } from './sidebar.tsx';
+export { Resizable } from './resizable.tsx';
+export type { ResizableRootProps, ResizablePaneProps, ResizableHandleProps } from './resizable.tsx';

package/dist/{layout → packages/layout/src}/page-toolbar.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentProps, ReactNode } from 'react';
-import { Button } from '../index.ts';
+import { Button } from '../../core/src/index.ts';
 type PageToolbarProps = {
     readonly title: ReactNode;
     readonly actions?: ReactNode;

package/dist/packages/layout/src/resizable.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentProps, ReactNode } from 'react';
+export type ResizableRootProps = {
+    readonly orientation?: 'horizontal' | 'vertical';
+    readonly initialSizes?: Readonly<Record<string, number>>;
+    readonly onSizesChange?: (sizes: Readonly<Record<string, number>>) => void;
+    readonly disabled?: boolean;
+} & Omit<ComponentProps<'div'>, 'onChange' | 'defaultValue'>;
+export type ResizablePaneProps = {
+    readonly id: string;
+    readonly initialSizePercent?: number;
+    readonly minimumSizePercent?: number;
+    readonly maximumSizePercent?: number;
+    readonly collapsible?: boolean;
+} & Omit<ComponentProps<'div'>, 'id' | 'onResize'>;
+export type ResizableHandleProps = {
+    readonly 'aria-label': string;
+    readonly 'disabled'?: boolean;
+} & Omit<ComponentProps<'div'>, 'children'>;
+declare function ResizableRoot({ orientation, initialSizes, onSizesChange, disabled, ref, ...props }: ResizableRootProps): ReactNode;
+declare function ResizablePane({ id, initialSizePercent, minimumSizePercent, maximumSizePercent, collapsible, ref, ...props }: ResizablePaneProps): ReactNode;
+declare function ResizableHandle({ ref, ...props }: ResizableHandleProps): ReactNode;
+export declare const Resizable: {
+    Root: typeof ResizableRoot;
+    Pane: typeof ResizablePane;
+    Handle: typeof ResizableHandle;
+};
+export {};

package/dist/{layout → packages/layout/src}/sidebar.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentProps, ReactNode, RefObject } from 'react';
-import { Button, Drawer } from '../index.ts';
+import { Button, Drawer } from '../../core/src/index.ts';
 type SidebarState = {
     readonly isExpanded: boolean;
     readonly sidebarId: string;

package/dist/pierre-diff-D3m4JCu0.js

@@ -0,0 +1,66 @@
+import { n as e, t } from "./pierre-theme-CPlfl-AA.js";
+import * as n from "@stylexjs/stylex";
+import { useCallback as r, useState as i } from "react";
+import { jsx as a } from "react/jsx-runtime";
+import { Virtualizer as o, parseDiffFromFile as s, parsePatchFiles as c, registerCustomTheme as l } from "@pierre/diffs";
+import { FileDiff as u, VirtualizerContext as d } from "@pierre/diffs/react";
+// packages/content/src/diff/pierre-diff.tsx
+var f = {
+	kVQacm: "xysyzu8",
+	$$css: !0
+}, p = { viewport: (e) => [
+	f,
+	{
+		kskxy: e == null ? e : "x1jols5v",
+		$$css: !0
+	},
+	{ "--x-maxHeight": ((e) => typeof e == "number" ? e + "px" : e ?? void 0)(e) }
+] };
+l("mechane", () => Promise.resolve(t), "zed");
+function m(e) {
+	return e === null ? null : {
+		name: e.name,
+		contents: e.code,
+		lang: e.language ?? "text"
+	};
+}
+function h(e) {
+	return e.patch === void 0 ? [s(m(e.before), m(e.after), {}, !0)] : c(e.patch, { throwOnError: !0 }).flatMap((e) => e.files);
+}
+function g({ files: t, layout: s, wrap: c, annotations: l, maxHeight: f, label: m }) {
+	let [h] = i(() => new o()), g = r((e) => {
+		e === null ? h.cleanUp() : h.setup(e);
+	}, [h]);
+	return /* @__PURE__ */ a(d.Provider, {
+		value: h,
+		children: /* @__PURE__ */ a("div", {
+			ref: g,
+			role: "region",
+			"aria-label": `${m} changes`,
+			tabIndex: 0,
+			...n.props(p.viewport(f)),
+			children: /* @__PURE__ */ a("div", { children: t.map((t) => /* @__PURE__ */ a(u, {
+				fileDiff: t,
+				disableWorkerPool: !0,
+				options: {
+					preferredHighlighter: "highlights",
+					theme: "mechane",
+					themeType: "system",
+					unsafeCSS: e,
+					diffStyle: s,
+					overflow: c ? "wrap" : "scroll",
+					hunkSeparators: "line-info",
+					tokenizeMaxLength: 2e5,
+					tokenizeMaxLineLength: 4096
+				},
+				lineAnnotations: l.filter((e) => e.file === t.name).map((e) => ({
+					side: e.side === "old" ? "deletions" : "additions",
+					lineNumber: e.line,
+					metadata: e.content
+				})),
+				renderAnnotation: (e) => e.metadata
+			}, t.name)) })
+		})
+	});
+}
+export { g as PierreDiff, h as prepareDiff };

package/dist/pierre-theme-CPlfl-AA.js

@@ -0,0 +1,96 @@
+import { colors as e, controls as t, spacing as n, syntaxColors as r, typography as i } from "./tokens.js";
+// packages/content/src/pierre-theme.ts
+var a = {
+	name: "Mechane",
+	appearance: "light",
+	cssVariables: {
+		prefix: "--mechane-syntax-",
+		defaults: {
+			foreground: e.ink,
+			background: e.surface,
+			keyword: r.keyword,
+			string: r.string,
+			comment: r.comment,
+			number: r.number,
+			type: r.type,
+			punctuation: e.muted
+		}
+	},
+	style: {
+		"editor.background": "background",
+		"editor.foreground": "foreground",
+		syntax: {
+			keyword: {
+				color: "keyword",
+				font_weight: 600
+			},
+			string: "string",
+			comment: "comment",
+			number: "number",
+			type: "type",
+			function: "foreground",
+			operator: "punctuation",
+			punctuation: "punctuation"
+		}
+	}
+}, o = `
+:host {
+  color-scheme: inherit;
+  --diffs-font-family: ${i.monoFamily};
+  --diffs-header-font-family: ${i.fontFamily};
+  --diffs-font-size: ${i.captionSize};
+  --diffs-line-height: ${i.bodyLineHeight};
+  --diffs-bg: ${e.surface};
+  --diffs-fg: ${e.ink};
+  --diffs-fg-number: ${e.muted};
+  --diffs-bg-addition: ${e.accentSoft};
+  --diffs-bg-deletion: ${e.dangerSoft};
+  --diffs-addition-color-override: ${e.accent};
+  --diffs-deletion-color-override: ${e.danger};
+  --diffs-modified-color-override: ${e.focus};
+  --diffs-bg-context-override: ${e.surface};
+  --diffs-bg-context-gutter-override: ${e.canvas};
+  --diffs-bg-separator-override: ${e.canvas};
+  --diffs-selection-background: ${e.accentSoft};
+  font-family: ${i.monoFamily};
+  font-size: ${i.captionSize};
+  color: ${e.ink};
+  background: ${e.surface};
+}
+pre { font-family: ${i.monoFamily}; font-size: ${i.captionSize}; line-height: ${i.bodyLineHeight}; }
+[data-line-number] { color: ${e.muted}; }
+[data-diffs-header] { min-height: ${t.mdHeight}; border-bottom: 1px solid ${e.line}; }
+`, s = `
+:host {
+  color-scheme: inherit;
+  color: ${e.ink};
+  background: ${e.surface};
+  font-family: ${i.fontFamily};
+  font-size: ${i.bodySize};
+  --trees-font-family-override: ${i.fontFamily};
+  --trees-font-size-override: ${i.bodySize};
+  --trees-bg-override: ${e.surface};
+  --trees-fg-override: ${e.ink};
+  --trees-fg-muted-override: ${e.muted};
+  --trees-bg-muted-override: ${e.canvas};
+  --trees-input-bg-override: ${e.surface};
+  --trees-border-color-override: ${e.line};
+  --trees-border-radius-override: 0px;
+  --trees-accent-override: ${e.focus};
+  --trees-focus-ring-color-override: ${e.focus};
+  --trees-focus-ring-width-override: ${t.focusWidth};
+  --trees-selected-fg-override: ${e.ink};
+  --trees-selected-bg-override: ${e.canvas};
+  --trees-selected-focused-border-color-override: ${e.focus};
+  --trees-status-added-override: ${e.accent};
+  --trees-status-deleted-override: ${e.danger};
+  --trees-status-ignored-override: ${e.muted};
+  --trees-status-modified-override: ${e.warning};
+  --trees-status-renamed-override: ${e.warning};
+  --trees-status-untracked-override: ${e.accent};
+}
+[role="treeitem"] { border-radius: 0; padding-inline: ${n.sm}; }
+[role="treeitem"][aria-selected="true"] { background: ${e.canvas}; color: ${e.ink}; }
+[role="treeitem"]:focus-visible { outline: ${t.focusWidth} solid ${e.focus}; outline-offset: -2px; }
+`;
+export { o as n, s as r, a as t };