@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/diff/libesm/diff/css.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/diff/css.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,0BAA0B,EAAC,MAAM,aAAa,CAAC;AAEnL,cAAM,OAAQ,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM;CAGvB;AAED,eAAO,MAAM,OAAO,SAAgB,CAAC;AAErC;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,uBAAuB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACjE,SAAS,CAAA;AACZ,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,0BAA0B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACvE,SAAS,CAAA;AACZ,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,uBAAuB,GAC/B,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,0BAA0B,GACnC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

package/node_modules/diff/libesm/diff/css.js

@@ -1,10 +0,0 @@
-import Diff from './base.js';
-class CssDiff extends Diff {
-    tokenize(value) {
-        return value.split(/([{}:;,]|\s+)/);
-    }
-}
-export const cssDiff = new CssDiff();
-export function diffCss(oldStr, newStr, options) {
-    return cssDiff.diff(oldStr, newStr, options);
-}

package/node_modules/diff/libesm/diff/json.d.ts

@@ -1,24 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable } from '../types.js';
-import { tokenize } from './line.js';
-declare class JsonDiff extends Diff<string, string, string | object> {
-    get useLongestToken(): boolean;
-    tokenize: typeof tokenize;
-    castInput(value: string | object, options: DiffJsonOptionsNonabortable | DiffJsonOptionsAbortable): string;
-    equals(left: string, right: string, options: DiffJsonOptionsNonabortable | DiffJsonOptionsAbortable): boolean;
-}
-export declare const jsonDiff: JsonDiff;
-/**
- * diffs two JSON-serializable objects by first serializing them to prettily-formatted JSON and then treating each line of the JSON as a token.
- * Object properties are ordered alphabetically in the serialized JSON, so the order of properties in the objects being compared doesn't affect the result.
- *
- * @returns a list of change objects.
- */
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options?: DiffJsonOptionsNonabortable): ChangeObject<string>[];
-export declare function canonicalize(obj: any, stack: Array<any> | null, replacementStack: Array<any> | null, replacer: (k: string, v: any) => any, key?: string): any;
-export {};
-//# sourceMappingURL=json.d.ts.map

package/node_modules/diff/libesm/diff/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/diff/json.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,2BAA2B,EAAC,MAAM,aAAa,CAAC;AACrL,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1D,IAAI,eAAe,YAIlB;IAED,QAAQ,kBAAY;IAEpB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,2BAA2B,GAAG,wBAAwB;IAMjG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,2BAA2B,GAAG,wBAAwB;CAGpG;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GAClE,SAAS,CAAA;AACZ,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,2BAA2B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACxE,SAAS,CAAA;AACZ,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,GAChC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,CAAC,EAAE,2BAA2B,GACpC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AAQzB,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAC7D,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,KAAK,GAAG,EACpC,GAAG,CAAC,EAAE,MAAM,OA0Db"}

package/node_modules/diff/libesm/diff/json.js

@@ -1,78 +0,0 @@
-import Diff from './base.js';
-import { tokenize } from './line.js';
-class JsonDiff extends Diff {
-    constructor() {
-        super(...arguments);
-        this.tokenize = tokenize;
-    }
-    get useLongestToken() {
-        // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
-        // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
-        return true;
-    }
-    castInput(value, options) {
-        const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v } = options;
-        return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, '  ');
-    }
-    equals(left, right, options) {
-        return super.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
-    }
-}
-export const jsonDiff = new JsonDiff();
-export function diffJson(oldStr, newStr, options) {
-    return jsonDiff.diff(oldStr, newStr, options);
-}
-// This function handles the presence of circular references by bailing out when encountering an
-// object that is already on the "stack" of items being processed. Accepts an optional replacer
-export function canonicalize(obj, stack, replacementStack, replacer, key) {
-    stack = stack || [];
-    replacementStack = replacementStack || [];
-    if (replacer) {
-        obj = replacer(key === undefined ? '' : key, obj);
-    }
-    let i;
-    for (i = 0; i < stack.length; i += 1) {
-        if (stack[i] === obj) {
-            return replacementStack[i];
-        }
-    }
-    let canonicalizedObj;
-    if ('[object Array]' === Object.prototype.toString.call(obj)) {
-        stack.push(obj);
-        canonicalizedObj = new Array(obj.length);
-        replacementStack.push(canonicalizedObj);
-        for (i = 0; i < obj.length; i += 1) {
-            canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
-        }
-        stack.pop();
-        replacementStack.pop();
-        return canonicalizedObj;
-    }
-    if (obj && obj.toJSON) {
-        obj = obj.toJSON();
-    }
-    if (typeof obj === 'object' && obj !== null) {
-        stack.push(obj);
-        canonicalizedObj = {};
-        replacementStack.push(canonicalizedObj);
-        const sortedKeys = [];
-        let key;
-        for (key in obj) {
-            /* istanbul ignore else */
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                sortedKeys.push(key);
-            }
-        }
-        sortedKeys.sort();
-        for (i = 0; i < sortedKeys.length; i += 1) {
-            key = sortedKeys[i];
-            canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);
-        }
-        stack.pop();
-        replacementStack.pop();
-    }
-    else {
-        canonicalizedObj = obj;
-    }
-    return canonicalizedObj;
-}

package/node_modules/diff/libesm/diff/line.d.ts

@@ -1,24 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable } from '../types.js';
-declare class LineDiff extends Diff<string, string> {
-    tokenize: typeof tokenize;
-    equals(left: string, right: string, options: DiffLinesOptionsAbortable | DiffLinesOptionsNonabortable): boolean;
-}
-export declare const lineDiff: LineDiff;
-/**
- * diffs two blocks of text, treating each line as a token.
- * @returns a list of change objects.
- */
-export declare function diffLines(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffLines(oldStr: string, newStr: string, options?: DiffLinesOptionsNonabortable): ChangeObject<string>[];
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options?: DiffLinesOptionsNonabortable): ChangeObject<string>[];
-export declare function tokenize(value: string, options: DiffLinesOptionsAbortable | DiffLinesOptionsNonabortable): string[];
-export {};
-//# sourceMappingURL=line.d.ts.map

package/node_modules/diff/libesm/diff/line.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/diff/line.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,4BAA4B,EAAC,MAAM,aAAa,CAAC;AAGvL,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACzC,QAAQ,kBAAY;IAEpB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B;CAyBtG;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AAWzB,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AAOzB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B,YA0BxG"}

package/node_modules/diff/libesm/diff/line.js

@@ -1,65 +0,0 @@
-import Diff from './base.js';
-import { generateOptions } from '../util/params.js';
-class LineDiff extends Diff {
-    constructor() {
-        super(...arguments);
-        this.tokenize = tokenize;
-    }
-    equals(left, right, options) {
-        // If we're ignoring whitespace, we need to normalise lines by stripping
-        // whitespace before checking equality. (This has an annoying interaction
-        // with newlineIsToken that requires special handling: if newlines get their
-        // own token, then we DON'T want to trim the *newline* tokens down to empty
-        // strings, since this would cause us to treat whitespace-only line content
-        // as equal to a separator between lines, which would be weird and
-        // inconsistent with the documented behavior of the options.)
-        if (options.ignoreWhitespace) {
-            if (!options.newlineIsToken || !left.includes('\n')) {
-                left = left.trim();
-            }
-            if (!options.newlineIsToken || !right.includes('\n')) {
-                right = right.trim();
-            }
-        }
-        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-            if (left.endsWith('\n')) {
-                left = left.slice(0, -1);
-            }
-            if (right.endsWith('\n')) {
-                right = right.slice(0, -1);
-            }
-        }
-        return super.equals(left, right, options);
-    }
-}
-export const lineDiff = new LineDiff();
-export function diffLines(oldStr, newStr, options) {
-    return lineDiff.diff(oldStr, newStr, options);
-}
-export function diffTrimmedLines(oldStr, newStr, options) {
-    options = generateOptions(options, { ignoreWhitespace: true });
-    return lineDiff.diff(oldStr, newStr, options);
-}
-// Exported standalone so it can be used from jsonDiff too.
-export function tokenize(value, options) {
-    if (options.stripTrailingCr) {
-        // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
-        value = value.replace(/\r\n/g, '\n');
-    }
-    const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-    // Ignore the final empty token that occurs if the string ends with a new line
-    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-        linesAndNewlines.pop();
-    }
-    // Merge the content and line separators into single tokens
-    for (let i = 0; i < linesAndNewlines.length; i++) {
-        const line = linesAndNewlines[i];
-        if (i % 2 && !options.newlineIsToken) {
-            retLines[retLines.length - 1] += line;
-        }
-        else {
-            retLines.push(line);
-        }
-    }
-    return retLines;
-}

package/node_modules/diff/libesm/diff/sentence.d.ts

@@ -1,21 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable } from '../types.js';
-declare class SentenceDiff extends Diff<string, string> {
-    tokenize(value: string): string[];
-}
-export declare const sentenceDiff: SentenceDiff;
-/**
- * diffs two blocks of text, treating each sentence, and the whitespace between each pair of sentences, as a token.
- * The characters `.`, `!`, and `?`, when followed by whitespace, are treated as marking the end of a sentence; nothing else besides the end of the string is considered to mark a sentence end.
- *
- * (For more sophisticated detection of sentence breaks, including support for non-English punctuation, consider instead tokenizing with an [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) with `granularity: 'sentence'` and passing the result to `diffArrays`.)
- *
- * @returns a list of change objects.
- */
-export declare function diffSentences(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffSentences(oldStr: string, newStr: string, options?: DiffSentencesOptionsNonabortable): ChangeObject<string>[];
-export {};
-//# sourceMappingURL=sentence.d.ts.map

package/node_modules/diff/libesm/diff/sentence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sentence.d.ts","sourceRoot":"","sources":["../../src/diff/sentence.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EACV,YAAY,EACZ,uBAAuB,EACvB,0BAA0B,EAC1B,wBAAwB,EACxB,6BAA6B,EAC7B,gCAAgC,EACjC,MAAM,aAAa,CAAC;AAMrB,cAAM,YAAa,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM;CAoCvB;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACvE,SAAS,CAAA;AACZ,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gCAAgC,GAAG,0BAA0B,CAAC,MAAM,CAAC,GAC7E,SAAS,CAAA;AACZ,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gCAAgC,GACzC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

package/node_modules/diff/libesm/diff/sentence.js

@@ -1,43 +0,0 @@
-import Diff from './base.js';
-function isSentenceEndPunct(char) {
-    return char == '.' || char == '!' || char == '?';
-}
-class SentenceDiff extends Diff {
-    tokenize(value) {
-        var _a;
-        // If in future we drop support for environments that don't support lookbehinds, we can replace
-        // this entire function with:
-        //     return value.split(/(?<=[.!?])(\s+|$)/);
-        // but until then, for similar reasons to the trailingWs function in string.ts, we are forced
-        // to do this verbosely "by hand" instead of using a regex.
-        const result = [];
-        let tokenStartI = 0;
-        for (let i = 0; i < value.length; i++) {
-            if (i == value.length - 1) {
-                result.push(value.slice(tokenStartI));
-                break;
-            }
-            if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
-                // We've hit a sentence break - i.e. a punctuation mark followed by whitespace.
-                // We now want to push TWO tokens to the result:
-                // 1. the sentence
-                result.push(value.slice(tokenStartI, i + 1));
-                // 2. the whitespace
-                i = tokenStartI = i + 1;
-                while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) {
-                    i++;
-                }
-                result.push(value.slice(tokenStartI, i + 1));
-                // Then the next token (a sentence) starts on the character after the whitespace.
-                // (It's okay if this is off the end of the string - then the outer loop will terminate
-                // here anyway.)
-                tokenStartI = i + 1;
-            }
-        }
-        return result;
-    }
-}
-export const sentenceDiff = new SentenceDiff();
-export function diffSentences(oldStr, newStr, options) {
-    return sentenceDiff.diff(oldStr, newStr, options);
-}

package/node_modules/diff/libesm/diff/word.d.ts

@@ -1,35 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable } from '../types.js';
-declare class WordDiff extends Diff<string, string> {
-    equals(left: string, right: string, options: DiffWordsOptionsAbortable | DiffWordsOptionsNonabortable): boolean;
-    tokenize(value: string, options?: DiffWordsOptionsAbortable | DiffWordsOptionsNonabortable): string[];
-    join(tokens: string[]): string;
-    postProcess(changes: ChangeObject<string>[], options: any): ChangeObject<string>[];
-}
-export declare const wordDiff: WordDiff;
-/**
- * diffs two blocks of text, treating each word and each punctuation mark as a token.
- * Whitespace is ignored when computing the diff (but preserved as far as possible in the final change objects).
- *
- * @returns a list of change objects.
- */
-export declare function diffWords(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffWords(oldStr: string, newStr: string, options?: DiffWordsOptionsNonabortable): ChangeObject<string>[];
-declare class WordsWithSpaceDiff extends Diff<string, string> {
-    tokenize(value: string): [] | RegExpMatchArray;
-}
-export declare const wordsWithSpaceDiff: WordsWithSpaceDiff;
-/**
- * diffs two blocks of text, treating each word, punctuation mark, newline, or run of (non-newline) whitespace as a token.
- * @returns a list of change objects
- */
-export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffWordsWithSpace(oldStr: string, newStr: string, options?: DiffWordsOptionsNonabortable): ChangeObject<string>[];
-export {};
-//# sourceMappingURL=word.d.ts.map

package/node_modules/diff/libesm/diff/word.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"word.d.ts","sourceRoot":"","sources":["../../src/diff/word.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,4BAA4B,EAAC,MAAM,aAAa,CAAC;AAqDvL,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B;IASrG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,yBAAyB,GAAG,4BAAiC;IAwC9F,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE;IAerB,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG;CA6B1D;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AA4IzB,cAAM,kBAAmB,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM;CASvB;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

package/node_modules/diff/libesm/diff/word.js

@@ -1,281 +0,0 @@
-import Diff from './base.js';
-import { longestCommonPrefix, longestCommonSuffix, replacePrefix, replaceSuffix, removePrefix, removeSuffix, maximumOverlap, leadingWs, trailingWs, leadingAndTrailingWs, segment } from '../util/string.js';
-// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
-//
-// Chars/ranges counted as "word" characters by this regex are as follows:
-//
-// + U+00AD  Soft hyphen
-// + 00C0–00FF (letters with diacritics from the Latin-1 Supplement), except:
-//   - U+00D7  × Multiplication sign
-//   - U+00F7  ÷ Division sign
-// + Latin Extended-A, 0100–017F
-// + Latin Extended-B, 0180–024F
-// + IPA Extensions, 0250–02AF
-// + Spacing Modifier Letters, 02B0–02FF, except:
-//   - U+02C7  ˇ ˇ  Caron
-//   - U+02D8  ˘ ˘  Breve
-//   - U+02D9  ˙ ˙  Dot Above
-//   - U+02DA  ˚ ˚  Ring Above
-//   - U+02DB  ˛ ˛  Ogonek
-//   - U+02DC  ˜ ˜  Small Tilde
-//   - U+02DD  ˝ ˝  Double Acute Accent
-// + Latin Extended Additional, 1E00–1EFF
-const extendedWordChars = 'a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}';
-// Each token is one of the following:
-// - A punctuation mark plus the surrounding whitespace
-// - A word plus the surrounding whitespace
-// - Pure whitespace (but only in the special case where the entire text
-//   is just whitespace)
-//
-// We have to include surrounding whitespace in the tokens because the two
-// alternative approaches produce horribly broken results:
-// * If we just discard the whitespace, we can't fully reproduce the original
-//   text from the sequence of tokens and any attempt to render the diff will
-//   get the whitespace wrong.
-// * If we have separate tokens for whitespace, then in a typical text every
-//   second token will be a single space character. But this often results in
-//   the optimal diff between two texts being a perverse one that preserves
-//   the spaces between words but deletes and reinserts actual common words.
-//   See https://github.com/kpdecker/jsdiff/issues/160#issuecomment-1866099640
-//   for an example.
-//
-// Keeping the surrounding whitespace of course has implications for .equals
-// and .join, not just .tokenize.
-// This regex does NOT fully implement the tokenization rules described above.
-// Instead, it gives runs of whitespace their own "token". The tokenize method
-// then handles stitching whitespace tokens onto adjacent word or punctuation
-// tokens.
-const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, 'ug');
-class WordDiff extends Diff {
-    equals(left, right, options) {
-        if (options.ignoreCase) {
-            left = left.toLowerCase();
-            right = right.toLowerCase();
-        }
-        return left.trim() === right.trim();
-    }
-    tokenize(value, options = {}) {
-        let parts;
-        if (options.intlSegmenter) {
-            const segmenter = options.intlSegmenter;
-            if (segmenter.resolvedOptions().granularity != 'word') {
-                throw new Error('The segmenter passed must have a granularity of "word"');
-            }
-            // We want `parts` to be an array whose elements alternate between being
-            // pure whitespace and being pure non-whitespace. This is ALMOST what the
-            // segments returned by a word-based Intl.Segmenter already look like,
-            // but not quite - see explanation in the docs of our custom segment()
-            // function.
-            parts = segment(value, segmenter);
-        }
-        else {
-            parts = value.match(tokenizeIncludingWhitespace) || [];
-        }
-        const tokens = [];
-        let prevPart = null;
-        parts.forEach(part => {
-            if ((/\s/).test(part)) {
-                if (prevPart == null) {
-                    tokens.push(part);
-                }
-                else {
-                    tokens.push(tokens.pop() + part);
-                }
-            }
-            else if (prevPart != null && (/\s/).test(prevPart)) {
-                if (tokens[tokens.length - 1] == prevPart) {
-                    tokens.push(tokens.pop() + part);
-                }
-                else {
-                    tokens.push(prevPart + part);
-                }
-            }
-            else {
-                tokens.push(part);
-            }
-            prevPart = part;
-        });
-        return tokens;
-    }
-    join(tokens) {
-        // Tokens being joined here will always have appeared consecutively in the
-        // same text, so we can simply strip off the leading whitespace from all the
-        // tokens except the first (and except any whitespace-only tokens - but such
-        // a token will always be the first and only token anyway) and then join them
-        // and the whitespace around words and punctuation will end up correct.
-        return tokens.map((token, i) => {
-            if (i == 0) {
-                return token;
-            }
-            else {
-                return token.replace((/^\s+/), '');
-            }
-        }).join('');
-    }
-    postProcess(changes, options) {
-        if (!changes || options.oneChangePerToken) {
-            return changes;
-        }
-        let lastKeep = null;
-        // Change objects representing any insertion or deletion since the last
-        // "keep" change object. There can be at most one of each.
-        let insertion = null;
-        let deletion = null;
-        changes.forEach(change => {
-            if (change.added) {
-                insertion = change;
-            }
-            else if (change.removed) {
-                deletion = change;
-            }
-            else {
-                if (insertion || deletion) { // May be false at start of text
-                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
-                }
-                lastKeep = change;
-                insertion = null;
-                deletion = null;
-            }
-        });
-        if (insertion || deletion) {
-            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
-        }
-        return changes;
-    }
-}
-export const wordDiff = new WordDiff();
-export function diffWords(oldStr, newStr, options) {
-    // This option has never been documented and never will be (it's clearer to
-    // just call `diffWordsWithSpace` directly if you need that behavior), but
-    // has existed in jsdiff for a long time, so we retain support for it here
-    // for the sake of backwards compatibility.
-    if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
-        return diffWordsWithSpace(oldStr, newStr, options);
-    }
-    return wordDiff.diff(oldStr, newStr, options);
-}
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
-    // Before returning, we tidy up the leading and trailing whitespace of the
-    // change objects to eliminate cases where trailing whitespace in one object
-    // is repeated as leading whitespace in the next.
-    // Below are examples of the outcomes we want here to explain the code.
-    // I=insert, K=keep, D=delete
-    // 1. diffing 'foo bar baz' vs 'foo baz'
-    //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'
-    //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'
-    //
-    // 2. Diffing 'foo bar baz' vs 'foo qux baz'
-    //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'
-    //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'
-    //
-    // 3. Diffing 'foo\nbar baz' vs 'foo baz'
-    //    Prior to cleanup, we have K:'foo ' D:'\nbar ' K:' baz'
-    //    After cleanup, we want K'foo' D:'\nbar' K:' baz'
-    //
-    // 4. Diffing 'foo baz' vs 'foo\nbar baz'
-    //    Prior to cleanup, we have K:'foo\n' I:'\nbar ' K:' baz'
-    //    After cleanup, we ideally want K'foo' I:'\nbar' K:' baz'
-    //    but don't actually manage this currently (the pre-cleanup change
-    //    objects don't contain enough information to make it possible).
-    //
-    // 5. Diffing 'foo   bar baz' vs 'foo  baz'
-    //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'
-    //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'
-    //
-    // Our handling is unavoidably imperfect in the case where there's a single
-    // indel between keeps and the whitespace has changed. For instance, consider
-    // diffing 'foo\tbar\nbaz' vs 'foo baz'. Unless we create an extra change
-    // object to represent the insertion of the space character (which isn't even
-    // a token), we have no way to avoid losing information about the texts'
-    // original whitespace in the result we return. Still, we do our best to
-    // output something that will look sensible if we e.g. print it with
-    // insertions in green and deletions in red.
-    // Between two "keep" change objects (or before the first or after the last
-    // change object), we can have either:
-    // * A "delete" followed by an "insert"
-    // * Just an "insert"
-    // * Just a "delete"
-    // We handle the three cases separately.
-    if (deletion && insertion) {
-        const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
-        const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
-        if (startKeep) {
-            const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-            startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-            deletion.value = removePrefix(deletion.value, commonWsPrefix);
-            insertion.value = removePrefix(insertion.value, commonWsPrefix);
-        }
-        if (endKeep) {
-            const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-            endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-            deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-            insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-        }
-    }
-    else if (insertion) {
-        // The whitespaces all reflect what was in the new text rather than
-        // the old, so we essentially have no information about whitespace
-        // insertion or deletion. We just want to dedupe the whitespace.
-        // We do that by having each change object keep its trailing
-        // whitespace and deleting duplicate leading whitespace where
-        // present.
-        if (startKeep) {
-            const ws = leadingWs(insertion.value, segmenter);
-            insertion.value = insertion.value.substring(ws.length);
-        }
-        if (endKeep) {
-            const ws = leadingWs(endKeep.value, segmenter);
-            endKeep.value = endKeep.value.substring(ws.length);
-        }
-        // otherwise we've got a deletion and no insertion
-    }
-    else if (startKeep && endKeep) {
-        const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
-        // Any whitespace that comes straight after startKeep in both the old and
-        // new texts, assign to startKeep and remove from the deletion.
-        const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-        deletion.value = removePrefix(deletion.value, newWsStart);
-        // Any whitespace that comes straight before endKeep in both the old and
-        // new texts, and hasn't already been assigned to startKeep, assign to
-        // endKeep and remove from the deletion.
-        const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-        deletion.value = removeSuffix(deletion.value, newWsEnd);
-        endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-        // If there's any whitespace from the new text that HASN'T already been
-        // assigned, assign it to the start:
-        startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-    }
-    else if (endKeep) {
-        // We are at the start of the text. Preserve all the whitespace on
-        // endKeep, and just remove whitespace from the end of deletion to the
-        // extent that it overlaps with the start of endKeep.
-        const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
-        const deletionWsSuffix = trailingWs(deletion.value, segmenter);
-        const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
-        deletion.value = removeSuffix(deletion.value, overlap);
-    }
-    else if (startKeep) {
-        // We are at the END of the text. Preserve all the whitespace on
-        // startKeep, and just remove whitespace from the start of deletion to
-        // the extent that it overlaps with the end of startKeep.
-        const startKeepWsSuffix = trailingWs(startKeep.value, segmenter);
-        const deletionWsPrefix = leadingWs(deletion.value, segmenter);
-        const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-        deletion.value = removePrefix(deletion.value, overlap);
-    }
-}
-class WordsWithSpaceDiff extends Diff {
-    tokenize(value) {
-        // Slightly different to the tokenizeIncludingWhitespace regex used above in
-        // that this one treats each individual newline as a distinct token, rather
-        // than merging them into other surrounding whitespace. This was requested
-        // in https://github.com/kpdecker/jsdiff/issues/180 &
-        //    https://github.com/kpdecker/jsdiff/issues/211
-        const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, 'ug');
-        return value.match(regex) || [];
-    }
-}
-export const wordsWithSpaceDiff = new WordsWithSpaceDiff();
-export function diffWordsWithSpace(oldStr, newStr, options) {
-    return wordsWithSpaceDiff.diff(oldStr, newStr, options);
-}

package/node_modules/diff/libesm/index.d.ts

@@ -1,20 +0,0 @@
-import Diff from './diff/base.js';
-import { diffChars, characterDiff } from './diff/character.js';
-import { diffWords, diffWordsWithSpace, wordDiff, wordsWithSpaceDiff } from './diff/word.js';
-import { diffLines, diffTrimmedLines, lineDiff } from './diff/line.js';
-import { diffSentences, sentenceDiff } from './diff/sentence.js';
-import { diffCss, cssDiff } from './diff/css.js';
-import { diffJson, canonicalize, jsonDiff } from './diff/json.js';
-import { diffArrays, arrayDiff } from './diff/array.js';
-import { applyPatch, applyPatches } from './patch/apply.js';
-import type { ApplyPatchOptions, ApplyPatchesOptions } from './patch/apply.js';
-import { parsePatch } from './patch/parse.js';
-import { reversePatch } from './patch/reverse.js';
-import { structuredPatch, createTwoFilesPatch, createPatch, formatPatch, INCLUDE_HEADERS, FILE_HEADERS_ONLY, OMIT_HEADERS } from './patch/create.js';
-import type { StructuredPatchOptionsAbortable, StructuredPatchOptionsNonabortable, CreatePatchOptionsAbortable, CreatePatchOptionsNonabortable, HeaderOptions } from './patch/create.js';
-import { convertChangesToDMP } from './convert/dmp.js';
-import { convertChangesToXML } from './convert/xml.js';
-import type { ChangeObject, Change, ArrayChange, DiffArraysOptionsAbortable, DiffArraysOptionsNonabortable, DiffCharsOptionsAbortable, DiffCharsOptionsNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable, DiffCssOptionsAbortable, DiffCssOptionsNonabortable, StructuredPatch, StructuredPatchHunk } from './types.js';
-export { Diff, diffChars, characterDiff, diffWords, wordDiff, diffWordsWithSpace, wordsWithSpaceDiff, diffLines, lineDiff, diffTrimmedLines, diffSentences, sentenceDiff, diffCss, cssDiff, diffJson, jsonDiff, diffArrays, arrayDiff, structuredPatch, createTwoFilesPatch, createPatch, formatPatch, INCLUDE_HEADERS, FILE_HEADERS_ONLY, OMIT_HEADERS, applyPatch, applyPatches, parsePatch, reversePatch, convertChangesToDMP, convertChangesToXML, canonicalize };
-export type { ChangeObject, Change, ArrayChange, DiffArraysOptionsAbortable, DiffArraysOptionsNonabortable, DiffCharsOptionsAbortable, DiffCharsOptionsNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable, DiffCssOptionsAbortable, DiffCssOptionsNonabortable, StructuredPatch, StructuredPatchHunk, ApplyPatchOptions, ApplyPatchesOptions, StructuredPatchOptionsAbortable, StructuredPatchOptionsNonabortable, CreatePatchOptionsAbortable, CreatePatchOptionsNonabortable, HeaderOptions };
-//# sourceMappingURL=index.d.ts.map