@nimbus-cqrs/mongodb 2.0.0-beta.0

package/esm/deps/jsr.io/@std/text/1.0.18/_util.d.ts

@@ -0,0 +1,3 @@
+export declare function splitToWords(input: string): [] | RegExpMatchArray;
+export declare function capitalizeWord(word: string): string;
+//# sourceMappingURL=_util.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/_util.ts"],"names":[],"mappings":"AAaA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,yBAEzC;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/esm/deps/jsr.io/@std/text/1.0.18/_util.js

@@ -0,0 +1,13 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+const CAPITALIZED_WORD_REGEXP = /\p{Lu}\p{Ll}+/u; // e.g. Apple
+const ACRONYM_REGEXP = /\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)/u; // e.g. ID, URL, handles an acronym followed by a capitalized word e.g. HTMLElement
+const LOWERCASED_WORD_REGEXP = /(\p{Ll}+)/u; // e.g. apple
+const ANY_LETTERS_REGEXP = /\p{L}+/u; // will match any sequence of letters, including in languages without a concept of upper/lower case
+const DIGITS_REGEXP = /\p{N}+/u; // e.g. 123
+const WORD_OR_NUMBER_REGEXP = new RegExp(`${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS_REGEXP.source}|${DIGITS_REGEXP.source}`, "gu");
+export function splitToWords(input) {
+    return input.match(WORD_OR_NUMBER_REGEXP) ?? [];
+}
+export function capitalizeWord(word) {
+    return word ? word[0].toUpperCase() + word.slice(1).toLowerCase() : word;
+}

package/esm/deps/jsr.io/@std/text/1.0.18/closest_string.d.ts

@@ -0,0 +1,42 @@
+/** Options for {@linkcode closestString}. */
+export interface ClosestStringOptions {
+    /**
+     * Whether the distance should include case.
+     *
+     * @default {false}
+     */
+    caseSensitive?: boolean;
+    /**
+     * A custom comparison function to use for comparing strings.
+     *
+     * @param a The first string for comparison.
+     * @param b The second string for comparison.
+     * @returns The distance between the two strings.
+     * @default {levenshteinDistance}
+     */
+    compareFn?: (a: string, b: string) => number;
+}
+/**
+ * Finds the most similar string from an array of strings.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Usage
+ * ```ts
+ * import { closestString } from "@std/text/closest-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestion = closestString("hep", possibleWords);
+ *
+ * assertEquals(suggestion, "help");
+ * ```
+ *
+ * @param givenWord The string to measure distance against
+ * @param possibleWords The string-array to pick the closest string from
+ * @param options The options for the comparison.
+ * @returns The closest string
+ */
+export declare function closestString(givenWord: string, possibleWords: ReadonlyArray<string>, options?: ClosestStringOptions): string;
+//# sourceMappingURL=closest_string.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/closest_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closest_string.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/closest_string.ts"],"names":[],"mappings":"AAIA,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAwBR"}

package/esm/deps/jsr.io/@std/text/1.0.18/closest_string.js

@@ -0,0 +1,46 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { levenshteinDistance } from "./levenshtein_distance.js";
+/**
+ * Finds the most similar string from an array of strings.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Usage
+ * ```ts
+ * import { closestString } from "@std/text/closest-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestion = closestString("hep", possibleWords);
+ *
+ * assertEquals(suggestion, "help");
+ * ```
+ *
+ * @param givenWord The string to measure distance against
+ * @param possibleWords The string-array to pick the closest string from
+ * @param options The options for the comparison.
+ * @returns The closest string
+ */
+export function closestString(givenWord, possibleWords, options) {
+    if (possibleWords.length === 0) {
+        throw new TypeError("When using closestString(), the possibleWords array must contain at least one word");
+    }
+    const { caseSensitive, compareFn = levenshteinDistance } = { ...options };
+    if (!caseSensitive) {
+        givenWord = givenWord.toLowerCase();
+    }
+    let nearestWord = possibleWords[0];
+    let closestStringDistance = Infinity;
+    for (const each of possibleWords) {
+        const distance = caseSensitive
+            ? compareFn(givenWord, each)
+            : compareFn(givenWord, each.toLowerCase());
+        if (distance < closestStringDistance) {
+            nearestWord = each;
+            closestStringDistance = distance;
+        }
+    }
+    return nearestWord;
+}

package/esm/deps/jsr.io/@std/text/1.0.18/compare_similarity.d.ts

@@ -0,0 +1,47 @@
+/** Options for {@linkcode compareSimilarity}. */
+export interface CompareSimilarityOptions {
+    /**
+     * Whether the distance should include case.
+     *
+     * @default {false}
+     */
+    caseSensitive?: boolean;
+    /**
+     * A custom comparison function to use for comparing strings.
+     *
+     * @param a The first string for comparison.
+     * @param b The second string for comparison.
+     * @returns The distance between the two strings.
+     * @default {levenshteinDistance}
+     */
+    compareFn?: (a: string, b: string) => number;
+}
+/**
+ * Takes a string and generates a comparator function to determine which of two
+ * strings is more similar to the given one.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @param givenWord The string to measure distance against.
+ * @param options Options for the sort.
+ * @returns The difference in distance. This will be a negative number if `a`
+ * is more similar to `givenWord` than `b`, a positive number if `b` is more
+ * similar, or `0` if they are equally similar.
+ *
+ * @example Usage
+ *
+ * Most-similar words will be at the start of the array.
+ *
+ * ```ts
+ * import { compareSimilarity } from "@std/text/compare-similarity";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const words = ["hi", "hello", "help"];
+ * const sortedWords = words.toSorted(compareSimilarity("hep"));
+ *
+ * assertEquals(sortedWords, ["help", "hi", "hello"]);
+ * ```
+ */
+export declare function compareSimilarity(givenWord: string, options?: CompareSimilarityOptions): (a: string, b: string) => number;
+//# sourceMappingURL=compare_similarity.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/compare_similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare_similarity.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/compare_similarity.ts"],"names":[],"mappings":"AAIA,iDAAiD;AACjD,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,wBAAwB,GACjC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAUlC"}

package/esm/deps/jsr.io/@std/text/1.0.18/compare_similarity.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { levenshteinDistance } from "./levenshtein_distance.js";
+/**
+ * Takes a string and generates a comparator function to determine which of two
+ * strings is more similar to the given one.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @param givenWord The string to measure distance against.
+ * @param options Options for the sort.
+ * @returns The difference in distance. This will be a negative number if `a`
+ * is more similar to `givenWord` than `b`, a positive number if `b` is more
+ * similar, or `0` if they are equally similar.
+ *
+ * @example Usage
+ *
+ * Most-similar words will be at the start of the array.
+ *
+ * ```ts
+ * import { compareSimilarity } from "@std/text/compare-similarity";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const words = ["hi", "hello", "help"];
+ * const sortedWords = words.toSorted(compareSimilarity("hep"));
+ *
+ * assertEquals(sortedWords, ["help", "hi", "hello"]);
+ * ```
+ */
+export function compareSimilarity(givenWord, options) {
+    const { compareFn = levenshteinDistance } = { ...options };
+    if (options?.caseSensitive) {
+        return (a, b) => compareFn(givenWord, a) - compareFn(givenWord, b);
+    }
+    givenWord = givenWord.toLowerCase();
+    return (a, b) => compareFn(givenWord, a.toLowerCase()) -
+        compareFn(givenWord, b.toLowerCase());
+}

package/esm/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Calculates the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}
+ * between two strings.
+ *
+ * > [!NOTE]
+ * > The complexity of this function is O(m * n), where m and n are the lengths
+ * > of the two strings. It's recommended to limit the length and validate input
+ * > if arbitrarily accepting input.
+ *
+ * @example Usage
+ * ```ts
+ * import { levenshteinDistance } from "@std/text/levenshtein-distance";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(levenshteinDistance("aa", "bb"), 2);
+ * ```
+ * @param str1 The first string.
+ * @param str2 The second string.
+ * @returns The Levenshtein distance between the two strings.
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+//# sourceMappingURL=levenshtein_distance.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.ts"],"names":[],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAWtE"}

package/esm/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.js

@@ -0,0 +1,127 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+const { ceil } = Math;
+// This implements Myers' bit-vector algorithm as described here:
+// https://dl.acm.org/doi/pdf/10.1145/316542.316550
+const peq = new Uint32Array(0x110000);
+function myers32(t, p) {
+    const n = t.length;
+    const m = p.length;
+    for (let i = 0; i < m; i++) {
+        peq[p[i].codePointAt(0)] |= 1 << i;
+    }
+    const last = m - 1;
+    let pv = -1;
+    let mv = 0;
+    let score = m;
+    for (let j = 0; j < n; j++) {
+        const eq = peq[t[j].codePointAt(0)];
+        const xv = eq | mv;
+        const xh = (((eq & pv) + pv) ^ pv) | eq;
+        let ph = mv | ~(xh | pv);
+        let mh = pv & xh;
+        score += ((ph >>> last) & 1) - ((mh >>> last) & 1);
+        // Set the horizontal delta in the first row to +1
+        // because we are computing the distance between two full strings.
+        ph = (ph << 1) | 1;
+        mh = mh << 1;
+        pv = mh | ~(xv | ph);
+        mv = ph & xv;
+    }
+    for (let i = 0; i < m; i++) {
+        peq[p[i].codePointAt(0)] = 0;
+    }
+    return score;
+}
+function myersX(t, p) {
+    const n = t.length;
+    const m = p.length;
+    // Initialize the horizontal deltas to +1.
+    const h = new Int8Array(n).fill(1);
+    const bmax = ceil(m / 32) - 1;
+    // Process the blocks row by row so that we can use the fixed-size peq array.
+    for (let b = 0; b < bmax; b++) {
+        const start = b * 32;
+        const end = (b + 1) * 32;
+        for (let i = start; i < end; i++) {
+            peq[p[i].codePointAt(0)] |= 1 << i;
+        }
+        let pv = -1;
+        let mv = 0;
+        for (let j = 0; j < n; j++) {
+            const hin = h[j];
+            let eq = peq[t[j].codePointAt(0)];
+            const xv = eq | mv;
+            eq |= hin >>> 31;
+            const xh = (((eq & pv) + pv) ^ pv) | eq;
+            let ph = mv | ~(xh | pv);
+            let mh = pv & xh;
+            h[j] = (ph >>> 31) - (mh >>> 31);
+            ph = (ph << 1) | (-hin >>> 31);
+            mh = (mh << 1) | (hin >>> 31);
+            pv = mh | ~(xv | ph);
+            mv = ph & xv;
+        }
+        for (let i = start; i < end; i++) {
+            peq[p[i].codePointAt(0)] = 0;
+        }
+    }
+    const start = bmax * 32;
+    for (let i = start; i < m; i++) {
+        peq[p[i].codePointAt(0)] |= 1 << i;
+    }
+    const last = m - 1;
+    let pv = -1;
+    let mv = 0;
+    let score = m;
+    for (let j = 0; j < n; j++) {
+        const hin = h[j];
+        let eq = peq[t[j].codePointAt(0)];
+        const xv = eq | mv;
+        eq |= hin >>> 31;
+        const xh = (((eq & pv) + pv) ^ pv) | eq;
+        let ph = mv | ~(xh | pv);
+        let mh = pv & xh;
+        score += ((ph >>> last) & 1) - ((mh >>> last) & 1);
+        ph = (ph << 1) | (-hin >>> 31);
+        mh = (mh << 1) | (hin >>> 31);
+        pv = mh | ~(xv | ph);
+        mv = ph & xv;
+    }
+    for (let i = start; i < m; i++) {
+        peq[p[i].codePointAt(0)] = 0;
+    }
+    return score;
+}
+/**
+ * Calculates the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}
+ * between two strings.
+ *
+ * > [!NOTE]
+ * > The complexity of this function is O(m * n), where m and n are the lengths
+ * > of the two strings. It's recommended to limit the length and validate input
+ * > if arbitrarily accepting input.
+ *
+ * @example Usage
+ * ```ts
+ * import { levenshteinDistance } from "@std/text/levenshtein-distance";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(levenshteinDistance("aa", "bb"), 2);
+ * ```
+ * @param str1 The first string.
+ * @param str2 The second string.
+ * @returns The Levenshtein distance between the two strings.
+ */
+export function levenshteinDistance(str1, str2) {
+    let t = [...str1];
+    let p = [...str2];
+    if (t.length < p.length) {
+        [p, t] = [t, p];
+    }
+    if (p.length === 0) {
+        return t.length;
+    }
+    return p.length <= 32 ? myers32(t, p) : myersX(t, p);
+}

package/esm/deps/jsr.io/@std/text/1.0.18/mod.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility functions for working with text.
+ *
+ * ```ts
+ * import { toCamelCase, compareSimilarity } from "@std/text";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toCamelCase("snake_case"), "snakeCase");
+ *
+ * const words = ["hi", "help", "hello"];
+ *
+ * // Words most similar to "hep" will be at the front
+ * assertEquals(words.sort(compareSimilarity("hep")), ["help", "hi", "hello"]);
+ * ```
+ *
+ * @module
+ */
+export * from "./levenshtein_distance.js";
+export * from "./closest_string.js";
+export * from "./compare_similarity.js";
+export * from "./word_similarity_sort.js";
+export * from "./to_camel_case.js";
+export * from "./to_kebab_case.js";
+export * from "./to_pascal_case.js";
+export * from "./to_snake_case.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}

package/esm/deps/jsr.io/@std/text/1.0.18/mod.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Utility functions for working with text.
+ *
+ * ```ts
+ * import { toCamelCase, compareSimilarity } from "@std/text";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toCamelCase("snake_case"), "snakeCase");
+ *
+ * const words = ["hi", "help", "hello"];
+ *
+ * // Words most similar to "hep" will be at the front
+ * assertEquals(words.sort(compareSimilarity("hep")), ["help", "hi", "hello"]);
+ * ```
+ *
+ * @module
+ */
+export * from "./levenshtein_distance.js";
+export * from "./closest_string.js";
+export * from "./compare_similarity.js";
+export * from "./word_similarity_sort.js";
+export * from "./to_camel_case.js";
+export * from "./to_kebab_case.js";
+export * from "./to_pascal_case.js";
+export * from "./to_snake_case.js";

package/esm/deps/jsr.io/@std/text/1.0.18/to_camel_case.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts a string into camelCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toCamelCase } from "@std/text/to-camel-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toCamelCase("deno is awesome"),"denoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into camelCase
+ * @returns The string as camelCase
+ */
+export declare function toCamelCase(input: string): string;
+//# sourceMappingURL=to_camel_case.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/to_camel_case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_camel_case.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/to_camel_case.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/esm/deps/jsr.io/@std/text/1.0.18/to_camel_case.js

@@ -0,0 +1,22 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { capitalizeWord, splitToWords } from "./_util.js";
+/**
+ * Converts a string into camelCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toCamelCase } from "@std/text/to-camel-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toCamelCase("deno is awesome"),"denoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into camelCase
+ * @returns The string as camelCase
+ */
+export function toCamelCase(input) {
+    input = input.trim();
+    const [first = "", ...rest] = splitToWords(input);
+    return [first.toLowerCase(), ...rest.map(capitalizeWord)].join("");
+}

package/esm/deps/jsr.io/@std/text/1.0.18/to_kebab_case.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts a string into kebab-case.
+ *
+ * @example Usage
+ * ```ts
+ * import { toKebabCase } from "@std/text/to-kebab-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toKebabCase("deno is awesome"), "deno-is-awesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into kebab-case
+ * @returns The string as kebab-case
+ */
+export declare function toKebabCase(input: string): string;
+//# sourceMappingURL=to_kebab_case.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/to_kebab_case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_kebab_case.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/to_kebab_case.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD"}

package/esm/deps/jsr.io/@std/text/1.0.18/to_kebab_case.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { splitToWords } from "./_util.js";
+/**
+ * Converts a string into kebab-case.
+ *
+ * @example Usage
+ * ```ts
+ * import { toKebabCase } from "@std/text/to-kebab-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toKebabCase("deno is awesome"), "deno-is-awesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into kebab-case
+ * @returns The string as kebab-case
+ */
+export function toKebabCase(input) {
+    input = input.trim();
+    return splitToWords(input).join("-").toLowerCase();
+}

package/esm/deps/jsr.io/@std/text/1.0.18/to_pascal_case.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts a string into PascalCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toPascalCase } from "@std/text/to-pascal-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toPascalCase("deno is awesome"), "DenoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into PascalCase
+ * @returns The string as PascalCase
+ */
+export declare function toPascalCase(input: string): string;
+//# sourceMappingURL=to_pascal_case.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/to_pascal_case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_pascal_case.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/to_pascal_case.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD"}

package/esm/deps/jsr.io/@std/text/1.0.18/to_pascal_case.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { capitalizeWord, splitToWords } from "./_util.js";
+/**
+ * Converts a string into PascalCase.
+ *
+ * @example Usage
+ * ```ts
+ * import { toPascalCase } from "@std/text/to-pascal-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toPascalCase("deno is awesome"), "DenoIsAwesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into PascalCase
+ * @returns The string as PascalCase
+ */
+export function toPascalCase(input) {
+    input = input.trim();
+    return splitToWords(input).map(capitalizeWord).join("");
+}

package/esm/deps/jsr.io/@std/text/1.0.18/to_snake_case.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts a string into snake_case.
+ *
+ * @example Usage
+ * ```ts
+ * import { toSnakeCase } from "@std/text/to-snake-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toSnakeCase("deno is awesome"), "deno_is_awesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into snake_case
+ * @returns The string as snake_case
+ */
+export declare function toSnakeCase(input: string): string;
+//# sourceMappingURL=to_snake_case.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/to_snake_case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_snake_case.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/to_snake_case.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD"}

package/esm/deps/jsr.io/@std/text/1.0.18/to_snake_case.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { splitToWords } from "./_util.js";
+/**
+ * Converts a string into snake_case.
+ *
+ * @example Usage
+ * ```ts
+ * import { toSnakeCase } from "@std/text/to-snake-case";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toSnakeCase("deno is awesome"), "deno_is_awesome");
+ * ```
+ *
+ * @param input The string that is going to be converted into snake_case
+ * @returns The string as snake_case
+ */
+export function toSnakeCase(input) {
+    input = input.trim();
+    return splitToWords(input).join("_").toLowerCase();
+}

package/esm/deps/jsr.io/@std/text/1.0.18/word_similarity_sort.d.ts

@@ -0,0 +1,42 @@
+import { type CompareSimilarityOptions } from "./compare_similarity.js";
+/** Options for {@linkcode wordSimilaritySort}. */
+export interface WordSimilaritySortOptions extends CompareSimilarityOptions {
+}
+/**
+ * Sorts a string-array by similarity to a given string.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Basic usage
+ *
+ * ```ts
+ * import { wordSimilaritySort } from "@std/text/word-similarity-sort";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestions = wordSimilaritySort("hep", possibleWords);
+ *
+ * assertEquals(suggestions, ["help", "size", "blah", "length"]);
+ * ```
+ *
+ * @example Case-sensitive sorting
+ *
+ * ```ts
+ * import { wordSimilaritySort } from "@std/text/word-similarity-sort";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "Size", "blah", "HELP"];
+ * const suggestions = wordSimilaritySort("hep", possibleWords, { caseSensitive: true });
+ *
+ * assertEquals(suggestions, ["Size", "blah", "HELP", "length"]);
+ * ```
+ *
+ * @param givenWord The string to measure distance against.
+ * @param possibleWords The string-array that will be sorted. This array will
+ * not be mutated, but the sorted copy will be returned.
+ * @param options Options for the sort.
+ * @returns A sorted copy of `possibleWords`.
+ */
+export declare function wordSimilaritySort(givenWord: string, possibleWords: ReadonlyArray<string>, options?: WordSimilaritySortOptions): string[];
+//# sourceMappingURL=word_similarity_sort.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.18/word_similarity_sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word_similarity_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/word_similarity_sort.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,kDAAkD;AAClD,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;CAAG;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,OAAO,CAAC,EAAE,yBAAyB,GAClC,MAAM,EAAE,CAGV"}