@langchain/langgraph 0.4.9 → 1.0.0-alpha.1

package/dist/graph/annotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation.d.ts","names":["RunnableLike","BaseChannel","BinaryOperator","BinaryOperatorAggregate","LastValue","SingleReducer","ValueType","UpdateType","StateDefinition","ExtractValueType","C","ReturnType","ExtractUpdateType","StateType","SD","key","NodeType","Partial","AnnotationFunction","S","AnnotationRoot","Annotation","getChannel","V","U"],"sources":["../../src/graph/annotation.d.ts"],"sourcesContent":["import { RunnableLike } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { BinaryOperator, BinaryOperatorAggregate } from \"../channels/binop.js\";\nimport { LastValue } from \"../channels/last_value.js\";\nexport type SingleReducer<ValueType, UpdateType = ValueType> = {\n    reducer: BinaryOperator<ValueType, UpdateType>;\n    default?: () => ValueType;\n} | {\n    /**\n     * @deprecated Use `reducer` instead\n     */\n    value: BinaryOperator<ValueType, UpdateType>;\n    default?: () => ValueType;\n} | null;\nexport interface StateDefinition {\n    [key: string]: BaseChannel | (() => BaseChannel);\n}\ntype ExtractValueType<C> = C extends BaseChannel ? C[\"ValueType\"] : C extends () => BaseChannel ? ReturnType<C>[\"ValueType\"] : never;\ntype ExtractUpdateType<C> = C extends BaseChannel ? C[\"UpdateType\"] : C extends () => BaseChannel ? ReturnType<C>[\"UpdateType\"] : never;\nexport type StateType<SD extends StateDefinition> = {\n    [key in keyof SD]: ExtractValueType<SD[key]>;\n};\nexport type UpdateType<SD extends StateDefinition> = {\n    [key in keyof SD]?: ExtractUpdateType<SD[key]>;\n};\nexport type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;\n/** @ignore */\nexport interface AnnotationFunction {\n    <ValueType>(): LastValue<ValueType>;\n    <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;\n    Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;\n}\n/**\n * Should not be instantiated directly. See {@link Annotation}.\n */\nexport declare class AnnotationRoot<SD extends StateDefinition> {\n    lc_graph_name: string;\n    State: StateType<SD>;\n    Update: UpdateType<SD>;\n    Node: NodeType<SD>;\n    spec: SD;\n    constructor(s: SD);\n}\n/**\n * Helper that instantiates channels within a StateGraph state.\n *\n * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:\n * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.\n * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.\n *\n * @example\n * ```ts\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single string key named \"currentOutput\"\n * const SimpleAnnotation = Annotation.Root({\n *   currentOutput: Annotation<string>,\n * });\n *\n * const graphBuilder = new StateGraph(SimpleAnnotation);\n *\n * // A node in the graph that returns an object with a \"currentOutput\" key\n * // replaces the value in the state. You can get the state type as shown below:\n * const myNode = (state: typeof SimpleAnnotation.State) => {\n *   return {\n *     currentOutput: \"some_new_value\",\n *   };\n * }\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n *\n * @example\n * ```ts\n * import { type BaseMessage, AIMessage } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const AnnotationWithReducer = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     // Different types are allowed for updates\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(AnnotationWithReducer);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof AnnotationWithReducer.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n * @namespace\n * @property Root\n * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.\n */\nexport declare const Annotation: AnnotationFunction;\nexport declare function getChannel<V, U = V>(reducer: SingleReducer<V, U>): BaseChannel<V, U>;\nexport {};\n"],"mappings":";;;;;;KAIYK,sCAAsCC;WACrCJ,eAAeI,WAAWC;EAD3BF,OAAAA,CAAAA,EAAAA,GAAAA,GAEQC,SAFK;CAAA,GAAA;;;;OACZJ,EAMFA,cANEA,CAMaI,SANbJ,EAMwBK,UANxBL,CAAAA;SACOI,CAAAA,EAAAA,GAAAA,GAMAA,SANAA;QAKMA;AAAWC,UAGpBC,eAAAA,CAHoBD;MAA1BL,EAAAA,MAAAA,CAAAA,EAIQD,WAJRC,GAAAA,CAAAA,GAAAA,GAI6BD,WAJ7BC,CAAAA;;KAMNO,sBAAsBC,UAAUT,cAAcS,iBAAiBA,iBAAgBT,eAAcU,WAAWD;AAH7G,KAIKE,iBAJ2B,CAAA,CAAA,CAAA,GAIJF,CAJI,SAIMT,WAJN,GAIoBS,CAJpB,CAAA,YAAA,CAAA,GAIsCA,CAJtC,UAAA,GAAA,GAIsDT,WAJtD,IAIoEU,UAJpE,CAI+ED,CAJ/E,CAAA,CAAA,YAAA,CAAA,GAAA,KAAA;AAAA,KAKpBG,SALoB,CAAA,WAKCL,eALD,CAAA,GAAA,UACbP,MAKDa,EALCb,GAKIQ,gBALJR,CAKqBa,EALrBb,CAKwBc,GALxBd,CAAAA,CAAAA;KAOPM,sBAAsBC,6BAL7BC,MAMaK,EANbL,IAMmBG,iBANH,CAMqBE,EANrB,CAMwBC,GANxB,CAAA,CAAA,EAAA;AAAML,KAQfM,QAReN,CAAAA,WAQKF,eARLE,CAAAA,GAQwBV,YARxBU,CAQqCG,SARrCH,CAQ+CI,EAR/CJ,CAAAA,EAQoDH,UARpDG,CAQ+DI,EAR/DJ,CAAAA,GAQqEO,OARrEP,CAQ6EG,SAR7EH,CAQuFI,EARvFJ,CAAAA,CAAAA,CAAAA;;AAAwBA,UAUlCQ,kBAAAA,CAVkCR;YAAiBA,CAAAA,EAAAA,EAWjDN,SAXiDM,CAWvCJ,SAXuCI,CAAAA;YAAgBT,EAAAA,aAYvDK,SAZuDL,CAAAA,CAAAA,UAAAA,EAYhCI,aAZgCJ,CAYlBK,SAZkBL,EAYPM,UAZON,CAAAA,CAAAA,EAYOE,uBAZPF,CAY+BK,SAZ/BL,EAY0CM,UAZ1CN,CAAAA;MAAyBS,EAAAA,CAAAA,UAaxFF,eAbwFE,CAAAA,CAAAA,EAAAA,EAanES,CAbmET,EAAAA,GAa7DU,cAb6DV,CAa9CS,CAb8CT,CAAAA;;;AAAD;;AAChFA,cAiBPU,cAjBOV,CAAAA,WAiBmBF,eAjBnBE,CAAAA,CAAAA;eAAUT,EAAAA,MAAAA;OAAcS,EAmBzCG,SAnByCH,CAmB/BI,EAnB+BJ,CAAAA;QAAkBA,EAoB1DH,UApB0DG,CAoB/CI,EApB+CJ,CAAAA;MAAgBT,EAqB5Ee,QArB4Ef,CAqBnEa,EArBmEb,CAAAA;MAAyBS,EAsBrGI,EAtBqGJ;aAAXC,CAAAA,CAAAA,EAuBjFG,EAvBiFH;;AACpG;;;;;;;;AAGA;;;;;;;;AAGA;;;;;;;;;;;;AAEA;;;;;;;;;;;;;;;;AAQA;;;;;;;;;;;;AA+EA;;;;;;;;;;;;;;;cAAqBU,YAAYH"}

package/dist/graph/annotation.js

@@ -1,120 +1,99 @@
 import { BinaryOperatorAggregate } from "../channels/binop.js";
 import { LastValue } from "../channels/last_value.js";
+
+//#region src/graph/annotation.ts
 /**
- * Should not be instantiated directly. See {@link Annotation}.
- */
-export class AnnotationRoot {
-    constructor(s) {
-        Object.defineProperty(this, "lc_graph_name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "AnnotationRoot"
-        });
-        Object.defineProperty(this, "spec", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.spec = s;
-    }
-}
+* Should not be instantiated directly. See {@link Annotation}.
+*/
+var AnnotationRoot = class {
+	lc_graph_name = "AnnotationRoot";
+	spec;
+	constructor(s) {
+		this.spec = s;
+	}
+};
 /**
- * Helper that instantiates channels within a StateGraph state.
- *
- * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
- * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
- * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
- *
- * @example
- * ```ts
- * import { StateGraph, Annotation } from "@langchain/langgraph";
- *
- * // Define a state with a single string key named "currentOutput"
- * const SimpleAnnotation = Annotation.Root({
- *   currentOutput: Annotation<string>,
- * });
- *
- * const graphBuilder = new StateGraph(SimpleAnnotation);
- *
- * // A node in the graph that returns an object with a "currentOutput" key
- * // replaces the value in the state. You can get the state type as shown below:
- * const myNode = (state: typeof SimpleAnnotation.State) => {
- *   return {
- *     currentOutput: "some_new_value",
- *   };
- * }
- *
- * const graph = graphBuilder
- *   .addNode("myNode", myNode)
- *   ...
- *   .compile();
- * ```
- *
- * @example
- * ```ts
- * import { type BaseMessage, AIMessage } from "@langchain/core/messages";
- * import { StateGraph, Annotation } from "@langchain/langgraph";
- *
- * // Define a state with a single key named "messages" that will
- * // combine a returned BaseMessage or arrays of BaseMessages
- * const AnnotationWithReducer = Annotation.Root({
- *   messages: Annotation<BaseMessage[]>({
- *     // Different types are allowed for updates
- *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
- *       if (Array.isArray(right)) {
- *         return left.concat(right);
- *       }
- *       return left.concat([right]);
- *     },
- *     default: () => [],
- *   }),
- * });
- *
- * const graphBuilder = new StateGraph(AnnotationWithReducer);
- *
- * // A node in the graph that returns an object with a "messages" key
- * // will update the state by combining the existing value with the returned one.
- * const myNode = (state: typeof AnnotationWithReducer.State) => {
- *   return {
- *     messages: [new AIMessage("Some new response")],
- *   };
- * };
- *
- * const graph = graphBuilder
- *   .addNode("myNode", myNode)
- *   ...
- *   .compile();
- * ```
- * @namespace
- * @property Root
- * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
- */
-export const Annotation = function (annotation) {
-    if (annotation) {
-        return getChannel(annotation);
-    }
-    else {
-        // @ts-expect-error - Annotation without reducer
-        return new LastValue();
-    }
+* Helper that instantiates channels within a StateGraph state.
+*
+* Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
+* 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
+* 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
+*
+* @example
+* ```ts
+* import { StateGraph, Annotation } from "@langchain/langgraph";
+*
+* // Define a state with a single string key named "currentOutput"
+* const SimpleAnnotation = Annotation.Root({
+*   currentOutput: Annotation<string>,
+* });
+*
+* const graphBuilder = new StateGraph(SimpleAnnotation);
+*
+* // A node in the graph that returns an object with a "currentOutput" key
+* // replaces the value in the state. You can get the state type as shown below:
+* const myNode = (state: typeof SimpleAnnotation.State) => {
+*   return {
+*     currentOutput: "some_new_value",
+*   };
+* }
+*
+* const graph = graphBuilder
+*   .addNode("myNode", myNode)
+*   ...
+*   .compile();
+* ```
+*
+* @example
+* ```ts
+* import { type BaseMessage, AIMessage } from "@langchain/core/messages";
+* import { StateGraph, Annotation } from "@langchain/langgraph";
+*
+* // Define a state with a single key named "messages" that will
+* // combine a returned BaseMessage or arrays of BaseMessages
+* const AnnotationWithReducer = Annotation.Root({
+*   messages: Annotation<BaseMessage[]>({
+*     // Different types are allowed for updates
+*     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+*       if (Array.isArray(right)) {
+*         return left.concat(right);
+*       }
+*       return left.concat([right]);
+*     },
+*     default: () => [],
+*   }),
+* });
+*
+* const graphBuilder = new StateGraph(AnnotationWithReducer);
+*
+* // A node in the graph that returns an object with a "messages" key
+* // will update the state by combining the existing value with the returned one.
+* const myNode = (state: typeof AnnotationWithReducer.State) => {
+*   return {
+*     messages: [new AIMessage("Some new response")],
+*   };
+* };
+*
+* const graph = graphBuilder
+*   .addNode("myNode", myNode)
+*   ...
+*   .compile();
+* ```
+* @namespace
+* @property Root
+* Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
+*/
+const Annotation = function(annotation) {
+	if (annotation) return getChannel(annotation);
+	else return new LastValue();
 };
 Annotation.Root = (sd) => new AnnotationRoot(sd);
-export function getChannel(reducer) {
-    if (typeof reducer === "object" &&
-        reducer &&
-        "reducer" in reducer &&
-        reducer.reducer) {
-        return new BinaryOperatorAggregate(reducer.reducer, reducer.default);
-    }
-    if (typeof reducer === "object" &&
-        reducer &&
-        "value" in reducer &&
-        reducer.value) {
-        return new BinaryOperatorAggregate(reducer.value, reducer.default);
-    }
-    // @ts-expect-error - Annotation without reducer
-    return new LastValue();
+function getChannel(reducer) {
+	if (typeof reducer === "object" && reducer && "reducer" in reducer && reducer.reducer) return new BinaryOperatorAggregate(reducer.reducer, reducer.default);
+	if (typeof reducer === "object" && reducer && "value" in reducer && reducer.value) return new BinaryOperatorAggregate(reducer.value, reducer.default);
+	return new LastValue();
 }
+
+//#endregion
+export { Annotation, AnnotationRoot, getChannel };
 //# sourceMappingURL=annotation.js.map

package/dist/graph/annotation.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotation.js","sourceRoot":"","sources":["../../src/graph/annotation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAsDtD;;GAEG;AACH,MAAM,OAAO,cAAc;IAWzB,YAAY,CAAK;QAVjB;;;;mBAAgB,gBAAgB;WAAC;QAQjC;;;;;WAAS;QAGP,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;IAChB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAuB,UAI5C,UAAiD;IAEjD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,UAAU,CAAwB,UAAU,CAAC,CAAC;IACvD,CAAC;SAAM,CAAC;QACN,gDAAgD;QAChD,OAAO,IAAI,SAAS,EAAa,CAAC;IACpC,CAAC;AACH,CAAuB,CAAC;AAExB,UAAU,CAAC,IAAI,GAAG,CAA4B,EAAK,EAAE,EAAE,CAAC,IAAI,cAAc,CAAC,EAAE,CAAC,CAAC;AAE/E,MAAM,UAAU,UAAU,CACxB,OAA4B;IAE5B,IACE,OAAO,OAAO,KAAK,QAAQ;QAC3B,OAAO;QACP,SAAS,IAAI,OAAO;QACpB,OAAO,CAAC,OAAO,EACf,CAAC;QACD,OAAO,IAAI,uBAAuB,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACvE,CAAC;IACD,IACE,OAAO,OAAO,KAAK,QAAQ;QAC3B,OAAO;QACP,OAAO,IAAI,OAAO;QAClB,OAAO,CAAC,KAAK,EACb,CAAC;QACD,OAAO,IAAI,uBAAuB,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IACD,gDAAgD;IAChD,OAAO,IAAI,SAAS,EAAK,CAAC;AAC5B,CAAC"}
+{"version":3,"file":"annotation.js","names":["Annotation: AnnotationFunction"],"sources":["../../src/graph/annotation.ts"],"sourcesContent":["import { RunnableLike } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { BinaryOperator, BinaryOperatorAggregate } from \"../channels/binop.js\";\nimport { LastValue } from \"../channels/last_value.js\";\n\nexport type SingleReducer<ValueType, UpdateType = ValueType> =\n  | {\n      reducer: BinaryOperator<ValueType, UpdateType>;\n      default?: () => ValueType;\n    }\n  | {\n      /**\n       * @deprecated Use `reducer` instead\n       */\n      value: BinaryOperator<ValueType, UpdateType>;\n      default?: () => ValueType;\n    }\n  | null;\n\nexport interface StateDefinition {\n  [key: string]: BaseChannel | (() => BaseChannel);\n}\n\ntype ExtractValueType<C> = C extends BaseChannel\n  ? C[\"ValueType\"]\n  : C extends () => BaseChannel\n  ? ReturnType<C>[\"ValueType\"]\n  : never;\n\ntype ExtractUpdateType<C> = C extends BaseChannel\n  ? C[\"UpdateType\"]\n  : C extends () => BaseChannel\n  ? ReturnType<C>[\"UpdateType\"]\n  : never;\n\nexport type StateType<SD extends StateDefinition> = {\n  [key in keyof SD]: ExtractValueType<SD[key]>;\n};\n\nexport type UpdateType<SD extends StateDefinition> = {\n  [key in keyof SD]?: ExtractUpdateType<SD[key]>;\n};\n\nexport type NodeType<SD extends StateDefinition> = RunnableLike<\n  StateType<SD>,\n  UpdateType<SD> | Partial<StateType<SD>>\n>;\n\n/** @ignore */\nexport interface AnnotationFunction {\n  <ValueType>(): LastValue<ValueType>;\n  <ValueType, UpdateType = ValueType>(\n    annotation: SingleReducer<ValueType, UpdateType>\n  ): BinaryOperatorAggregate<ValueType, UpdateType>;\n  Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;\n}\n\n/**\n * Should not be instantiated directly. See {@link Annotation}.\n */\nexport class AnnotationRoot<SD extends StateDefinition> {\n  lc_graph_name = \"AnnotationRoot\";\n\n  declare State: StateType<SD>;\n\n  declare Update: UpdateType<SD>;\n\n  declare Node: NodeType<SD>;\n\n  spec: SD;\n\n  constructor(s: SD) {\n    this.spec = s;\n  }\n}\n\n/**\n * Helper that instantiates channels within a StateGraph state.\n *\n * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:\n * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.\n * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.\n *\n * @example\n * ```ts\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single string key named \"currentOutput\"\n * const SimpleAnnotation = Annotation.Root({\n *   currentOutput: Annotation<string>,\n * });\n *\n * const graphBuilder = new StateGraph(SimpleAnnotation);\n *\n * // A node in the graph that returns an object with a \"currentOutput\" key\n * // replaces the value in the state. You can get the state type as shown below:\n * const myNode = (state: typeof SimpleAnnotation.State) => {\n *   return {\n *     currentOutput: \"some_new_value\",\n *   };\n * }\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n *\n * @example\n * ```ts\n * import { type BaseMessage, AIMessage } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const AnnotationWithReducer = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     // Different types are allowed for updates\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(AnnotationWithReducer);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof AnnotationWithReducer.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   ...\n *   .compile();\n * ```\n * @namespace\n * @property Root\n * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.\n */\nexport const Annotation: AnnotationFunction = function <\n  ValueType,\n  UpdateType = ValueType\n>(\n  annotation?: SingleReducer<ValueType, UpdateType>\n): BaseChannel<ValueType, UpdateType> {\n  if (annotation) {\n    return getChannel<ValueType, UpdateType>(annotation);\n  } else {\n    // @ts-expect-error - Annotation without reducer\n    return new LastValue<ValueType>();\n  }\n} as AnnotationFunction;\n\nAnnotation.Root = <S extends StateDefinition>(sd: S) => new AnnotationRoot(sd);\n\nexport function getChannel<V, U = V>(\n  reducer: SingleReducer<V, U>\n): BaseChannel<V, U> {\n  if (\n    typeof reducer === \"object\" &&\n    reducer &&\n    \"reducer\" in reducer &&\n    reducer.reducer\n  ) {\n    return new BinaryOperatorAggregate(reducer.reducer, reducer.default);\n  }\n  if (\n    typeof reducer === \"object\" &&\n    reducer &&\n    \"value\" in reducer &&\n    reducer.value\n  ) {\n    return new BinaryOperatorAggregate(reducer.value, reducer.default);\n  }\n  // @ts-expect-error - Annotation without reducer\n  return new LastValue<V>();\n}\n"],"mappings":";;;;;;;AA4DA,IAAa,iBAAb,MAAwD;CACtD,gBAAgB;CAQhB;CAEA,YAAY,GAAO;AACjB,OAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EhB,MAAaA,aAAiC,SAI5C,YACoC;AACpC,KAAI,WACF,QAAO,WAAkC;KAGzC,QAAO,IAAI;;AAIf,WAAW,QAAmC,OAAU,IAAI,eAAe;AAE3E,SAAgB,WACd,SACmB;AACnB,KACE,OAAO,YAAY,YACnB,WACA,aAAa,WACb,QAAQ,QAER,QAAO,IAAI,wBAAwB,QAAQ,SAAS,QAAQ;AAE9D,KACE,OAAO,YAAY,YACnB,WACA,WAAW,WACX,QAAQ,MAER,QAAO,IAAI,wBAAwB,QAAQ,OAAO,QAAQ;AAG5D,QAAO,IAAI"}