@gfdelarue/testkit 0.3.0

package/node_modules/diff/libcjs/types.d.ts

@@ -0,0 +1,260 @@
+export interface ChangeObject<ValueT> {
+    /**
+     * The concatenated content of all the tokens represented by this change object - i.e. generally the text that is either added, deleted, or common, as a single string.
+     * In cases where tokens are considered common but are non-identical (e.g. because an option like `ignoreCase` or a custom `comparator` was used), the value from the *new* string will be provided here.
+     */
+    value: ValueT;
+    /**
+     * true if the value was inserted into the new string, otherwise false
+     */
+    added: boolean;
+    /**
+     * true if the value was removed from the old string, otherwise false
+     */
+    removed: boolean;
+    /**
+     * How many tokens (e.g. chars for `diffChars`, lines for `diffLines`) the value in the change object consists of
+     */
+    count: number;
+}
+export type Change = ChangeObject<string>;
+export type ArrayChange<T> = ChangeObject<T[]>;
+export interface CommonDiffOptions {
+    /**
+     * If `true`, the array of change objects returned will contain one change object per token (e.g. one per line if calling `diffLines`), instead of runs of consecutive tokens that are all added / all removed / all conserved being combined into a single change object.
+     */
+    oneChangePerToken?: boolean;
+}
+export interface TimeoutOption {
+    /**
+     * A number of milliseconds after which the diffing algorithm will abort and return `undefined`.
+     * Supported by the same functions as `maxEditLength`.
+     */
+    timeout: number;
+}
+export interface MaxEditLengthOption {
+    /**
+     * A number specifying the maximum edit distance to consider between the old and new texts.
+     * You can use this to limit the computational cost of diffing large, very different texts by giving up early if the cost will be huge.
+     * This option can be passed either to diffing functions (`diffLines`, `diffChars`, etc) or to patch-creation function (`structuredPatch`, `createPatch`, etc), all of which will indicate that the max edit length was reached by returning `undefined` instead of whatever they'd normally return.
+     */
+    maxEditLength: number;
+}
+export type AbortableDiffOptions = TimeoutOption | MaxEditLengthOption;
+export type DiffCallbackNonabortable<T> = (result: ChangeObject<T>[]) => void;
+export type DiffCallbackAbortable<T> = (result: ChangeObject<T>[] | undefined) => void;
+export interface CallbackOptionNonabortable<T> {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback: DiffCallbackNonabortable<T>;
+}
+export interface CallbackOptionAbortable<T> {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback: DiffCallbackAbortable<T>;
+}
+interface DiffArraysOptions<T> extends CommonDiffOptions {
+    comparator?: (a: T, b: T) => boolean;
+}
+export interface DiffArraysOptionsNonabortable<T> extends DiffArraysOptions<T> {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<T[]>;
+}
+export type DiffArraysOptionsAbortable<T> = DiffArraysOptions<T> & AbortableDiffOptions & Partial<CallbackOptionAbortable<T[]>>;
+interface DiffCharsOptions extends CommonDiffOptions {
+    /**
+     * If `true`, the uppercase and lowercase forms of a character are considered equal.
+     * @default false
+     */
+    ignoreCase?: boolean;
+}
+export interface DiffCharsOptionsNonabortable extends DiffCharsOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffCharsOptionsAbortable = DiffCharsOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffLinesOptions extends CommonDiffOptions {
+    /**
+     * `true` to remove all trailing CR (`\r`) characters before performing the diff.
+     * This helps to get a useful diff when diffing UNIX text files against Windows text files.
+     * @default false
+     */
+    stripTrailingCr?: boolean;
+    /**
+     * `true` to treat the newline character at the end of each line as its own token.
+     * This allows for changes to the newline structure to occur independently of the line content and to be treated as such.
+     * In general this is the more human friendly form of `diffLines`; the default behavior with this option turned off is better suited for patches and other computer friendly output.
+     *
+     * Note that while using `ignoreWhitespace` in combination with `newlineIsToken` is not an error, results may not be as expected.
+     * With `ignoreWhitespace: true` and `newlineIsToken: false`, changing a completely empty line to contain some spaces is treated as a non-change, but with `ignoreWhitespace: true` and `newlineIsToken: true`, it is treated as an insertion.
+     * This is because the content of a completely blank line is not a token at all in `newlineIsToken` mode.
+     *
+     * @default false
+     */
+    newlineIsToken?: boolean;
+    /**
+     * `true` to ignore a missing newline character at the end of the last line when comparing it to other lines.
+     * (By default, the line `'b\n'` in text `'a\nb\nc'` is not considered equal to the line `'b'` in text `'a\nb'`; this option makes them be considered equal.)
+     * Ignored if `ignoreWhitespace` or `newlineIsToken` are also true.
+     * @default false
+     */
+    ignoreNewlineAtEof?: boolean;
+    /**
+     * `true` to ignore leading and trailing whitespace characters when checking if two lines are equal.
+     * @default false
+     */
+    ignoreWhitespace?: boolean;
+}
+export interface DiffLinesOptionsNonabortable extends DiffLinesOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffLinesOptionsAbortable = DiffLinesOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffWordsOptions extends CommonDiffOptions {
+    /**
+     * Same as in `diffChars`.
+     * @default false
+     */
+    ignoreCase?: boolean;
+    /**
+     * An optional [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) object (which must have a `granularity` of `'word'`) for `diffWords` to use to split the text into words.
+     *
+     * Note that this is (deliberately) incorrectly typed as `any` to avoid users whose `lib` & `target` settings in tsconfig.json are older than es2022 getting type errors when they build about `Intl.Segmenter` not existing.
+     * This is kind of ugly, since it makes the type declarations worse for users who genuinely use this feature, but seemed worth it to avoid the majority of the library's users (who probably do not use this particular option) getting confusing errors and being forced to change their `lib` to es2022 (even if their own code doesn't use any es2022 functions).
+     *
+     * By default, `diffWords` does not use an `Intl.Segmenter`, just some regexes for splitting text into words. This will tend to give worse results than `Intl.Segmenter` would, but ensures the results are consistent across environments; `Intl.Segmenter` behaviour is only loosely specced and the implementations in browsers could in principle change dramatically in future. If you want to use `diffWords` with an `Intl.Segmenter` but ensure it behaves the same whatever environment you run it in, use an `Intl.Segmenter` polyfill instead of the JavaScript engine's native `Intl.Segmenter` implementation.
+     *
+     * Using an `Intl.Segmenter` should allow better word-level diffing of non-English text than the default behaviour. For instance, `Intl.Segmenter`s can generally identify via built-in dictionaries which sequences of adjacent Chinese characters form words, allowing word-level diffing of Chinese. By specifying a language when instantiating the segmenter (e.g. `new Intl.Segmenter('sv', {granularity: 'word'})`) you can also support language-specific rules, like treating Swedish's colon separated contractions (like *k:a* for *kyrka*) as single words; by default this would be seen as two words separated by a colon.
+     */
+    intlSegmenter?: any;
+}
+export interface DiffWordsOptionsNonabortable extends DiffWordsOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffWordsOptionsAbortable = DiffWordsOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffSentencesOptions extends CommonDiffOptions {
+}
+export interface DiffSentencesOptionsNonabortable extends DiffSentencesOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffSentencesOptionsAbortable = DiffSentencesOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffJsonOptions extends CommonDiffOptions {
+    /**
+     * A value to replace `undefined` with. Ignored if a `stringifyReplacer` is provided.
+     */
+    undefinedReplacement?: any;
+    /**
+     * A custom replacer function.
+     * Operates similarly to the `replacer` parameter to [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter), but must be a function.
+     */
+    stringifyReplacer?: (k: string, v: any) => any;
+}
+export interface DiffJsonOptionsNonabortable extends DiffJsonOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffJsonOptionsAbortable = DiffJsonOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffCssOptions extends CommonDiffOptions {
+}
+export interface DiffCssOptionsNonabortable extends DiffCssOptions {
+    /**
+     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+     */
+    callback?: DiffCallbackNonabortable<string>;
+}
+export type DiffCssOptionsAbortable = DiffCssOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+/**
+ * Note that this contains the union of ALL options accepted by any of the built-in diffing
+ * functions. The README notes which options are usable which functions. Using an option with a
+ * diffing function that doesn't support it might yield unreasonable results.
+ */
+export type AllDiffOptions = DiffArraysOptions<unknown> & DiffCharsOptions & DiffWordsOptions & DiffLinesOptions & DiffJsonOptions;
+export interface StructuredPatch {
+    oldFileName: string | undefined;
+    newFileName: string | undefined;
+    oldHeader: string | undefined;
+    newHeader: string | undefined;
+    hunks: StructuredPatchHunk[];
+    index?: string;
+    /**
+     * Set to true when the patch was parsed from a Git-style diff (one with a
+     * `diff --git` header). Controls whether `formatPatch` emits a `diff --git`
+     * header (instead of `Index:` / underline headers) when formatting the patch.
+     */
+    isGit?: boolean;
+    /**
+     * Set to true when parsing a Git diff that includes `rename from`/`rename to`
+     * extended headers, indicating the file was renamed (and the old file no
+     * longer exists). Consumers applying the patch should delete the old file.
+     */
+    isRename?: boolean;
+    /**
+     * Set to true when parsing a Git diff that includes `copy from`/`copy to`
+     * extended headers, indicating the file was copied (and the old file still
+     * exists). Consumers applying the patch should NOT delete the old file.
+     */
+    isCopy?: boolean;
+    /**
+     * Set to true when parsing a Git diff that includes a `new file mode` extended
+     * header, indicating the file was newly created.
+     */
+    isCreate?: boolean;
+    /**
+     * Set to true when parsing a Git diff that includes a `deleted file mode`
+     * extended header, indicating the file was deleted.
+     */
+    isDelete?: boolean;
+    /**
+     * The file mode (e.g. `'100644'`, `'100755'`) of the old file, parsed from
+     * Git extended headers (`old mode` or `deleted file mode`).
+     */
+    oldMode?: string;
+    /**
+     * The file mode (e.g. `'100644'`, `'100755'`) of the new file, parsed from
+     * Git extended headers (`new mode` or `new file mode`).
+     */
+    newMode?: string;
+    /**
+     * Set to true when parsing a Git diff that includes a
+     * `Binary files ... differ` line, indicating a binary file change.
+     * Binary patches have no hunks, so the patch content alone is not
+     * sufficient to apply the change; consumers should handle this case
+     * specially (e.g. by warning the user or fetching the binary content
+     * separately).
+     */
+    isBinary?: boolean;
+}
+export interface StructuredPatchHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/node_modules/diff/libcjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/node_modules/diff/libcjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/diff/libcjs/util/array.d.ts

@@ -0,0 +1,3 @@
+export declare function arrayEqual(a: any[], b: any[]): boolean;
+export declare function arrayStartsWith(array: any[], start: any[]): boolean;
+//# sourceMappingURL=array.d.ts.map

package/node_modules/diff/libcjs/util/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/util/array.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,OAAO,CAMtD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,OAAO,CAYnE"}

package/node_modules/diff/libcjs/util/array.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayEqual = arrayEqual;
+exports.arrayStartsWith = arrayStartsWith;
+function arrayEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return arrayStartsWith(a, b);
+}
+function arrayStartsWith(array, start) {
+    if (start.length > array.length) {
+        return false;
+    }
+    for (let i = 0; i < start.length; i++) {
+        if (start[i] !== array[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/node_modules/diff/libcjs/util/distance-iterator.d.ts

@@ -0,0 +1,2 @@
+export default function (start: number, minLine: number, maxLine: number): () => number | undefined;
+//# sourceMappingURL=distance-iterator.d.ts.map

package/node_modules/diff/libcjs/util/distance-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance-iterator.d.ts","sourceRoot":"","sources":["../../src/util/distance-iterator.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,WAAU,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,MAAM,GAAG,SAAS,CA0CjG"}

package/node_modules/diff/libcjs/util/distance-iterator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+// Iterator that traverses in the range of [min, max], stepping
+// by distance from a given start position. I.e. for [0, 4], with
+// start of 2, this will iterate 2, 3, 1, 4, 0.
+function default_1(start, minLine, maxLine) {
+    let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
+    return function iterator() {
+        if (wantForward && !forwardExhausted) {
+            if (backwardExhausted) {
+                localOffset++;
+            }
+            else {
+                wantForward = false;
+            }
+            // Check if trying to fit beyond text length, and if not, check it fits
+            // after offset location (or desired location on first iteration)
+            if (start + localOffset <= maxLine) {
+                return start + localOffset;
+            }
+            forwardExhausted = true;
+        }
+        if (!backwardExhausted) {
+            if (!forwardExhausted) {
+                wantForward = true;
+            }
+            // Check if trying to fit before text beginning, and if not, check it fits
+            // before offset location
+            if (minLine <= start - localOffset) {
+                return start - localOffset++;
+            }
+            backwardExhausted = true;
+            return iterator();
+        }
+        // We tried to fit hunk before text beginning and beyond text length, then
+        // hunk can't fit on the text. Return undefined
+        return undefined;
+    };
+}

package/node_modules/diff/libcjs/util/params.d.ts

@@ -0,0 +1,4 @@
+export declare function generateOptions(options: {
+    [key: string]: any;
+} | ((_: unknown) => void), defaults: any): object;
+//# sourceMappingURL=params.d.ts.map

package/node_modules/diff/libcjs/util/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/util/params.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAC7B,OAAO,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC,EACtD,QAAQ,EAAE,GAAG,GACZ,MAAM,CAYR"}

package/node_modules/diff/libcjs/util/params.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptions = generateOptions;
+function generateOptions(options, defaults) {
+    if (typeof options === 'function') {
+        defaults.callback = options;
+    }
+    else if (options) {
+        for (const name in options) {
+            /* istanbul ignore else */
+            if (Object.prototype.hasOwnProperty.call(options, name)) {
+                defaults[name] = options[name];
+            }
+        }
+    }
+    return defaults;
+}

package/node_modules/diff/libcjs/util/string.d.ts

@@ -0,0 +1,30 @@
+export declare function longestCommonPrefix(str1: string, str2: string): string;
+export declare function longestCommonSuffix(str1: string, str2: string): string;
+export declare function replacePrefix(string: string, oldPrefix: string, newPrefix: string): string;
+export declare function replaceSuffix(string: string, oldSuffix: string, newSuffix: string): string;
+export declare function removePrefix(string: string, oldPrefix: string): string;
+export declare function removeSuffix(string: string, oldSuffix: string): string;
+export declare function maximumOverlap(string1: string, string2: string): string;
+/**
+ * Returns true if the string consistently uses Windows line endings.
+ */
+export declare function hasOnlyWinLineEndings(string: string): boolean;
+/**
+ * Returns true if the string consistently uses Unix line endings.
+ */
+export declare function hasOnlyUnixLineEndings(string: string): boolean;
+/**
+ * Split a string into segments using a word segmenter, merging consecutive
+ * segments if they are both whitespace segments. Whitespace segments can
+ * appear adjacent to one another for two reasons:
+ * - newlines always get their own segment
+ * - where a diacritic is attached to a whitespace character in the text, the
+ *   segment ends after the diacritic, so e.g. " \u0300 " becomes two segments.
+ * This function therefore runs the segmenter's .segment() method and then
+ * merges consecutive segments of whitespace into a single part.
+ */
+export declare function segment(string: string, segmenter: Intl.Segmenter): string[];
+export declare function trailingWs(string: string, segmenter?: Intl.Segmenter): string;
+export declare function leadingWs(string: string, segmenter?: Intl.Segmenter): string;
+export declare function leadingAndTrailingWs(string: string, segmenter?: Intl.Segmenter): [string, string];
+//# sourceMappingURL=string.d.ts.map

package/node_modules/diff/libcjs/util/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/util/string.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQtE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBtE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAK1F;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAS1F;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvE;AAkCD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,GAAG,MAAM,EAAE,CAW3E;AAgBD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,SAAS,GAAG,MAAM,CAuB7E;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,SAAS,GAAG,MAAM,CAQ5E;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,IAAI,CAAC,SAAS,GACzB,CAAC,MAAM,EAAE,MAAM,CAAC,CAelB"}

package/node_modules/diff/libcjs/util/string.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longestCommonPrefix = longestCommonPrefix;
+exports.longestCommonSuffix = longestCommonSuffix;
+exports.replacePrefix = replacePrefix;
+exports.replaceSuffix = replaceSuffix;
+exports.removePrefix = removePrefix;
+exports.removeSuffix = removeSuffix;
+exports.maximumOverlap = maximumOverlap;
+exports.hasOnlyWinLineEndings = hasOnlyWinLineEndings;
+exports.hasOnlyUnixLineEndings = hasOnlyUnixLineEndings;
+exports.segment = segment;
+exports.trailingWs = trailingWs;
+exports.leadingWs = leadingWs;
+exports.leadingAndTrailingWs = leadingAndTrailingWs;
+function longestCommonPrefix(str1, str2) {
+    let i;
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+        if (str1[i] != str2[i]) {
+            return str1.slice(0, i);
+        }
+    }
+    return str1.slice(0, i);
+}
+function longestCommonSuffix(str1, str2) {
+    let i;
+    // Unlike longestCommonPrefix, we need a special case to handle all scenarios
+    // where we return the empty string since str1.slice(-0) will return the
+    // entire string.
+    if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+        return '';
+    }
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+        if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+            return str1.slice(-i);
+        }
+    }
+    return str1.slice(-i);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+    if (string.slice(0, oldPrefix.length) != oldPrefix) {
+        throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+    }
+    return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+    if (!oldSuffix) {
+        return string + newSuffix;
+    }
+    if (string.slice(-oldSuffix.length) != oldSuffix) {
+        throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+    }
+    return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+    return replacePrefix(string, oldPrefix, '');
+}
+function removeSuffix(string, oldSuffix) {
+    return replaceSuffix(string, oldSuffix, '');
+}
+function maximumOverlap(string1, string2) {
+    return string2.slice(0, overlapCount(string1, string2));
+}
+// Nicked from https://stackoverflow.com/a/60422853/1709587
+function overlapCount(a, b) {
+    // Deal with cases where the strings differ in length
+    let startA = 0;
+    if (a.length > b.length) {
+        startA = a.length - b.length;
+    }
+    let endB = b.length;
+    if (a.length < b.length) {
+        endB = a.length;
+    }
+    // Create a back-reference for each index
+    //   that should be followed in case of a mismatch.
+    //   We only need B to make these references:
+    const map = Array(endB);
+    let k = 0; // Index that lags behind j
+    map[0] = 0;
+    for (let j = 1; j < endB; j++) {
+        if (b[j] == b[k]) {
+            map[j] = map[k]; // skip over the same character (optional optimisation)
+        }
+        else {
+            map[j] = k;
+        }
+        while (k > 0 && b[j] != b[k]) {
+            k = map[k];
+        }
+        if (b[j] == b[k]) {
+            k++;
+        }
+    }
+    // Phase 2: use these references while iterating over A
+    k = 0;
+    for (let i = startA; i < a.length; i++) {
+        while (k > 0 && a[i] != b[k]) {
+            k = map[k];
+        }
+        if (a[i] == b[k]) {
+            k++;
+        }
+    }
+    return k;
+}
+/**
+ * Returns true if the string consistently uses Windows line endings.
+ */
+function hasOnlyWinLineEndings(string) {
+    return string.includes('\r\n') && !string.startsWith('\n') && !string.match(/[^\r]\n/);
+}
+/**
+ * Returns true if the string consistently uses Unix line endings.
+ */
+function hasOnlyUnixLineEndings(string) {
+    return !string.includes('\r\n') && string.includes('\n');
+}
+/**
+ * Split a string into segments using a word segmenter, merging consecutive
+ * segments if they are both whitespace segments. Whitespace segments can
+ * appear adjacent to one another for two reasons:
+ * - newlines always get their own segment
+ * - where a diacritic is attached to a whitespace character in the text, the
+ *   segment ends after the diacritic, so e.g. " \u0300 " becomes two segments.
+ * This function therefore runs the segmenter's .segment() method and then
+ * merges consecutive segments of whitespace into a single part.
+ */
+function segment(string, segmenter) {
+    const parts = [];
+    for (const segmentObj of Array.from(segmenter.segment(string))) {
+        const segment = segmentObj.segment;
+        if (parts.length && (/\s/).test(parts[parts.length - 1]) && (/\s/).test(segment)) {
+            parts[parts.length - 1] += segment;
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    return parts;
+}
+// The functions below take a `segmenter` argument so that, when called from
+// diffWords when it is using a segmenter, they can use a notion of what
+// constitutes "whitespace" that is consistent with the segmenter.
+//
+// USUALLY this will be identical to the result of the non-segmenter-based
+// logic, but it differs in at least one case: when whitespace characters are
+// modified by diacritics. A word segmenter considers these diacritics to be
+// part of the whitespace, whereas our non-segmenter-based logic does not.
+//
+// Because the segmenter-based approach necessarily requires segmenting the
+// entire string, we offer a leadingAndTrailingWs function to allow getting the
+// whitespace prefix AND whitespace suffix with a single call to the segmenter,
+// for efficiency's sake.
+function trailingWs(string, segmenter) {
+    if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[1];
+    }
+    // Yes, this looks overcomplicated and dumb - why not replace the whole function with
+    //     return string.match(/\s*$/)[0]
+    // you ask? Because:
+    // 1. the trap described at https://markamery.com/blog/quadratic-time-regexes/ would mean doing
+    //    this would cause this function to take O(n²) time in the worst case (specifically when
+    //    there is a massive run of NON-TRAILING whitespace in `string`), and
+    // 2. the fix proposed in the same blog post, of using a negative lookbehind, is incompatible
+    //    with old Safari versions that we'd like to not break if possible (see
+    //    https://github.com/kpdecker/jsdiff/pull/550)
+    // It feels absurd to do this with an explicit loop instead of a regex, but I really can't see a
+    // better way that doesn't result in broken behaviour.
+    let i;
+    for (i = string.length - 1; i >= 0; i--) {
+        if (!string[i].match(/\s/)) {
+            break;
+        }
+    }
+    return string.substring(i + 1);
+}
+function leadingWs(string, segmenter) {
+    if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[0];
+    }
+    // Thankfully the annoying considerations described in trailingWs don't apply here:
+    const match = string.match(/^\s*/);
+    return match ? match[0] : '';
+}
+function leadingAndTrailingWs(string, segmenter) {
+    if (!segmenter) {
+        return [leadingWs(string), trailingWs(string)];
+    }
+    if (segmenter.resolvedOptions().granularity != 'word') {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+    }
+    const segments = segment(string, segmenter);
+    const firstSeg = segments[0];
+    const lastSeg = segments[segments.length - 1];
+    const head = (/\s/).test(firstSeg) ? firstSeg : '';
+    const tail = (/\s/).test(lastSeg) ? lastSeg : '';
+    return [head, tail];
+}

package/node_modules/diff/libesm/convert/dmp.d.ts

@@ -0,0 +1,8 @@
+import type { ChangeObject } from '../types.js';
+type DmpOperation = 1 | 0 | -1;
+/**
+ * converts a list of change objects to the format returned by Google's [diff-match-patch](https://github.com/google/diff-match-patch) library
+ */
+export declare function convertChangesToDMP<ValueT>(changes: ChangeObject<ValueT>[]): [DmpOperation, ValueT][];
+export {};
+//# sourceMappingURL=dmp.d.ts.map

package/node_modules/diff/libesm/convert/dmp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dmp.d.ts","sourceRoot":"","sources":["../../src/convert/dmp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAE9C,KAAK,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/B;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,EAAE,CAiBrG"}

package/node_modules/diff/libesm/convert/dmp.js

@@ -0,0 +1,21 @@
+/**
+ * converts a list of change objects to the format returned by Google's [diff-match-patch](https://github.com/google/diff-match-patch) library
+ */
+export function convertChangesToDMP(changes) {
+    const ret = [];
+    let change, operation;
+    for (let i = 0; i < changes.length; i++) {
+        change = changes[i];
+        if (change.added) {
+            operation = 1;
+        }
+        else if (change.removed) {
+            operation = -1;
+        }
+        else {
+            operation = 0;
+        }
+        ret.push([operation, change.value]);
+    }
+    return ret;
+}

package/node_modules/diff/libesm/convert/xml.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeObject } from '../types.js';
+/**
+ * converts a list of change objects to a serialized XML format
+ */
+export declare function convertChangesToXML(changes: ChangeObject<string>[]): string;
+//# sourceMappingURL=xml.d.ts.map