@peter.naydenov/walk-async 6.1.0 → 7.0.0

package/src/runCallback.js

@@ -0,0 +1,55 @@
+"use strict"
+
+import IGNORE from "./ignore.js";
+import PASS, { isPass } from "./pass.js";
+import FINISH, { isFinish } from "./finish.js";
+
+
+
+async function runCallback ( callback, context, pending, name, ...args ) {
+    let
+          task
+        , done
+        , tag = `${name} at '${context.breadcrumbs ?? context.key}'`
+        ;
+
+    // Reading resolve or reject selects the v6 explicit-settlement API.
+    // Return-based callbacks need no extra settlement promise.
+    function explicit () {
+        if ( !task ) {
+                task = new Promise ( resolve => { done = resolve } )
+                // Observe rejected values immediately, even while the callback
+                // is still awaiting other work. The original rejection is
+                // propagated when task is awaited below.
+                task.catch ( () => {} )
+            }
+    } // explicit func.
+
+    Object.defineProperties ( context, {
+              resolve : {
+                          enumerable : true
+                        , get : () => { explicit (); return done }
+                    }
+            , reject : {
+                          enumerable : true
+                        , get : () => { explicit (); return () => done ( IGNORE() ) }
+                    }
+        })
+
+    pending.add ( tag )
+    try {
+            const returned = await callback ( context, ...args );
+            const value = task ? await task : returned;
+            // Keep the callback pending while an instruction replacement settles too.
+            if ( name === 'objectCallback' && isPass ( value ) && value.hasValue )   return PASS ( await value.value )
+            if ( isFinish ( value ) && value.hasValue )   return FINISH ( await value.value )
+            return value
+        }
+    finally {
+            pending.delete ( tag )
+        }
+} // runCallback func.
+
+
+
+export default runCallback

package/src/setKey.js

@@ -0,0 +1,12 @@
+// Plain assignment of a '__proto__' key triggers the inherited setter and
+// replaces the prototype of 'target' instead of creating an own property.
+function setKey ( target, k, value ) {
+    if ( k === '__proto__' )   Object.defineProperty ( target, k, { value, enumerable:true, writable:true, configurable:true })
+    else                       target[k] = value
+} // setKey func.
+
+
+
+export default setKey
+
+

package/src/validateForInsertion.js

@@ -0,0 +1,12 @@
+function validateForInsertion ( k, result ) {
+    if ( !Array.isArray ( result ) )   return false
+    const index = Number ( k );
+    // Array indexes are canonical decimal strings from 0 through 2^32 - 2.
+    return Number.isInteger ( index ) && index >= 0 && index < 4294967295 && String ( index ) === k
+} // validateForInsertion func.
+
+
+
+export default validateForInsertion
+
+

package/types/copyObject.d.ts

@@ -0,0 +1,8 @@
+declare function copyObject(resource: any, result: any, extend: any, cb: any, breadcrumbs: any, settings: any, control: any, parentPath: any, pass: any, parent: any, ancestors: any, pending: any, ...args: any[]): Promise<{
+    data: any;
+    location: any;
+    parent: any;
+    depth: any;
+} | undefined>;
+export default copyObject;
+//# sourceMappingURL=copyObject.d.ts.map

package/types/copyObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyObject.d.ts","sourceRoot":"","sources":["../src/copyObject.js"],"names":[],"mappings":"AAaA,iBAAe,UAAU,CAAG,QAAQ,KAAA,EAAE,MAAM,KAAA,EAAE,MAAM,KAAA,EAAE,EAAE,KAAA,EAAE,WAAW,KAAA,EAAE,QAAQ,KAAA,EAAE,OAAO,KAAA,EAAE,UAAU,KAAA,EAAE,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,SAAS,KAAA,EAAE,OAAO,KAAA,EAAE,GAAG,IAAI,OAAA;;;;;eAuG9I;eA4Bc,UAAU"}

package/types/createCallbackArgs.d.ts

@@ -0,0 +1,32 @@
+import FINISH from "./finish.js";
+declare function createCallbackArgs(value: any, key: any, IGNORE: any, breadcrumbs: any, parentPath: any, settings: any): {
+    value: any;
+    key: any;
+    breadcrumbs: any;
+    parentPath: any;
+    IGNORE: any;
+    FINISH: typeof FINISH;
+} | {
+    value: any;
+    key: any;
+    breadcrumbs: any;
+    IGNORE: any;
+    FINISH: typeof FINISH;
+    parentPath?: undefined;
+} | {
+    breadcrumbs?: undefined;
+    value: any;
+    key: any;
+    parentPath: any;
+    IGNORE: any;
+    FINISH: typeof FINISH;
+} | {
+    breadcrumbs?: undefined;
+    parentPath?: undefined;
+    value: any;
+    key: any;
+    IGNORE: any;
+    FINISH: typeof FINISH;
+};
+export default createCallbackArgs;
+//# sourceMappingURL=createCallbackArgs.d.ts.map

package/types/createCallbackArgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCallbackArgs.d.ts","sourceRoot":"","sources":["../src/createCallbackArgs.js"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAC;AAIjC,iBAAS,kBAAkB,CAAG,KAAK,KAAA,EAAE,GAAG,KAAA,EAAE,MAAM,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,QAAQ,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlF;eAIc,kBAAkB"}

package/types/findType.d.ts

@@ -0,0 +1,3 @@
+declare function findType(x: any): "array" | "object" | "simple";
+export default findType;
+//# sourceMappingURL=findType.d.ts.map

package/types/findType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findType.d.ts","sourceRoot":"","sources":["../src/findType.js"],"names":[],"mappings":"AAAA,iBAAS,QAAQ,CAAG,CAAC,KAAA,iCAoBnB;eAIc,QAAQ"}

package/types/finish.d.ts

@@ -0,0 +1,25 @@
+export type FinishInstruction = {
+    value: any;
+    hasValue: boolean;
+};
+/**
+ *  Private instruction created by the FINISH helper.
+ *
+ *  @typedef {object} FinishInstruction
+ *  @property {*} value
+ *  @property {boolean} hasValue
+ */
+/**
+ *  Stop the entire walk. Omit the current value when no argument is
+ *  supplied. From objectCallback, a supplied value selects the final
+ *  branch for key callbacks with isFinished true. From keyCallback,
+ *  include the supplied value directly and stop immediately.
+ *
+ *  @param {*} [value] - Final value or branch.
+ *  @returns {FinishInstruction}
+ */
+declare function FINISH(value?: any): FinishInstruction;
+declare function isFinish(value: any): boolean;
+export { isFinish };
+export default FINISH;
+//# sourceMappingURL=finish.d.ts.map

package/types/finish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finish.d.ts","sourceRoot":"","sources":["../src/finish.js"],"names":[],"mappings":"AAQI,YAAkB,iBAAiB,GACnC;IAAc,KAAK,EAAR,GAAC,CACZ;IAAoB,QAAQ,EAAjB,OAAO,CACrB;CAAA,CAAA;AAND;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,iBAAS,MAAM,CAAG,KAAK,AAHnB,CACA,EADQ,GAGW,GAFT,iBAAiB,CAM9B;AAID,iBAAS,QAAQ,CAAG,KAAK,KAAA,WAExB;AAID,OAAO,EAAE,QAAQ,EAAE,CAAA;eACJ,MAAM"}

package/types/ignore.d.ts

@@ -0,0 +1,10 @@
+/**
+ *  Remove the current key or the entire current object/array branch.
+ *
+ *  @returns {symbol}
+ */
+declare function IGNORE(): symbol;
+declare function isIgnore(value: any): boolean;
+export { isIgnore };
+export default IGNORE;
+//# sourceMappingURL=ignore.d.ts.map

package/types/ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../src/ignore.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,iBAAS,MAAM,IAFD,MAAM,CAInB;AAID,iBAAS,QAAQ,CAAG,KAAK,KAAA,WAExB;AAID,OAAO,EAAE,QAAQ,EAAE,CAAA;eACJ,MAAM"}

package/types/main.d.ts

@@ -1,18 +1,9 @@
-/**
- *     walk-async
- *
- *     Alternative of deep-copy that provides much better control during creation of immutable
- *     copies of javascript data structures.
- *     Library is using 'generator functions'. If support for old browsers is required,
- *     add a polyfill for 'generators'.
- *
- *     History notes:
- *        - Walk-async was born on September 18th, 2022
- *        - Converted to ES module on January 1st, 2024
- *
- */
 export type Resolve = (value: any) => void;
 export type Reject = (reason?: any) => void;
+export type IgnoreToken = symbol;
+export type IgnoreFunction = () => IgnoreToken;
+export type PassFunction = (value?: any) => import('./pass.js').PassInstruction;
+export type FinishFunction = (value?: any) => import('./finish.js').FinishInstruction;
 export type CallbackArgs = {
     /**
      * - The current value being processed.
@@ -23,23 +14,59 @@ export type CallbackArgs = {
      */
     key: string;
     /**
-     * - Slash-delimited path to the current key, starting with `root` (e.g. `"root/props/age"`).
+     * - Slash-delimited path including the current key. Absent when `settings.breadcrumbs` is false.
+     */
+    breadcrumbs?: string;
+    /**
+     * - Read-only path to the parent, excluding the current key. Absent when `settings.parentPath` is false.
      */
-    breadcrumbs: string;
+    parentPath?: ReadonlyArray<string>;
     /**
-     * - Resolve the callback with the new value (see `Resolve` typedef).
+     * - Reading this field opts into explicit settlement with resolve(value) or reject().
      */
     resolve: Resolve;
     /**
-     * - Reject the callback to drop the current key (see `Reject` typedef).
+     * - Drop the current key or branch; does not reject the walk promise.
      */
     reject: Reject;
+    /**
+     * - Return FINISH() to omit the current value and stop, or FINISH(value) to include a final value or branch.
+     */
+    FINISH: FinishFunction;
+    /**
+     * - Return IGNORE() from the callback to drop the current key from the result.
+     */
+    IGNORE: IgnoreFunction;
+};
+export type KeyCallbackArgs = CallbackArgs & {
+    isFinished: boolean;
+};
+export type ObjectCallbackArgs = CallbackArgs & {
+    PASS: PassFunction;
+};
+export type KeyCallback = (args: KeyCallbackArgs, ...rest: any) => any | Promise<any>;
+export type ObjectCallback = (args: ObjectCallbackArgs, ...rest: any) => any | Promise<any>;
+export type Settings = {
+    /**
+     * - Defaults to true. Only false disables result creation; callbacks still run and walk resolves undefined.
+     */
+    copy?: boolean;
+    /**
+     * - Defaults to true. Only false disables breadcrumbs preparation.
+     */
+    breadcrumbs?: boolean;
+    /**
+     * - Defaults to true. Only false disables parent-path preparation.
+     */
+    parentPath?: boolean;
+    /**
+     * - Defaults to true. Only false disables circular-reference checks and their bookkeeping; visited data and replacements must then be acyclic or callbacks must prune cyclic branches.
+     */
+    detectCycles?: boolean;
 };
-export type KeyCallback = (args: CallbackArgs, ...rest: any) => void;
-export type ObjectCallback = (args: CallbackArgs, ...rest: any) => void;
 export type Options = {
     /**
-     * - Required. Any JS data structure that will be copied.
+     * - Required. Any JS data structure that will be walked.
      */
     data: any;
     /**
@@ -51,97 +78,156 @@ export type Options = {
      */
     objectCallback?: ObjectCallback;
     /**
-     * - Optional. Milliseconds. When set, the promise is rejected if callbacks do not resolve in time. Error lists the pending callbacks.
+     * - Optional milliseconds. Reject the walk with pending-callback diagnostics when time expires.
      */
     timeout?: number;
+    /**
+     * - Optional. Disable copying, unused callback metadata, or cycle detection with false.
+     */
+    settings?: Settings;
 };
 /**
- *  Resolve the callback with the new value to store at the current key:
- *    - resolving a primitive (or a built-in like `Date` / `Map` / `Set`) → stored as-is by reference;
- *    - resolving a plain object or array → walk continues into it with the other callback applied to its children;
- *
- *  You must call `resolve` or `reject` on every code path — otherwise the walk promise never settles
- *  (use the `timeout` option to turn that silent hang into a rejection with diagnostics).
+ *  Explicitly settle a callback with its current value or a replacement.
+ *  Promises supplied to resolve are awaited before traversal continues.
  *
  *  @callback Resolve
  *  @param {*} value
  *  @returns {void}
  */
 /**
- *  Reject the callback. The current key is dropped from the result.
+ *  Drop the current key or entire branch. Retained for v6 callbacks.
+ *  To reject the walk itself, throw or return a rejected promise.
  *
  *  @callback Reject
  *  @param {*} [reason]
  *  @returns {void}
  */
 /**
- *  Arguments object received by both `keyCallback` and `objectCallback`.
+ *  Private sentinel returned by IGNORE().
+ *
+ *  @typedef {symbol} IgnoreToken
+ */
+/**
+ *  Call and return the result to drop the current key or entire branch.
+ *
+ *  @callback IgnoreFunction
+ *  @returns {IgnoreToken}
+ */
+/**
+ *  Call with no arguments to keep the current value, or pass a replacement.
+ *  Supplied replacement promises are awaited before traversal continues.
+ *  Return the instruction from `objectCallback` to skip `keyCallback` on
+ *  its immediate properties. Nested objects and arrays continue normally.
+ *
+ *  @callback PassFunction
+ *  @param {*} [value]
+ *  @returns {import('./pass.js').PassInstruction}
+ */
+/**
+ *  Stop the walk, optionally including a final value or branch.
+ *  Supplied replacement promises are awaited before traversal continues.
+ *
+ *  @callback FinishFunction
+ *  @param {*} [value]
+ *  @returns {import('./finish.js').FinishInstruction}
+ */
+/**
+ *  Shared arguments received by `keyCallback` and `objectCallback`.
  *
  *  @typedef {object} CallbackArgs
  *  @property {*}          value        - The current value being processed.
  *  @property {string}     key          - Property key as a string.
- *  @property {string}     breadcrumbs  - Slash-delimited path to the current key, starting with `root` (e.g. `"root/props/age"`).
- *  @property {Resolve}    resolve      - Resolve the callback with the new value (see `Resolve` typedef).
- *  @property {Reject}     reject       - Reject the callback to drop the current key (see `Reject` typedef).
+ *  @property {string}     [breadcrumbs] - Slash-delimited path including the current key. Absent when `settings.breadcrumbs` is false.
+ *  @property {ReadonlyArray<string>} [parentPath] - Read-only path to the parent, excluding the current key. Absent when `settings.parentPath` is false.
+ *  @property {Resolve} resolve - Reading this field opts into explicit settlement with resolve(value) or reject().
+ *  @property {Reject} reject - Drop the current key or branch; does not reject the walk promise.
+ *  @property {FinishFunction} FINISH - Return FINISH() to omit the current value and stop, or FINISH(value) to include a final value or branch.
+ *  @property {IgnoreFunction} IGNORE   - Return IGNORE() from the callback to drop the current key from the result.
+ */
+/**
+ *  @typedef {CallbackArgs & { isFinished: boolean }} KeyCallbackArgs
  */
 /**
- *  Called once per primitive property (string, number, bigint, boolean,
+ *  @typedef {CallbackArgs & { PASS: PassFunction }} ObjectCallbackArgs
+ */
+/**
+ *  Called once per primitive property unless its immediate parent returns
+ *  `PASS()` or `PASS(value)` from `objectCallback`. Types: string, number, bigint, boolean,
  *  symbol, null, undefined, function, Date, RegExp, Map, Set, WeakMap,
- *  WeakSet, ArrayBuffer, DataView, typed arrays, DOM nodes).
+ *  WeakSet, ArrayBuffer, DataView, typed arrays, DOM nodes.
  *
- *  Resolve with the new value to store, or reject to drop the key:
- *    - resolve a primitive (or a built-in like `Date` / `Map` / `Set`) → stored as-is by reference;
- *    - resolve a plain object or array → walk continues into it with the other callback applied to its children;
- *    - reject → that key is dropped from the result.
+ *  Return the new value to store, or `IGNORE()` to drop the key:
+ *    - return a primitive (or a built-in like `Date`/`Map`/`Set`) → stored as-is by reference;
+ *    - return a plain object or array → walk continues into it with the other callback applied to its children;
+ *    - return `IGNORE()` → that key is dropped from the result;
+ *    - return `FINISH()` → omit the current key and stop the entire walk;
+ *    - return `FINISH(value)` → include the supplied value directly and stop, without descending into it.
+ *  isFinished is true for keys in a final branch selected by objectCallback.
+ *  With settings.copy false, no values are stored; returned containers
+ *  still control what gets visited.
  *
  *  @callback KeyCallback
- *  @param {CallbackArgs} args
+ *  @param {KeyCallbackArgs} args
  *  @param {...*}         rest - Any extra arguments passed to `walk()` are forwarded to the callback.
- *  @returns {void}
+ *  @returns {* | Promise<*>}
  */
 /**
  *  Called once per object or array property, including the root.
- *  The resolved value becomes the new value at that key:
- *    - resolve an object or array → walk continues into it with the other callbacks applied to its children;
- *    - resolve a primitive        → it is stored at that key as-is, and walk does not descend into it (primitives have no children to walk);
- *    - reject                     → the key is dropped from the result.
+ *  The returned value becomes the new value at that key:
+ *    - return an object or array → walk continues into it with the other callbacks;
+ *    - return a primitive        → passed to `keyCallback` when active, otherwise stored as-is;
+ *    - return `IGNORE()`         → the key is dropped from the result.
+ *    - return `PASS()`           → keep the current object/array without its immediate key callbacks; nested callbacks continue normally.
+ *    - return `PASS(value)`      → use the replacement with the same rule; simple replacements are stored directly.
+ *    - return `FINISH()`         → omit the branch and stop the entire walk.
+ *    - return `FINISH(value)`    → process only the final branch with keyCallback and isFinished true, suppressing later object callbacks; without keyCallback, include it directly.
+ *  With settings.copy false, returned values control traversal without
+ *  being stored in a result or assigned to the source.
  *
  *  @callback ObjectCallback
- *  @param {CallbackArgs} args
+ *  @param {ObjectCallbackArgs} args
  *  @param {...*}         rest
- *  @returns {void}
+ *  @returns {* | Promise<*>}
+ */
+/**
+ *  @typedef {object} Settings
+ *  @property {boolean} [copy]        - Defaults to true. Only false disables result creation; callbacks still run and walk resolves undefined.
+ *  @property {boolean} [breadcrumbs] - Defaults to true. Only false disables breadcrumbs preparation.
+ *  @property {boolean} [parentPath]  - Defaults to true. Only false disables parent-path preparation.
+ *  @property {boolean} [detectCycles] - Defaults to true. Only false disables circular-reference checks and their bookkeeping; visited data and replacements must then be acyclic or callbacks must prune cyclic branches.
  */
 /**
  *  @typedef {object} Options
- *  @property {*}             data           - Required. Any JS data structure that will be copied.
+ *  @property {*}             data           - Required. Any JS data structure that will be walked.
  *  @property {KeyCallback}    [keyCallback]    - Optional. Executed on each primitive property.
  *  @property {ObjectCallback} [objectCallback] - Optional. Executed on each object/array property, including the root.
- *  @property {number}         [timeout]         - Optional. Milliseconds. When set, the promise is rejected if callbacks do not resolve in time. Error lists the pending callbacks.
+ *  @property {number}         [timeout] - Optional milliseconds. Reject the walk with pending-callback diagnostics when time expires.
+ *  @property {Settings}       [settings]       - Optional. Disable copying, unused callback metadata, or cycle detection with false.
  */
 /**
  *  Walk-async
  *
- *  Async sibling of `@peter.naydenov/walk`. Visits every member of a deep
- *  JavaScript data structure once, in a single pass, and runs two optional
- *  callbacks during the visit that can mask, filter, or substitute values
- *  as the result is built.
- *
- *  The deep copy of the original data is mostly a side-effect: the real
- *  power is the ability to do all your modifications in one pass, with full
- *  freedom inside a single callback — now with async work, awaits, and
- *  timeouts supported.
+ *  Walks through a deep JavaScript data structure, building a copy by default.
+ *  Two optional callbacks can mask, filter, substitute, or collect values.
+ *  Callback results are awaited in traversal order; thrown errors and rejected promises reject the walk.
+ *  Set settings.copy to false to walk without building a result.
+ *  By default, circular references point to the ancestor copy without visiting its contents again.
  *
  *  @function walk
- *  @param {Options} options   - Required. Object with required `data` property, two optional callback functions (`keyCallback`, `objectCallback`), and an optional `timeout`.
+ *  @param {Options} options   - Required. Object with `data`, optional callbacks, and optional `settings`.
  *  @param {...*}    args      - Optional. Additional arguments forwarded to both callbacks.
- *  @returns {Promise<*>}      - A promise that resolves to the immutable copy of `options.data` (with the callbacks' transformations applied).
+ *  @returns {Promise<*>}      - Resolves to the created result, or undefined when settings.copy is false.
  *  @example
- *  const result = await walk ({
+ *  let result = await walk ({
  *      data: someData,
  *      keyCallback:    keyCallbackFn,
  *      objectCallback: objectCallbackFn
  *  })
+ *
+ *  // Note: objectCallback is executed before keyCallback.
+ *  // If you modify an object with objectCallback, keyCallback will be
+ *  // executed on the result of objectCallback.
  */
-declare function walk({ data: origin, objectCallback, keyCallback, timeout }: Options, ...args: any[]): Promise<any>;
+declare function walk(options: Options, ...args: any[]): Promise<any>;
 export default walk;
 //# sourceMappingURL=main.d.ts.map

package/types/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;GAYG;AAaC,YAAU,OAAO,GACjB,CAAW,KAAK,EAAR,GACR,KAAU,IACb,CAAA;AAKG,YAAU,MAAM,GAChB,CAAY,MAAM,AAAlB,CACA,EADQ,GACR,KAAU,IACb,CAAA;AAKG,YAAkB,YAAY,GAC9B;;;;IAAuB,KAAK,EAAjB,GAAC,CACZ;;;;IAAuB,GAAG,EAAf,MAAM,CACjB;;;;IAAuB,WAAW,EAAvB,MAAM,CACjB;;;;IAAuB,OAAO,EAAnB,OAAO,CAClB;;;;IAAuB,MAAM,EAAlB,MAAM,CACpB;CAAA,CAAA;AAYG,YAAU,WAAW,GACrB,CAAsB,IAAI,EAAlB,YACR,EAAA,GACA,AADsB,IAAI,EAAf,GACX,KAAU,IACb,CAAA;AASG,YAAU,cAAc,GACxB,CAAsB,IAAI,EAAlB,YACR,EAAA,GACA,AADsB,IAAI,EAAf,GACX,KAAU,IACb,CAAA;AAGG,YAAkB,OAAO,GACzB;;;;IAA0B,IAAI,EAAnB,GAAC,CACZ;;;;IAA4B,WAAW,AAAvC,CACA,EADW,WAAW,CACtB;;;;IAA4B,cAAc,AAA1C,CACA,EADW,cAAc,CACzB;;;;IAA4B,OAAO,AAAnC,CACH,EADc,MAAM,CACpB;CAAA,CAAA;AAnED;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AAGH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,IAAI,CAAE,EACG,IAAI,EAAC,MAAM,EACX,cAAqB,EACrB,WAAkB,EAClB,OAAc,EACnB,EAfD,OAeC,EAAE,GAAG,IAAI,EAdP,GAAC,EAcM,GAbR,OAAO,CAAC,GAAC,CAAC,CA2EvB;eA4Lc,IAAI"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.js"],"names":[],"mappings":"AA6BI,YAAU,OAAO,GACjB,CAAW,KAAK,EAAR,GACR,KAAU,IACb,CAAA;AAMG,YAAU,MAAM,GAChB,CAAY,MAAM,AAAlB,CACA,EADQ,GACR,KAAU,IACb,CAAA;AAKG,YAAkB,WAAW,GAAnB,MAAM,CAAa;AAM7B,YAAU,cAAc,GACxB,MAAU,WACb,CAAA;AAQG,YAAU,YAAY,GACtB,CAAY,KAAK,AAAjB,CACA,EADQ,GACR,KAAU,OAAO,WAAW,EAAE,eACjC,CAAA;AAMG,YAAU,cAAc,GACxB,CAAY,KAAK,AAAjB,CACA,EADQ,GACR,KAAU,OAAO,aAAa,EAAE,iBACnC,CAAA;AAKG,YAAkB,YAAY,GAC9B;;;;IAAuB,KAAK,EAAjB,GAAC,CACZ;;;;IAAuB,GAAG,EAAf,MAAM,CACjB;;;;IAAwB,WAAW,AAAnC,CACA,EADW,MAAM,CACjB;;;;IAAmC,UAAU,AAA7C,CACA,EADW,aAAa,CAAC,MAAM,CAAC,CAChC;;;;IAAoB,OAAO,EAAhB,OAAO,CAClB;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAA2B,MAAM,EAAtB,cAAc,CACzB;;;;IAA2B,MAAM,EAAtB,cAAc,CAC5B;CAAA,CAAA;AAGG,YAAkD,eAAe,GAAvD,YAAY,GAAG;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAiB;AAIjE,YAAiD,kBAAkB,GAAzD,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAoB;AAmBnE,YAAU,WAAW,GACrB,CAAyB,IAAI,EAArB,eACR,EAAA,GACA,AADsB,IAAI,EAAf,GACX,KAAU,MAAI,OAAO,KACxB,CAAA;AAeG,YAAU,cAAc,GACxB,CAA4B,IAAI,EAAxB,kBACR,EAAA,GACA,AADsB,IAAI,EAAf,GACX,KAAU,MAAI,OAAO,KACxB,CAAA;AAGG,YAAkB,QAAQ,GAC1B;;;;IAAqB,IAAI,AAAzB,CACA,EADW,OAAO,CAClB;;;;IAAqB,WAAW,AAAhC,CACA,EADW,OAAO,CAClB;;;;IAAqB,UAAU,AAA/B,CACA,EADW,OAAO,CAClB;;;;IAAqB,YAAY,AAAjC,CACH,EADc,OAAO,CACrB;CAAA,CAAA;AAGG,YAAkB,OAAO,GACzB;;;;IAA0B,IAAI,EAAnB,GAAC,CACZ;;;;IAA4B,WAAW,AAAvC,CACA,EADW,WAAW,CACtB;;;;IAA4B,cAAc,AAA1C,CACA,EADW,cAAc,CACzB;;;;IAA4B,OAAO,AAAnC,CACA,EADW,MAAM,CACjB;;;;IAA4B,QAAQ,AAApC,CACH,EADc,QAAQ,CACtB;CAAA,CAAA;AAjID;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAGH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAe,IAAI,CAAE,OAAO,EAdhB,OAcgB,EAAC,GAAG,IAAI,EAbrB,GAAC,EAaoB,GAZtB,OAAO,CAAC,GAAC,CAAC,CA8BvB;eAmHc,IAAI"}

package/types/pass.d.ts

@@ -0,0 +1,23 @@
+export type PassInstruction = {
+    value: any;
+    hasValue: boolean;
+};
+/**
+ *  Private instruction created by the PASS helper.
+ *
+ *  @typedef {object} PassInstruction
+ *  @property {*} value
+ *  @property {boolean} hasValue
+ */
+/**
+ *  Use the current value, or a supplied replacement, without its
+ *  immediate key callbacks. Nested object callbacks continue normally.
+ *
+ *  @param {*} [value] - Replacement value. Omit to keep the current value.
+ *  @returns {PassInstruction}
+ */
+declare function PASS(value?: any): PassInstruction;
+declare function isPass(value: any): boolean;
+export { isPass };
+export default PASS;
+//# sourceMappingURL=pass.d.ts.map

package/types/pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass.d.ts","sourceRoot":"","sources":["../src/pass.js"],"names":[],"mappings":"AAQI,YAAkB,eAAe,GACjC;IAAc,KAAK,EAAR,GAAC,CACZ;IAAoB,QAAQ,EAAjB,OAAO,CACrB;CAAA,CAAA;AAND;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,iBAAS,IAAI,CAAG,KAAK,AAHjB,CACA,EADQ,GAGS,GAFP,eAAe,CAM5B;AAID,iBAAS,MAAM,CAAG,KAAK,KAAA,WAEtB;AAID,OAAO,EAAE,MAAM,EAAE,CAAA;eACF,IAAI"}

package/types/runCallback.d.ts

@@ -0,0 +1,3 @@
+declare function runCallback(callback: any, context: any, pending: any, name: any, ...args: any[]): Promise<any>;
+export default runCallback;
+//# sourceMappingURL=runCallback.d.ts.map

package/types/runCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runCallback.d.ts","sourceRoot":"","sources":["../src/runCallback.js"],"names":[],"mappings":"AAQA,iBAAe,WAAW,CAAG,QAAQ,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,GAAG,IAAI,OAAA,gBA0CrE;eAIc,WAAW"}

package/types/setKey.d.ts

@@ -0,0 +1,3 @@
+declare function setKey(target: any, k: any, value: any): void;
+export default setKey;
+//# sourceMappingURL=setKey.d.ts.map

package/types/setKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setKey.d.ts","sourceRoot":"","sources":["../src/setKey.js"],"names":[],"mappings":"AAEA,iBAAS,MAAM,CAAG,MAAM,KAAA,EAAE,CAAC,KAAA,EAAE,KAAK,KAAA,QAGjC;eAIc,MAAM"}

package/types/validateForInsertion.d.ts

@@ -0,0 +1,3 @@
+declare function validateForInsertion(k: any, result: any): boolean;
+export default validateForInsertion;
+//# sourceMappingURL=validateForInsertion.d.ts.map

package/types/validateForInsertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateForInsertion.d.ts","sourceRoot":"","sources":["../src/validateForInsertion.js"],"names":[],"mappings":"AAAA,iBAAS,oBAAoB,CAAG,CAAC,KAAA,EAAE,MAAM,KAAA,WAKxC;eAIc,oBAAoB"}