effect 2.0.3 → 2.0.5

package/dist/cjs/Trie.js

@@ -0,0 +1,680 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.valuesWithPrefix = exports.values = exports.unsafeGet = exports.toEntriesWithPrefix = exports.toEntries = exports.size = exports.removeMany = exports.remove = exports.reduce = exports.modify = exports.map = exports.make = exports.longestPrefixOf = exports.keysWithPrefix = exports.keys = exports.isEmpty = exports.insertMany = exports.insert = exports.has = exports.get = exports.fromIterable = exports.forEach = exports.filterMap = exports.filter = exports.entriesWithPrefix = exports.entries = exports.empty = exports.compact = void 0;
+var TR = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/trie.js"));
+function _getRequireWildcardCache(e) {
+  if ("function" != typeof WeakMap) return null;
+  var r = new WeakMap(),
+    t = new WeakMap();
+  return (_getRequireWildcardCache = function (e) {
+    return e ? t : r;
+  })(e);
+}
+function _interopRequireWildcard(e, r) {
+  if (!r && e && e.__esModule) return e;
+  if (null === e || "object" != typeof e && "function" != typeof e) return {
+    default: e
+  };
+  var t = _getRequireWildcardCache(r);
+  if (t && t.has(e)) return t.get(e);
+  var n = {
+      __proto__: null
+    },
+    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
+    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+  }
+  return n.default = e, t && t.set(e, n), n;
+}
+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
+ */
+const empty = exports.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
+ */
+const fromIterable = exports.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
+ */
+const make = exports.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
+ */
+const insert = exports.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
+ */
+const keys = exports.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
+ */
+const values = exports.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
+ */
+const entries = exports.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
+ */
+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
+ */
+exports.toEntries = toEntries;
+const keysWithPrefix = exports.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
+ */
+const valuesWithPrefix = exports.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
+ */
+const entriesWithPrefix = exports.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
+ */
+const toEntriesWithPrefix = exports.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
+ */
+const longestPrefixOf = exports.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
+ */
+const size = exports.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
+ */
+const get = exports.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
+ */
+const has = exports.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
+ */
+const isEmpty = exports.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
+ */
+const unsafeGet = exports.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
+ */
+const remove = exports.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
+ */
+const reduce = exports.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
+ */
+const map = exports.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
+ */
+const filter = exports.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
+ */
+const filterMap = exports.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
+ */
+const compact = exports.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
+ */
+const forEach = exports.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
+ */
+const modify = exports.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
+ */
+const removeMany = exports.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
+ */
+const insertMany = exports.insertMany = TR.insertMany;
+//# sourceMappingURL=Trie.js.map

package/dist/cjs/Trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Trie.js","names":["TR","_interopRequireWildcard","require","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","prototype","hasOwnProperty","call","i","set","TypeId","TrieTypeId","empty","exports","fromIterable","make","insert","keys","values","entries","toEntries","self","Array","from","keysWithPrefix","valuesWithPrefix","entriesWithPrefix","toEntriesWithPrefix","longestPrefixOf","size","isEmpty","unsafeGet","remove","reduce","map","filter","filterMap","compact","forEach","modify","removeMany","insertMany"],"sources":["../../src/Trie.ts"],"sourcesContent":[null],"mappings":"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"}