opencode-hashline 1.0.0

package/dist/chunk-IVZSANZ4.js

@@ -0,0 +1,411 @@
+// src/hashline.ts
+import picomatch from "picomatch";
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/node_modules/**",
+  "**/*.lock",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/*.min.js",
+  "**/*.min.css",
+  "**/*.bundle.js",
+  "**/*.map",
+  "**/*.wasm",
+  "**/*.png",
+  "**/*.jpg",
+  "**/*.jpeg",
+  "**/*.gif",
+  "**/*.ico",
+  "**/*.svg",
+  "**/*.woff",
+  "**/*.woff2",
+  "**/*.ttf",
+  "**/*.eot",
+  "**/*.pdf",
+  "**/*.zip",
+  "**/*.tar",
+  "**/*.gz",
+  "**/*.exe",
+  "**/*.dll",
+  "**/*.so",
+  "**/*.dylib"
+];
+var DEFAULT_PREFIX = "#HL ";
+var DEFAULT_CONFIG = {
+  exclude: DEFAULT_EXCLUDE_PATTERNS,
+  maxFileSize: 1048576,
+  // 1 MB
+  hashLength: 0,
+  // 0 = adaptive
+  cacheSize: 100,
+  prefix: DEFAULT_PREFIX
+};
+function resolveConfig(config, pluginConfig) {
+  const merged = {
+    ...pluginConfig,
+    ...config
+  };
+  if (!merged || Object.keys(merged).length === 0) {
+    return { ...DEFAULT_CONFIG, exclude: [...DEFAULT_CONFIG.exclude] };
+  }
+  return {
+    exclude: merged.exclude ?? [...DEFAULT_CONFIG.exclude],
+    maxFileSize: merged.maxFileSize ?? DEFAULT_CONFIG.maxFileSize,
+    hashLength: merged.hashLength ?? DEFAULT_CONFIG.hashLength,
+    cacheSize: merged.cacheSize ?? DEFAULT_CONFIG.cacheSize,
+    prefix: merged.prefix !== void 0 ? merged.prefix : DEFAULT_CONFIG.prefix
+  };
+}
+function fnv1aHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash;
+}
+var modulusCache = /* @__PURE__ */ new Map();
+function getModulus(hashLen) {
+  let cached = modulusCache.get(hashLen);
+  if (cached === void 0) {
+    cached = Math.pow(16, hashLen);
+    modulusCache.set(hashLen, cached);
+  }
+  return cached;
+}
+function getAdaptiveHashLength(lineCount) {
+  if (lineCount <= 4096) return 3;
+  return 4;
+}
+function computeLineHash(idx, line, hashLen = 3) {
+  const trimmed = line.trimEnd();
+  const input = `${idx}:${trimmed}`;
+  const raw = fnv1aHash(input);
+  const modulus = getModulus(hashLen);
+  const hash = raw % modulus;
+  return hash.toString(16).padStart(hashLen, "0");
+}
+function formatFileWithHashes(content, hashLen, prefix) {
+  const lines = content.split("\n");
+  const effectiveLen = hashLen && hashLen >= 3 ? hashLen : getAdaptiveHashLength(lines.length);
+  const effectivePrefix = prefix === void 0 ? DEFAULT_PREFIX : prefix === false ? "" : prefix;
+  const hashes = new Array(lines.length);
+  const seen = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < lines.length; idx++) {
+    const hash = computeLineHash(idx, lines[idx], effectiveLen);
+    if (seen.has(hash)) {
+      const longerLen = Math.min(effectiveLen + 1, 8);
+      hashes[idx] = computeLineHash(idx, lines[idx], longerLen);
+    } else {
+      seen.set(hash, idx);
+      hashes[idx] = hash;
+    }
+  }
+  return lines.map((line, idx) => {
+    return `${effectivePrefix}${idx + 1}:${hashes[idx]}|${line}`;
+  }).join("\n");
+}
+var stripRegexCache = /* @__PURE__ */ new Map();
+function stripHashes(content, prefix) {
+  const effectivePrefix = prefix === void 0 ? DEFAULT_PREFIX : prefix === false ? "" : prefix;
+  const escapedPrefix = effectivePrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let hashLinePattern = stripRegexCache.get(escapedPrefix);
+  if (!hashLinePattern) {
+    hashLinePattern = new RegExp(`^${escapedPrefix}\\d+:[0-9a-f]{2,8}\\|`);
+    stripRegexCache.set(escapedPrefix, hashLinePattern);
+  }
+  return content.split("\n").map((line) => {
+    const match = line.match(hashLinePattern);
+    if (match) {
+      return line.slice(match[0].length);
+    }
+    return line;
+  }).join("\n");
+}
+function parseHashRef(ref) {
+  const match = ref.match(/^(\d+):([0-9a-f]{2,8})$/);
+  if (!match) {
+    throw new Error(`Invalid hash reference: "${ref}". Expected format: "<line>:<2-8 char hex>"`);
+  }
+  return {
+    line: parseInt(match[1], 10),
+    hash: match[2]
+  };
+}
+function normalizeHashRef(ref) {
+  const trimmed = ref.trim();
+  const plain = trimmed.match(/^(\d+):([0-9a-f]{2,8})$/i);
+  if (plain) {
+    return `${parseInt(plain[1], 10)}:${plain[2].toLowerCase()}`;
+  }
+  const annotated = trimmed.match(/^(?:[#\w]*\s+)?(\d+):([0-9a-f]{2,8})\|.*$/i);
+  if (annotated) {
+    return `${parseInt(annotated[1], 10)}:${annotated[2].toLowerCase()}`;
+  }
+  throw new Error(
+    `Invalid hash reference: "${ref}". Expected "<line>:<hash>" or an annotated line like "#HL <line>:<hash>|..."`
+  );
+}
+function buildHashMap(content, hashLen) {
+  const lines = content.split("\n");
+  const effectiveLen = hashLen && hashLen >= 3 ? hashLen : getAdaptiveHashLength(lines.length);
+  const map = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < lines.length; idx++) {
+    const hash = computeLineHash(idx, lines[idx], effectiveLen);
+    const lineNum = idx + 1;
+    map.set(`${lineNum}:${hash}`, lineNum);
+  }
+  return map;
+}
+function verifyHash(lineNumber, hash, currentContent, hashLen, lines) {
+  const contentLines = lines ?? currentContent.split("\n");
+  const effectiveLen = hashLen && hashLen >= 2 ? hashLen : hash.length;
+  if (lineNumber < 1 || lineNumber > contentLines.length) {
+    return {
+      valid: false,
+      message: `Line ${lineNumber} is out of range (file has ${contentLines.length} lines)`
+    };
+  }
+  const idx = lineNumber - 1;
+  const actualHash = computeLineHash(idx, contentLines[idx], effectiveLen);
+  if (actualHash !== hash) {
+    return {
+      valid: false,
+      expected: hash,
+      actual: actualHash,
+      message: `Hash mismatch at line ${lineNumber}: expected "${hash}", got "${actualHash}". The file may have changed since it was read.`
+    };
+  }
+  return { valid: true };
+}
+function resolveRange(startRef, endRef, content, hashLen) {
+  const start = parseHashRef(startRef);
+  const end = parseHashRef(endRef);
+  if (start.line > end.line) {
+    throw new Error(
+      `Invalid range: start line ${start.line} is after end line ${end.line}`
+    );
+  }
+  const lines = content.split("\n");
+  const startVerify = verifyHash(start.line, start.hash, content, hashLen, lines);
+  if (!startVerify.valid) {
+    throw new Error(`Start reference invalid: ${startVerify.message}`);
+  }
+  const endVerify = verifyHash(end.line, end.hash, content, hashLen, lines);
+  if (!endVerify.valid) {
+    throw new Error(`End reference invalid: ${endVerify.message}`);
+  }
+  const rangeLines = lines.slice(start.line - 1, end.line);
+  return {
+    startLine: start.line,
+    endLine: end.line,
+    lines: rangeLines,
+    content: rangeLines.join("\n")
+  };
+}
+function replaceRange(startRef, endRef, content, replacement, hashLen) {
+  const range = resolveRange(startRef, endRef, content, hashLen);
+  const lines = content.split("\n");
+  const before = lines.slice(0, range.startLine - 1);
+  const after = lines.slice(range.endLine);
+  const replacementLines = replacement.split("\n");
+  return [...before, ...replacementLines, ...after].join("\n");
+}
+function applyHashEdit(input, content, hashLen) {
+  const normalizedStart = normalizeHashRef(input.startRef);
+  const start = parseHashRef(normalizedStart);
+  const lines = content.split("\n");
+  const startVerify = verifyHash(start.line, start.hash, content, hashLen, lines);
+  if (!startVerify.valid) {
+    throw new Error(`Start reference invalid: ${startVerify.message}`);
+  }
+  if (input.operation === "insert_before" || input.operation === "insert_after") {
+    if (input.replacement === void 0) {
+      throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+    }
+    const insertionLines = input.replacement.split("\n");
+    const insertIndex = input.operation === "insert_before" ? start.line - 1 : start.line;
+    const next2 = [
+      ...lines.slice(0, insertIndex),
+      ...insertionLines,
+      ...lines.slice(insertIndex)
+    ].join("\n");
+    return {
+      operation: input.operation,
+      startLine: start.line,
+      endLine: start.line,
+      content: next2
+    };
+  }
+  const normalizedEnd = normalizeHashRef(input.endRef ?? input.startRef);
+  const end = parseHashRef(normalizedEnd);
+  if (start.line > end.line) {
+    throw new Error(
+      `Invalid range: start line ${start.line} is after end line ${end.line}`
+    );
+  }
+  const endVerify = verifyHash(end.line, end.hash, content, hashLen, lines);
+  if (!endVerify.valid) {
+    throw new Error(`End reference invalid: ${endVerify.message}`);
+  }
+  const replacement = input.operation === "delete" ? "" : input.replacement;
+  if (replacement === void 0) {
+    throw new Error(`Operation "${input.operation}" requires "replacement" content`);
+  }
+  const before = lines.slice(0, start.line - 1);
+  const after = lines.slice(end.line);
+  const replacementLines = input.operation === "delete" ? [] : replacement.split("\n");
+  const next = [...before, ...replacementLines, ...after].join("\n");
+  return {
+    operation: input.operation,
+    startLine: start.line,
+    endLine: end.line,
+    content: next
+  };
+}
+var HashlineCache = class {
+  cache;
+  maxSize;
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  /**
+   * Get cached annotated content for a file, or null if not cached / stale.
+   */
+  get(filePath, content) {
+    const entry = this.cache.get(filePath);
+    if (!entry) return null;
+    const currentHash = fnv1aHash(content);
+    if (entry.contentHash !== currentHash) {
+      this.cache.delete(filePath);
+      return null;
+    }
+    this.cache.delete(filePath);
+    this.cache.set(filePath, entry);
+    return entry.annotated;
+  }
+  /**
+   * Store annotated content in the cache.
+   */
+  set(filePath, content, annotated) {
+    if (this.cache.has(filePath)) {
+      this.cache.delete(filePath);
+    }
+    if (this.cache.size >= this.maxSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== void 0) {
+        this.cache.delete(oldest);
+      }
+    }
+    this.cache.set(filePath, {
+      contentHash: fnv1aHash(content),
+      annotated
+    });
+  }
+  /**
+   * Invalidate a specific file from the cache.
+   */
+  invalidate(filePath) {
+    this.cache.delete(filePath);
+  }
+  /**
+   * Clear the entire cache.
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get the current number of cached entries.
+   */
+  get size() {
+    return this.cache.size;
+  }
+};
+function matchesGlob(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const isMatch = picomatch(normalizedPattern, { dot: true });
+  return isMatch(normalizedPath);
+}
+function shouldExclude(filePath, patterns) {
+  return patterns.some((pattern) => matchesGlob(filePath, pattern));
+}
+var textEncoder = new TextEncoder();
+function getByteLength(content) {
+  return textEncoder.encode(content).length;
+}
+function createHashline(config) {
+  const resolved = resolveConfig(config);
+  const cache = new HashlineCache(resolved.cacheSize);
+  const hl = resolved.hashLength || 0;
+  const pfx = resolved.prefix;
+  return {
+    config: resolved,
+    cache,
+    formatFileWithHashes(content, filePath) {
+      if (filePath) {
+        const cached = cache.get(filePath, content);
+        if (cached) return cached;
+      }
+      const result = formatFileWithHashes(content, hl, pfx);
+      if (filePath) {
+        cache.set(filePath, content, result);
+      }
+      return result;
+    },
+    stripHashes(content) {
+      return stripHashes(content, pfx);
+    },
+    computeLineHash(idx, line) {
+      return computeLineHash(idx, line, hl || 3);
+    },
+    buildHashMap(content) {
+      return buildHashMap(content, hl);
+    },
+    verifyHash(lineNumber, hash, currentContent) {
+      return verifyHash(lineNumber, hash, currentContent, hl);
+    },
+    resolveRange(startRef, endRef, content) {
+      return resolveRange(startRef, endRef, content, hl);
+    },
+    replaceRange(startRef, endRef, content, replacement) {
+      return replaceRange(startRef, endRef, content, replacement, hl);
+    },
+    applyHashEdit(input, content) {
+      return applyHashEdit(input, content, hl);
+    },
+    normalizeHashRef(ref) {
+      return normalizeHashRef(ref);
+    },
+    parseHashRef(ref) {
+      return parseHashRef(ref);
+    },
+    shouldExclude(filePath) {
+      return shouldExclude(filePath, resolved.exclude);
+    }
+  };
+}
+
+export {
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_PREFIX,
+  DEFAULT_CONFIG,
+  resolveConfig,
+  getAdaptiveHashLength,
+  computeLineHash,
+  formatFileWithHashes,
+  stripHashes,
+  parseHashRef,
+  normalizeHashRef,
+  buildHashMap,
+  verifyHash,
+  resolveRange,
+  replaceRange,
+  applyHashEdit,
+  HashlineCache,
+  matchesGlob,
+  shouldExclude,
+  getByteLength,
+  createHashline
+};

package/dist/hashline-Civwirvf.d.cts

@@ -0,0 +1,278 @@
+/**
+ * Core Hashline logic — content-addressable line hashing for precise AI code editing.
+ *
+ * Each line gets a hex hash tag derived from its index and trimmed content.
+ * Hash length adapts to file size: 3 chars (≤4096 lines), 4 chars (>4096).
+ * Minimum hash length is 3 to reduce collision risk.
+ * Format: `#HL <lineNumber>:<hash>|<originalLine>`
+ *
+ * Example:
+ *   #HL 1:a3f|function hello() {
+ *   #HL 2:f1c|  return "world";
+ *   #HL 3:0e7|}
+ */
+/**
+ * Configuration object for Hashline.
+ */
+interface HashlineConfig {
+    /** Glob patterns to exclude from processing */
+    exclude?: string[];
+    /** Maximum file size in bytes to process (default: 1MB) */
+    maxFileSize?: number;
+    /** Override hash length (3–4). If not set, adaptive length is used. */
+    hashLength?: number;
+    /** LRU cache size — number of files to cache (default: 100) */
+    cacheSize?: number;
+    /**
+     * Magic prefix for hashline annotations.
+     * Default: "#HL " — lines are formatted as `#HL 1:a3f|code here`.
+     * Set to `false` to disable prefix (legacy format: `1:a3f|code here`).
+     */
+    prefix?: string | false;
+}
+/** Default exclude patterns */
+declare const DEFAULT_EXCLUDE_PATTERNS: string[];
+/** Default prefix for hashline annotations */
+declare const DEFAULT_PREFIX = "#HL ";
+/** Default configuration values */
+declare const DEFAULT_CONFIG: Required<HashlineConfig>;
+/**
+ * Merge user config with defaults.
+ *
+ * @param config - optional partial user config
+ * @param pluginConfig - optional config from plugin context (e.g. opencode.json)
+ */
+declare function resolveConfig(config?: HashlineConfig, pluginConfig?: HashlineConfig): Required<HashlineConfig>;
+/**
+ * Determine the appropriate hash length based on the number of lines.
+ *
+ * Minimum hash length is 3 to reduce collision risk.
+ * - ≤4096 lines → 3 hex chars (4096 values)
+ * - >4096 lines → 4 hex chars (65536 values)
+ */
+declare function getAdaptiveHashLength(lineCount: number): number;
+/**
+ * Compute a hex hash for a given line.
+ *
+ * Uses trimEnd() so that leading whitespace (indentation) IS significant,
+ * but trailing whitespace is ignored.
+ *
+ * @param idx - 0-based line index
+ * @param line - the raw line content
+ * @param hashLen - number of hex characters (3–4, default 3)
+ * @returns lowercase hex string of the specified length
+ */
+declare function computeLineHash(idx: number, line: string, hashLen?: number): string;
+/**
+ * Format file content with hashline annotations.
+ *
+ * Each line becomes: `<prefix><1-based lineNumber>:<hash>|<originalLine>`
+ * Hash length adapts to file size unless overridden.
+ * Includes collision detection: if two lines produce the same hash,
+ * the colliding line gets a longer hash.
+ *
+ * @param content - raw file content
+ * @param hashLen - override hash length (0 or undefined = adaptive)
+ * @param prefix - prefix string (default "#HL "), or false to disable
+ * @returns annotated content with hash prefixes
+ */
+declare function formatFileWithHashes(content: string, hashLen?: number, prefix?: string | false): string;
+/**
+ * Strip hashline prefixes to recover original file content.
+ *
+ * Recognizes the pattern `<prefix><number>:<2-8 hex>|` at the start of each line.
+ * By default looks for the `#HL ` prefix to avoid false positives.
+ *
+ * @param content - hashline-annotated content
+ * @param prefix - prefix string (default "#HL "), or false for legacy format
+ * @returns original content without hash prefixes
+ */
+declare function stripHashes(content: string, prefix?: string | false): string;
+/**
+ * Parse a hash reference like "2:f1a" or "2:f1a3" into its components.
+ *
+ * @param ref - reference string in the format "<lineNumber>:<hash>"
+ * @returns parsed line number (1-based) and hash string
+ */
+declare function parseHashRef(ref: string): {
+    line: number;
+    hash: string;
+};
+/**
+ * Normalize a hash reference.
+ *
+ * Accepts:
+ * - plain refs: `2:f1c`
+ * - annotated refs: `#HL 2:f1c|line content` or `2:f1c|line content`
+ *
+ * Returns canonical lowercased format: `<line>:<hash>`
+ */
+declare function normalizeHashRef(ref: string): string;
+/**
+ * Supported hash-aware edit operations.
+ */
+type HashEditOperation = "replace" | "delete" | "insert_before" | "insert_after";
+/**
+ * Input for hash-aware edit application.
+ */
+interface HashEditInput {
+    operation: HashEditOperation;
+    startRef: string;
+    endRef?: string;
+    replacement?: string;
+}
+/**
+ * Result of applying a hash-aware edit.
+ */
+interface HashEditResult {
+    operation: HashEditOperation;
+    startLine: number;
+    endLine: number;
+    content: string;
+}
+/**
+ * Build a mapping from hash tags to 1-based line numbers.
+ *
+ * Note: If multiple lines produce the same hash, the last one wins.
+ * In practice, collisions are rare since the hash incorporates the line index.
+ *
+ * @param content - raw file content (without hash prefixes)
+ * @param hashLen - override hash length (0 or undefined = adaptive)
+ * @returns Map from "<lineNumber>:<hash>" to 1-based line number
+ */
+declare function buildHashMap(content: string, hashLen?: number): Map<string, number>;
+/**
+ * Result of hash verification.
+ */
+interface VerifyHashResult {
+    valid: boolean;
+    expected?: string;
+    actual?: string;
+    message?: string;
+}
+/**
+ * Verify that a line's hash matches the current content.
+ *
+ * This protects against race conditions — if the file changed between
+ * read and edit, the hash won't match.
+ *
+ * The hash length is determined from the provided hash string itself
+ * (hash.length), not from the current file size. This ensures that
+ * a reference like "2:f1a" remains valid even if the file has grown.
+ *
+ * @param lineNumber - 1-based line number
+ * @param hash - expected hash from the hash reference
+ * @param currentContent - current raw file content (string or pre-split lines)
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @param lines - optional pre-split lines array to avoid re-splitting
+ * @returns verification result
+ */
+declare function verifyHash(lineNumber: number, hash: string, currentContent: string, hashLen?: number, lines?: string[]): VerifyHashResult;
+/**
+ * Result of a range resolution.
+ */
+interface ResolvedRange {
+    startLine: number;
+    endLine: number;
+    lines: string[];
+    content: string;
+}
+/**
+ * Resolve a range of lines by hash references.
+ * Splits content once and passes lines array to verifyHash to avoid redundant splits.
+ *
+ * @param startRef - start hash reference (e.g. "1:a3f")
+ * @param endRef - end hash reference (e.g. "3:0e7")
+ * @param content - raw file content
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @returns resolved range with line numbers and content
+ */
+declare function resolveRange(startRef: string, endRef: string, content: string, hashLen?: number): ResolvedRange;
+/**
+ * Replace a range of lines identified by hash references with new content.
+ * Splits content once and reuses the lines array.
+ *
+ * @param startRef - start hash reference
+ * @param endRef - end hash reference
+ * @param content - current raw file content
+ * @param replacement - new content to replace the range with
+ * @param hashLen - override hash length (0 or undefined = use hash.length from ref)
+ * @returns new file content with the range replaced
+ */
+declare function replaceRange(startRef: string, endRef: string, content: string, replacement: string, hashLen?: number): string;
+/**
+ * Apply a hash-aware edit operation directly against file content.
+ *
+ * Unlike search/replace tools, this resolves references by line+hash and
+ * verifies them before editing, so exact old-string matching is not required.
+ */
+declare function applyHashEdit(input: HashEditInput, content: string, hashLen?: number): HashEditResult;
+/**
+ * Simple LRU cache for annotated file content.
+ */
+declare class HashlineCache {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Get cached annotated content for a file, or null if not cached / stale.
+     */
+    get(filePath: string, content: string): string | null;
+    /**
+     * Store annotated content in the cache.
+     */
+    set(filePath: string, content: string, annotated: string): void;
+    /**
+     * Invalidate a specific file from the cache.
+     */
+    invalidate(filePath: string): void;
+    /**
+     * Clear the entire cache.
+     */
+    clear(): void;
+    /**
+     * Get the current number of cached entries.
+     */
+    get size(): number;
+}
+/**
+ * Glob matcher using picomatch for full glob support.
+ * Supports `*`, `**`, `?`, `{a,b}`, `[abc]`, and all standard glob patterns.
+ * Windows paths are normalized to forward slashes.
+ */
+declare function matchesGlob(filePath: string, pattern: string): boolean;
+/**
+ * Check if a file path should be excluded based on config patterns.
+ */
+declare function shouldExclude(filePath: string, patterns: string[]): boolean;
+declare function getByteLength(content: string): number;
+/**
+ * A Hashline instance with custom configuration.
+ */
+interface HashlineInstance {
+    config: Required<HashlineConfig>;
+    cache: HashlineCache;
+    formatFileWithHashes: (content: string, filePath?: string) => string;
+    stripHashes: (content: string) => string;
+    computeLineHash: (idx: number, line: string) => string;
+    buildHashMap: (content: string) => Map<string, number>;
+    verifyHash: (lineNumber: number, hash: string, currentContent: string) => VerifyHashResult;
+    resolveRange: (startRef: string, endRef: string, content: string) => ResolvedRange;
+    replaceRange: (startRef: string, endRef: string, content: string, replacement: string) => string;
+    applyHashEdit: (input: HashEditInput, content: string) => HashEditResult;
+    normalizeHashRef: (ref: string) => string;
+    parseHashRef: (ref: string) => {
+        line: number;
+        hash: string;
+    };
+    shouldExclude: (filePath: string) => boolean;
+}
+/**
+ * Create a Hashline instance with custom configuration.
+ *
+ * @param config - custom configuration options
+ * @returns configured Hashline instance
+ */
+declare function createHashline(config?: HashlineConfig): HashlineInstance;
+
+export { DEFAULT_CONFIG as D, type HashlineConfig as H, type ResolvedRange as R, type VerifyHashResult as V, type HashEditInput as a, type HashEditOperation as b, type HashEditResult as c, type HashlineInstance as d, HashlineCache as e, DEFAULT_EXCLUDE_PATTERNS as f, DEFAULT_PREFIX as g, applyHashEdit as h, buildHashMap as i, computeLineHash as j, createHashline as k, formatFileWithHashes as l, getAdaptiveHashLength as m, getByteLength as n, matchesGlob as o, normalizeHashRef as p, parseHashRef as q, replaceRange as r, resolveConfig as s, resolveRange as t, shouldExclude as u, stripHashes as v, verifyHash as w };