@aparte/plugin-diff 0.0.0-stage → 1.7.0

package/dist/setup.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `setupDiff()` — a tool's result shown as a diff, under the tool's line in the reply.
+ *
+ * An edit tool's row keeps everything core gives it: its name, the summary the app set, its
+ * states (running, waiting for approval, refused, failed). What it holds behind its line is
+ * the change, opened — `<aparte-diff>` in place of the raw Input and Output. Through the
+ * display's `details`, so it is the same row in every framework and every state.
+ *
+ * DOM-free at import: the element is created only when a chat draws a resolved call, in a
+ * browser. On a server the setup registers the same display and draws nothing.
+ */
+import { type AparteConfig, type AparteToolCallSegment, type AparteToolMatcher } from '@aparte/core';
+import type { AparteDiffInput } from './types.js';
+/** How an app shows a tool's result as a diff. */
+export interface DiffSetupOptions {
+    /** The tool (or tools) whose result is a change. */
+    tool: AparteToolMatcher | AparteToolMatcher[];
+    /**
+     * The change, from the tool's result — its `structuredContent` when it has one, else its
+     * text parsed as JSON, else the text — and the call's input: a unified diff's text,
+     * `{ path, before, after }`, or a list of files. Return `null` for a result with no change
+     * to show. Without `map`, the result must already be one of those.
+     */
+    map?: (result: any, input: Record<string, unknown>, segment: AparteToolCallSegment) => AparteDiffInput | null | undefined;
+    /** Let the reader comment on its lines: `aparte-diff-comment` bubbles out of the chat. Off by default. */
+    commentable?: boolean;
+    /** Show the diff opened under the line (the default), or `false` for closed until the reader opens it. */
+    open?: boolean;
+}
+/**
+ * Show a tool's result as a diff, under the tool's line in the reply. Returns the function that
+ * takes it off again.
+ *
+ * The rest of the tool's display (its label, its summary, its icon) stays the app's: set it
+ * with `registerToolDisplay` before or after. Taking the setup off gives back what the tool
+ * showed behind its line before.
+ *
+ * @example
+ * setupDiff({
+ *   tool: 'edit_file',
+ *   map: (result, input) => ({ path: String(input.path), before: result.before, after: result.after }),
+ * });
+ */
+export declare function setupDiff(options: DiffSetupOptions, config?: AparteConfig): () => void;
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAsB,KAAK,YAAY,EAAE,KAAK,qBAAqB,EAA0B,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjJ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC7B,oDAAoD;IACpD,IAAI,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,CAAC;IAC9C;;;;;OAKG;IAGH,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,qBAAqB,KAAK,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1H,0GAA0G;IAC1G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,0GAA0G;IAC1G,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAqCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,GAAE,YAAiC,GAAG,MAAM,IAAI,CAuD1G"}

package/dist/styles.d.ts

@@ -0,0 +1,5 @@
+/** The sheet, as the element puts it on the page. */
+export declare const DIFF_STYLES: string;
+/** Put the sheet on the page, unless it is there already. */
+export declare function ensureStyles(doc?: Document): void;
+//# sourceMappingURL=styles.d.ts.map

package/dist/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../src/styles.ts"],"names":[],"mappings":"AAOA,qDAAqD;AACrD,eAAO,MAAM,WAAW,QAAS,CAAC;AAElC,6DAA6D;AAC7D,wBAAgB,YAAY,CAAC,GAAG,GAAE,QAAmB,GAAG,IAAI,CAM3D"}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The shape of a change, shared by the computation (`diffTexts`, `parseUnifiedDiff`), the
+ * element and the setup. Plain data: no DOM, so a server can build it and send it as JSON.
+ */
+/** What a line of a hunk is: unchanged, added, or removed. */
+export type AparteDiffLineKind = 'context' | 'add' | 'del';
+/** One line of a hunk. */
+export interface AparteDiffLine {
+    kind: AparteDiffLineKind;
+    /** The line's text, without its `+` / `-` / space marker and without its line ending. */
+    text: string;
+    /** Its number in the old file: on a removed or an unchanged line. */
+    oldLine?: number;
+    /** Its number in the new file: on an added or an unchanged line. */
+    newLine?: number;
+    /** The file ends on this line without a newline (``). */
+    noNewline?: boolean;
+}
+/** A run of changes with the unchanged lines around them, as one `@@ … @@` block. */
+export interface AparteDiffHunk {
+    /** The first old line the hunk covers (the line before it when `oldCount` is 0). */
+    oldStart: number;
+    oldCount: number;
+    /** The first new line the hunk covers (the line before it when `newCount` is 0). */
+    newStart: number;
+    newCount: number;
+    /** What follows the second `@@`, when the tool that made the diff wrote it: the function the hunk is in. */
+    section?: string;
+    lines: AparteDiffLine[];
+}
+/** What happened to a file. */
+export type AparteDiffFileStatus = 'modified' | 'added' | 'deleted' | 'renamed';
+/** One file's change. */
+export interface AparteDiffFile {
+    /** The file's path: the new one, or the old one for a deleted file. */
+    path: string;
+    /** Its path before, when it was renamed. */
+    oldPath?: string;
+    /** What happened to it. Absent reads as `modified`, or `renamed` when `oldPath` differs from `path`. */
+    status?: AparteDiffFileStatus;
+    /** How many lines were added. */
+    added: number;
+    /** How many lines were removed. */
+    removed: number;
+    hunks: AparteDiffHunk[];
+    /** A binary file: the diff says it changed, and shows no line. */
+    binary?: boolean;
+}
+/**
+ * A file's text before and after: the element computes the diff, and can show every unchanged
+ * line. A side that does not exist is `null` — `before: null` for a file created, `after: null`
+ * for one deleted — and `''` is a file that exists and is empty.
+ */
+export interface AparteDiffSource {
+    path: string;
+    before: string | null;
+    after: string | null;
+    /** Its path before, when it was renamed. */
+    oldPath?: string;
+}
+/** What `<aparte-diff>` shows: a unified diff's text, a file's two texts, or a list of files. */
+export type AparteDiffInput = string | AparteDiffSource | ReadonlyArray<AparteDiffFile | AparteDiffSource>;
+/** Which side of the change a line number counts on: the old file, or the new one. */
+export type AparteDiffSide = 'old' | 'new';
+/** A comment on a line or a range, as the app hands it to `<aparte-diff>` to show. */
+export interface AparteDiffComment {
+    /** Yours, to tell comments apart. The element does not read it. */
+    id?: string;
+    path: string;
+    side: AparteDiffSide;
+    startLine: number;
+    endLine: number;
+    text: string;
+    /** Where it stands: kept to be sent (`pending`), or sent. Shown beside the comment. */
+    state?: 'pending' | 'sent';
+}
+/**
+ * A reader wrote a comment on a line or a range of `<aparte-diff commentable>` and sent it.
+ * Bubbles out of the chat, and is cancelable: cancel it to keep the form open with the text
+ * (the comment could not be kept, say). The element shows nothing of it on its own: hand it
+ * back through `comments` to show it under its lines.
+ *
+ * @event aparte-diff-comment
+ */
+export interface AparteDiffCommentEventDetail {
+    path: string;
+    side: AparteDiffSide;
+    startLine: number;
+    endLine: number;
+    text: string;
+    /** The lines commented on, as they read on that side, joined with `\n`. */
+    code: string;
+}
+interface DiffEventMap {
+    'aparte-diff-comment': CustomEvent<AparteDiffCommentEventDetail>;
+}
+declare global {
+    interface HTMLElementEventMap extends DiffEventMap {
+    }
+    interface DocumentEventMap extends DiffEventMap {
+    }
+    interface WindowEventMap extends DiffEventMap {
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAE3D,0BAA0B;AAC1B,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,yFAAyF;IACzF,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC3B,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,4GAA4G;IAC5G,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,+BAA+B;AAC/B,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAEhF,yBAAyB;AACzB,MAAM,WAAW,cAAc;IAC3B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wGAAwG;IACxG,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,kEAAkE;IAClE,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,iGAAiG;AACjG,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAAC,cAAc,GAAG,gBAAgB,CAAC,CAAC;AAE3G,sFAAsF;AACtF,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,KAAK,CAAC;AAE3C,sFAAsF;AACtF,MAAM,WAAW,iBAAiB;IAC9B,mEAAmE;IACnE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,KAAK,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;CAChB;AAKD,UAAU,YAAY;IAClB,qBAAqB,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;CACpE;AACD,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,mBAAoB,SAAQ,YAAY;KAAG;IACrD,UAAU,gBAAiB,SAAQ,YAAY;KAAG;IAClD,UAAU,cAAe,SAAQ,YAAY;KAAG;CACnD"}

package/dist/words.d.ts

@@ -0,0 +1,334 @@
+/**
+ * The words `<aparte-diff>` says, in the chat's language.
+ *
+ * Core's locale is a closed list of what CORE draws, so this plugin reads its own keys off
+ * `getLocale()` and defaults them here: the app's locale first, then this table for the
+ * chat's language (the ten `@aparte/locales` ships), then English.
+ *
+ *   aparteGlobalConfig.extendLocale({ diffCommentSubmit: 'Envoyer' });
+ *
+ * A count is a set of plural forms, each named by its `Intl.PluralRules` category, as core's
+ * `turnTools` is: Russian needs `few` and `many`, Japanese, Korean and Chinese one form.
+ */
+import { type AparteConfig } from '@aparte/core';
+export declare const WORDS: {
+    /** A file's added lines, said to a screen reader beside the `+3` it shows. */
+    diffAdded: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A file's removed lines, said to a screen reader beside the `−1` it shows. */
+    diffRemoved: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** What the `+` of an added line says to a screen reader. */
+    diffMarkerAdded: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** What the `−` of a removed line says to a screen reader. */
+    diffMarkerRemoved: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** The button over a run of unchanged lines the element can show. */
+    diffShowUnchanged: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A run of unchanged lines the diff does not hold (a unified diff's text), between two hunks. */
+    diffUnchanged: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A new file's tag, beside its path. */
+    diffStatusAdded: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A deleted file's tag, beside its path. */
+    diffStatusDeleted: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A renamed file's tag, beside its paths. */
+    diffStatusRenamed: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** Where a binary file's lines would be. */
+    diffBinary: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** Under the last line of a file that ends without a newline. */
+    diffNoNewline: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** An unchanged line's number, as its button and a comment name it. */
+    diffLine: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** An added line's number, as its button names it. */
+    diffLineAdded: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A removed line's number, as its button and a comment name it. */
+    diffLineRemoved: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A range a comment is on. */
+    diffLines: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A range of removed lines a comment is on. */
+    diffLinesRemoved: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** The comment field's name, on one line. */
+    diffCommentLine: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** The comment field's name, on a range. */
+    diffCommentLines: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** What the empty comment field shows. */
+    diffCommentPlaceholder: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** The button that sends the comment. */
+    diffCommentSubmit: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** The button that closes the comment field. */
+    diffCommentCancel: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A comment kept to be sent. */
+    diffCommentPending: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A comment that was sent. */
+    diffCommentSent: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+    /** A diff with no change in it. */
+    diffEmpty: {
+        en: string;
+        fr: string;
+        de: string;
+        es: string;
+        it: string;
+        ja: string;
+        ko: string;
+        pt: string;
+        ru: string;
+        zh: string;
+    };
+};
+export type WordKey = keyof typeof WORDS;
+/**
+ * The word for `key`: the app's locale, else this table in the chat's language, else English;
+ * `{name}` slots filled from `vars`, and a count's plural form chosen when `vars.n` is a number.
+ */
+export declare function word(config: AparteConfig, key: WordKey, vars?: Record<string, string | number>): string;
+//# sourceMappingURL=words.d.ts.map

package/dist/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../src/words.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAa,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5D,eAAO,MAAM,KAAK;IACd,8EAA8E;;;;;;;;;;;;;IAa9E,gFAAgF;;;;;;;;;;;;;IAahF,6DAA6D;;;;;;;;;;;;;IAK7D,8DAA8D;;;;;;;;;;;;;IAK9D,qEAAqE;;;;;;;;;;;;;IAarE,kGAAkG;;;;;;;;;;;;;IAalG,yCAAyC;;;;;;;;;;;;;IAKzC,6CAA6C;;;;;;;;;;;;;IAK7C,8CAA8C;;;;;;;;;;;;;IAK9C,4CAA4C;;;;;;;;;;;;;IAQ5C,iEAAiE;;;;;;;;;;;;;IAQjE,uEAAuE;;;;;;;;;;;;;IAKvE,sDAAsD;;;;;;;;;;;;;IAMtD,oEAAoE;;;;;;;;;;;;;IAMpE,+BAA+B;;;;;;;;;;;;;IAM/B,gDAAgD;;;;;;;;;;;;;IAOhD,6CAA6C;;;;;;;;;;;;;IAM7C,4CAA4C;;;;;;;;;;;;;IAO5C,0CAA0C;;;;;;;;;;;;;IAM1C,yCAAyC;;;;;;;;;;;;;IAKzC,gDAAgD;;;;;;;;;;;;;IAKhD,iCAAiC;;;;;;;;;;;;;IAKjC,+BAA+B;;;;;;;;;;;;;IAK/B,mCAAmC;;;;;;;;;;;;;CAKP,CAAC;AAEjC,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,KAAK,CAAC;AAQzC;;;GAGG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAM,GAAG,MAAM,CAS3G"}

package/package.json

@@ -1,6 +1,95 @@
 {
   "name": "@aparte/plugin-diff",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.7.0",
+  "homepage": "https://apartejs.dev/components/diff/",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "A diff view for aparté — a file change as hunks with old and new line numbers, in the reply or beside it, with comments on a line or a range.",
+  "customElements": "dist/custom-elements.json",
+  "type": "module",
+  "sideEffects": [
+    "./dist/*.js",
+    "./src/index.ts",
+    "./src/aparte-diff.ts"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@aparte-workspace/source": "./src/index.ts",
+      "node": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "worker": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "workerd": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "edge-light": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "deno": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "bun": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@aparte/core": ">=1.7.0 <2.0.0"
+  },
+  "devDependencies": {
+    "@custom-elements-manifest/analyzer": "^0.11.0",
+    "typescript": "^5.4.0",
+    "vite": "^6.0.0",
+    "@aparte/core": "1.7.0"
+  },
+  "keywords": [
+    "aparte",
+    "plugin",
+    "diff",
+    "unified-diff",
+    "code-review",
+    "patch",
+    "web-components"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apartejs/aparte.git",
+    "directory": "packages/plugins/diff"
+  },
+  "bugs": {
+    "url": "https://github.com/apartejs/aparte/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -b --emitDeclarationOnly --force && pnpm run analyze && node ../../../scripts/stamp-dist.mjs",
+    "analyze": "cem analyze",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
 }