effect 2.0.3 → 2.0.5

package/dist/esm/Trie.js

@@ -0,0 +1,648 @@
+import * as TR from "./internal/trie.js";
+const TypeId = TR.TrieTypeId;
+/**
+ * Creates an empty `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.empty<string>()
+ *
+ * assert.equal(Trie.size(trie), 0)
+ * assert.deepStrictEqual(Array.from(trie), [])
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = TR.empty;
+/**
+ * Creates a new `Trie` from an iterable collection of key/value pairs (e.g. `Array<[string, V]>`).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const iterable: Array<readonly [string, number]> = [["call", 0], ["me", 1], ["mind", 2], ["mid", 3]]
+ * const trie = Trie.fromIterable(iterable)
+ *
+ * // The entries in the `Trie` are extracted in alphabetical order, regardless of the insertion order
+ * assert.deepStrictEqual(Array.from(trie), [["call", 0], ["me", 1], ["mid", 3], ["mind", 2]])
+ * assert.equal(Equal.equals(Trie.make(["call", 0], ["me", 1], ["mind", 2], ["mid", 3]), trie), true)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = TR.fromIterable;
+/**
+ * Constructs a new `Trie` from the specified entries (`[string, V]`).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.make(["ca", 0], ["me", 1])
+ *
+ * assert.deepStrictEqual(Array.from(trie), [["ca", 0], ["me", 1]])
+ * assert.equal(Equal.equals(Trie.fromIterable([["ca", 0], ["me", 1]]), trie), true)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = TR.make;
+/**
+ * Insert a new entry in the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie1 = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0)
+ * )
+ * const trie2 = trie1.pipe(Trie.insert("me", 1))
+ * const trie3 = trie2.pipe(Trie.insert("mind", 2))
+ * const trie4 = trie3.pipe(Trie.insert("mid", 3))
+ *
+ * assert.deepStrictEqual(Array.from(trie1), [["call", 0]])
+ * assert.deepStrictEqual(Array.from(trie2), [["call", 0], ["me", 1]])
+ * assert.deepStrictEqual(Array.from(trie3), [["call", 0], ["me", 1], ["mind", 2]])
+ * assert.deepStrictEqual(Array.from(trie4), [["call", 0], ["me", 1], ["mid", 3], ["mind", 2]])
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const insert = TR.insert;
+/**
+ * Returns an `IterableIterator` of the keys within the `Trie`.
+ *
+ * The keys are returned in alphabetical order, regardless of insertion order.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("cab", 0),
+ *   Trie.insert("abc", 1),
+ *   Trie.insert("bca", 2)
+ * )
+ *
+ * const result = Array.from(Trie.keys(trie))
+ * assert.deepStrictEqual(result, ["abc", "bca", "cab"])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const keys = TR.keys;
+/**
+ * Returns an `IterableIterator` of the values within the `Trie`.
+ *
+ * Values are ordered based on their key in alphabetical order, regardless of insertion order.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1),
+ *   Trie.insert("and", 2)
+ * )
+ *
+ * const result = Array.from(Trie.values(trie))
+ * assert.deepStrictEqual(result, [2, 0, 1])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const values = TR.values;
+/**
+ * Returns an `IterableIterator` of the entries within the `Trie`.
+ *
+ * The entries are returned by keys in alphabetical order, regardless of insertion order.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1)
+ * )
+ *
+ * const result = Array.from(Trie.entries(trie))
+ * assert.deepStrictEqual(result, [["call", 0], ["me", 1]])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const entries = TR.entries;
+/**
+ * Returns an `Array<[K, V]>` of the entries within the `Trie`.
+ *
+ * Equivalent to `Array.from(Trie.entries(trie))`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1)
+ * )
+ * const result = Trie.toEntries(trie)
+ *
+ * assert.deepStrictEqual(result, [["call", 0], ["me", 1]])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const toEntries = self => Array.from(entries(self));
+/**
+ * Returns an `IterableIterator` of the keys within the `Trie`
+ * that have `prefix` as prefix (`prefix` included if it exists).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("she", 0),
+ *   Trie.insert("shells", 1),
+ *   Trie.insert("sea", 2),
+ *   Trie.insert("shore", 3)
+ * )
+ *
+ * const result = Array.from(Trie.keysWithPrefix(trie, "she"))
+ * assert.deepStrictEqual(result, ["she", "shells"])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const keysWithPrefix = TR.keysWithPrefix;
+/**
+ * Returns an `IterableIterator` of the values within the `Trie`
+ * that have `prefix` as prefix (`prefix` included if it exists).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("she", 0),
+ *   Trie.insert("shells", 1),
+ *   Trie.insert("sea", 2),
+ *   Trie.insert("shore", 3)
+ * )
+ *
+ * const result = Array.from(Trie.valuesWithPrefix(trie, "she"))
+ *
+ * // 0: "she", 1: "shells"
+ * assert.deepStrictEqual(result, [0, 1])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const valuesWithPrefix = TR.valuesWithPrefix;
+/**
+ * Returns an `IterableIterator` of the entries within the `Trie`
+ * that have `prefix` as prefix (`prefix` included if it exists).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("she", 0),
+ *   Trie.insert("shells", 1),
+ *   Trie.insert("sea", 2),
+ *   Trie.insert("shore", 3)
+ * )
+ *
+ * const result = Array.from(Trie.entriesWithPrefix(trie, "she"))
+ * assert.deepStrictEqual(result, [["she", 0], ["shells", 1]])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const entriesWithPrefix = TR.entriesWithPrefix;
+/**
+ * Returns `Array<[K, V]>` of the entries within the `Trie`
+ * that have `prefix` as prefix (`prefix` included if it exists).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("sea", 2),
+ *   Trie.insert("she", 3)
+ * )
+ *
+ * const result = Trie.toEntriesWithPrefix(trie, "she")
+ * assert.deepStrictEqual(result, [["she", 3], ["shells", 0]])
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const toEntriesWithPrefix = TR.toEntriesWithPrefix;
+/**
+ * Returns the longest key/value in the `Trie`
+ * that is a prefix of that `key` if it exists, `None` otherwise.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), Option.none())
+ * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), Option.some(["sells", 1]))
+ * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), Option.some(["she", 2]))
+ * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), Option.some(["shells", 0]))
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const longestPrefixOf = TR.longestPrefixOf;
+/**
+ * Returns the size of the `Trie` (number of entries in the `Trie`).
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("a", 0),
+ *   Trie.insert("b", 1)
+ * )
+ *
+ * assert.equal(Trie.size(trie), 2)
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size = TR.size;
+/**
+ * Safely lookup the value for the specified key in the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1),
+ *   Trie.insert("mind", 2),
+ *   Trie.insert("mid", 3)
+ * )
+ *
+ * assert.deepStrictEqual(Trie.get(trie, "call"), Option.some(0))
+ * assert.deepStrictEqual(Trie.get(trie, "me"), Option.some(1))
+ * assert.deepStrictEqual(Trie.get(trie, "mind"), Option.some(2))
+ * assert.deepStrictEqual(Trie.get(trie, "mid"), Option.some(3))
+ * assert.deepStrictEqual(Trie.get(trie, "cale"), Option.none())
+ * assert.deepStrictEqual(Trie.get(trie, "ma"), Option.none())
+ * assert.deepStrictEqual(Trie.get(trie, "midn"), Option.none())
+ * assert.deepStrictEqual(Trie.get(trie, "mea"), Option.none())
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const get = TR.get;
+/**
+ * Check if the given key exists in the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1),
+ *   Trie.insert("mind", 2),
+ *   Trie.insert("mid", 3)
+ * )
+ *
+ * assert.equal(Trie.has(trie, "call"), true)
+ * assert.equal(Trie.has(trie, "me"), true)
+ * assert.equal(Trie.has(trie, "mind"), true)
+ * assert.equal(Trie.has(trie, "mid"), true)
+ * assert.equal(Trie.has(trie, "cale"), false)
+ * assert.equal(Trie.has(trie, "ma"), false)
+ * assert.equal(Trie.has(trie, "midn"), false)
+ * assert.equal(Trie.has(trie, "mea"), false)
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const has = TR.has;
+/**
+ * Checks if the `Trie` contains any entries.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>()
+ * const trie1 = trie.pipe(Trie.insert("ma", 0))
+ *
+ * assert.equal(Trie.isEmpty(trie), true)
+ * assert.equal(Trie.isEmpty(trie1), false)
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isEmpty = TR.isEmpty;
+/**
+ * Unsafely lookup the value for the specified key in the `Trie`.
+ *
+ * `unsafeGet` will throw if the key is not found. Use `get` instead to safely
+ * get a value from the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1)
+ * )
+ *
+ * assert.throws(() => Trie.unsafeGet(trie, "mae"))
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeGet = TR.unsafeGet;
+/**
+ * Remove the entry for the specified key in the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("call", 0),
+ *   Trie.insert("me", 1),
+ *   Trie.insert("mind", 2),
+ *   Trie.insert("mid", 3)
+ * )
+ *
+ * const trie1 = trie.pipe(Trie.remove("call"))
+ * const trie2 = trie1.pipe(Trie.remove("mea"))
+ *
+ * assert.deepStrictEqual(Trie.get(trie, "call"), Option.some(0))
+ * assert.deepStrictEqual(Trie.get(trie1, "call"), Option.none())
+ * assert.deepStrictEqual(Trie.get(trie2, "call"), Option.none())
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const remove = TR.remove;
+/**
+ * Reduce a state over the entries of the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * assert.equal(
+ *   trie.pipe(
+ *     Trie.reduce(0, (acc, n) => acc + n)
+ *   ),
+ *   3
+ * )
+ * assert.equal(
+ *   trie.pipe(
+ *     Trie.reduce(10, (acc, n) => acc + n)
+ *   ),
+ *   13
+ * )
+ * assert.equal(
+ *   trie.pipe(
+ *     Trie.reduce("", (acc, _, key) => acc + key)
+ *   ),
+ *   "sellssheshells"
+ * )
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce = TR.reduce;
+/**
+ * Maps over the entries of the `Trie` using the specified function.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieMapV = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 1),
+ *   Trie.insert("sells", 2),
+ *   Trie.insert("she", 3)
+ * )
+ *
+ * const trieMapK = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 6),
+ *   Trie.insert("sells", 5),
+ *   Trie.insert("she", 3)
+ * )
+ *
+ * assert.equal(Equal.equals(Trie.map(trie, (v) => v + 1), trieMapV), true)
+ * assert.equal(Equal.equals(Trie.map(trie, (_, k) => k.length), trieMapK), true)
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const map = TR.map;
+/**
+ * Filters entries out of a `Trie` using the specified predicate.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieMapV = Trie.empty<number>().pipe(
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieMapK = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1)
+ * )
+ *
+ * assert.equal(Equal.equals(Trie.filter(trie, (v) => v > 1), trieMapV), true)
+ * assert.equal(Equal.equals(Trie.filter(trie, (_, k) => k.length > 3), trieMapK), true)
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filter = TR.filter;
+/**
+ * Maps over the entries of the `Trie` using the specified partial function
+ * and filters out `None` values.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieMapV = Trie.empty<number>().pipe(
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieMapK = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1)
+ * )
+ *
+ * assert.equal(Equal.equals(Trie.filterMap(trie, (v) => v > 1 ? Option.some(v) : Option.none()), trieMapV), true)
+ * assert.equal(
+ *   Equal.equals(Trie.filterMap(trie, (v, k) => k.length > 3 ? Option.some(v) : Option.none()), trieMapK),
+ *   true
+ * )
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filterMap = TR.filterMap;
+/**
+ * Filters out `None` values from a `Trie` of `Options`s.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<Option.Option<number>>().pipe(
+ *   Trie.insert("shells", Option.some(0)),
+ *   Trie.insert("sells", Option.none()),
+ *   Trie.insert("she", Option.some(2))
+ * )
+ *
+ * const trieMapV = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * assert.equal(Equal.equals(Trie.compact(trie), trieMapV), true)
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const compact = TR.compact;
+/**
+ * Applies the specified function to the entries of the `Trie`.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ *
+ * let value = 0
+ *
+ * Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2),
+ *   Trie.forEach((n, key) => {
+ *     value += n + key.length
+ *   })
+ * )
+ *
+ * assert.equal(value, 17)
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach = TR.forEach;
+/**
+ * Updates the value of the specified key within the `Trie` if it exists.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ * import * as Option from "effect/Option"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * assert.deepStrictEqual(trie.pipe(Trie.modify("she", (v) => v + 10), Trie.get("she")), Option.some(12))
+ *
+ * assert.equal(Equal.equals(trie.pipe(Trie.modify("me", (v) => v)), trie), true)
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const modify = TR.modify;
+/**
+ * Removes all entries in the `Trie` which have the specified keys.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * assert.equal(
+ *   Equal.equals(trie.pipe(Trie.removeMany(["she", "sells"])), Trie.empty<number>().pipe(Trie.insert("shells", 0))),
+ *   true
+ * )
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const removeMany = TR.removeMany;
+/**
+ * Insert multiple entries in the `Trie` at once.
+ *
+ * @example
+ * import * as Trie from "effect/Trie"
+ * import * as Equal from "effect/Equal"
+ *
+ * const trie = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insert("sells", 1),
+ *   Trie.insert("she", 2)
+ * )
+ *
+ * const trieInsert = Trie.empty<number>().pipe(
+ *   Trie.insert("shells", 0),
+ *   Trie.insertMany(
+ *     [["sells", 1], ["she", 2]]
+ *   )
+ * )
+ *
+ * assert.equal(
+ *   Equal.equals(trie, trieInsert),
+ *   true
+ * )
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const insertMany = TR.insertMany;
+//# sourceMappingURL=Trie.js.map

package/dist/esm/Trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Trie.js","names":["TR","TypeId","TrieTypeId","empty","fromIterable","make","insert","keys","values","entries","toEntries","self","Array","from","keysWithPrefix","valuesWithPrefix","entriesWithPrefix","toEntriesWithPrefix","longestPrefixOf","size","get","has","isEmpty","unsafeGet","remove","reduce","map","filter","filterMap","compact","forEach","modify","removeMany","insertMany"],"sources":["../../src/Trie.ts"],"sourcesContent":[null],"mappings":"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"}

package/dist/esm/index.js

@@ -225,6 +225,10 @@ export * as Fiber from "./Fiber.js";
  * @since 2.0.0
  */
 export * as FiberId from "./FiberId.js";
+/**
+ * @since 2.0.0
+ */
+export * as FiberMap from "./FiberMap.js";
 /**
  * @since 2.0.0
  */
@@ -237,6 +241,10 @@ export * as FiberRefs from "./FiberRefs.js";
  * @since 2.0.0
  */
 export * as FiberRefsPatch from "./FiberRefsPatch.js";
+/**
+ * @since 2.0.0
+ */
+export * as FiberSet from "./FiberSet.js";
 /**
  * @since 2.0.0
  */
@@ -695,6 +703,24 @@ export * as TestSized from "./TestSized.js";
  * @since 2.0.0
  */
 export * as Tracer from "./Tracer.js";
+/**
+ * A `Trie` is used for locating specific `string` keys from within a set.
+ *
+ * It works similar to `HashMap`, but with keys required to be `string`.
+ * This constraint unlocks some performance optimizations and new methods to get string prefixes (e.g. `keysWithPrefix`, `longestPrefixOf`).
+ *
+ * Prefix search is also the main feature that makes a `Trie` more suited than `HashMap` for certain usecases.
+ *
+ * A `Trie` is often used to store a dictionary (list of words) that can be searched
+ * in a manner that allows for efficient generation of completion lists
+ * (e.g. predict the rest of a word a user is typing).
+ *
+ * A `Trie` has O(n) lookup time where `n` is the size of the key,
+ * or even less than `n` on search misses.
+ *
+ * @since 2.0.0
+ */
+export * as Trie from "./Trie.js";
 /**
  * This module provides utility functions for working with tuples in TypeScript.
  *