@deepcitation/deepcitation-js 1.1.27 → 1.1.29

package/lib/utils/diff.js

@@ -1,414 +0,0 @@
-/**
- * Custom diff implementation to replace the 'diff' npm package.
- * This avoids dependency issues in Firebase Functions environments.
- *
- * Implements a Myers diff algorithm with optimizations inspired by jsdiff.
- * @see https://github.com/kpdecker/jsdiff
- *
- * ---
- *
- * BSD 3-Clause License
- *
- * Copyright (c) 2009-2015, Kevin Decker <kpdecker@gmail.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * Myers diff algorithm with diagonal pruning optimization.
- * This reduces complexity from O(n+d²) to O(n+d) for common cases like appending text.
- *
- * @see https://blog.jcoglan.com/2017/02/12/the-myers-diff-algorithm-part-1/
- */
-function computeDiff(oldTokens, newTokens, equals = (a, b) => a === b) {
-    const oldLen = oldTokens.length;
-    const newLen = newTokens.length;
-    // Handle edge cases
-    if (oldLen === 0 && newLen === 0) {
-        return [];
-    }
-    // Quick path for completely new content
-    if (oldLen === 0) {
-        return [{ value: newTokens.join(""), added: true, count: newTokens.length }];
-    }
-    // Quick path for completely removed content
-    if (newLen === 0) {
-        return [
-            { value: oldTokens.join(""), removed: true, count: oldTokens.length },
-        ];
-    }
-    // Find common prefix
-    let commonPrefixLen = 0;
-    while (commonPrefixLen < oldLen &&
-        commonPrefixLen < newLen &&
-        equals(oldTokens[commonPrefixLen], newTokens[commonPrefixLen])) {
-        commonPrefixLen++;
-    }
-    // Find common suffix (but don't overlap with prefix)
-    let commonSuffixLen = 0;
-    while (commonSuffixLen < oldLen - commonPrefixLen &&
-        commonSuffixLen < newLen - commonPrefixLen &&
-        equals(oldTokens[oldLen - 1 - commonSuffixLen], newTokens[newLen - 1 - commonSuffixLen])) {
-        commonSuffixLen++;
-    }
-    // Extract the differing middle portions
-    const oldMiddle = oldTokens.slice(commonPrefixLen, oldLen - commonSuffixLen);
-    const newMiddle = newTokens.slice(commonPrefixLen, newLen - commonSuffixLen);
-    // If middles are empty, we only have common prefix/suffix
-    if (oldMiddle.length === 0 && newMiddle.length === 0) {
-        return [{ value: oldTokens.join(""), count: oldTokens.length }];
-    }
-    // Compute diff on the middle portion using Myers algorithm
-    const middleDiff = myersDiff(oldMiddle, newMiddle, equals);
-    // Build result with prefix, middle diff, and suffix
-    const result = [];
-    if (commonPrefixLen > 0) {
-        result.push({
-            value: oldTokens.slice(0, commonPrefixLen).join(""),
-            count: commonPrefixLen,
-        });
-    }
-    result.push(...middleDiff);
-    if (commonSuffixLen > 0) {
-        result.push({
-            value: oldTokens.slice(oldLen - commonSuffixLen).join(""),
-            count: commonSuffixLen,
-        });
-    }
-    return mergeConsecutiveChanges(result);
-}
-/**
- * Myers diff algorithm implementation.
- * Uses the "middle snake" approach for better memory efficiency.
- */
-function myersDiff(oldTokens, newTokens, equals) {
-    const oldLen = oldTokens.length;
-    const newLen = newTokens.length;
-    const maxD = oldLen + newLen;
-    // V array indexed by k = x - y (diagonal)
-    // We use an object to handle negative indices
-    const v = { 1: 0 };
-    // Store the path for backtracking
-    const trace = [];
-    // Iterate through edit distances
-    outer: for (let d = 0; d <= maxD; d++) {
-        trace.push({ ...v });
-        // Iterate through diagonals
-        for (let k = -d; k <= d; k += 2) {
-            // Decide whether to go down or right
-            let x;
-            if (k === -d || (k !== d && v[k - 1] < v[k + 1])) {
-                x = v[k + 1]; // Move down (insert)
-            }
-            else {
-                x = v[k - 1] + 1; // Move right (delete)
-            }
-            let y = x - k;
-            // Follow diagonal (matches)
-            while (x < oldLen && y < newLen && equals(oldTokens[x], newTokens[y])) {
-                x++;
-                y++;
-            }
-            v[k] = x;
-            // Check if we've reached the end
-            if (x >= oldLen && y >= newLen) {
-                break outer;
-            }
-        }
-    }
-    // Backtrack to build the diff
-    return backtrack(trace, oldTokens, newTokens);
-}
-/**
- * Backtrack through the trace to build the diff result.
- */
-function backtrack(trace, oldTokens, newTokens) {
-    const changes = [];
-    let x = oldTokens.length;
-    let y = newTokens.length;
-    for (let d = trace.length - 1; d >= 0; d--) {
-        const v = trace[d];
-        const k = x - y;
-        let prevK;
-        if (k === -d || (k !== d && v[k - 1] < v[k + 1])) {
-            prevK = k + 1;
-        }
-        else {
-            prevK = k - 1;
-        }
-        const prevX = v[prevK] ?? 0;
-        const prevY = prevX - prevK;
-        // Add diagonal matches (unchanged)
-        while (x > prevX && y > prevY) {
-            x--;
-            y--;
-            changes.unshift({ value: oldTokens[x], count: 1 });
-        }
-        if (d > 0) {
-            if (x === prevX) {
-                // Insertion (went down)
-                y--;
-                changes.unshift({ value: newTokens[y], added: true, count: 1 });
-            }
-            else {
-                // Deletion (went right)
-                x--;
-                changes.unshift({ value: oldTokens[x], removed: true, count: 1 });
-            }
-        }
-    }
-    return changes;
-}
-/**
- * Merge consecutive changes of the same type.
- */
-function mergeConsecutiveChanges(changes) {
-    if (changes.length === 0)
-        return [];
-    const result = [];
-    for (const change of changes) {
-        const last = result[result.length - 1];
-        if (last &&
-            last.added === change.added &&
-            last.removed === change.removed) {
-            last.value += change.value;
-            last.count = (last.count || 1) + (change.count || 1);
-        }
-        else {
-            result.push({ ...change });
-        }
-    }
-    return result;
-}
-/**
- * Split text into lines, preserving line endings.
- * Handles both Unix (\n) and Windows (\r\n) line endings.
- */
-function splitLines(text) {
-    if (!text)
-        return [];
-    const lines = [];
-    let current = "";
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        current += char;
-        if (char === "\n") {
-            lines.push(current);
-            current = "";
-        }
-    }
-    // Don't forget the last line if it doesn't end with newline
-    if (current.length > 0) {
-        lines.push(current);
-    }
-    return lines;
-}
-/**
- * Extended word character class - matches jsdiff's extendedWordChars.
- * Includes: a-zA-Z0-9_, soft hyphen, Latin Extended-A/B, IPA Extensions,
- * Spacing Modifier Letters, and Latin Extended Additional.
- *
- * @see https://github.com/kpdecker/jsdiff/blob/master/src/diff/word.ts
- */
-const EXTENDED_WORD_CHARS = "a-zA-Z0-9_\\u00AD\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C6\\u02C8-\\u02D7\\u02DE-\\u02FF\\u1E00-\\u1EFF";
-/**
- * Tokenization regex matching jsdiff's approach.
- * Matches: word character runs, whitespace runs, or single non-word chars.
- */
-const TOKENIZE_REGEX = new RegExp(`[${EXTENDED_WORD_CHARS}]+|\\s+|[^${EXTENDED_WORD_CHARS}]`, "gu");
-/**
- * Split text into tokens using jsdiff's tokenization approach.
- * Each token is one of:
- * - A word (extended word characters)
- * - A whitespace run
- * - A single punctuation/symbol character
- */
-function tokenizeWords(text) {
-    if (!text)
-        return [];
-    return text.match(TOKENIZE_REGEX) || [];
-}
-/**
- * Find the longest common prefix between two strings.
- */
-function longestCommonPrefix(a, b) {
-    let i = 0;
-    while (i < a.length && i < b.length && a[i] === b[i]) {
-        i++;
-    }
-    return a.slice(0, i);
-}
-/**
- * Find the longest common suffix between two strings.
- */
-function longestCommonSuffix(a, b) {
-    let i = 0;
-    while (i < a.length &&
-        i < b.length &&
-        a[a.length - 1 - i] === b[b.length - 1 - i]) {
-        i++;
-    }
-    return a.slice(a.length - i);
-}
-/**
- * Check if a string is only whitespace.
- */
-function isWhitespace(str) {
-    return /^\s*$/.test(str);
-}
-/**
- * Deduplicate whitespace in change objects.
- * This is a simplified version of jsdiff's dedupeWhitespaceInChangeObjects.
- *
- * Handles three main scenarios:
- * 1. Deletion followed by insertion - extract common leading/trailing whitespace
- * 2. Lone insertion after unchanged - strip duplicate leading whitespace
- * 3. Lone deletion between unchanged - distribute whitespace properly
- */
-function dedupeWhitespaceInChangeObjects(changes) {
-    const result = [];
-    for (let i = 0; i < changes.length; i++) {
-        const change = changes[i];
-        // Scenario 1: Deletion followed by insertion
-        if (change.removed && changes[i + 1]?.added) {
-            const deletion = change;
-            const insertion = changes[i + 1];
-            // Find common prefix (must be whitespace)
-            const commonPrefix = longestCommonPrefix(deletion.value, insertion.value);
-            const wsPrefix = commonPrefix.match(/^\s*/)?.[0] || "";
-            // Find common suffix (must be whitespace)
-            const delWithoutPrefix = deletion.value.slice(wsPrefix.length);
-            const insWithoutPrefix = insertion.value.slice(wsPrefix.length);
-            const commonSuffix = longestCommonSuffix(delWithoutPrefix, insWithoutPrefix);
-            const wsSuffix = commonSuffix.match(/\s*$/)?.[0] || "";
-            // Build the cleaned changes
-            if (wsPrefix) {
-                result.push({ value: wsPrefix, count: 1 });
-            }
-            const cleanedDel = deletion.value.slice(wsPrefix.length, deletion.value.length - wsSuffix.length);
-            const cleanedIns = insertion.value.slice(wsPrefix.length, insertion.value.length - wsSuffix.length);
-            if (cleanedDel) {
-                result.push({ value: cleanedDel, removed: true, count: 1 });
-            }
-            if (cleanedIns) {
-                result.push({ value: cleanedIns, added: true, count: 1 });
-            }
-            if (wsSuffix) {
-                result.push({ value: wsSuffix, count: 1 });
-            }
-            i++; // Skip the insertion since we processed it
-            continue;
-        }
-        // Scenario 2: Lone insertion after unchanged text
-        if (change.added && i > 0 && !changes[i - 1].added && !changes[i - 1].removed) {
-            const prev = result[result.length - 1];
-            if (prev && !prev.added && !prev.removed) {
-                // Check for duplicate leading whitespace
-                const leadingWs = change.value.match(/^\s*/)?.[0] || "";
-                const trailingWs = prev.value.match(/\s*$/)?.[0] || "";
-                if (leadingWs && trailingWs) {
-                    const overlap = longestCommonSuffix(trailingWs, leadingWs);
-                    if (overlap) {
-                        // Remove overlap from the insertion
-                        result.push({
-                            value: change.value.slice(overlap.length),
-                            added: true,
-                            count: 1,
-                        });
-                        continue;
-                    }
-                }
-            }
-        }
-        // Scenario 3: Lone deletion between unchanged text
-        if (change.removed &&
-            !changes[i + 1]?.added &&
-            i > 0 &&
-            !changes[i - 1]?.added &&
-            !changes[i - 1]?.removed) {
-            const prev = result[result.length - 1];
-            const next = changes[i + 1];
-            if (prev && next && !next.added && !next.removed) {
-                const leadingWs = change.value.match(/^\s*/)?.[0] || "";
-                const trailingWs = change.value.match(/\s*$/)?.[0] || "";
-                const prevTrailingWs = prev.value.match(/\s*$/)?.[0] || "";
-                const nextLeadingWs = next.value.match(/^\s*/)?.[0] || "";
-                // If deletion starts/ends with whitespace that overlaps with neighbors
-                if (leadingWs && prevTrailingWs) {
-                    const overlap = longestCommonSuffix(prevTrailingWs, leadingWs);
-                    if (overlap.length === leadingWs.length) {
-                        // Leading whitespace is already in prev, strip it
-                        result.push({
-                            value: change.value.slice(leadingWs.length),
-                            removed: true,
-                            count: 1,
-                        });
-                        continue;
-                    }
-                }
-                if (trailingWs && nextLeadingWs) {
-                    const overlap = longestCommonPrefix(trailingWs, nextLeadingWs);
-                    if (overlap.length === trailingWs.length) {
-                        // Trailing whitespace will be in next, strip it
-                        result.push({
-                            value: change.value.slice(0, -trailingWs.length) || change.value,
-                            removed: true,
-                            count: 1,
-                        });
-                        continue;
-                    }
-                }
-            }
-        }
-        // Default: just add the change as-is
-        result.push({ ...change });
-    }
-    return mergeConsecutiveChanges(result);
-}
-/**
- * Compare two strings line by line.
- * Similar to Diff.diffLines from the 'diff' package.
- */
-export function diffLines(oldStr, newStr) {
-    const oldLines = splitLines(oldStr);
-    const newLines = splitLines(newStr);
-    return computeDiff(oldLines, newLines);
-}
-/**
- * Compare two strings word by word, preserving whitespace.
- * Similar to Diff.diffWordsWithSpace from the 'diff' package.
- *
- * Features matching jsdiff:
- * - Extended Unicode word character support
- * - Proper tokenization (words, whitespace runs, single punctuation)
- * - Whitespace deduplication in consecutive changes
- */
-export function diffWordsWithSpace(oldStr, newStr) {
-    const oldWords = tokenizeWords(oldStr);
-    const newWords = tokenizeWords(newStr);
-    const diff = computeDiff(oldWords, newWords);
-    return dedupeWhitespaceInChangeObjects(diff);
-}

package/lib/utils/sha.d.ts

@@ -1,10 +0,0 @@
-/**
- * Pure JavaScript SHA-1 implementation.
- * Based on the FIPS 180-4 specification.
- * No external dependencies.
- */
-/**
- * Computes a SHA-1 hash of the provided data.
- * Used internally by generateCitationKey in react/utils.ts
- */
-export declare function sha1Hash(data: string | any): string;

package/lib/utils/sha.js

@@ -1,108 +0,0 @@
-/**
- * Pure JavaScript SHA-1 implementation.
- * Based on the FIPS 180-4 specification.
- * No external dependencies.
- */
-function utf8Encode(str) {
-    const encoder = new TextEncoder();
-    return encoder.encode(str);
-}
-function sha1(message) {
-    // Initial hash values
-    let h0 = 0x67452301;
-    let h1 = 0xefcdab89;
-    let h2 = 0x98badcfe;
-    let h3 = 0x10325476;
-    let h4 = 0xc3d2e1f0;
-    // Pre-processing: adding padding bits
-    const msgLen = message.length;
-    const bitLen = msgLen * 8;
-    // Calculate padded length: message + 1 (0x80) + padding + 8 (length)
-    // Total must be multiple of 64 bytes (512 bits)
-    const totalLen = msgLen + 1 + 8; // minimum: msg + 0x80 + 64-bit length
-    const paddedLen = Math.ceil(totalLen / 64) * 64;
-    // Create padded buffer
-    const padded = new ArrayBuffer(paddedLen);
-    const paddedView = new Uint8Array(padded);
-    const dataView = new DataView(padded);
-    // Copy message
-    paddedView.set(message);
-    // Append bit '1' (0x80)
-    paddedView[msgLen] = 0x80;
-    // Append length as 64-bit big-endian (in bits)
-    // High 32 bits (for messages > 512MB, which we don't support)
-    dataView.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
-    // Low 32 bits
-    dataView.setUint32(paddedLen - 4, bitLen >>> 0, false);
-    // Process each 512-bit (64-byte) chunk
-    const w = new Uint32Array(80);
-    for (let offset = 0; offset < paddedLen; offset += 64) {
-        // Break chunk into sixteen 32-bit big-endian words
-        for (let i = 0; i < 16; i++) {
-            w[i] = dataView.getUint32(offset + i * 4, false);
-        }
-        // Extend the sixteen 32-bit words into eighty 32-bit words
-        for (let i = 16; i < 80; i++) {
-            const val = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
-            w[i] = (val << 1) | (val >>> 31);
-        }
-        // Initialize working variables
-        let a = h0;
-        let b = h1;
-        let c = h2;
-        let d = h3;
-        let e = h4;
-        // Main loop
-        for (let i = 0; i < 80; i++) {
-            let f;
-            let k;
-            if (i < 20) {
-                f = (b & c) | (~b & d);
-                k = 0x5a827999;
-            }
-            else if (i < 40) {
-                f = b ^ c ^ d;
-                k = 0x6ed9eba1;
-            }
-            else if (i < 60) {
-                f = (b & c) | (b & d) | (c & d);
-                k = 0x8f1bbcdc;
-            }
-            else {
-                f = b ^ c ^ d;
-                k = 0xca62c1d6;
-            }
-            const temp = (((a << 5) | (a >>> 27)) + f + e + k + w[i]) >>> 0;
-            e = d;
-            d = c;
-            c = ((b << 30) | (b >>> 2)) >>> 0;
-            b = a;
-            a = temp;
-        }
-        // Add this chunk's hash to result
-        h0 = (h0 + a) >>> 0;
-        h1 = (h1 + b) >>> 0;
-        h2 = (h2 + c) >>> 0;
-        h3 = (h3 + d) >>> 0;
-        h4 = (h4 + e) >>> 0;
-    }
-    // Produce the final hash value (160-bit) as hex string
-    const hex = (n) => n.toString(16).padStart(8, "0");
-    return hex(h0) + hex(h1) + hex(h2) + hex(h3) + hex(h4);
-}
-/**
- * Computes a SHA-1 hash of the provided data.
- * Used internally by generateCitationKey in react/utils.ts
- */
-export function sha1Hash(data) {
-    try {
-        if (!data)
-            return "";
-        const str = typeof data === "string" ? data : JSON.stringify(data);
-        return sha1(utf8Encode(str));
-    }
-    catch (error) {
-        console.error("Error in making the hash:", error);
-    }
-    return "";
-}