@rimbu/deep 0.14.5 → 1.0.0-alpha.2

package/src/protected.mts

@@ -0,0 +1,30 @@
+import type { IsAny, IsPlainObj } from '@rimbu/base';
+
+/**
+ * A deep readonly typed version of given type T. Makes all properties or elements read only.
+ * It maps types using the following rules:
+ * - arrays and tuples become readonly counterparts, and all element types are wrapped in `Protected` if applicable
+ * - Maps of key type K and value type V become Maps of key type `Protected<K>` and value type `Protected<V>`
+ * - Sets of element type E become Sets of element type `Protected<E>`
+ * - Promises of value type E become Promises of value type `Protected<E>`
+ * - Objects that have only simple properties (no functions or iterators) will have all the properties as Protected if applicable
+ * - Any other type will not be mapped
+ * @typeparam T - the input type
+ */
+export type Protected<T> = IsAny<T> extends true
+  ? // to prevent infinite recursion, any will be any
+    T
+  : T extends readonly any[] & infer A
+  ? // convert all keys to readonly and all values to `Protected`
+    { readonly [K in keyof A]: Protected<A[K]> }
+  : T extends Map<infer K, infer V>
+  ? ReadonlyMap<Protected<K>, Protected<V>>
+  : T extends Set<infer E>
+  ? ReadonlySet<Protected<E>>
+  : T extends Promise<infer E>
+  ? Promise<Protected<E>>
+  : IsPlainObj<T> extends true
+  ? // convert all keys to readonly and all values to `Protected`
+    { readonly [K in keyof T]: Protected<T[K]> }
+  : // nothing to do, just return `T`
+    T;

package/src/selector.mts

@@ -0,0 +1,90 @@
+import type { IsAnyFunc, IsArray } from '@rimbu/base';
+import { Deep, Path, type Protected } from './internal.mjs';
+
+/**
+ * Type defining the allowed selectors on an object of type `T`.
+ * Selectors can be:
+ * - a path string into type `T`.
+ * - a function receiving a `Protected` version of type `T`, and returning an arbitrary value.
+ * - a tuple of `Selectors` for type `T`
+ * - an object where the property values are `Selectors` for type `T`.
+ * @typeparam T - the source value type.
+ */
+export type Selector<T> =
+  | Path.Get<T>
+  | ((value: Protected<T>) => any)
+  | readonly Selector<T>[]
+  | { readonly [key: string | symbol]: Selector<T> };
+
+export namespace Selector {
+  /**
+   * Type defining the shape of allowed selectors, used to improve compiler checking.
+   * @typeparam SL - the selector type
+   */
+  export type Shape<SL> = IsAnyFunc<SL> extends true
+    ? // functions are allowed, type provided by `Selector`
+      SL
+    : IsArray<SL> extends true
+    ? // ensure tuple type is preserved
+      readonly [...(SL extends readonly unknown[] ? SL : never)]
+    : SL extends { readonly [key: string | number | symbol]: unknown }
+    ? // ensure all object properties satisfy `Shape`
+      { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
+    : // nothing to check
+      SL;
+
+  /**
+   * Type defining the result type of applying the SL selector type to the T value type.
+   * @typeparam T - the source value type
+   * @typeparam SL - the selector type
+   */
+  export type Result<T, SL> = Selector<T> extends SL
+    ? never
+    : SL extends (...args: any[]) => infer R
+    ? R
+    : SL extends string
+    ? Path.Result<T, SL>
+    : {
+        readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
+      };
+}
+
+/**
+ * Returns the result of applying the given `selector` shape to the given `source` value.
+ * @typeparam T - the patch value type
+ * @typeparam SL - the selector shape type
+ * @param source - the source value to select from
+ * @param selector - a shape indicating the selection from the source values
+ * @example
+ * ```ts
+ * const item = { a: { b:  1, c: 'a' } };
+ * Deep.select(item, { q: 'a.c', y: ['a.b', 'a.c'], z: (v) => v.a.b + 1 });
+ * // => { q: 'a', y: [1, 'a'], z: 2 }
+ * ```
+ */
+export function select<T, SL extends Selector<T>>(
+  source: T,
+  selector: Selector.Shape<SL>
+): Selector.Result<T, SL> {
+  if (typeof selector === 'function') {
+    // selector is function, resolve selector function
+    return (selector as any)(source as Protected<T>);
+  } else if (typeof selector === 'string') {
+    // selector is string path, get the value at the given path
+    return Deep.getAt(source, selector as Path.Get<T>) as any;
+  } else if (Array.isArray(selector)) {
+    // selector is tuple, get each tuple item value
+    return selector.map((s) => select(source, s)) as any;
+  }
+
+  // selector is object
+
+  const result: any = {};
+
+  for (const key in selector as any) {
+    // set each selected object key to the selector value
+    result[key] = select(source, (selector as any)[key]);
+  }
+
+  return result;
+}

package/src/tuple.mts

@@ -0,0 +1,197 @@
+import { Arr } from '@rimbu/base';
+import type { Update } from '@rimbu/common';
+
+/**
+ * A readonly array of fixed length and types.
+ */
+export type Tuple<T extends Tuple.Source> = Readonly<T>;
+
+export namespace Tuple {
+  /**
+   * A non-empty readonly array that can serve as a source for a Tuple.
+   */
+  export type NonEmptySource = readonly [unknown, ...unknown[]];
+
+  /**
+   * A readonly array that can serve as a source for a Tuple.
+   */
+  export type Source = readonly unknown[];
+
+  export type IsTuple<T> = T extends { length: infer L }
+    ? 0 extends L
+      ? false
+      : true
+    : false;
+
+  /**
+   * Returns the indices/keys that are in a tuple.
+   * @typeparam T - the input tuple type
+   */
+  export type KeysOf<T> = { [K in keyof T]: K }[keyof T & number];
+
+  /**
+   * Convenience method to type Tuple types
+   * @param values - the values of the tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * // type of t => Tuple<[number, string, boolean]>
+   * ```
+   */
+  export function of<T extends Tuple.NonEmptySource>(...values: T): Tuple<T> {
+    return values as any;
+  }
+
+  /**
+   * Returns the item at the given `index` in the givn `tuple`.
+   * @param tuple - the tuple to get the item from
+   * @param index - the index in of the tuple element
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.getIndex(t, 1))
+   * // => 'a'
+   * ```
+   */
+  export function getIndex<T extends Tuple.Source, K extends keyof T = keyof T>(
+    tuple: T,
+    index: K
+  ): T[K] {
+    return tuple[index];
+  }
+
+  /**
+   * Returns the first element of a Tuple.
+   * @param tuple - the source tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.first(t))
+   * // => 1
+   * ```
+   */
+  export function first<T extends Tuple.Source>(tuple: T): T[0] {
+    return tuple[0];
+  }
+
+  /**
+   * Returns the second element of a Tuple.
+   * @param tuple - the source tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.second(t))
+   * // => 'a'
+   * ```
+   */
+  export function second<T extends Tuple.Source>(tuple: T): T[1] {
+    return tuple[1];
+  }
+
+  /**
+   * Returns the last element of a Tuple.
+   * @param tuple - the source tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.last(t))
+   * // => true
+   * ```
+   */
+  export function last<T extends readonly unknown[], R>(
+    tuple: readonly [...T, R]
+  ): R {
+    return tuple[tuple.length - 1] as any;
+  }
+
+  /**
+   * Returns a copy of the given `tuple` where the element at given `index` is updated with the
+   * given `updater`.
+   * @param tuple - the source tuple
+   * @param index - the index in the tuple
+   * @param updater - the updater for the value
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.updateAt(t, 1, 'b'))
+   * // => [1, 'b', true]
+   * ```
+   */
+  export function updateAt<T extends Tuple.Source, K extends keyof T = keyof T>(
+    tuple: T,
+    index: K,
+    updater: Update<T[K]>
+  ): T {
+    return Arr.update(tuple, index as number, updater) as T;
+  }
+
+  /**
+   * Returns the given `tuple` with the given `values` appended.
+   * @param tuple - the source tuple
+   * @param values - the values to append
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a')
+   * console.log(Tuple.append(t, true, 5))
+   * // => [1, 'a', true, 5]
+   * ```
+   */
+  export function append<
+    T extends Tuple.Source,
+    V extends readonly [unknown, ...unknown[]]
+  >(tuple: T, ...values: V): readonly [...T, ...V] {
+    return [...tuple, ...values];
+  }
+
+  /**
+   * Returns a Tuple containing the elements of given `tuple1` followed by the elements
+   * of given `tuple2`.
+   * @param tuple1 - the first Tuple
+   * @param tuple2 - the second Tuple
+   * @example
+   * ```ts
+   * const t1 = Tuple.of(1, 'a')
+   * const t2 = Tuple.of(true, 5)
+   * console.log(Tuple.concat(t1, t2))
+   * // => [1, 'a', true, 5]
+   * ```
+   */
+  export function concat<T1 extends Tuple.Source, T2 extends Tuple.Source>(
+    tuple1: T1,
+    tuple2: T2
+  ): readonly [...T1, ...T2] {
+    return tuple1.concat(tuple2) as any;
+  }
+
+  /**
+   * Returns a Tuple containing all but the last element of the given `tuple`.
+   * @param tuple - the source tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.init(t))
+   * // => [1, 'a']
+   * ```
+   */
+  export function init<T extends readonly unknown[]>(
+    tuple: readonly [...T, unknown]
+  ): Readonly<T> {
+    return Arr.init(tuple) as any;
+  }
+
+  /**
+   * Returns a Tuple containing all but the first element of the given `tuple`.
+   * @param tuple - the source tuple
+   * @example
+   * ```ts
+   * const t = Tuple.of(1, 'a', true)
+   * console.log(Tuple.tail(t))
+   * // => ['a', true]
+   * ```
+   */
+  export function tail<T extends readonly [...unknown[]]>(
+    tuple: readonly [unknown, ...T]
+  ): Readonly<T> {
+    return Arr.tail(tuple) as any;
+  }
+}

package/dist/main/deep.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withType = exports.selectAtWith = exports.selectAt = exports.selectWith = exports.matchAtWith = exports.matchAt = exports.matchWith = exports.patchAtWith = exports.patchWith = exports.getAtWith = exports.protect = exports.select = exports.patchAt = exports.getAt = exports.patch = exports.match = void 0;
-var internal_1 = require("./internal");
-var match_1 = require("./match");
-Object.defineProperty(exports, "match", { enumerable: true, get: function () { return match_1.match; } });
-var patch_1 = require("./patch");
-Object.defineProperty(exports, "patch", { enumerable: true, get: function () { return patch_1.patch; } });
-var path_1 = require("./path");
-Object.defineProperty(exports, "getAt", { enumerable: true, get: function () { return path_1.getAt; } });
-Object.defineProperty(exports, "patchAt", { enumerable: true, get: function () { return path_1.patchAt; } });
-var selector_1 = require("./selector");
-Object.defineProperty(exports, "select", { enumerable: true, get: function () { return selector_1.select; } });
-/**
- * Returns the same value wrapped in the `Protected` type.
- * @typeparam T - the source value type
- * @param source - the value to wrap
- * @note does not perform any runtime protection, it is only a utility to easily add the `Protected`
- * type to a value
- * @example
- * ```ts
- * const obj = Deep.protect({ a: 1, b: { c: true, d: [1] } })
- * obj.a = 2        // compiler error: a is readonly
- * obj.b.c = false  // compiler error: c is readonly
- * obj.b.d.push(2)  // compiler error: d is a readonly array
- * (obj as any).b.d.push(2)  // will actually mutate the object
- * ```
- */
-function protect(source) {
-    return source;
-}
-exports.protect = protect;
-/**
- * Returns a function that gets the value at the given string `path` inside an object.
- * @typeparam T - the input value type
- * @typeparam P - the string literal path type in the object
- * @param path - the string path in the object
- * @param source - the value from which to extract the path value
- * @example
- * ```ts
- * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
- * items.map(Deep.getAtWith('a.c'));
- * // => ['a', 'b']
- * ```
- */
-function getAtWith(path) {
-    return function (source) { return internal_1.Deep.getAt(source, path); };
-}
-exports.getAtWith = getAtWith;
-/**
- * Returns a function that patches a given `source` with the given `patchItems`.
- * @typeparam T - the patch value type
- * @typeparam TE - utility type
- * @typeparam TT - utility type
- * @param patchItem - the `Patch` definition to update the given value of type `T` with.
- * @param source - the value to use the given `patchItem` on.
- * @example
- * ```ts
- * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
- * items.map(Deep.patchWith([{ a: v => v + 1 }]));
- * // => [{ a: 2, b: 'a' }, { a: 3, b: 'b' }]
- * ```
- */
-function patchWith(patchItem) {
-    return function (source) { return internal_1.Deep.patch(source, patchItem); };
-}
-exports.patchWith = patchWith;
-/**
- * Returns a function that patches a given `value` with the given `patchItems` at the given `path`.
- * @typeparam T - the patch value type
- * @typeparam P - the string literal path type in the object
- * @typeparam TE - utility type
- * @typeparam TT - utility type
- * @param path - the string path in the object
- * @param patchItem - the `Patch` definition to update the value at the given `path` in `T` with.
- * @param source - the value to use the given `patchItem` on at the given `path`.
- * @example
- * ```ts
- * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
- * items.map(Deep.patchAtWith('a', [{ b: (v) => v + 1 }]));
- * // => [{ a: { b: 2, c: 'a' } }, { a: { b: 3, c: 'b' } }]
- * ```
- */
-function patchAtWith(path, patchItem) {
-    return function (source) { return internal_1.Deep.patchAt(source, path, patchItem); };
-}
-exports.patchAtWith = patchAtWith;
-/**
- * Returns a function that matches a given `value` with the given `matcher`.
- * @typeparam T - the patch value type
- * @param matcher - a matcher object that matches input values.
- * @param source - the value to use the given `patchItem` on at the given `path`.
- * @example
- * ```ts
- * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
- * items.filter(Deep.matchWith({ a: 2 }));
- * // => [{ a: 2, b: 'b' }]
- * ```
- */
-function matchWith(matcher) {
-    return function (source) { return internal_1.Deep.match(source, matcher); };
-}
-exports.matchWith = matchWith;
-/**
- * Returns true if the given `value` object matches the given `matcher` at the given `path`, false otherwise.
- * @typeparam T - the input value type
- * @typeparam P - the string literal path type in the object
- * @param source - the input value
- * @param path - the string path in the object
- * @param matcher - a matcher object or a function taking the matcher API and returning a match object
- * @example
- * ```ts
- * const input = { a: 1, b: { c: true, d: 'a' } }
- * Deep.matchAt(input, 'b', { c: true })
- * // => true
- * ```
- */
-function matchAt(source, path, matcher) {
-    return internal_1.Deep.match(internal_1.Deep.getAt(source, path), matcher);
-}
-exports.matchAt = matchAt;
-/**
- * Returns a function that matches a given `value` with the given `matcher` at the given string `path`.
- * @typeparam T - the patch value type
- * @typeparam P - the string literal path type in the object
- * @typeparam TE - utility type
- * @param path - the string path in the object
- * @param matcher - a matcher object that matches input values.
- * @param source - the value to use the given `matcher` on at the given `path`.
- * @example
- * ```ts
- * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
- * items.filter(Deep.matchAtWith('a.b', 2));
- * // => [{ a: 2, b: 'b' }]
- * ```
- */
-function matchAtWith(path, matcher) {
-    return function (source) { return internal_1.Deep.matchAt(source, path, matcher); };
-}
-exports.matchAtWith = matchAtWith;
-/**
- * Returns a function that selects a certain shape from a given `value` with the given `selector`.
- * @typeparam T - the patch value type
- * @typeparam SL - the selector shape type
- * @param selector - a shape indicating the selection from the source values
- * @param source - the value to use the given `selector` on.
- * @example
- * ```ts
- * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
- * items.map(Deep.selectWith({ q: 'a.c', z: ['a.b', v => v.a.b + 1] as const }));
- * // => [{ q: 'a', z: [1, 2] }, { q: 'b', z: [2, 3] }]
- * ```
- */
-function selectWith(selector) {
-    return function (source) { return internal_1.Deep.select(source, selector); };
-}
-exports.selectWith = selectWith;
-/**
- * Returns the result of applying the given `selector` shape to the given `source` value.
- * @typeparam T - the patch value type
- * @typeparam P - the string literal path type in the object
- * @typeparam SL - the selector shape type
- * @param source - the source value to select from
- * @param path - the string path in the object
- * @param selector - a shape indicating the selection from the source value at the given path
- * @example
- * ```ts
- * const item = { a: { b:  1, c: 'a' } };
- * Deep.selectAt(item, 'a', { q: 'c', z: ['b', v => v.b + 1] as const });
- * // => { q: 'a', z: [1, 2] }
- * ```
- */
-function selectAt(source, path, selector) {
-    return internal_1.Deep.select(internal_1.Deep.getAt(source, path), selector);
-}
-exports.selectAt = selectAt;
-/**
- * Returns a function that selects a certain shape from a given `value` with the given `selector` at the given string `path`.
- * @typeparam T - the patch value type
- * @typeparam P - the string literal path type in the object
- * @typeparam SL - the selector shape type
- * @param path - the string path in the object
- * @param selector - a shape indicating the selection from the source values
- * @example
- * ```ts
- * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
- * items.map(Deep.selectAtWith('a', { q: 'c', z: ['b', v => v.b + 1] as const }));
- * // => [{ q: 'a', z: [1, 2] }, { q: 'b', z: [2, 3] }]
- * ```
- */
-function selectAtWith(path, selector) {
-    return function (source) { return internal_1.Deep.selectAt(source, path, selector); };
-}
-exports.selectAtWith = selectAtWith;
-/**
- * Returns a curried API with a known target type. This can be useful for using the methods in
- * contexts where the target type can be inferred from the usage.
- * @typeparam T - the target type
- * @example
- * ```ts
- * const s = { a: 1, b: { c: 'a', d: true }}
- * const upd = Deep.withType<typeof s>().patchWith([{ d: (v) => !v }])
- * upd(s)
- * // => { a: 1, b: { c: 'a', d: false }}
- * ```
- */
-function withType() {
-    return internal_1.Deep;
-}
-exports.withType = withType;
-//# sourceMappingURL=deep.js.map

package/dist/main/deep.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep.js","sourceRoot":"","sources":["../../src/deep.ts"],"names":[],"mappings":";;;AACA,uCAAkC;AAElC,iCAA4C;AAAnC,8FAAA,KAAK,OAAA;AACd,iCAA4C;AAAnC,8FAAA,KAAK,OAAA;AACd,+BAAmD;AAA1C,6FAAA,KAAK,OAAA;AAAE,+FAAA,OAAO,OAAA;AACvB,uCAAmD;AAA1C,kGAAA,MAAM,OAAA;AAGf;;;;;;;;;;;;;;GAcG;AACH,SAAgB,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAFD,0BAEC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,SAAS,CACvB,IAAO;IAEP,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAxB,CAAwB,CAAC;AAC9C,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CACvB,SAAwB;IAExB,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,EAApC,CAAoC,CAAC;AAC1D,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,EAA5C,CAA4C,CAAC;AAClE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,SAAS,CAAI,OAAiB;IAC5C,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAA3B,CAA2B,CAAC;AACjD,CAAC;AAFD,8BAEC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,eAAI,CAAC,KAAK,CAAC,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAND,0BAMC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,EAA1C,CAA0C,CAAC;AAChE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CACxB,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAA7B,CAA6B,CAAC;AACnD,CAAC;AAJD,gCAIC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,eAAI,CAAC,MAAM,CAAC,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAVD,4BAUC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAArC,CAAqC,CAAC;AAC3D,CAAC;AATD,oCASC;AAkID;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ;IACtB,OAAO,eAAI,CAAC;AACd,CAAC;AAFD,4BAEC"}

package/dist/main/index.js

@@ -1,19 +0,0 @@
-"use strict";
-/**
- * @packageDocumentation
- *
- * The `@rimbu/deep` package provides utilities to patch and match plain JavaScript objects.<br/>
- * <br/>
- * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deep = exports.Path = exports.Tuple = void 0;
-var tslib_1 = require("tslib");
-var tuple_1 = require("./tuple");
-Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return tuple_1.Tuple; } });
-var internal_1 = require("./internal");
-Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return internal_1.Path; } });
-tslib_1.__exportStar(require("./deep"), exports);
-var Deep = tslib_1.__importStar(require("./deep"));
-exports.Deep = Deep;
-//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;AAEH,iCAAgC;AAAvB,8FAAA,KAAK,OAAA;AAGd,uCAA6D;AAApD,gGAAA,IAAI,OAAA;AAEb,iDAAuB;AAEvB,mDAA+B;AAM7B,oBAAI"}

package/dist/main/internal.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deep = exports.Path = void 0;
-var tslib_1 = require("tslib");
-var path_1 = require("./path");
-Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return path_1.Path; } });
-var Deep = tslib_1.__importStar(require("./deep"));
-exports.Deep = Deep;
-//# sourceMappingURL=internal.js.map

package/dist/main/internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":";;;;AACA,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AAKb,mDAA+B;AACtB,oBAAI"}