@pierre/diffs 1.1.2 → 1.1.4

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["ElementContent","BundledLanguage","BundledTheme","CodeToHastOptions","DecorationItem","HighlighterGeneric","LanguageRegistration","ShikiTransformer","ThemedToken","ThemeRegistrationResolved","FileContents","SupportedLanguages","HighlighterTypes","DiffsThemeNames","ThemesType","Record","DiffsHighlighter","ChangeTypes","ParsedPatch","FileDiffMetadata","ContextContent","ChangeContent","Hunk","HunkLineType","ThemeTypes","HunkSeparators","LineDiffTypes","BaseCodeOptions","BaseDiffOptions","BaseDiffOptionsWithDefaults","Omit","Required","CustomPreProperties","PrePropertiesConfig","Pick","RenderHeaderMetadataProps","RenderHeaderMetadataCallback","Element","RenderHeaderPrefixCallback","RenderFileMetadata","ExtensionFormatMap","AnnotationSide","SelectionSide","OptionalMetadata","T","LineAnnotation","DiffLineAnnotation","MergeConflictResolution","MergeConflictRegion","MergeConflictActionPayload","GapSpan","LineSpans","AnnotationSpan","LineTypes","LineInfo","SharedRenderState","LineEventBaseProps","HTMLElement","DiffLineEventBaseProps","ObservedAnnotationNodes","ObservedGridNodes","CodeColumnType","HunkData","AnnotationLineMap","LAnnotation","ExpansionDirections","ThemedFileResult","RenderDiffFilesResult","ThemedDiffResult","HunkExpansionRegion","ForceDiffPlainTextOptions","Map","ForceFilePlainTextOptions","RenderFileOptions","RenderDiffOptions","RenderFileResult","RenderDiffResult","RenderedFileASTCache","RenderRange","RenderedDiffASTCache","RenderWindow","VirtualWindowSpecs","VirtualFileMetrics","SelectionPoint"],"sources":["../src/types.d.ts"],"sourcesContent":["import type { ElementContent } from 'hast';\nimport type { BundledLanguage, BundledTheme, CodeToHastOptions, DecorationItem, HighlighterGeneric, LanguageRegistration, ShikiTransformer, ThemedToken, ThemeRegistrationResolved } from 'shiki';\n/**\n * Represents a file's contents for generating diffs via `parseDiffFromFile` or\n * for when rendering a file directly using the File components\n */\nexport interface FileContents {\n    /** Filename used for display in headers and for inferring the language for\n     * syntax highlighting. */\n    name: string;\n    /** The raw text contents of the file. */\n    contents: string;\n    /** Explicitly set the syntax highlighting language instead of inferring from\n     * filename. Generally you should not be setting this. */\n    lang?: SupportedLanguages;\n    /** Optional header passed to the jsdiff library's `createTwoFilesPatch`. */\n    header?: string;\n    /** This unique key is only used for Worker Pools to avoid subsequent requests\n     * if we've already highlighted the file.  Please note that if you modify the\n     * `contents` or `name`, you must update the `cacheKey`. */\n    cacheKey?: string;\n}\nexport type HighlighterTypes = 'shiki-js' | 'shiki-wasm';\nexport type { BundledLanguage, CodeToHastOptions, DecorationItem, LanguageRegistration, ShikiTransformer, ThemeRegistrationResolved, ThemedToken, };\nexport type DiffsThemeNames = BundledTheme | 'pierre-dark' | 'pierre-light' | (string & {});\nexport type ThemesType = Record<'dark' | 'light', DiffsThemeNames>;\n/**\n * A Shiki highlighter instance configured with the library's supported\n * languages and themes. Used internally to generate syntax-highlighted AST\n * from file contents. By default diffs will ensure that only 1 highlighter is\n * instantiated per thread and shared for all syntax highlighting.  This\n * applies to the main thread and worker threads.\n */\nexport type DiffsHighlighter = HighlighterGeneric<SupportedLanguages, DiffsThemeNames>;\n/**\n * Describes the type of change for a file in a diff.\n * - `change`: File content was modified, name unchanged.\n * - `rename-pure`: File was renamed/moved without content changes (100% similarity).\n * - `rename-changed`: File was renamed/moved and content was also modified.\n * - `new`: A new file was added.\n * - `deleted`: An existing file was removed.\n */\nexport type ChangeTypes = 'change' | 'rename-pure' | 'rename-changed' | 'new' | 'deleted';\n/**\n * Represents a parsed patch file, typically corresponding to a single commit.\n * Returned by `parsePatchFiles` when parsing raw patch/diff strings.\n */\nexport interface ParsedPatch {\n    /** Optional raw introductory text before the file diffs that may have been\n     * included in the patch (e.g., commit message, author, date). */\n    patchMetadata?: string;\n    /** Array of file changes contained in the patch. */\n    files: FileDiffMetadata[];\n}\n/**\n * Represents a block of unchanged context lines within a hunk.  Basically a\n * batch of lines in a hunk that are prefixed with a space ` `.  Consecutive\n * lines prefixed with a ` ` are grouped together into a single ContextContent.\n */\nexport interface ContextContent {\n    type: 'context';\n    /** Number of unchanged lines in this context block. */\n    lines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where this context\n     * block starts.\n     */\n    additionLineIndex: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where this context\n     * block starts.\n     */\n    deletionLineIndex: number;\n}\n/**\n * Represents a block of changes (additions and/or deletions) within a hunk.\n * Consecutive `+` and `-` lines are grouped together into a single\n * ChangeContent.\n */\nexport interface ChangeContent {\n    type: 'change';\n    /** Number of lines prefixed with `-` in this change block. */\n    deletions: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where the deleted\n     * lines start.\n     */\n    deletionLineIndex: number;\n    /** Number of lines prefixed with `+` in this change block. */\n    additions: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where the added\n     * lines start.\n     */\n    additionLineIndex: number;\n}\n/**\n * Represents a single hunk from a diff, corresponding to\n * one `@@ ... @@` block.\n */\nexport interface Hunk {\n    /**\n     * Number of unchanged lines between the previous hunk (or file start) and\n     * this hunk.\n     */\n    collapsedBefore: number;\n    /**\n     * Starting line number in the new file version, parsed from the `+X`\n     * in the hunk header.\n     */\n    additionStart: number;\n    /**\n     * Total line count in the new file version for this hunk, parsed from\n     * `+X,count` in the hunk header.  If this hunk was viewed in `diffStyle:\n     * split` this would correspond to the number of lines in the right\n     * `additions` column.  It includes both `context` lines and lines\n     * prefixed with `+`.\n     */\n    additionCount: number;\n    /** This corresponds to the number of lines prefixed with `+` in this hunk. */\n    additionLines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where this hunk's\n     * content starts.\n     */\n    additionLineIndex: number;\n    /**\n     * Starting line number in the old file version, parsed from the `-X`\n     * in the hunk header.\n     */\n    deletionStart: number;\n    /**\n     * Total line count in the old file version for this hunk, parsed from\n     * `-X,count` in the hunk header.  If this hunk was viewed in `diffStyle:\n     * split` this would correspond to the number of lines in the left\n     * `deletions` column.  It includes both `context` lines and lines\n     * prefixed with `-`.\n     */\n    deletionCount: number;\n    /** This corresponds to the number of lines prefixed with `-` in this hunk. */\n    deletionLines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where this hunk's\n     * content starts.\n     */\n    deletionLineIndex: number;\n    /**\n     * Array of content segments within this hunk, each representing either\n     * a context line group or a change group.\n     */\n    hunkContent: (ContextContent | ChangeContent)[];\n    /**\n     * Function/method name that appears after the `@@` markers if it existed in\n     * the diff.\n     */\n    hunkContext?: string;\n    /** Raw hunk header string (e.g., `@@ -1,5 +1,7 @@`). */\n    hunkSpecs?: string;\n    /**\n     * Starting line index for this hunk when rendered in split (side-by-side)\n     * view.\n     */\n    splitLineStart: number;\n    /** Total rendered line count for this hunk in split view. */\n    splitLineCount: number;\n    /** Starting line index for this hunk when rendered in unified view. */\n    unifiedLineStart: number;\n    /** Total rendered line count for this hunk in unified view. */\n    unifiedLineCount: number;\n    /**\n     * True if the old file version has no trailing newline at end of file.  This\n     * is parsed from the patch file directly at the end of the hunk.  If the\n     * final hunkContent is a `context` group, then both values will be true or\n     * false together.  If it's from a `change` content group, then it may differ\n     * depending on the patch.\n     */\n    noEOFCRDeletions: boolean;\n    /**\n     * True if the new file version has no trailing newline at end of file.  This\n     * is parsed from the patch file directly at the end of the hunk.  If the\n     * final hunkContent is a `context` group, then both values will be true or\n     * false together.  If it's from a `change` content group, then it may differ\n     * depending on the patch.\n     */\n    noEOFCRAdditions: boolean;\n}\n/**\n * Metadata and content for a single file's diff.  Think of this as a JSON\n * compatible representation of a diff for a single file.\n */\nexport interface FileDiffMetadata {\n    /** The file's name and path. */\n    name: string;\n    /** Previous file path, present only if file was renamed or moved. */\n    prevName?: string;\n    /**\n     * Explicitly override the syntax highlighting language instead of inferring\n     * from filename.  This will never be set by default, since all internal diff\n     * APIs will attempt to detect the language automatically.  If you'd like to\n     * specify a language override, you can do so via the method `setLanguageOverride`\n     */\n    lang?: SupportedLanguages;\n    /**\n     * Object ID for the new file content parsed from the `index` line in a\n     * patch file.\n     */\n    newObjectId?: string;\n    /**\n     * Object ID for the previous file content parsed from the `index` line in a\n     * patch file.\n     */\n    prevObjectId?: string;\n    /**\n     * Git file mode parsed from the diff (e.g., `100644` for regular files) when\n     * present in the patch metadata.\n     */\n    mode?: string;\n    /** Previous git file mode, present if the mode changed. */\n    prevMode?: string;\n    /** The type of change for this file. */\n    type: ChangeTypes;\n    /** Array of diff hunks containing line-level change information.  Each hunk\n     * corresponds to a `@@ -X,X +X,X @@` group in a diff. */\n    hunks: Hunk[];\n    /** Pre-computed line size for this diff if rendered in `split` diffStyle. */\n    splitLineCount: number;\n    /** Pre-computed line size for this diff if rendered in `unified` diffStyle. */\n    unifiedLineCount: number;\n    /**\n     * Whether the diff was parsed from a patch file (true) or generated from\n     * full file contents (false).\n     *\n     * When true, `deletionLines`/`additionLines` contain only the lines present\n     * in the patch and hunk expansion is unavailable.\n     *\n     * When false, they contain the complete file contents.\n     */\n    isPartial: boolean;\n    /**\n     * Array of lines from previous version of the file. If `isPartial` is false,\n     * it means that `deletionLines` can be considered the entire contents of the\n     * old version of the file.  Otherwise `deletionLines` will just be an array\n     * of all the content processed from the `context` and `deletion` lines of\n     * the patch.\n     */\n    deletionLines: string[];\n    /**\n     * Array of lines from new version of the file. If `isPartial` is false, it\n     * means that `additionLines` can be considered the entire contents of the\n     * new version of the file.  Otherwise `additionLines` will just be an array\n     * of all the content processed from the `context` and `addition` lines of\n     * the patch.\n     */\n    additionLines: string[];\n    /**\n     * This unique key is only used for Worker Pools to avoid subsequent requests\n     * to highlight if we've already highlighted the diff.  Please note that if\n     * you modify the contents of the diff in any way, you will need to update\n     * the `cacheKey`.\n     */\n    cacheKey?: string;\n}\nexport type SupportedLanguages = BundledLanguage | 'text' | 'ansi' | (string & {});\nexport type HunkLineType = 'context' | 'expanded' | 'addition' | 'deletion' | 'metadata';\nexport type ThemeTypes = 'system' | 'light' | 'dark';\n/**\n * The `'custom'` variant is deprecated and will be removed in a future version.\n */\nexport type HunkSeparators = 'simple' | 'metadata' | 'line-info' | 'line-info-basic' | 'custom';\nexport type LineDiffTypes = 'word-alt' | 'word' | 'char' | 'none';\nexport interface BaseCodeOptions {\n    theme?: DiffsThemeNames | ThemesType;\n    disableLineNumbers?: boolean;\n    overflow?: 'scroll' | 'wrap';\n    themeType?: ThemeTypes;\n    collapsed?: boolean;\n    disableFileHeader?: boolean;\n    disableVirtualizationBuffers?: boolean;\n    preferredHighlighter?: HighlighterTypes;\n    useCSSClasses?: boolean;\n    tokenizeMaxLineLength?: number;\n    unsafeCSS?: string;\n}\nexport interface BaseDiffOptions extends BaseCodeOptions {\n    diffStyle?: 'unified' | 'split';\n    diffIndicators?: 'classic' | 'bars' | 'none';\n    disableBackground?: boolean;\n    hunkSeparators?: HunkSeparators;\n    expandUnchanged?: boolean;\n    collapsedContextThreshold?: number;\n    lineDiffType?: LineDiffTypes;\n    maxLineDiffLength?: number;\n    expansionLineCount?: number;\n}\nexport type BaseDiffOptionsWithDefaults = Required<Omit<BaseDiffOptions, 'unsafeCSS' | 'preferredHighlighter'>>;\nexport type CustomPreProperties = Record<string, string | number | undefined>;\nexport interface PrePropertiesConfig extends Required<Pick<BaseDiffOptions, 'diffIndicators' | 'disableBackground' | 'disableLineNumbers' | 'overflow' | 'themeType'>> {\n    type: 'diff' | 'file';\n    split: boolean;\n    themeStyles: string;\n    totalLines: number;\n    customProperties?: CustomPreProperties;\n}\nexport interface RenderHeaderMetadataProps {\n    deletionFile?: FileContents;\n    additionFile?: FileContents;\n    fileDiff?: FileDiffMetadata;\n}\nexport type RenderHeaderMetadataCallback = (props: RenderHeaderMetadataProps) => Element | null | undefined | string | number;\nexport type RenderHeaderPrefixCallback = (props: RenderHeaderMetadataProps) => Element | null | undefined | string | number;\nexport type RenderFileMetadata = (file: FileContents) => Element | null | undefined | string | number;\nexport type ExtensionFormatMap = Record<string, SupportedLanguages | undefined>;\nexport type AnnotationSide = 'deletions' | 'additions';\nexport type SelectionSide = 'deletions' | 'additions';\ntype OptionalMetadata<T> = T extends undefined ? {\n    metadata?: undefined;\n} : {\n    metadata: T;\n};\nexport type LineAnnotation<T = undefined> = {\n    lineNumber: number;\n} & OptionalMetadata<T>;\nexport type DiffLineAnnotation<T = undefined> = {\n    side: AnnotationSide;\n    lineNumber: number;\n} & OptionalMetadata<T>;\nexport type MergeConflictResolution = 'current' | 'incoming' | 'both';\nexport interface MergeConflictRegion {\n    conflictIndex: number;\n    startLineIndex: number;\n    startLineNumber: number;\n    separatorLineIndex: number;\n    separatorLineNumber: number;\n    endLineIndex: number;\n    endLineNumber: number;\n    baseMarkerLineIndex?: number;\n    baseMarkerLineNumber?: number;\n}\nexport interface MergeConflictActionPayload {\n    resolution: MergeConflictResolution;\n    conflict: MergeConflictRegion;\n}\nexport interface GapSpan {\n    type: 'gap';\n    rows: number;\n}\nexport type LineSpans = GapSpan | AnnotationSpan;\nexport type LineTypes = 'change-deletion' | 'change-addition' | 'context' | 'context-expanded';\nexport interface LineInfo {\n    type: LineTypes;\n    lineNumber: number;\n    altLineNumber?: number;\n    lineIndex: number | `${number},${number}`;\n}\nexport interface SharedRenderState {\n    lineInfo: (LineInfo | undefined)[] | ((shikiLineNumber: number) => LineInfo);\n}\nexport interface AnnotationSpan {\n    type: 'annotation';\n    hunkIndex: number;\n    lineIndex: number;\n    annotations: string[];\n}\nexport interface LineEventBaseProps {\n    type: 'line';\n    lineNumber: number;\n    lineElement: HTMLElement;\n    numberElement: HTMLElement;\n    numberColumn: boolean;\n}\nexport interface DiffLineEventBaseProps extends Omit<LineEventBaseProps, 'type'> {\n    type: 'diff-line';\n    annotationSide: AnnotationSide;\n    lineType: LineTypes;\n}\nexport interface ObservedAnnotationNodes {\n    type: 'annotations';\n    column1: {\n        container: HTMLElement;\n        child: HTMLElement;\n        childHeight: number;\n    };\n    column2: {\n        container: HTMLElement;\n        child: HTMLElement;\n        childHeight: number;\n    };\n    currentHeight: number | 'auto';\n}\nexport interface ObservedGridNodes {\n    type: 'code';\n    codeElement: HTMLElement;\n    numberElement: HTMLElement | null;\n    codeWidth: number | 'auto';\n    numberWidth: number;\n}\nexport type CodeColumnType = 'unified' | 'additions' | 'deletions';\nexport interface HunkData {\n    slotName: string;\n    hunkIndex: number;\n    lines: number;\n    type: CodeColumnType;\n    expandable?: {\n        chunked: boolean;\n        up: boolean;\n        down: boolean;\n    };\n}\nexport type AnnotationLineMap<LAnnotation> = Record<number, DiffLineAnnotation<LAnnotation>[] | undefined>;\nexport type ExpansionDirections = 'up' | 'down' | 'both';\nexport interface ThemedFileResult {\n    code: ElementContent[];\n    themeStyles: string;\n    baseThemeType: 'light' | 'dark' | undefined;\n}\nexport interface RenderDiffFilesResult {\n    deletionLines: ElementContent[];\n    additionLines: ElementContent[];\n}\nexport interface ThemedDiffResult {\n    code: RenderDiffFilesResult;\n    themeStyles: string;\n    baseThemeType: 'light' | 'dark' | undefined;\n}\nexport interface HunkExpansionRegion {\n    fromStart: number;\n    fromEnd: number;\n}\nexport interface ForceDiffPlainTextOptions {\n    forcePlainText: boolean;\n    startingLine?: number;\n    totalLines?: number;\n    expandedHunks?: Map<number, HunkExpansionRegion> | true;\n    collapsedContextThreshold?: number;\n}\nexport interface ForceFilePlainTextOptions {\n    forcePlainText: boolean;\n    startingLine?: number;\n    totalLines?: number;\n    lines?: string[];\n}\nexport interface RenderFileOptions {\n    theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;\n    tokenizeMaxLineLength: number;\n}\nexport interface RenderDiffOptions {\n    theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;\n    tokenizeMaxLineLength: number;\n    lineDiffType: LineDiffTypes;\n}\nexport interface RenderFileResult {\n    result: ThemedFileResult;\n    options: RenderFileOptions;\n}\nexport interface RenderDiffResult {\n    result: ThemedDiffResult;\n    options: RenderDiffOptions;\n}\nexport interface RenderedFileASTCache {\n    file: FileContents;\n    highlighted: boolean;\n    options: RenderFileOptions;\n    result: ThemedFileResult | undefined;\n    renderRange: RenderRange | undefined;\n}\nexport interface RenderedDiffASTCache {\n    diff: FileDiffMetadata;\n    highlighted: boolean;\n    options: RenderDiffOptions;\n    result: ThemedDiffResult | undefined;\n    renderRange: RenderRange | undefined;\n}\nexport interface RenderRange {\n    startingLine: number;\n    totalLines: number;\n    bufferBefore: number;\n    bufferAfter: number;\n}\nexport interface RenderWindow {\n    top: number;\n    bottom: number;\n}\nexport interface VirtualWindowSpecs {\n    top: number;\n    bottom: number;\n}\nexport interface VirtualFileMetrics {\n    hunkLineCount: number;\n    lineHeight: number;\n    diffHeaderHeight: number;\n    hunkSeparatorHeight: number;\n    fileGap: number;\n}\nexport interface SelectionPoint {\n    lineNumber: number;\n    side: SelectionSide | undefined;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":["ElementContent","BundledLanguage","BundledTheme","CodeToHastOptions","DecorationItem","HighlighterGeneric","LanguageRegistration","ShikiTransformer","ThemedToken","ThemeRegistrationResolved","FileContents","SupportedLanguages","HighlighterTypes","DiffsThemeNames","ThemesType","Record","DiffsHighlighter","ChangeTypes","ParsedPatch","FileDiffMetadata","ContextContent","ChangeContent","Hunk","MergeConflictMarkerRowType","MergeConflictMarkerRow","HunkLineType","ThemeTypes","HunkSeparators","LineDiffTypes","BaseCodeOptions","BaseDiffOptions","BaseDiffOptionsWithDefaults","Omit","Required","CustomPreProperties","PrePropertiesConfig","Pick","RenderHeaderMetadataProps","RenderHeaderMetadataCallback","Element","RenderHeaderPrefixCallback","RenderFileMetadata","ExtensionFormatMap","AnnotationSide","SelectionSide","OptionalMetadata","T","LineAnnotation","DiffLineAnnotation","MergeConflictResolution","MergeConflictRegion","MergeConflictActionPayload","GapSpan","LineSpans","AnnotationSpan","LineTypes","LineInfo","SharedRenderState","LineEventBaseProps","HTMLElement","DiffLineEventBaseProps","ObservedAnnotationNodes","ObservedGridNodes","CodeColumnType","HunkData","AnnotationLineMap","LAnnotation","ExpansionDirections","ThemedFileResult","RenderDiffFilesResult","ThemedDiffResult","HunkExpansionRegion","ForceDiffPlainTextOptions","Map","ForceFilePlainTextOptions","RenderFileOptions","RenderDiffOptions","RenderFileResult","RenderDiffResult","RenderedFileASTCache","RenderRange","RenderedDiffASTCache","RenderWindow","VirtualWindowSpecs","VirtualFileMetrics","SelectionPoint","DiffAcceptRejectHunkType","ConflictResolverTypes","DiffAcceptRejectHunkConfig","ProcessFileConflictData"],"sources":["../src/types.d.ts"],"sourcesContent":["import type { ElementContent } from 'hast';\nimport type { BundledLanguage, BundledTheme, CodeToHastOptions, DecorationItem, HighlighterGeneric, LanguageRegistration, ShikiTransformer, ThemedToken, ThemeRegistrationResolved } from 'shiki';\n/**\n * Represents a file's contents for generating diffs via `parseDiffFromFile` or\n * for when rendering a file directly using the File components\n */\nexport interface FileContents {\n    /** Filename used for display in headers and for inferring the language for\n     * syntax highlighting. */\n    name: string;\n    /** The raw text contents of the file. */\n    contents: string;\n    /** Explicitly set the syntax highlighting language instead of inferring from\n     * filename. Generally you should not be setting this. */\n    lang?: SupportedLanguages;\n    /** Optional header passed to the jsdiff library's `createTwoFilesPatch`. */\n    header?: string;\n    /** This unique key is only used for Worker Pools to avoid subsequent requests\n     * if we've already highlighted the file.  Please note that if you modify the\n     * `contents` or `name`, you must update the `cacheKey`. */\n    cacheKey?: string;\n}\nexport type HighlighterTypes = 'shiki-js' | 'shiki-wasm';\nexport type { BundledLanguage, CodeToHastOptions, DecorationItem, LanguageRegistration, ShikiTransformer, ThemeRegistrationResolved, ThemedToken, };\nexport type DiffsThemeNames = BundledTheme | 'pierre-dark' | 'pierre-light' | (string & {});\nexport type ThemesType = Record<'dark' | 'light', DiffsThemeNames>;\n/**\n * A Shiki highlighter instance configured with the library's supported\n * languages and themes. Used internally to generate syntax-highlighted AST\n * from file contents. By default diffs will ensure that only 1 highlighter is\n * instantiated per thread and shared for all syntax highlighting.  This\n * applies to the main thread and worker threads.\n */\nexport type DiffsHighlighter = HighlighterGeneric<SupportedLanguages, DiffsThemeNames>;\n/**\n * Describes the type of change for a file in a diff.\n * - `change`: File content was modified, name unchanged.\n * - `rename-pure`: File was renamed/moved without content changes (100% similarity).\n * - `rename-changed`: File was renamed/moved and content was also modified.\n * - `new`: A new file was added.\n * - `deleted`: An existing file was removed.\n */\nexport type ChangeTypes = 'change' | 'rename-pure' | 'rename-changed' | 'new' | 'deleted';\n/**\n * Represents a parsed patch file, typically corresponding to a single commit.\n * Returned by `parsePatchFiles` when parsing raw patch/diff strings.\n */\nexport interface ParsedPatch {\n    /** Optional raw introductory text before the file diffs that may have been\n     * included in the patch (e.g., commit message, author, date). */\n    patchMetadata?: string;\n    /** Array of file changes contained in the patch. */\n    files: FileDiffMetadata[];\n}\n/**\n * Represents a block of unchanged context lines within a hunk.  Basically a\n * batch of lines in a hunk that are prefixed with a space ` `.  Consecutive\n * lines prefixed with a ` ` are grouped together into a single ContextContent.\n */\nexport interface ContextContent {\n    type: 'context';\n    /** Number of unchanged lines in this context block. */\n    lines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where this context\n     * block starts.\n     */\n    additionLineIndex: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where this context\n     * block starts.\n     */\n    deletionLineIndex: number;\n}\n/**\n * Represents a block of changes (additions and/or deletions) within a hunk.\n * Consecutive `+` and `-` lines are grouped together into a single\n * ChangeContent.\n */\nexport interface ChangeContent {\n    type: 'change';\n    /** Number of lines prefixed with `-` in this change block. */\n    deletions: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where the deleted\n     * lines start.\n     */\n    deletionLineIndex: number;\n    /** Number of lines prefixed with `+` in this change block. */\n    additions: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where the added\n     * lines start.\n     */\n    additionLineIndex: number;\n}\n/**\n * Represents a single hunk from a diff, corresponding to\n * one `@@ ... @@` block.\n */\nexport interface Hunk {\n    /**\n     * Number of unchanged lines between the previous hunk (or file start) and\n     * this hunk.\n     */\n    collapsedBefore: number;\n    /**\n     * Starting line number in the new file version, parsed from the `+X`\n     * in the hunk header.\n     */\n    additionStart: number;\n    /**\n     * Total line count in the new file version for this hunk, parsed from\n     * `+X,count` in the hunk header.  If this hunk was viewed in `diffStyle:\n     * split` this would correspond to the number of lines in the right\n     * `additions` column.  It includes both `context` lines and lines\n     * prefixed with `+`.\n     */\n    additionCount: number;\n    /** This corresponds to the number of lines prefixed with `+` in this hunk. */\n    additionLines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.additionLines` where this hunk's\n     * content starts.\n     */\n    additionLineIndex: number;\n    /**\n     * Starting line number in the old file version, parsed from the `-X`\n     * in the hunk header.\n     */\n    deletionStart: number;\n    /**\n     * Total line count in the old file version for this hunk, parsed from\n     * `-X,count` in the hunk header.  If this hunk was viewed in `diffStyle:\n     * split` this would correspond to the number of lines in the left\n     * `deletions` column.  It includes both `context` lines and lines\n     * prefixed with `-`.\n     */\n    deletionCount: number;\n    /** This corresponds to the number of lines prefixed with `-` in this hunk. */\n    deletionLines: number;\n    /**\n     * Zero-based index into `FileDiffMetadata.deletionLines` where this hunk's\n     * content starts.\n     */\n    deletionLineIndex: number;\n    /**\n     * Array of content segments within this hunk, each representing either\n     * a context line group or a change group.\n     */\n    hunkContent: (ContextContent | ChangeContent)[];\n    /**\n     * Function/method name that appears after the `@@` markers if it existed in\n     * the diff.\n     */\n    hunkContext?: string;\n    /** Raw hunk header string (e.g., `@@ -1,5 +1,7 @@`). */\n    hunkSpecs?: string;\n    /**\n     * Starting line index for this hunk when rendered in split (side-by-side)\n     * view.\n     */\n    splitLineStart: number;\n    /** Total rendered line count for this hunk in split view. */\n    splitLineCount: number;\n    /** Starting line index for this hunk when rendered in unified view. */\n    unifiedLineStart: number;\n    /** Total rendered line count for this hunk in unified view. */\n    unifiedLineCount: number;\n    /**\n     * True if the old file version has no trailing newline at end of file.  This\n     * is parsed from the patch file directly at the end of the hunk.  If the\n     * final hunkContent is a `context` group, then both values will be true or\n     * false together.  If it's from a `change` content group, then it may differ\n     * depending on the patch.\n     */\n    noEOFCRDeletions: boolean;\n    /**\n     * True if the new file version has no trailing newline at end of file.  This\n     * is parsed from the patch file directly at the end of the hunk.  If the\n     * final hunkContent is a `context` group, then both values will be true or\n     * false together.  If it's from a `change` content group, then it may differ\n     * depending on the patch.\n     */\n    noEOFCRAdditions: boolean;\n}\n/**\n * Metadata and content for a single file's diff.  Think of this as a JSON\n * compatible representation of a diff for a single file.\n */\nexport interface FileDiffMetadata {\n    /** The file's name and path. */\n    name: string;\n    /** Previous file path, present only if file was renamed or moved. */\n    prevName?: string;\n    /**\n     * Explicitly override the syntax highlighting language instead of inferring\n     * from filename.  This will never be set by default, since all internal diff\n     * APIs will attempt to detect the language automatically.  If you'd like to\n     * specify a language override, you can do so via the method `setLanguageOverride`\n     */\n    lang?: SupportedLanguages;\n    /**\n     * Object ID for the new file content parsed from the `index` line in a\n     * patch file.\n     */\n    newObjectId?: string;\n    /**\n     * Object ID for the previous file content parsed from the `index` line in a\n     * patch file.\n     */\n    prevObjectId?: string;\n    /**\n     * Git file mode parsed from the diff (e.g., `100644` for regular files) when\n     * present in the patch metadata.\n     */\n    mode?: string;\n    /** Previous git file mode, present if the mode changed. */\n    prevMode?: string;\n    /** The type of change for this file. */\n    type: ChangeTypes;\n    /** Array of diff hunks containing line-level change information.  Each hunk\n     * corresponds to a `@@ -X,X +X,X @@` group in a diff. */\n    hunks: Hunk[];\n    /** Pre-computed line size for this diff if rendered in `split` diffStyle. */\n    splitLineCount: number;\n    /** Pre-computed line size for this diff if rendered in `unified` diffStyle. */\n    unifiedLineCount: number;\n    /**\n     * Whether the diff was parsed from a patch file (true) or generated from\n     * full file contents (false).\n     *\n     * When true, `deletionLines`/`additionLines` contain only the lines present\n     * in the patch and hunk expansion is unavailable.\n     *\n     * When false, they contain the complete file contents.\n     */\n    isPartial: boolean;\n    /**\n     * Array of lines from previous version of the file. If `isPartial` is false,\n     * it means that `deletionLines` can be considered the entire contents of the\n     * old version of the file.  Otherwise `deletionLines` will just be an array\n     * of all the content processed from the `context` and `deletion` lines of\n     * the patch.\n     */\n    deletionLines: string[];\n    /**\n     * Array of lines from new version of the file. If `isPartial` is false, it\n     * means that `additionLines` can be considered the entire contents of the\n     * new version of the file.  Otherwise `additionLines` will just be an array\n     * of all the content processed from the `context` and `addition` lines of\n     * the patch.\n     */\n    additionLines: string[];\n    /**\n     * This unique key is only used for Worker Pools to avoid subsequent requests\n     * to highlight if we've already highlighted the diff.  Please note that if\n     * you modify the contents of the diff in any way, you will need to update\n     * the `cacheKey`.\n     */\n    cacheKey?: string;\n}\nexport type MergeConflictMarkerRowType = 'marker-start' | 'marker-base' | 'marker-separator' | 'marker-end';\nexport interface MergeConflictMarkerRow {\n    type: MergeConflictMarkerRowType;\n    hunkIndex: number;\n    /** Index into `hunk.hunkContent` for the structural block this row belongs to. */\n    contentIndex: number;\n    conflictIndex: number;\n    lineText: string;\n    /** Unified rendered-row index where this virtual row should be injected. */\n    lineIndex: number;\n}\nexport type SupportedLanguages = BundledLanguage | 'text' | 'ansi' | (string & {});\nexport type HunkLineType = 'context' | 'expanded' | 'addition' | 'deletion' | 'metadata';\nexport type ThemeTypes = 'system' | 'light' | 'dark';\n/**\n * The `'custom'` variant is deprecated and will be removed in a future version.\n */\nexport type HunkSeparators = 'simple' | 'metadata' | 'line-info' | 'line-info-basic' | 'custom';\nexport type LineDiffTypes = 'word-alt' | 'word' | 'char' | 'none';\nexport interface BaseCodeOptions {\n    theme?: DiffsThemeNames | ThemesType;\n    disableLineNumbers?: boolean;\n    overflow?: 'scroll' | 'wrap';\n    themeType?: ThemeTypes;\n    collapsed?: boolean;\n    disableFileHeader?: boolean;\n    disableVirtualizationBuffers?: boolean;\n    preferredHighlighter?: HighlighterTypes;\n    useCSSClasses?: boolean;\n    tokenizeMaxLineLength?: number;\n    unsafeCSS?: string;\n}\nexport interface BaseDiffOptions extends BaseCodeOptions {\n    diffStyle?: 'unified' | 'split';\n    diffIndicators?: 'classic' | 'bars' | 'none';\n    disableBackground?: boolean;\n    hunkSeparators?: HunkSeparators;\n    expandUnchanged?: boolean;\n    collapsedContextThreshold?: number;\n    lineDiffType?: LineDiffTypes;\n    maxLineDiffLength?: number;\n    expansionLineCount?: number;\n}\nexport type BaseDiffOptionsWithDefaults = Required<Omit<BaseDiffOptions, 'unsafeCSS' | 'preferredHighlighter'>>;\nexport type CustomPreProperties = Record<string, string | number | undefined>;\nexport interface PrePropertiesConfig extends Required<Pick<BaseDiffOptions, 'diffIndicators' | 'disableBackground' | 'disableLineNumbers' | 'overflow' | 'themeType'>> {\n    type: 'diff' | 'file';\n    split: boolean;\n    themeStyles: string;\n    totalLines: number;\n    customProperties?: CustomPreProperties;\n}\nexport interface RenderHeaderMetadataProps {\n    deletionFile?: FileContents;\n    additionFile?: FileContents;\n    fileDiff?: FileDiffMetadata;\n}\nexport type RenderHeaderMetadataCallback = (props: RenderHeaderMetadataProps) => Element | null | undefined | string | number;\nexport type RenderHeaderPrefixCallback = (props: RenderHeaderMetadataProps) => Element | null | undefined | string | number;\nexport type RenderFileMetadata = (file: FileContents) => Element | null | undefined | string | number;\nexport type ExtensionFormatMap = Record<string, SupportedLanguages | undefined>;\nexport type AnnotationSide = 'deletions' | 'additions';\nexport type SelectionSide = 'deletions' | 'additions';\ntype OptionalMetadata<T> = T extends undefined ? {\n    metadata?: undefined;\n} : {\n    metadata: T;\n};\nexport type LineAnnotation<T = undefined> = {\n    lineNumber: number;\n} & OptionalMetadata<T>;\nexport type DiffLineAnnotation<T = undefined> = {\n    side: AnnotationSide;\n    lineNumber: number;\n} & OptionalMetadata<T>;\nexport type MergeConflictResolution = 'current' | 'incoming' | 'both';\nexport interface MergeConflictRegion {\n    conflictIndex: number;\n    startLineIndex: number;\n    startLineNumber: number;\n    separatorLineIndex: number;\n    separatorLineNumber: number;\n    endLineIndex: number;\n    endLineNumber: number;\n    baseMarkerLineIndex?: number;\n    baseMarkerLineNumber?: number;\n}\nexport interface MergeConflictActionPayload {\n    resolution: MergeConflictResolution;\n    conflict: MergeConflictRegion;\n}\nexport interface GapSpan {\n    type: 'gap';\n    rows: number;\n}\nexport type LineSpans = GapSpan | AnnotationSpan;\nexport type LineTypes = 'change-deletion' | 'change-addition' | 'context' | 'context-expanded';\nexport interface LineInfo {\n    type: LineTypes;\n    lineNumber: number;\n    altLineNumber?: number;\n    lineIndex: number | `${number},${number}`;\n}\nexport interface SharedRenderState {\n    lineInfo: (LineInfo | undefined)[] | ((shikiLineNumber: number) => LineInfo);\n}\nexport interface AnnotationSpan {\n    type: 'annotation';\n    hunkIndex: number;\n    lineIndex: number;\n    annotations: string[];\n}\nexport interface LineEventBaseProps {\n    type: 'line';\n    lineNumber: number;\n    lineElement: HTMLElement;\n    numberElement: HTMLElement;\n    numberColumn: boolean;\n}\nexport interface DiffLineEventBaseProps extends Omit<LineEventBaseProps, 'type'> {\n    type: 'diff-line';\n    annotationSide: AnnotationSide;\n    lineType: LineTypes;\n}\nexport interface ObservedAnnotationNodes {\n    type: 'annotations';\n    column1: {\n        container: HTMLElement;\n        child: HTMLElement;\n        childHeight: number;\n    };\n    column2: {\n        container: HTMLElement;\n        child: HTMLElement;\n        childHeight: number;\n    };\n    currentHeight: number | 'auto';\n}\nexport interface ObservedGridNodes {\n    type: 'code';\n    codeElement: HTMLElement;\n    numberElement: HTMLElement | null;\n    codeWidth: number | 'auto';\n    numberWidth: number;\n}\nexport type CodeColumnType = 'unified' | 'additions' | 'deletions';\nexport interface HunkData {\n    slotName: string;\n    hunkIndex: number;\n    lines: number;\n    type: CodeColumnType;\n    expandable?: {\n        chunked: boolean;\n        up: boolean;\n        down: boolean;\n    };\n}\nexport type AnnotationLineMap<LAnnotation> = Record<number, DiffLineAnnotation<LAnnotation>[] | undefined>;\nexport type ExpansionDirections = 'up' | 'down' | 'both';\nexport interface ThemedFileResult {\n    code: ElementContent[];\n    themeStyles: string;\n    baseThemeType: 'light' | 'dark' | undefined;\n}\nexport interface RenderDiffFilesResult {\n    deletionLines: ElementContent[];\n    additionLines: ElementContent[];\n}\nexport interface ThemedDiffResult {\n    code: RenderDiffFilesResult;\n    themeStyles: string;\n    baseThemeType: 'light' | 'dark' | undefined;\n}\nexport interface HunkExpansionRegion {\n    fromStart: number;\n    fromEnd: number;\n}\nexport interface ForceDiffPlainTextOptions {\n    forcePlainText: boolean;\n    startingLine?: number;\n    totalLines?: number;\n    expandedHunks?: Map<number, HunkExpansionRegion> | true;\n    collapsedContextThreshold?: number;\n}\nexport interface ForceFilePlainTextOptions {\n    forcePlainText: boolean;\n    startingLine?: number;\n    totalLines?: number;\n    lines?: string[];\n}\nexport interface RenderFileOptions {\n    theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;\n    tokenizeMaxLineLength: number;\n}\nexport interface RenderDiffOptions {\n    theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;\n    tokenizeMaxLineLength: number;\n    lineDiffType: LineDiffTypes;\n}\nexport interface RenderFileResult {\n    result: ThemedFileResult;\n    options: RenderFileOptions;\n}\nexport interface RenderDiffResult {\n    result: ThemedDiffResult;\n    options: RenderDiffOptions;\n}\nexport interface RenderedFileASTCache {\n    file: FileContents;\n    highlighted: boolean;\n    options: RenderFileOptions;\n    result: ThemedFileResult | undefined;\n    renderRange: RenderRange | undefined;\n}\nexport interface RenderedDiffASTCache {\n    diff: FileDiffMetadata;\n    highlighted: boolean;\n    options: RenderDiffOptions;\n    result: ThemedDiffResult | undefined;\n    renderRange: RenderRange | undefined;\n}\nexport interface RenderRange {\n    startingLine: number;\n    totalLines: number;\n    bufferBefore: number;\n    bufferAfter: number;\n}\nexport interface RenderWindow {\n    top: number;\n    bottom: number;\n}\nexport interface VirtualWindowSpecs {\n    top: number;\n    bottom: number;\n}\nexport interface VirtualFileMetrics {\n    hunkLineCount: number;\n    lineHeight: number;\n    diffHeaderHeight: number;\n    hunkSeparatorHeight: number;\n    fileGap: number;\n}\nexport interface SelectionPoint {\n    lineNumber: number;\n    side: SelectionSide | undefined;\n}\nexport type DiffAcceptRejectHunkType = 'accept' | 'reject' | 'both';\nexport type ConflictResolverTypes = 'current' | 'incoming' | 'both';\nexport interface DiffAcceptRejectHunkConfig {\n    type: DiffAcceptRejectHunkType;\n    changeIndex: number;\n}\n/**\n * Unresolved merge conflict indexes use three different coordinate spaces:\n * - source line indexes live on `conflict.*LineIndex`\n * - hunk-content indexes live on the fields below, with `startContentIndex`\n *   serving as both the conflict-range start and the start-marker anchor\n * - rendered row indexes live on unresolved `markerRows`\n */\nexport interface ProcessFileConflictData {\n    /** Index of the hunk that owns this unresolved conflict. */\n    hunkIndex: number;\n    /** First hunk-content entry that belongs to the conflict region. */\n    startContentIndex: number;\n    /** Last hunk-content entry that belongs to the conflict region. */\n    endContentIndex: number;\n    /** Hunk-content index for the current/ours change block. */\n    currentContentIndex?: number;\n    /** Hunk-content index for the optional base context block. */\n    baseContentIndex?: number;\n    /** Hunk-content index for the incoming/theirs change block. */\n    incomingContentIndex?: number;\n    /** Hunk-content index that anchors the end marker row. */\n    endMarkerContentIndex: number;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}

package/dist/utils/areMergeConflictActionsEqual.js

@@ -1,6 +1,6 @@
 //#region src/utils/areMergeConflictActionsEqual.ts
 function areMergeConflictActionsEqual(a, b) {
-	return a.actionOriginalLineIndex === b.actionOriginalLineIndex && a.actionOriginalLineNumber === b.actionOriginalLineNumber && a.currentLineNumber === b.currentLineNumber && a.incomingLineNumber === b.incomingLineNumber && a.conflictIndex === b.conflictIndex && areConflictsEqual(a.conflict, b.conflict);
+	return a.hunkIndex === b.hunkIndex && a.startContentIndex === b.startContentIndex && a.endContentIndex === b.endContentIndex && a.currentContentIndex === b.currentContentIndex && a.baseContentIndex === b.baseContentIndex && a.incomingContentIndex === b.incomingContentIndex && a.endMarkerContentIndex === b.endMarkerContentIndex && a.conflictIndex === b.conflictIndex && areConflictsEqual(a.conflict, b.conflict);
 }
 function areConflictsEqual(a, b) {
 	return a.conflictIndex === b.conflictIndex && a.startLineIndex === b.startLineIndex && a.startLineNumber === b.startLineNumber && a.separatorLineIndex === b.separatorLineIndex && a.separatorLineNumber === b.separatorLineNumber && a.endLineIndex === b.endLineIndex && a.endLineNumber === b.endLineNumber && a.baseMarkerLineIndex === b.baseMarkerLineIndex && a.baseMarkerLineNumber === b.baseMarkerLineNumber;

package/dist/utils/areMergeConflictActionsEqual.js.map

@@ -1 +1 @@
-{"version":3,"file":"areMergeConflictActionsEqual.js","names":[],"sources":["../../src/utils/areMergeConflictActionsEqual.ts"],"sourcesContent":["import type { MergeConflictRegion } from '../types';\nimport type { MergeConflictDiffAction } from './parseMergeConflictDiffFromFile';\n\nexport function areMergeConflictActionsEqual(\n  a: MergeConflictDiffAction,\n  b: MergeConflictDiffAction\n): boolean {\n  return (\n    a.actionOriginalLineIndex === b.actionOriginalLineIndex &&\n    a.actionOriginalLineNumber === b.actionOriginalLineNumber &&\n    a.currentLineNumber === b.currentLineNumber &&\n    a.incomingLineNumber === b.incomingLineNumber &&\n    a.conflictIndex === b.conflictIndex &&\n    areConflictsEqual(a.conflict, b.conflict)\n  );\n}\n\nfunction areConflictsEqual(a: MergeConflictRegion, b: MergeConflictRegion) {\n  return (\n    a.conflictIndex === b.conflictIndex &&\n    a.startLineIndex === b.startLineIndex &&\n    a.startLineNumber === b.startLineNumber &&\n    a.separatorLineIndex === b.separatorLineIndex &&\n    a.separatorLineNumber === b.separatorLineNumber &&\n    a.endLineIndex === b.endLineIndex &&\n    a.endLineNumber === b.endLineNumber &&\n    a.baseMarkerLineIndex === b.baseMarkerLineIndex &&\n    a.baseMarkerLineNumber === b.baseMarkerLineNumber\n  );\n}\n"],"mappings":";AAGA,SAAgB,6BACd,GACA,GACS;AACT,QACE,EAAE,4BAA4B,EAAE,2BAChC,EAAE,6BAA6B,EAAE,4BACjC,EAAE,sBAAsB,EAAE,qBAC1B,EAAE,uBAAuB,EAAE,sBAC3B,EAAE,kBAAkB,EAAE,iBACtB,kBAAkB,EAAE,UAAU,EAAE,SAAS;;AAI7C,SAAS,kBAAkB,GAAwB,GAAwB;AACzE,QACE,EAAE,kBAAkB,EAAE,iBACtB,EAAE,mBAAmB,EAAE,kBACvB,EAAE,oBAAoB,EAAE,mBACxB,EAAE,uBAAuB,EAAE,sBAC3B,EAAE,wBAAwB,EAAE,uBAC5B,EAAE,iBAAiB,EAAE,gBACrB,EAAE,kBAAkB,EAAE,iBACtB,EAAE,wBAAwB,EAAE,uBAC5B,EAAE,yBAAyB,EAAE"}
+{"version":3,"file":"areMergeConflictActionsEqual.js","names":[],"sources":["../../src/utils/areMergeConflictActionsEqual.ts"],"sourcesContent":["import type { MergeConflictRegion } from '../types';\nimport type { MergeConflictDiffAction } from './parseMergeConflictDiffFromFile';\n\nexport function areMergeConflictActionsEqual(\n  a: MergeConflictDiffAction,\n  b: MergeConflictDiffAction\n): boolean {\n  return (\n    a.hunkIndex === b.hunkIndex &&\n    a.startContentIndex === b.startContentIndex &&\n    a.endContentIndex === b.endContentIndex &&\n    a.currentContentIndex === b.currentContentIndex &&\n    a.baseContentIndex === b.baseContentIndex &&\n    a.incomingContentIndex === b.incomingContentIndex &&\n    a.endMarkerContentIndex === b.endMarkerContentIndex &&\n    a.conflictIndex === b.conflictIndex &&\n    areConflictsEqual(a.conflict, b.conflict)\n  );\n}\n\nfunction areConflictsEqual(a: MergeConflictRegion, b: MergeConflictRegion) {\n  return (\n    a.conflictIndex === b.conflictIndex &&\n    a.startLineIndex === b.startLineIndex &&\n    a.startLineNumber === b.startLineNumber &&\n    a.separatorLineIndex === b.separatorLineIndex &&\n    a.separatorLineNumber === b.separatorLineNumber &&\n    a.endLineIndex === b.endLineIndex &&\n    a.endLineNumber === b.endLineNumber &&\n    a.baseMarkerLineIndex === b.baseMarkerLineIndex &&\n    a.baseMarkerLineNumber === b.baseMarkerLineNumber\n  );\n}\n"],"mappings":";AAGA,SAAgB,6BACd,GACA,GACS;AACT,QACE,EAAE,cAAc,EAAE,aAClB,EAAE,sBAAsB,EAAE,qBAC1B,EAAE,oBAAoB,EAAE,mBACxB,EAAE,wBAAwB,EAAE,uBAC5B,EAAE,qBAAqB,EAAE,oBACzB,EAAE,yBAAyB,EAAE,wBAC7B,EAAE,0BAA0B,EAAE,yBAC9B,EAAE,kBAAkB,EAAE,iBACtB,kBAAkB,EAAE,UAAU,EAAE,SAAS;;AAI7C,SAAS,kBAAkB,GAAwB,GAAwB;AACzE,QACE,EAAE,kBAAkB,EAAE,iBACtB,EAAE,mBAAmB,EAAE,kBACvB,EAAE,oBAAoB,EAAE,mBACxB,EAAE,uBAAuB,EAAE,sBAC3B,EAAE,wBAAwB,EAAE,uBAC5B,EAAE,iBAAiB,EAAE,gBACrB,EAAE,kBAAkB,EAAE,iBACtB,EAAE,wBAAwB,EAAE,uBAC5B,EAAE,yBAAyB,EAAE"}

package/dist/utils/diffAcceptRejectHunk.d.ts

@@ -1,7 +1,8 @@
-import { FileDiffMetadata } from "../types.js";
+import { DiffAcceptRejectHunkConfig, DiffAcceptRejectHunkType, FileDiffMetadata } from "../types.js";
 
 //#region src/utils/diffAcceptRejectHunk.d.ts
-declare function diffAcceptRejectHunk(diff: FileDiffMetadata, hunkIndex: number, type: 'accept' | 'reject'): FileDiffMetadata;
+type DiffAcceptRejectHunkOptions = DiffAcceptRejectHunkType | DiffAcceptRejectHunkConfig;
+declare function diffAcceptRejectHunk(diff: FileDiffMetadata, hunkIndex: number, options: DiffAcceptRejectHunkOptions): FileDiffMetadata;
 //#endregion
 export { diffAcceptRejectHunk };
 //# sourceMappingURL=diffAcceptRejectHunk.d.ts.map

package/dist/utils/diffAcceptRejectHunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diffAcceptRejectHunk.d.ts","names":["FileDiffMetadata","diffAcceptRejectHunk"],"sources":["../../src/utils/diffAcceptRejectHunk.d.ts"],"sourcesContent":["import type { FileDiffMetadata } from '../types';\nexport declare function diffAcceptRejectHunk(diff: FileDiffMetadata, hunkIndex: number, type: 'accept' | 'reject'): FileDiffMetadata;\n//# sourceMappingURL=diffAcceptRejectHunk.d.ts.map"],"mappings":";;;iBACwBC,oBAAAA,OAA2BD,iEAAiEA"}
+{"version":3,"file":"diffAcceptRejectHunk.d.ts","names":["DiffAcceptRejectHunkConfig","DiffAcceptRejectHunkType","FileDiffMetadata","DiffAcceptRejectHunkOptions","diffAcceptRejectHunk"],"sources":["../../src/utils/diffAcceptRejectHunk.d.ts"],"sourcesContent":["import type { DiffAcceptRejectHunkConfig, DiffAcceptRejectHunkType, FileDiffMetadata } from '../types';\ntype DiffAcceptRejectHunkOptions = DiffAcceptRejectHunkType | DiffAcceptRejectHunkConfig;\nexport declare function diffAcceptRejectHunk(diff: FileDiffMetadata, hunkIndex: number, options: DiffAcceptRejectHunkOptions): FileDiffMetadata;\nexport {};\n//# sourceMappingURL=diffAcceptRejectHunk.d.ts.map"],"mappings":";;;KACKG,2BAAAA,GAA8BF,2BAA2BD;iBACtCI,oBAAAA,OAA2BF,8CAA8CC,8BAA8BD"}

package/dist/utils/diffAcceptRejectHunk.js

@@ -1,95 +1,30 @@
+import { normalizeDiffResolution } from "./normalizeDiffResolution.js";
+import { resolveRegion } from "./resolveRegion.js";
+
 //#region src/utils/diffAcceptRejectHunk.ts
-function diffAcceptRejectHunk(diff, hunkIndex, type) {
-	diff = {
-		...diff,
-		hunks: [...diff.hunks],
-		deletionLines: type === "accept" ? [...diff.deletionLines] : diff.deletionLines,
-		additionLines: type === "reject" ? [...diff.additionLines] : diff.additionLines,
-		cacheKey: diff.cacheKey != null ? `${diff.cacheKey}:${type[0]}-${hunkIndex}` : void 0
-	};
-	const { additionLines, deletionLines } = diff;
-	if (additionLines != null && deletionLines != null) {
-		const hunk = diff.hunks[hunkIndex];
-		if (hunk == null) {
-			console.error({
-				diff,
-				hunkIndex
-			});
-			throw new Error(`diffResolveRejectHunk: Invalid hunk index: ${hunkIndex}`);
-		}
-		if (type === "reject") additionLines.splice(hunk.additionLineIndex, hunk.additionCount, ...deletionLines.slice(hunk.deletionLineIndex, hunk.deletionLineIndex + hunk.deletionCount));
-		else deletionLines.splice(hunk.deletionLineIndex, hunk.deletionCount, ...additionLines.slice(hunk.additionLineIndex, hunk.additionLineIndex + hunk.additionCount));
+function diffAcceptRejectHunk(diff, hunkIndex, options) {
+	const hunk = diff.hunks[hunkIndex];
+	if (hunk == null) {
+		console.error({
+			hunkIndex,
+			diff
+		});
+		throw new Error("diffAcceptRejectHunk: Invalid hunk index");
 	}
-	let deletionOffset = 0;
-	let additionOffset = 0;
-	let splitOffset = 0;
-	let unifiedOffset = 0;
-	for (let i = hunkIndex; i < diff.hunks.length; i++) {
-		let hunk = diff.hunks[i];
-		if (hunk == null) {
-			console.error({
-				hunk,
-				i,
-				hunkIndex,
-				diff
-			});
-			throw new Error("diffResolveRejectHunk: iterating through hunks, hunk doesnt exist...");
-		}
-		const { noEOFCRAdditions, noEOFCRDeletions } = hunk;
-		diff.hunks[i] = hunk = { ...hunk };
-		if (i === hunkIndex) {
-			hunk.noEOFCRDeletions = false;
-			hunk.noEOFCRAdditions = false;
-			if (type === "accept" && noEOFCRAdditions || type === "reject" && noEOFCRDeletions) {
-				hunk.noEOFCRAdditions = true;
-				hunk.noEOFCRDeletions = true;
-			}
-			const newContent = {
-				type: "context",
-				lines: 0,
-				additionLineIndex: hunk.additionLineIndex,
-				deletionLineIndex: hunk.deletionLineIndex
+	return resolveRegion(diff, {
+		resolution: normalizeDiffResolution(options),
+		hunkIndex,
+		...(() => {
+			if (typeof options === "object") return {
+				startContentIndex: options.changeIndex,
+				endContentIndex: options.changeIndex
 			};
-			for (const content of hunk.hunkContent) if (content.type === "context") newContent.lines += content.lines;
-			else if (type === "accept") newContent.lines += content.additions;
-			else if (type === "reject") newContent.lines += content.deletions;
-			const lineCount = newContent.lines;
-			hunk.hunkContent = [newContent];
-			splitOffset = lineCount - hunk.splitLineCount;
-			hunk.splitLineCount = lineCount;
-			unifiedOffset = lineCount - hunk.unifiedLineCount;
-			hunk.unifiedLineCount = lineCount;
-			deletionOffset = lineCount - hunk.deletionCount;
-			hunk.deletionCount = lineCount;
-			hunk.deletionLines = 0;
-			additionOffset = lineCount - hunk.additionCount;
-			hunk.additionCount = lineCount;
-			hunk.additionLines = 0;
-			diff.splitLineCount += splitOffset;
-			diff.unifiedLineCount += unifiedOffset;
-			if (splitOffset === 0 && unifiedOffset === 0 && additionOffset === 0 && deletionOffset === 0) break;
-		} else {
-			hunk.splitLineStart += splitOffset;
-			hunk.unifiedLineStart += unifiedOffset;
-			hunk.additionStart += additionOffset;
-			hunk.additionLineIndex += additionOffset;
-			hunk.deletionLineIndex += deletionOffset;
-			hunk.deletionStart += deletionOffset;
-			if (deletionOffset !== 0 || additionOffset !== 0) {
-				let i$1 = 0;
-				while (i$1 < hunk.hunkContent.length) {
-					const content = hunk.hunkContent[i$1];
-					hunk.hunkContent[i$1] = {
-						...content,
-						additionLineIndex: content.additionLineIndex + additionOffset,
-						deletionLineIndex: content.deletionLineIndex + deletionOffset
-					};
-					i$1++;
-				}
-			}
-		}
-	}
-	return diff;
+			return {
+				startContentIndex: 0,
+				endContentIndex: Math.max(0, (hunk.hunkContent.length ?? 1) - 1)
+			};
+		})()
+	});
 }
 
 //#endregion

package/dist/utils/diffAcceptRejectHunk.js.map

@@ -1 +1 @@
-{"version":3,"file":"diffAcceptRejectHunk.js","names":["newContent: ContextContent","i"],"sources":["../../src/utils/diffAcceptRejectHunk.ts"],"sourcesContent":["import type { ContextContent, FileDiffMetadata } from '../types';\n\nexport function diffAcceptRejectHunk(\n  diff: FileDiffMetadata,\n  hunkIndex: number,\n  type: 'accept' | 'reject'\n): FileDiffMetadata {\n  diff = {\n    ...diff,\n    hunks: [...diff.hunks],\n    deletionLines:\n      type === 'accept' ? [...diff.deletionLines] : diff.deletionLines,\n    additionLines:\n      type === 'reject' ? [...diff.additionLines] : diff.additionLines,\n    // Automatically update cacheKey if it exists, since content is changing\n    cacheKey:\n      diff.cacheKey != null\n        ? `${diff.cacheKey}:${type[0]}-${hunkIndex}`\n        : undefined,\n  };\n  // Fix the content lines\n  const { additionLines, deletionLines } = diff;\n  if (additionLines != null && deletionLines != null) {\n    const hunk = diff.hunks[hunkIndex];\n    if (hunk == null) {\n      console.error({ diff, hunkIndex });\n      throw new Error(\n        `diffResolveRejectHunk: Invalid hunk index: ${hunkIndex}`\n      );\n    }\n    if (type === 'reject') {\n      additionLines.splice(\n        hunk.additionLineIndex,\n        hunk.additionCount,\n        ...deletionLines.slice(\n          hunk.deletionLineIndex,\n          hunk.deletionLineIndex + hunk.deletionCount\n        )\n      );\n    } else {\n      deletionLines.splice(\n        hunk.deletionLineIndex,\n        hunk.deletionCount,\n        ...additionLines.slice(\n          hunk.additionLineIndex,\n          hunk.additionLineIndex + hunk.additionCount\n        )\n      );\n    }\n  }\n  let deletionOffset = 0;\n  let additionOffset = 0;\n  let splitOffset = 0;\n  let unifiedOffset = 0;\n  for (let i = hunkIndex; i < diff.hunks.length; i++) {\n    let hunk = diff.hunks[i];\n    if (hunk == null) {\n      console.error({ hunk, i, hunkIndex, diff });\n      throw new Error(\n        'diffResolveRejectHunk: iterating through hunks, hunk doesnt exist...'\n      );\n    }\n    const { noEOFCRAdditions, noEOFCRDeletions } = hunk;\n    diff.hunks[i] = hunk = { ...hunk };\n\n    if (i === hunkIndex) {\n      hunk.noEOFCRDeletions = false;\n      hunk.noEOFCRAdditions = false;\n      if (\n        (type === 'accept' && noEOFCRAdditions) ||\n        (type === 'reject' && noEOFCRDeletions)\n      ) {\n        hunk.noEOFCRAdditions = true;\n        hunk.noEOFCRDeletions = true;\n      }\n      const newContent: ContextContent = {\n        type: 'context',\n        lines: 0,\n        additionLineIndex: hunk.additionLineIndex,\n        deletionLineIndex: hunk.deletionLineIndex,\n      };\n      for (const content of hunk.hunkContent) {\n        if (content.type === 'context') {\n          newContent.lines += content.lines;\n        } else if (type === 'accept') {\n          newContent.lines += content.additions;\n        } else if (type === 'reject') {\n          newContent.lines += content.deletions;\n        }\n      }\n      const lineCount = newContent.lines;\n      hunk.hunkContent = [newContent];\n      splitOffset = lineCount - hunk.splitLineCount;\n      hunk.splitLineCount = lineCount;\n      unifiedOffset = lineCount - hunk.unifiedLineCount;\n      hunk.unifiedLineCount = lineCount;\n      deletionOffset = lineCount - hunk.deletionCount;\n      hunk.deletionCount = lineCount;\n      hunk.deletionLines = 0;\n      additionOffset = lineCount - hunk.additionCount;\n      hunk.additionCount = lineCount;\n      hunk.additionLines = 0;\n      diff.splitLineCount += splitOffset;\n      diff.unifiedLineCount += unifiedOffset;\n      // If we don't need to make any value offset differences for the rest of\n      // the hunks, we done\n      if (\n        splitOffset === 0 &&\n        unifiedOffset === 0 &&\n        additionOffset === 0 &&\n        deletionOffset === 0\n      ) {\n        break;\n      }\n    } else {\n      hunk.splitLineStart += splitOffset;\n      hunk.unifiedLineStart += unifiedOffset;\n\n      hunk.additionStart += additionOffset;\n      hunk.additionLineIndex += additionOffset;\n\n      hunk.deletionLineIndex += deletionOffset;\n      hunk.deletionStart += deletionOffset;\n\n      if (deletionOffset !== 0 || additionOffset !== 0) {\n        let i = 0;\n        while (i < hunk.hunkContent.length) {\n          const content = hunk.hunkContent[i];\n          hunk.hunkContent[i] = {\n            ...content,\n            additionLineIndex: content.additionLineIndex + additionOffset,\n            deletionLineIndex: content.deletionLineIndex + deletionOffset,\n          };\n          i++;\n        }\n      }\n    }\n  }\n  return diff;\n}\n"],"mappings":";AAEA,SAAgB,qBACd,MACA,WACA,MACkB;AAClB,QAAO;EACL,GAAG;EACH,OAAO,CAAC,GAAG,KAAK,MAAM;EACtB,eACE,SAAS,WAAW,CAAC,GAAG,KAAK,cAAc,GAAG,KAAK;EACrD,eACE,SAAS,WAAW,CAAC,GAAG,KAAK,cAAc,GAAG,KAAK;EAErD,UACE,KAAK,YAAY,OACb,GAAG,KAAK,SAAS,GAAG,KAAK,GAAG,GAAG,cAC/B;EACP;CAED,MAAM,EAAE,eAAe,kBAAkB;AACzC,KAAI,iBAAiB,QAAQ,iBAAiB,MAAM;EAClD,MAAM,OAAO,KAAK,MAAM;AACxB,MAAI,QAAQ,MAAM;AAChB,WAAQ,MAAM;IAAE;IAAM;IAAW,CAAC;AAClC,SAAM,IAAI,MACR,8CAA8C,YAC/C;;AAEH,MAAI,SAAS,SACX,eAAc,OACZ,KAAK,mBACL,KAAK,eACL,GAAG,cAAc,MACf,KAAK,mBACL,KAAK,oBAAoB,KAAK,cAC/B,CACF;MAED,eAAc,OACZ,KAAK,mBACL,KAAK,eACL,GAAG,cAAc,MACf,KAAK,mBACL,KAAK,oBAAoB,KAAK,cAC/B,CACF;;CAGL,IAAI,iBAAiB;CACrB,IAAI,iBAAiB;CACrB,IAAI,cAAc;CAClB,IAAI,gBAAgB;AACpB,MAAK,IAAI,IAAI,WAAW,IAAI,KAAK,MAAM,QAAQ,KAAK;EAClD,IAAI,OAAO,KAAK,MAAM;AACtB,MAAI,QAAQ,MAAM;AAChB,WAAQ,MAAM;IAAE;IAAM;IAAG;IAAW;IAAM,CAAC;AAC3C,SAAM,IAAI,MACR,uEACD;;EAEH,MAAM,EAAE,kBAAkB,qBAAqB;AAC/C,OAAK,MAAM,KAAK,OAAO,EAAE,GAAG,MAAM;AAElC,MAAI,MAAM,WAAW;AACnB,QAAK,mBAAmB;AACxB,QAAK,mBAAmB;AACxB,OACG,SAAS,YAAY,oBACrB,SAAS,YAAY,kBACtB;AACA,SAAK,mBAAmB;AACxB,SAAK,mBAAmB;;GAE1B,MAAMA,aAA6B;IACjC,MAAM;IACN,OAAO;IACP,mBAAmB,KAAK;IACxB,mBAAmB,KAAK;IACzB;AACD,QAAK,MAAM,WAAW,KAAK,YACzB,KAAI,QAAQ,SAAS,UACnB,YAAW,SAAS,QAAQ;YACnB,SAAS,SAClB,YAAW,SAAS,QAAQ;YACnB,SAAS,SAClB,YAAW,SAAS,QAAQ;GAGhC,MAAM,YAAY,WAAW;AAC7B,QAAK,cAAc,CAAC,WAAW;AAC/B,iBAAc,YAAY,KAAK;AAC/B,QAAK,iBAAiB;AACtB,mBAAgB,YAAY,KAAK;AACjC,QAAK,mBAAmB;AACxB,oBAAiB,YAAY,KAAK;AAClC,QAAK,gBAAgB;AACrB,QAAK,gBAAgB;AACrB,oBAAiB,YAAY,KAAK;AAClC,QAAK,gBAAgB;AACrB,QAAK,gBAAgB;AACrB,QAAK,kBAAkB;AACvB,QAAK,oBAAoB;AAGzB,OACE,gBAAgB,KAChB,kBAAkB,KAClB,mBAAmB,KACnB,mBAAmB,EAEnB;SAEG;AACL,QAAK,kBAAkB;AACvB,QAAK,oBAAoB;AAEzB,QAAK,iBAAiB;AACtB,QAAK,qBAAqB;AAE1B,QAAK,qBAAqB;AAC1B,QAAK,iBAAiB;AAEtB,OAAI,mBAAmB,KAAK,mBAAmB,GAAG;IAChD,IAAIC,MAAI;AACR,WAAOA,MAAI,KAAK,YAAY,QAAQ;KAClC,MAAM,UAAU,KAAK,YAAYA;AACjC,UAAK,YAAYA,OAAK;MACpB,GAAG;MACH,mBAAmB,QAAQ,oBAAoB;MAC/C,mBAAmB,QAAQ,oBAAoB;MAChD;AACD;;;;;AAKR,QAAO"}
+{"version":3,"file":"diffAcceptRejectHunk.js","names":[],"sources":["../../src/utils/diffAcceptRejectHunk.ts"],"sourcesContent":["import type {\n  DiffAcceptRejectHunkConfig,\n  DiffAcceptRejectHunkType,\n  FileDiffMetadata,\n} from '../types';\nimport { normalizeDiffResolution } from './normalizeDiffResolution';\nimport { resolveRegion } from './resolveRegion';\n\ntype DiffAcceptRejectHunkOptions =\n  | DiffAcceptRejectHunkType\n  | DiffAcceptRejectHunkConfig;\n\nexport function diffAcceptRejectHunk(\n  diff: FileDiffMetadata,\n  hunkIndex: number,\n  options: DiffAcceptRejectHunkOptions\n): FileDiffMetadata {\n  const hunk = diff.hunks[hunkIndex];\n  if (hunk == null) {\n    console.error({ hunkIndex, diff });\n    throw new Error('diffAcceptRejectHunk: Invalid hunk index');\n  }\n\n  return resolveRegion(diff, {\n    resolution: normalizeDiffResolution(options),\n    hunkIndex,\n    ...(() => {\n      if (typeof options === 'object') {\n        return {\n          startContentIndex: options.changeIndex,\n          endContentIndex: options.changeIndex,\n        };\n      }\n      return {\n        startContentIndex: 0,\n        endContentIndex: Math.max(0, (hunk.hunkContent.length ?? 1) - 1),\n      };\n    })(),\n  });\n}\n"],"mappings":";;;;AAYA,SAAgB,qBACd,MACA,WACA,SACkB;CAClB,MAAM,OAAO,KAAK,MAAM;AACxB,KAAI,QAAQ,MAAM;AAChB,UAAQ,MAAM;GAAE;GAAW;GAAM,CAAC;AAClC,QAAM,IAAI,MAAM,2CAA2C;;AAG7D,QAAO,cAAc,MAAM;EACzB,YAAY,wBAAwB,QAAQ;EAC5C;EACA,UAAU;AACR,OAAI,OAAO,YAAY,SACrB,QAAO;IACL,mBAAmB,QAAQ;IAC3B,iBAAiB,QAAQ;IAC1B;AAEH,UAAO;IACL,mBAAmB;IACnB,iBAAiB,KAAK,IAAI,IAAI,KAAK,YAAY,UAAU,KAAK,EAAE;IACjE;MACC;EACL,CAAC"}

package/dist/utils/getMergeConflictActionSlotName.d.ts

@@ -1,14 +1,12 @@
-import { AnnotationSide } from "../types.js";
-
 //#region src/utils/getMergeConflictActionSlotName.d.ts
 interface MergeConflictActionSlotInput {
-  side: AnnotationSide;
-  lineNumber: number;
+  hunkIndex: number;
+  lineIndex: number;
   conflictIndex: number;
 }
 declare function getMergeConflictActionSlotName({
-  side,
-  lineNumber,
+  hunkIndex,
+  lineIndex,
   conflictIndex
 }: MergeConflictActionSlotInput): string;
 //#endregion

package/dist/utils/getMergeConflictActionSlotName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMergeConflictActionSlotName.d.ts","names":["AnnotationSide","MergeConflictActionSlotInput","getMergeConflictActionSlotName","side","lineNumber","conflictIndex"],"sources":["../../src/utils/getMergeConflictActionSlotName.d.ts"],"sourcesContent":["import type { AnnotationSide } from '../types';\ninterface MergeConflictActionSlotInput {\n    side: AnnotationSide;\n    lineNumber: number;\n    conflictIndex: number;\n}\nexport declare function getMergeConflictActionSlotName({ side, lineNumber, conflictIndex }: MergeConflictActionSlotInput): string;\nexport {};\n//# sourceMappingURL=getMergeConflictActionSlotName.d.ts.map"],"mappings":";;;UACUC,4BAAAA;QACAD;EADAC,UAAAA,EAAAA,MAAAA;EAKcC,aAAAA,EAAAA,MAAAA;;AAAuCE,iBAAvCF,8BAAAA,CAAuCE;EAAAA,IAAAA;EAAAA,UAAAA;EAAAA;AAAAA,CAAAA,EAA6BH,4BAA7BG,CAAAA,EAAAA,MAAAA"}
+{"version":3,"file":"getMergeConflictActionSlotName.d.ts","names":["MergeConflictActionSlotInput","getMergeConflictActionSlotName","hunkIndex","lineIndex","conflictIndex"],"sources":["../../src/utils/getMergeConflictActionSlotName.d.ts"],"sourcesContent":["interface MergeConflictActionSlotInput {\n    hunkIndex: number;\n    lineIndex: number;\n    conflictIndex: number;\n}\nexport declare function getMergeConflictActionSlotName({ hunkIndex, lineIndex, conflictIndex }: MergeConflictActionSlotInput): string;\nexport {};\n//# sourceMappingURL=getMergeConflictActionSlotName.d.ts.map"],"mappings":";UAAUA,4BAAAA;EAAAA,SAAAA,EAAAA,MAAAA;EAKcC,SAAAA,EAAAA,MAAAA;EAAiCC,aAAAA,EAAAA,MAAAA;;AAAsBE,iBAAvDH,8BAAAA,CAAuDG;EAAAA,SAAAA;EAAAA,SAAAA;EAAAA;AAAAA,CAAAA,EAAiBJ,4BAAjBI,CAAAA,EAAAA,MAAAA"}

package/dist/utils/getMergeConflictActionSlotName.js

@@ -1,6 +1,6 @@
 //#region src/utils/getMergeConflictActionSlotName.ts
-function getMergeConflictActionSlotName({ side, lineNumber, conflictIndex }) {
-	return `merge-conflict-action-${side}-${lineNumber}-${conflictIndex}`;
+function getMergeConflictActionSlotName({ hunkIndex, lineIndex, conflictIndex }) {
+	return `merge-conflict-action-${hunkIndex}-${lineIndex}-${conflictIndex}`;
 }
 
 //#endregion

package/dist/utils/getMergeConflictActionSlotName.js.map

@@ -1 +1 @@
-{"version":3,"file":"getMergeConflictActionSlotName.js","names":[],"sources":["../../src/utils/getMergeConflictActionSlotName.ts"],"sourcesContent":["import type { AnnotationSide } from '../types';\n\ninterface MergeConflictActionSlotInput {\n  side: AnnotationSide;\n  lineNumber: number;\n  conflictIndex: number;\n}\n\nexport function getMergeConflictActionSlotName({\n  side,\n  lineNumber,\n  conflictIndex,\n}: MergeConflictActionSlotInput): string {\n  return `merge-conflict-action-${side}-${lineNumber}-${conflictIndex}`;\n}\n"],"mappings":";AAQA,SAAgB,+BAA+B,EAC7C,MACA,YACA,iBACuC;AACvC,QAAO,yBAAyB,KAAK,GAAG,WAAW,GAAG"}
+{"version":3,"file":"getMergeConflictActionSlotName.js","names":[],"sources":["../../src/utils/getMergeConflictActionSlotName.ts"],"sourcesContent":["interface MergeConflictActionSlotInput {\n  hunkIndex: number;\n  lineIndex: number;\n  conflictIndex: number;\n}\n\nexport function getMergeConflictActionSlotName({\n  hunkIndex,\n  lineIndex,\n  conflictIndex,\n}: MergeConflictActionSlotInput): string {\n  return `merge-conflict-action-${hunkIndex}-${lineIndex}-${conflictIndex}`;\n}\n"],"mappings":";AAMA,SAAgB,+BAA+B,EAC7C,WACA,WACA,iBACuC;AACvC,QAAO,yBAAyB,UAAU,GAAG,UAAU,GAAG"}

package/dist/utils/getMergeConflictLineTypes.d.ts

@@ -7,9 +7,8 @@ interface MergeConflictParseResult {
   regions: MergeConflictRegion[];
 }
 declare function getMergeConflictLineTypes(lines: string[]): MergeConflictLineType[];
-declare function getMergeConflictRegions(lines: string[]): MergeConflictRegion[];
 declare function getMergeConflictParseResult(lines: string[]): MergeConflictParseResult;
 declare function getMergeConflictActionLineNumber(conflict: MergeConflictRegion): number;
 //#endregion
-export { MergeConflictLineType, MergeConflictParseResult, getMergeConflictActionLineNumber, getMergeConflictLineTypes, getMergeConflictParseResult, getMergeConflictRegions };
+export { MergeConflictLineType, MergeConflictParseResult, getMergeConflictActionLineNumber, getMergeConflictLineTypes, getMergeConflictParseResult };
 //# sourceMappingURL=getMergeConflictLineTypes.d.ts.map

package/dist/utils/getMergeConflictLineTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMergeConflictLineTypes.d.ts","names":["MergeConflictRegion","MergeConflictLineType","MergeConflictParseResult","getMergeConflictLineTypes","getMergeConflictRegions","getMergeConflictParseResult","getMergeConflictActionLineNumber"],"sources":["../../src/utils/getMergeConflictLineTypes.d.ts"],"sourcesContent":["import type { MergeConflictRegion } from '../types';\nexport type MergeConflictLineType = 'none' | 'marker-start' | 'marker-base' | 'marker-separator' | 'marker-end' | 'current' | 'base' | 'incoming';\nexport interface MergeConflictParseResult {\n    lineTypes: MergeConflictLineType[];\n    regions: MergeConflictRegion[];\n}\nexport declare function getMergeConflictLineTypes(lines: string[]): MergeConflictLineType[];\nexport declare function getMergeConflictRegions(lines: string[]): MergeConflictRegion[];\nexport declare function getMergeConflictParseResult(lines: string[]): MergeConflictParseResult;\nexport declare function getMergeConflictActionLineNumber(conflict: MergeConflictRegion): number;\n//# sourceMappingURL=getMergeConflictLineTypes.d.ts.map"],"mappings":";;;KACYC,qBAAAA;UACKC,wBAAAA;EADLD,SAAAA,EAEGA,qBAFkB,EAAA;EAChBC,OAAAA,EAEJF,mBAF4B,EAAA;AAIzC;AACwBI,iBADAD,yBAAAA,CAC0CH,KAAAA,EAAAA,MAAmB,EAAA,CAAA,EADjBC,qBACiB,EAAA;AAC7DI,iBADAD,uBAAAA,CAC8CF,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EADJF,mBAC4B,EAAA;AACtEM,iBADAD,2BAAAA,CAC2CL,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EADGE,wBACgB;iBAA9DI,gCAAAA,WAA2CN"}
+{"version":3,"file":"getMergeConflictLineTypes.d.ts","names":["MergeConflictRegion","MergeConflictLineType","MergeConflictParseResult","getMergeConflictLineTypes","getMergeConflictParseResult","getMergeConflictActionLineNumber"],"sources":["../../src/utils/getMergeConflictLineTypes.d.ts"],"sourcesContent":["import type { MergeConflictRegion } from '../types';\nexport type MergeConflictLineType = 'none' | 'marker-start' | 'marker-base' | 'marker-separator' | 'marker-end' | 'current' | 'base' | 'incoming';\nexport interface MergeConflictParseResult {\n    lineTypes: MergeConflictLineType[];\n    regions: MergeConflictRegion[];\n}\nexport declare function getMergeConflictLineTypes(lines: string[]): MergeConflictLineType[];\nexport declare function getMergeConflictParseResult(lines: string[]): MergeConflictParseResult;\nexport declare function getMergeConflictActionLineNumber(conflict: MergeConflictRegion): number;\n//# sourceMappingURL=getMergeConflictLineTypes.d.ts.map"],"mappings":";;;KACYC,qBAAAA;UACKC,wBAAAA;EADLD,SAAAA,EAEGA,qBAFkB,EAAA;EAChBC,OAAAA,EAEJF,mBAF4B,EAAA;AAIzC;AACwBI,iBADAD,yBAAAA,CAC8CD,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EADFD,qBAC0B,EAAA;AACtEI,iBADAD,2BAAAA,CAC2CJ,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EADGE,wBACgB;iBAA9DG,gCAAAA,WAA2CL"}

package/dist/utils/getMergeConflictLineTypes.js

@@ -1,17 +1,12 @@
+import { MERGE_CONFLICT_BASE_MARKER_REGEX, MERGE_CONFLICT_END_MARKER_REGEX, MERGE_CONFLICT_SEPARATOR_MARKER_REGEX, MERGE_CONFLICT_START_MARKER_REGEX } from "../constants.js";
+
 //#region src/utils/getMergeConflictLineTypes.ts
-const START_MARKER = /^<{7,}(?:\s.*)?$/;
-const BASE_MARKER = /^\|{7,}(?:\s.*)?$/;
-const SEPARATOR_MARKER = /^={7,}(?:\s.*)?$/;
-const END_MARKER = /^>{7,}(?:\s.*)?$/;
 function trimLineEnding(line) {
 	return line.replace(/(?:\r\n|\n|\r)$/, "");
 }
 function getMergeConflictLineTypes(lines) {
 	return getMergeConflictParseResult(lines).lineTypes;
 }
-function getMergeConflictRegions(lines) {
-	return getMergeConflictParseResult(lines).regions;
-}
 function getMergeConflictParseResult(lines) {
 	return parseMergeConflicts(lines);
 }
@@ -24,7 +19,7 @@ function parseMergeConflicts(lines) {
 	const regions = [];
 	for (let index = 0; index < lines.length; index++) {
 		const line = trimLineEnding(lines[index]);
-		if (START_MARKER.test(line)) {
+		if (MERGE_CONFLICT_START_MARKER_REGEX.test(line)) {
 			stack.push({
 				stage: "current",
 				startLineIndex: index
@@ -37,19 +32,19 @@ function parseMergeConflicts(lines) {
 			lineTypes[index] = "none";
 			continue;
 		}
-		if (BASE_MARKER.test(line)) {
+		if (MERGE_CONFLICT_BASE_MARKER_REGEX.test(line)) {
 			frame.stage = "base";
 			frame.baseMarkerLineIndex = index;
 			lineTypes[index] = "marker-base";
 			continue;
 		}
-		if (SEPARATOR_MARKER.test(line)) {
+		if (MERGE_CONFLICT_SEPARATOR_MARKER_REGEX.test(line)) {
 			frame.stage = "incoming";
 			frame.separatorLineIndex = index;
 			lineTypes[index] = "marker-separator";
 			continue;
 		}
-		if (END_MARKER.test(line)) {
+		if (MERGE_CONFLICT_END_MARKER_REGEX.test(line)) {
 			const completedFrame = stack.pop();
 			lineTypes[index] = "marker-end";
 			if (completedFrame?.separatorLineIndex != null) {
@@ -77,5 +72,5 @@ function parseMergeConflicts(lines) {
 }
 
 //#endregion
-export { getMergeConflictActionLineNumber, getMergeConflictLineTypes, getMergeConflictParseResult, getMergeConflictRegions };
+export { getMergeConflictActionLineNumber, getMergeConflictLineTypes, getMergeConflictParseResult };
 //# sourceMappingURL=getMergeConflictLineTypes.js.map

package/dist/utils/getMergeConflictLineTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"getMergeConflictLineTypes.js","names":["stack: MergeConflictFrame[]","regions: MergeConflictRegion[]"],"sources":["../../src/utils/getMergeConflictLineTypes.ts"],"sourcesContent":["import type { MergeConflictRegion } from '../types';\n\nexport type MergeConflictLineType =\n  | 'none'\n  | 'marker-start'\n  | 'marker-base'\n  | 'marker-separator'\n  | 'marker-end'\n  | 'current'\n  | 'base'\n  | 'incoming';\n\ntype MergeConflictStage = 'current' | 'base' | 'incoming';\n\ninterface MergeConflictFrame {\n  stage: MergeConflictStage;\n  startLineIndex: number;\n  baseMarkerLineIndex?: number;\n  separatorLineIndex?: number;\n}\n\nexport interface MergeConflictParseResult {\n  lineTypes: MergeConflictLineType[];\n  regions: MergeConflictRegion[];\n}\n\nconst START_MARKER = /^<{7,}(?:\\s.*)?$/;\nconst BASE_MARKER = /^\\|{7,}(?:\\s.*)?$/;\nconst SEPARATOR_MARKER = /^={7,}(?:\\s.*)?$/;\nconst END_MARKER = /^>{7,}(?:\\s.*)?$/;\n\nfunction trimLineEnding(line: string): string {\n  return line.replace(/(?:\\r\\n|\\n|\\r)$/, '');\n}\n\nexport function getMergeConflictLineTypes(\n  lines: string[]\n): MergeConflictLineType[] {\n  return getMergeConflictParseResult(lines).lineTypes;\n}\n\nexport function getMergeConflictRegions(\n  lines: string[]\n): MergeConflictRegion[] {\n  return getMergeConflictParseResult(lines).regions;\n}\n\nexport function getMergeConflictParseResult(\n  lines: string[]\n): MergeConflictParseResult {\n  return parseMergeConflicts(lines);\n}\n\nexport function getMergeConflictActionLineNumber(\n  conflict: MergeConflictRegion\n): number {\n  return Math.max(1, conflict.startLineNumber - 1);\n}\n\nfunction parseMergeConflicts(lines: string[]): MergeConflictParseResult {\n  const lineTypes = new Array<MergeConflictLineType>(lines.length);\n  const stack: MergeConflictFrame[] = [];\n  const regions: MergeConflictRegion[] = [];\n\n  for (let index = 0; index < lines.length; index++) {\n    const line = trimLineEnding(lines[index]);\n\n    if (START_MARKER.test(line)) {\n      stack.push({ stage: 'current', startLineIndex: index });\n      lineTypes[index] = 'marker-start';\n      continue;\n    }\n\n    const frame = stack.at(-1);\n    if (frame == null) {\n      lineTypes[index] = 'none';\n      continue;\n    }\n\n    if (BASE_MARKER.test(line)) {\n      frame.stage = 'base';\n      frame.baseMarkerLineIndex = index;\n      lineTypes[index] = 'marker-base';\n      continue;\n    }\n\n    if (SEPARATOR_MARKER.test(line)) {\n      frame.stage = 'incoming';\n      frame.separatorLineIndex = index;\n      lineTypes[index] = 'marker-separator';\n      continue;\n    }\n\n    if (END_MARKER.test(line)) {\n      const completedFrame = stack.pop();\n      lineTypes[index] = 'marker-end';\n      if (completedFrame?.separatorLineIndex != null) {\n        const conflictIndex = regions.length;\n        regions.push({\n          conflictIndex,\n          startLineIndex: completedFrame.startLineIndex,\n          startLineNumber: completedFrame.startLineIndex + 1,\n          separatorLineIndex: completedFrame.separatorLineIndex,\n          separatorLineNumber: completedFrame.separatorLineIndex + 1,\n          endLineIndex: index,\n          endLineNumber: index + 1,\n          baseMarkerLineIndex: completedFrame.baseMarkerLineIndex,\n          baseMarkerLineNumber:\n            completedFrame.baseMarkerLineIndex != null\n              ? completedFrame.baseMarkerLineIndex + 1\n              : undefined,\n        });\n      }\n      continue;\n    }\n\n    lineTypes[index] = frame.stage;\n  }\n\n  return { lineTypes, regions };\n}\n"],"mappings":";AA0BA,MAAM,eAAe;AACrB,MAAM,cAAc;AACpB,MAAM,mBAAmB;AACzB,MAAM,aAAa;AAEnB,SAAS,eAAe,MAAsB;AAC5C,QAAO,KAAK,QAAQ,mBAAmB,GAAG;;AAG5C,SAAgB,0BACd,OACyB;AACzB,QAAO,4BAA4B,MAAM,CAAC;;AAG5C,SAAgB,wBACd,OACuB;AACvB,QAAO,4BAA4B,MAAM,CAAC;;AAG5C,SAAgB,4BACd,OAC0B;AAC1B,QAAO,oBAAoB,MAAM;;AAGnC,SAAgB,iCACd,UACQ;AACR,QAAO,KAAK,IAAI,GAAG,SAAS,kBAAkB,EAAE;;AAGlD,SAAS,oBAAoB,OAA2C;CACtE,MAAM,YAAY,IAAI,MAA6B,MAAM,OAAO;CAChE,MAAMA,QAA8B,EAAE;CACtC,MAAMC,UAAiC,EAAE;AAEzC,MAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;EACjD,MAAM,OAAO,eAAe,MAAM,OAAO;AAEzC,MAAI,aAAa,KAAK,KAAK,EAAE;AAC3B,SAAM,KAAK;IAAE,OAAO;IAAW,gBAAgB;IAAO,CAAC;AACvD,aAAU,SAAS;AACnB;;EAGF,MAAM,QAAQ,MAAM,GAAG,GAAG;AAC1B,MAAI,SAAS,MAAM;AACjB,aAAU,SAAS;AACnB;;AAGF,MAAI,YAAY,KAAK,KAAK,EAAE;AAC1B,SAAM,QAAQ;AACd,SAAM,sBAAsB;AAC5B,aAAU,SAAS;AACnB;;AAGF,MAAI,iBAAiB,KAAK,KAAK,EAAE;AAC/B,SAAM,QAAQ;AACd,SAAM,qBAAqB;AAC3B,aAAU,SAAS;AACnB;;AAGF,MAAI,WAAW,KAAK,KAAK,EAAE;GACzB,MAAM,iBAAiB,MAAM,KAAK;AAClC,aAAU,SAAS;AACnB,OAAI,gBAAgB,sBAAsB,MAAM;IAC9C,MAAM,gBAAgB,QAAQ;AAC9B,YAAQ,KAAK;KACX;KACA,gBAAgB,eAAe;KAC/B,iBAAiB,eAAe,iBAAiB;KACjD,oBAAoB,eAAe;KACnC,qBAAqB,eAAe,qBAAqB;KACzD,cAAc;KACd,eAAe,QAAQ;KACvB,qBAAqB,eAAe;KACpC,sBACE,eAAe,uBAAuB,OAClC,eAAe,sBAAsB,IACrC;KACP,CAAC;;AAEJ;;AAGF,YAAU,SAAS,MAAM;;AAG3B,QAAO;EAAE;EAAW;EAAS"}
+{"version":3,"file":"getMergeConflictLineTypes.js","names":["stack: MergeConflictFrame[]","regions: MergeConflictRegion[]"],"sources":["../../src/utils/getMergeConflictLineTypes.ts"],"sourcesContent":["import {\n  MERGE_CONFLICT_BASE_MARKER_REGEX,\n  MERGE_CONFLICT_END_MARKER_REGEX,\n  MERGE_CONFLICT_SEPARATOR_MARKER_REGEX,\n  MERGE_CONFLICT_START_MARKER_REGEX,\n} from '../constants';\nimport type { MergeConflictRegion } from '../types';\n\nexport type MergeConflictLineType =\n  | 'none'\n  | 'marker-start'\n  | 'marker-base'\n  | 'marker-separator'\n  | 'marker-end'\n  | 'current'\n  | 'base'\n  | 'incoming';\n\ntype MergeConflictStage = 'current' | 'base' | 'incoming';\n\ninterface MergeConflictFrame {\n  stage: MergeConflictStage;\n  startLineIndex: number;\n  baseMarkerLineIndex?: number;\n  separatorLineIndex?: number;\n}\n\nexport interface MergeConflictParseResult {\n  lineTypes: MergeConflictLineType[];\n  regions: MergeConflictRegion[];\n}\n\nfunction trimLineEnding(line: string): string {\n  return line.replace(/(?:\\r\\n|\\n|\\r)$/, '');\n}\n\nexport function getMergeConflictLineTypes(\n  lines: string[]\n): MergeConflictLineType[] {\n  return getMergeConflictParseResult(lines).lineTypes;\n}\n\nexport function getMergeConflictParseResult(\n  lines: string[]\n): MergeConflictParseResult {\n  return parseMergeConflicts(lines);\n}\n\nexport function getMergeConflictActionLineNumber(\n  conflict: MergeConflictRegion\n): number {\n  return Math.max(1, conflict.startLineNumber - 1);\n}\n\nfunction parseMergeConflicts(lines: string[]): MergeConflictParseResult {\n  const lineTypes = new Array<MergeConflictLineType>(lines.length);\n  const stack: MergeConflictFrame[] = [];\n  const regions: MergeConflictRegion[] = [];\n\n  for (let index = 0; index < lines.length; index++) {\n    const line = trimLineEnding(lines[index]);\n\n    if (MERGE_CONFLICT_START_MARKER_REGEX.test(line)) {\n      stack.push({ stage: 'current', startLineIndex: index });\n      lineTypes[index] = 'marker-start';\n      continue;\n    }\n\n    const frame = stack.at(-1);\n    if (frame == null) {\n      lineTypes[index] = 'none';\n      continue;\n    }\n\n    if (MERGE_CONFLICT_BASE_MARKER_REGEX.test(line)) {\n      frame.stage = 'base';\n      frame.baseMarkerLineIndex = index;\n      lineTypes[index] = 'marker-base';\n      continue;\n    }\n\n    if (MERGE_CONFLICT_SEPARATOR_MARKER_REGEX.test(line)) {\n      frame.stage = 'incoming';\n      frame.separatorLineIndex = index;\n      lineTypes[index] = 'marker-separator';\n      continue;\n    }\n\n    if (MERGE_CONFLICT_END_MARKER_REGEX.test(line)) {\n      const completedFrame = stack.pop();\n      lineTypes[index] = 'marker-end';\n      if (completedFrame?.separatorLineIndex != null) {\n        const conflictIndex = regions.length;\n        regions.push({\n          conflictIndex,\n          startLineIndex: completedFrame.startLineIndex,\n          startLineNumber: completedFrame.startLineIndex + 1,\n          separatorLineIndex: completedFrame.separatorLineIndex,\n          separatorLineNumber: completedFrame.separatorLineIndex + 1,\n          endLineIndex: index,\n          endLineNumber: index + 1,\n          baseMarkerLineIndex: completedFrame.baseMarkerLineIndex,\n          baseMarkerLineNumber:\n            completedFrame.baseMarkerLineIndex != null\n              ? completedFrame.baseMarkerLineIndex + 1\n              : undefined,\n        });\n      }\n      continue;\n    }\n\n    lineTypes[index] = frame.stage;\n  }\n\n  return { lineTypes, regions };\n}\n"],"mappings":";;;AAgCA,SAAS,eAAe,MAAsB;AAC5C,QAAO,KAAK,QAAQ,mBAAmB,GAAG;;AAG5C,SAAgB,0BACd,OACyB;AACzB,QAAO,4BAA4B,MAAM,CAAC;;AAG5C,SAAgB,4BACd,OAC0B;AAC1B,QAAO,oBAAoB,MAAM;;AAGnC,SAAgB,iCACd,UACQ;AACR,QAAO,KAAK,IAAI,GAAG,SAAS,kBAAkB,EAAE;;AAGlD,SAAS,oBAAoB,OAA2C;CACtE,MAAM,YAAY,IAAI,MAA6B,MAAM,OAAO;CAChE,MAAMA,QAA8B,EAAE;CACtC,MAAMC,UAAiC,EAAE;AAEzC,MAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;EACjD,MAAM,OAAO,eAAe,MAAM,OAAO;AAEzC,MAAI,kCAAkC,KAAK,KAAK,EAAE;AAChD,SAAM,KAAK;IAAE,OAAO;IAAW,gBAAgB;IAAO,CAAC;AACvD,aAAU,SAAS;AACnB;;EAGF,MAAM,QAAQ,MAAM,GAAG,GAAG;AAC1B,MAAI,SAAS,MAAM;AACjB,aAAU,SAAS;AACnB;;AAGF,MAAI,iCAAiC,KAAK,KAAK,EAAE;AAC/C,SAAM,QAAQ;AACd,SAAM,sBAAsB;AAC5B,aAAU,SAAS;AACnB;;AAGF,MAAI,sCAAsC,KAAK,KAAK,EAAE;AACpD,SAAM,QAAQ;AACd,SAAM,qBAAqB;AAC3B,aAAU,SAAS;AACnB;;AAGF,MAAI,gCAAgC,KAAK,KAAK,EAAE;GAC9C,MAAM,iBAAiB,MAAM,KAAK;AAClC,aAAU,SAAS;AACnB,OAAI,gBAAgB,sBAAsB,MAAM;IAC9C,MAAM,gBAAgB,QAAQ;AAC9B,YAAQ,KAAK;KACX;KACA,gBAAgB,eAAe;KAC/B,iBAAiB,eAAe,iBAAiB;KACjD,oBAAoB,eAAe;KACnC,qBAAqB,eAAe,qBAAqB;KACzD,cAAc;KACd,eAAe,QAAQ;KACvB,qBAAqB,eAAe;KACpC,sBACE,eAAe,uBAAuB,OAClC,eAAe,sBAAsB,IACrC;KACP,CAAC;;AAEJ;;AAGF,YAAU,SAAS,MAAM;;AAG3B,QAAO;EAAE;EAAW;EAAS"}

package/dist/utils/normalizeDiffResolution.d.ts

@@ -0,0 +1,7 @@
+import { ConflictResolverTypes, DiffAcceptRejectHunkConfig, DiffAcceptRejectHunkType } from "../types.js";
+
+//#region src/utils/normalizeDiffResolution.d.ts
+declare function normalizeDiffResolution(options: DiffAcceptRejectHunkType | ConflictResolverTypes | DiffAcceptRejectHunkConfig): 'deletions' | 'additions' | 'both';
+//#endregion
+export { normalizeDiffResolution };
+//# sourceMappingURL=normalizeDiffResolution.d.ts.map

package/dist/utils/normalizeDiffResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDiffResolution.d.ts","names":["ConflictResolverTypes","DiffAcceptRejectHunkConfig","DiffAcceptRejectHunkType","normalizeDiffResolution"],"sources":["../../src/utils/normalizeDiffResolution.d.ts"],"sourcesContent":["import type { ConflictResolverTypes, DiffAcceptRejectHunkConfig, DiffAcceptRejectHunkType } from '../types';\nexport declare function normalizeDiffResolution(options: DiffAcceptRejectHunkType | ConflictResolverTypes | DiffAcceptRejectHunkConfig): 'deletions' | 'additions' | 'both';\n//# sourceMappingURL=normalizeDiffResolution.d.ts.map"],"mappings":";;;iBACwBG,uBAAAA,UAAiCD,2BAA2BF,wBAAwBC"}

package/dist/utils/normalizeDiffResolution.js

@@ -0,0 +1,11 @@
+//#region src/utils/normalizeDiffResolution.ts
+function normalizeDiffResolution(options) {
+	const type = (() => {
+		return typeof options === "string" ? options : options.type;
+	})();
+	return type === "accept" || type === "incoming" ? "additions" : type === "reject" || type === "current" ? "deletions" : "both";
+}
+
+//#endregion
+export { normalizeDiffResolution };
+//# sourceMappingURL=normalizeDiffResolution.js.map

package/dist/utils/normalizeDiffResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDiffResolution.js","names":[],"sources":["../../src/utils/normalizeDiffResolution.ts"],"sourcesContent":["import type {\n  ConflictResolverTypes,\n  DiffAcceptRejectHunkConfig,\n  DiffAcceptRejectHunkType,\n} from '../types';\n\n// Normalize shorthand and config-object inputs into one internal resolution\n// mode so the rest of the helper only handles the three concrete diff states.\nexport function normalizeDiffResolution(\n  options:\n    | DiffAcceptRejectHunkType\n    | ConflictResolverTypes\n    | DiffAcceptRejectHunkConfig\n): 'deletions' | 'additions' | 'both' {\n  const type = (() => {\n    return typeof options === 'string' ? options : options.type;\n  })();\n\n  return type === 'accept' || type === 'incoming'\n    ? 'additions'\n    : type === 'reject' || type === 'current'\n      ? 'deletions'\n      : 'both';\n}\n"],"mappings":";AAQA,SAAgB,wBACd,SAIoC;CACpC,MAAM,cAAc;AAClB,SAAO,OAAO,YAAY,WAAW,UAAU,QAAQ;KACrD;AAEJ,QAAO,SAAS,YAAY,SAAS,aACjC,cACA,SAAS,YAAY,SAAS,YAC5B,cACA"}

package/dist/utils/parseMergeConflictDiffFromFile.d.ts

@@ -1,26 +1,30 @@
-import { FileContents, FileDiffMetadata, MergeConflictRegion } from "../types.js";
+import { FileContents, FileDiffMetadata, MergeConflictMarkerRow, MergeConflictRegion, ProcessFileConflictData } from "../types.js";
 
 //#region src/utils/parseMergeConflictDiffFromFile.d.ts
 interface ParseMergeConflictDiffFromFileResult {
   fileDiff: FileDiffMetadata;
   currentFile: FileContents;
   incomingFile: FileContents;
-  actions: MergeConflictDiffAction[];
+  actions: (MergeConflictDiffAction | undefined)[];
+  markerRows: MergeConflictMarkerRow[];
 }
-interface MergeConflictDiffAction {
-  actionOriginalLineIndex: number;
-  actionOriginalLineNumber: number;
-  currentLineNumber: number | undefined;
-  incomingLineNumber: number | undefined;
+interface MergeConflictDiffAction extends ProcessFileConflictData {
   conflict: MergeConflictRegion;
   conflictIndex: number;
+  markerLines: {
+    start: string;
+    base?: string;
+    separator: string;
+    end: string;
+  };
 }
 interface GetMergeConflictActionAnchorReturn {
-  side: 'additions' | 'deletions';
-  lineNumber: number;
+  hunkIndex: number;
+  lineIndex: number;
 }
-declare function getMergeConflictActionAnchor(action: MergeConflictDiffAction): GetMergeConflictActionAnchorReturn | undefined;
-declare function parseMergeConflictDiffFromFile(file: FileContents): ParseMergeConflictDiffFromFileResult;
+declare function getMergeConflictActionAnchor(action: MergeConflictDiffAction, fileDiff: FileDiffMetadata): GetMergeConflictActionAnchorReturn | undefined;
+declare function parseMergeConflictDiffFromFile(file: FileContents, maxContextLines?: number): ParseMergeConflictDiffFromFileResult;
+declare function buildMergeConflictMarkerRows(fileDiff: FileDiffMetadata, actions: (MergeConflictDiffAction | undefined)[]): MergeConflictMarkerRow[];
 //#endregion
-export { MergeConflictDiffAction, ParseMergeConflictDiffFromFileResult, getMergeConflictActionAnchor, parseMergeConflictDiffFromFile };
+export { MergeConflictDiffAction, ParseMergeConflictDiffFromFileResult, buildMergeConflictMarkerRows, getMergeConflictActionAnchor, parseMergeConflictDiffFromFile };
 //# sourceMappingURL=parseMergeConflictDiffFromFile.d.ts.map

package/dist/utils/parseMergeConflictDiffFromFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseMergeConflictDiffFromFile.d.ts","names":["FileContents","FileDiffMetadata","MergeConflictRegion","ParseMergeConflictDiffFromFileResult","MergeConflictDiffAction","GetMergeConflictActionAnchorReturn","getMergeConflictActionAnchor","parseMergeConflictDiffFromFile"],"sources":["../../src/utils/parseMergeConflictDiffFromFile.d.ts"],"sourcesContent":["import type { FileContents, FileDiffMetadata, MergeConflictRegion } from '../types';\nexport interface ParseMergeConflictDiffFromFileResult {\n    fileDiff: FileDiffMetadata;\n    currentFile: FileContents;\n    incomingFile: FileContents;\n    actions: MergeConflictDiffAction[];\n}\nexport interface MergeConflictDiffAction {\n    actionOriginalLineIndex: number;\n    actionOriginalLineNumber: number;\n    currentLineNumber: number | undefined;\n    incomingLineNumber: number | undefined;\n    conflict: MergeConflictRegion;\n    conflictIndex: number;\n}\ninterface GetMergeConflictActionAnchorReturn {\n    side: 'additions' | 'deletions';\n    lineNumber: number;\n}\nexport declare function getMergeConflictActionAnchor(action: MergeConflictDiffAction): GetMergeConflictActionAnchorReturn | undefined;\nexport declare function parseMergeConflictDiffFromFile(file: FileContents): ParseMergeConflictDiffFromFileResult;\nexport {};\n//# sourceMappingURL=parseMergeConflictDiffFromFile.d.ts.map"],"mappings":";;;UACiBG,oCAAAA;YACHF;EADGE,WAAAA,EAEAH,YAFAG;EACHF,YAAAA,EAEID,YAFJC;EACGD,OAAAA,EAEJI,uBAFIJ,EAAAA;;AAEJI,UAEIA,uBAAAA,CAFJA;EAAuB,uBAAA,EAAA,MAAA;EAEnBA,wBAAAA,EAAuB,MAAA;EAQ9BC,iBAAAA,EAAAA,MAAAA,GAAAA,SAAkC;EAIpBC,kBAAAA,EAAAA,MAAAA,GAAAA,SAA4B;EAC5BC,QAAAA,EARVL,mBAQUK;;;UALdF,kCAAAA;;;;iBAIcC,4BAAAA,SAAqCF,0BAA0BC;iBAC/DE,8BAAAA,OAAqCP,eAAeG"}
+{"version":3,"file":"parseMergeConflictDiffFromFile.d.ts","names":["FileContents","FileDiffMetadata","MergeConflictMarkerRow","MergeConflictRegion","ProcessFileConflictData","ParseMergeConflictDiffFromFileResult","MergeConflictDiffAction","GetMergeConflictActionAnchorReturn","getMergeConflictActionAnchor","parseMergeConflictDiffFromFile","buildMergeConflictMarkerRows"],"sources":["../../src/utils/parseMergeConflictDiffFromFile.d.ts"],"sourcesContent":["import type { FileContents, FileDiffMetadata, MergeConflictMarkerRow, MergeConflictRegion, ProcessFileConflictData } from '../types';\nexport interface ParseMergeConflictDiffFromFileResult {\n    fileDiff: FileDiffMetadata;\n    currentFile: FileContents;\n    incomingFile: FileContents;\n    actions: (MergeConflictDiffAction | undefined)[];\n    markerRows: MergeConflictMarkerRow[];\n}\nexport interface MergeConflictDiffAction extends ProcessFileConflictData {\n    conflict: MergeConflictRegion;\n    conflictIndex: number;\n    markerLines: {\n        start: string;\n        base?: string;\n        separator: string;\n        end: string;\n    };\n}\ninterface GetMergeConflictActionAnchorReturn {\n    hunkIndex: number;\n    lineIndex: number;\n}\nexport declare function getMergeConflictActionAnchor(action: MergeConflictDiffAction, fileDiff: FileDiffMetadata): GetMergeConflictActionAnchorReturn | undefined;\nexport declare function parseMergeConflictDiffFromFile(file: FileContents, maxContextLines?: number): ParseMergeConflictDiffFromFileResult;\nexport declare function buildMergeConflictMarkerRows(fileDiff: FileDiffMetadata, actions: (MergeConflictDiffAction | undefined)[]): MergeConflictMarkerRow[];\nexport {};\n//# sourceMappingURL=parseMergeConflictDiffFromFile.d.ts.map"],"mappings":";;;UACiBK,oCAAAA;YACHJ;EADGI,WAAAA,EAEAL,YAFAK;EACHJ,YAAAA,EAEID,YAFJC;EACGD,OAAAA,EAAAA,CAEHM,uBAFGN,GAAAA,SAAAA,CAAAA,EAAAA;EACCA,UAAAA,EAEFE,sBAFEF,EAAAA;;AAEFE,UAECI,uBAAAA,SAAgCF,uBAFjCF,CAAAA;EAAsB,QAAA,EAGxBC,mBAHwB;EAErBG,aAAAA,EAAAA,MAAAA;EAUPC,WAAAA,EAAAA;IAIcC,KAAAA,EAAAA,MAAAA;IAAqCF,IAAAA,CAAAA,EAAAA,MAAAA;IAAmCL,SAAAA,EAAAA,MAAAA;IAAmBM,GAAAA,EAAAA,MAAAA;EAAkC,CAAA;AACrJ;AACA,UANUA,kCAAAA,CAM0C;EAAWN,SAAAA,EAAAA,MAAAA;EAA4BK,SAAAA,EAAAA,MAAAA;;AAA+D,iBAFlIE,4BAAAA,CAEkI,MAAA,EAF7FF,uBAE6F,EAAA,QAAA,EAF1DL,gBAE0D,CAAA,EAFvCM,kCAEuC,GAAA,SAAA;iBADlIE,8BAAAA,OAAqCT,yCAAyCK;iBAC9EK,4BAAAA,WAAuCT,4BAA4BK,yCAAyCJ"}