copilot-toolbox-template-news/node_modules/.vite/deps/chunk-IILPD2DB.js

import {
  __asyncGenerator,
  __asyncValues,
  __await,
  __awaiter,
  __extends,
  __generator,
  __read,
  __spreadArray,
  __values as __values2,
  external_exports,
  untruncateJson
} from "./chunk-A6PGQRKG.js";
import {
  __export
} from "./chunk-EWTE5DHJ.js";

// node_modules/@ag-ui/core/dist/index.mjs
var FunctionCallSchema = external_exports.object({
  name: external_exports.string(),
  arguments: external_exports.string()
});
var ToolCallSchema = external_exports.object({
  id: external_exports.string(),
  type: external_exports.literal("function"),
  function: FunctionCallSchema
});
var BaseMessageSchema = external_exports.object({
  id: external_exports.string(),
  role: external_exports.string(),
  content: external_exports.string().optional(),
  name: external_exports.string().optional()
});
var TextInputContentSchema = external_exports.object({
  type: external_exports.literal("text"),
  text: external_exports.string()
});
var BinaryInputContentObjectSchema = external_exports.object({
  type: external_exports.literal("binary"),
  mimeType: external_exports.string(),
  id: external_exports.string().optional(),
  url: external_exports.string().optional(),
  data: external_exports.string().optional(),
  filename: external_exports.string().optional()
});
var ensureBinaryPayload = (value, ctx) => {
  if (!value.id && !value.url && !value.data) {
    ctx.addIssue({
      code: external_exports.ZodIssueCode.custom,
      message: "BinaryInputContent requires at least one of id, url, or data.",
      path: ["id"]
    });
  }
};
var BinaryInputContentSchema = BinaryInputContentObjectSchema.superRefine((value, ctx) => {
  ensureBinaryPayload(value, ctx);
});
var InputContentBaseSchema = external_exports.discriminatedUnion("type", [
  TextInputContentSchema,
  BinaryInputContentObjectSchema
]);
var InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
  if (value.type === "binary") {
    ensureBinaryPayload(value, ctx);
  }
});
var DeveloperMessageSchema = BaseMessageSchema.extend({
  role: external_exports.literal("developer"),
  content: external_exports.string()
});
var SystemMessageSchema = BaseMessageSchema.extend({
  role: external_exports.literal("system"),
  content: external_exports.string()
});
var AssistantMessageSchema = BaseMessageSchema.extend({
  role: external_exports.literal("assistant"),
  content: external_exports.string().optional(),
  toolCalls: external_exports.array(ToolCallSchema).optional()
});
var UserMessageSchema = BaseMessageSchema.extend({
  role: external_exports.literal("user"),
  content: external_exports.union([external_exports.string(), external_exports.array(InputContentSchema)])
});
var ToolMessageSchema = external_exports.object({
  id: external_exports.string(),
  content: external_exports.string(),
  role: external_exports.literal("tool"),
  toolCallId: external_exports.string(),
  error: external_exports.string().optional()
});
var ActivityMessageSchema = external_exports.object({
  id: external_exports.string(),
  role: external_exports.literal("activity"),
  activityType: external_exports.string(),
  content: external_exports.record(external_exports.any())
});
var MessageSchema = external_exports.discriminatedUnion("role", [
  DeveloperMessageSchema,
  SystemMessageSchema,
  AssistantMessageSchema,
  UserMessageSchema,
  ToolMessageSchema,
  ActivityMessageSchema
]);
var RoleSchema = external_exports.union([
  external_exports.literal("developer"),
  external_exports.literal("system"),
  external_exports.literal("assistant"),
  external_exports.literal("user"),
  external_exports.literal("tool"),
  external_exports.literal("activity")
]);
var ContextSchema = external_exports.object({
  description: external_exports.string(),
  value: external_exports.string()
});
var ToolSchema = external_exports.object({
  name: external_exports.string(),
  description: external_exports.string(),
  parameters: external_exports.any()
  // JSON Schema for the tool parameters
});
var RunAgentInputSchema = external_exports.object({
  threadId: external_exports.string(),
  runId: external_exports.string(),
  parentRunId: external_exports.string().optional(),
  state: external_exports.any(),
  messages: external_exports.array(MessageSchema),
  tools: external_exports.array(ToolSchema),
  context: external_exports.array(ContextSchema),
  forwardedProps: external_exports.any()
});
var StateSchema = external_exports.any();
var AGUIError = class extends Error {
  constructor(message) {
    super(message);
  }
};
var AGUIConnectNotImplementedError = class extends AGUIError {
  constructor() {
    super("Connect not implemented. This method is not supported by the current agent.");
  }
};
var TextMessageRoleSchema = external_exports.union([
  external_exports.literal("developer"),
  external_exports.literal("system"),
  external_exports.literal("assistant"),
  external_exports.literal("user")
]);
var EventType = ((EventType22) => {
  EventType22["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
  EventType22["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
  EventType22["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
  EventType22["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
  EventType22["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
  EventType22["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
  EventType22["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
  EventType22["TOOL_CALL_START"] = "TOOL_CALL_START";
  EventType22["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
  EventType22["TOOL_CALL_END"] = "TOOL_CALL_END";
  EventType22["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
  EventType22["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
  EventType22["THINKING_START"] = "THINKING_START";
  EventType22["THINKING_END"] = "THINKING_END";
  EventType22["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
  EventType22["STATE_DELTA"] = "STATE_DELTA";
  EventType22["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
  EventType22["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
  EventType22["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
  EventType22["RAW"] = "RAW";
  EventType22["CUSTOM"] = "CUSTOM";
  EventType22["RUN_STARTED"] = "RUN_STARTED";
  EventType22["RUN_FINISHED"] = "RUN_FINISHED";
  EventType22["RUN_ERROR"] = "RUN_ERROR";
  EventType22["STEP_STARTED"] = "STEP_STARTED";
  EventType22["STEP_FINISHED"] = "STEP_FINISHED";
  return EventType22;
})(EventType || {});
var BaseEventSchema = external_exports.object({
  type: external_exports.nativeEnum(EventType),
  timestamp: external_exports.number().optional(),
  rawEvent: external_exports.any().optional()
});
var TextMessageStartEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TEXT_MESSAGE_START"
    /* TEXT_MESSAGE_START */
  ),
  messageId: external_exports.string(),
  role: TextMessageRoleSchema.default("assistant")
});
var TextMessageContentEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TEXT_MESSAGE_CONTENT"
    /* TEXT_MESSAGE_CONTENT */
  ),
  messageId: external_exports.string(),
  delta: external_exports.string().refine((s) => s.length > 0, "Delta must not be an empty string")
});
var TextMessageEndEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TEXT_MESSAGE_END"
    /* TEXT_MESSAGE_END */
  ),
  messageId: external_exports.string()
});
var TextMessageChunkEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TEXT_MESSAGE_CHUNK"
    /* TEXT_MESSAGE_CHUNK */
  ),
  messageId: external_exports.string().optional(),
  role: TextMessageRoleSchema.optional(),
  delta: external_exports.string().optional()
});
var ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "THINKING_TEXT_MESSAGE_START"
    /* THINKING_TEXT_MESSAGE_START */
  )
});
var ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
  messageId: true,
  type: true
}).extend({
  type: external_exports.literal(
    "THINKING_TEXT_MESSAGE_CONTENT"
    /* THINKING_TEXT_MESSAGE_CONTENT */
  )
});
var ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "THINKING_TEXT_MESSAGE_END"
    /* THINKING_TEXT_MESSAGE_END */
  )
});
var ToolCallStartEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TOOL_CALL_START"
    /* TOOL_CALL_START */
  ),
  toolCallId: external_exports.string(),
  toolCallName: external_exports.string(),
  parentMessageId: external_exports.string().optional()
});
var ToolCallArgsEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TOOL_CALL_ARGS"
    /* TOOL_CALL_ARGS */
  ),
  toolCallId: external_exports.string(),
  delta: external_exports.string()
});
var ToolCallEndEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TOOL_CALL_END"
    /* TOOL_CALL_END */
  ),
  toolCallId: external_exports.string()
});
var ToolCallResultEventSchema = BaseEventSchema.extend({
  messageId: external_exports.string(),
  type: external_exports.literal(
    "TOOL_CALL_RESULT"
    /* TOOL_CALL_RESULT */
  ),
  toolCallId: external_exports.string(),
  content: external_exports.string(),
  role: external_exports.literal("tool").optional()
});
var ToolCallChunkEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "TOOL_CALL_CHUNK"
    /* TOOL_CALL_CHUNK */
  ),
  toolCallId: external_exports.string().optional(),
  toolCallName: external_exports.string().optional(),
  parentMessageId: external_exports.string().optional(),
  delta: external_exports.string().optional()
});
var ThinkingStartEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "THINKING_START"
    /* THINKING_START */
  ),
  title: external_exports.string().optional()
});
var ThinkingEndEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "THINKING_END"
    /* THINKING_END */
  )
});
var StateSnapshotEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "STATE_SNAPSHOT"
    /* STATE_SNAPSHOT */
  ),
  snapshot: StateSchema
});
var StateDeltaEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "STATE_DELTA"
    /* STATE_DELTA */
  ),
  delta: external_exports.array(external_exports.any())
  // JSON Patch (RFC 6902)
});
var MessagesSnapshotEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "MESSAGES_SNAPSHOT"
    /* MESSAGES_SNAPSHOT */
  ),
  messages: external_exports.array(MessageSchema)
});
var ActivitySnapshotEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "ACTIVITY_SNAPSHOT"
    /* ACTIVITY_SNAPSHOT */
  ),
  messageId: external_exports.string(),
  activityType: external_exports.string(),
  content: external_exports.record(external_exports.any()),
  replace: external_exports.boolean().optional().default(true)
});
var ActivityDeltaEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "ACTIVITY_DELTA"
    /* ACTIVITY_DELTA */
  ),
  messageId: external_exports.string(),
  activityType: external_exports.string(),
  patch: external_exports.array(external_exports.any())
});
var RawEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "RAW"
    /* RAW */
  ),
  event: external_exports.any(),
  source: external_exports.string().optional()
});
var CustomEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "CUSTOM"
    /* CUSTOM */
  ),
  name: external_exports.string(),
  value: external_exports.any()
});
var RunStartedEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "RUN_STARTED"
    /* RUN_STARTED */
  ),
  threadId: external_exports.string(),
  runId: external_exports.string(),
  parentRunId: external_exports.string().optional(),
  input: RunAgentInputSchema.optional()
});
var RunFinishedEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "RUN_FINISHED"
    /* RUN_FINISHED */
  ),
  threadId: external_exports.string(),
  runId: external_exports.string(),
  result: external_exports.any().optional()
});
var RunErrorEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "RUN_ERROR"
    /* RUN_ERROR */
  ),
  message: external_exports.string(),
  code: external_exports.string().optional()
});
var StepStartedEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "STEP_STARTED"
    /* STEP_STARTED */
  ),
  stepName: external_exports.string()
});
var StepFinishedEventSchema = BaseEventSchema.extend({
  type: external_exports.literal(
    "STEP_FINISHED"
    /* STEP_FINISHED */
  ),
  stepName: external_exports.string()
});
var EventSchemas = external_exports.discriminatedUnion("type", [
  TextMessageStartEventSchema,
  TextMessageContentEventSchema,
  TextMessageEndEventSchema,
  TextMessageChunkEventSchema,
  ThinkingStartEventSchema,
  ThinkingEndEventSchema,
  ThinkingTextMessageStartEventSchema,
  ThinkingTextMessageContentEventSchema,
  ThinkingTextMessageEndEventSchema,
  ToolCallStartEventSchema,
  ToolCallArgsEventSchema,
  ToolCallEndEventSchema,
  ToolCallChunkEventSchema,
  ToolCallResultEventSchema,
  StateSnapshotEventSchema,
  StateDeltaEventSchema,
  MessagesSnapshotEventSchema,
  ActivitySnapshotEventSchema,
  ActivityDeltaEventSchema,
  RawEventSchema,
  CustomEventSchema,
  RunStartedEventSchema,
  RunFinishedEventSchema,
  RunErrorEventSchema,
  StepStartedEventSchema,
  StepFinishedEventSchema
]);

// node_modules/rxjs/dist/esm5/internal/util/isFunction.js
function isFunction(value) {
  return typeof value === "function";
}

// node_modules/rxjs/dist/esm5/internal/util/lift.js
function hasLift(source) {
  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
}
function operate(init) {
  return function(source) {
    if (hasLift(source)) {
      return source.lift(function(liftedSource) {
        try {
          return init(liftedSource, this);
        } catch (err) {
          this.error(err);
        }
      });
    }
    throw new TypeError("Unable to lift unknown Observable type");
  };
}

// node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
var isArrayLike = (function(x2) {
  return x2 && typeof x2.length === "number" && typeof x2 !== "function";
});

// node_modules/rxjs/dist/esm5/internal/util/isPromise.js
function isPromise(value) {
  return isFunction(value === null || value === void 0 ? void 0 : value.then);
}

// node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
function createErrorClass(createImpl) {
  var _super = function(instance) {
    Error.call(instance);
    instance.stack = new Error().stack;
  };
  var ctorFunc = createImpl(_super);
  ctorFunc.prototype = Object.create(Error.prototype);
  ctorFunc.prototype.constructor = ctorFunc;
  return ctorFunc;
}

// node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
var UnsubscriptionError = createErrorClass(function(_super) {
  return function UnsubscriptionErrorImpl(errors) {
    _super(this);
    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
      return i + 1 + ") " + err.toString();
    }).join("\n  ") : "";
    this.name = "UnsubscriptionError";
    this.errors = errors;
  };
});

// node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
function arrRemove(arr, item) {
  if (arr) {
    var index = arr.indexOf(item);
    0 <= index && arr.splice(index, 1);
  }
}

// node_modules/rxjs/dist/esm5/internal/Subscription.js
var Subscription = (function() {
  function Subscription2(initialTeardown) {
    this.initialTeardown = initialTeardown;
    this.closed = false;
    this._parentage = null;
    this._finalizers = null;
  }
  Subscription2.prototype.unsubscribe = function() {
    var e_1, _a, e_2, _b;
    var errors;
    if (!this.closed) {
      this.closed = true;
      var _parentage = this._parentage;
      if (_parentage) {
        this._parentage = null;
        if (Array.isArray(_parentage)) {
          try {
            for (var _parentage_1 = __values2(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
              var parent_1 = _parentage_1_1.value;
              parent_1.remove(this);
            }
          } catch (e_1_1) {
            e_1 = { error: e_1_1 };
          } finally {
            try {
              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
            } finally {
              if (e_1) throw e_1.error;
            }
          }
        } else {
          _parentage.remove(this);
        }
      }
      var initialFinalizer = this.initialTeardown;
      if (isFunction(initialFinalizer)) {
        try {
          initialFinalizer();
        } catch (e) {
          errors = e instanceof UnsubscriptionError ? e.errors : [e];
        }
      }
      var _finalizers = this._finalizers;
      if (_finalizers) {
        this._finalizers = null;
        try {
          for (var _finalizers_1 = __values2(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
            var finalizer = _finalizers_1_1.value;
            try {
              execFinalizer(finalizer);
            } catch (err) {
              errors = errors !== null && errors !== void 0 ? errors : [];
              if (err instanceof UnsubscriptionError) {
                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
              } else {
                errors.push(err);
              }
            }
          }
        } catch (e_2_1) {
          e_2 = { error: e_2_1 };
        } finally {
          try {
            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
          } finally {
            if (e_2) throw e_2.error;
          }
        }
      }
      if (errors) {
        throw new UnsubscriptionError(errors);
      }
    }
  };
  Subscription2.prototype.add = function(teardown) {
    var _a;
    if (teardown && teardown !== this) {
      if (this.closed) {
        execFinalizer(teardown);
      } else {
        if (teardown instanceof Subscription2) {
          if (teardown.closed || teardown._hasParent(this)) {
            return;
          }
          teardown._addParent(this);
        }
        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
      }
    }
  };
  Subscription2.prototype._hasParent = function(parent) {
    var _parentage = this._parentage;
    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
  };
  Subscription2.prototype._addParent = function(parent) {
    var _parentage = this._parentage;
    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
  };
  Subscription2.prototype._removeParent = function(parent) {
    var _parentage = this._parentage;
    if (_parentage === parent) {
      this._parentage = null;
    } else if (Array.isArray(_parentage)) {
      arrRemove(_parentage, parent);
    }
  };
  Subscription2.prototype.remove = function(teardown) {
    var _finalizers = this._finalizers;
    _finalizers && arrRemove(_finalizers, teardown);
    if (teardown instanceof Subscription2) {
      teardown._removeParent(this);
    }
  };
  Subscription2.EMPTY = (function() {
    var empty2 = new Subscription2();
    empty2.closed = true;
    return empty2;
  })();
  return Subscription2;
})();
var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
function isSubscription(value) {
  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
}
function execFinalizer(finalizer) {
  if (isFunction(finalizer)) {
    finalizer();
  } else {
    finalizer.unsubscribe();
  }
}

// node_modules/rxjs/dist/esm5/internal/config.js
var config = {
  onUnhandledError: null,
  onStoppedNotification: null,
  Promise: void 0,
  useDeprecatedSynchronousErrorHandling: false,
  useDeprecatedNextContext: false
};

// node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
var timeoutProvider = {
  setTimeout: function(handler, timeout2) {
    var args = [];
    for (var _i = 2; _i < arguments.length; _i++) {
      args[_i - 2] = arguments[_i];
    }
    var delegate = timeoutProvider.delegate;
    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
      return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
    }
    return setTimeout.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
  },
  clearTimeout: function(handle) {
    var delegate = timeoutProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
function reportUnhandledError(err) {
  timeoutProvider.setTimeout(function() {
    var onUnhandledError = config.onUnhandledError;
    if (onUnhandledError) {
      onUnhandledError(err);
    } else {
      throw err;
    }
  });
}

// node_modules/rxjs/dist/esm5/internal/util/noop.js
function noop() {
}

// node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
var COMPLETE_NOTIFICATION = (function() {
  return createNotification("C", void 0, void 0);
})();
function errorNotification(error) {
  return createNotification("E", void 0, error);
}
function nextNotification(value) {
  return createNotification("N", value, void 0);
}
function createNotification(kind, value, error) {
  return {
    kind,
    value,
    error
  };
}

// node_modules/rxjs/dist/esm5/internal/util/errorContext.js
var context = null;
function errorContext(cb) {
  if (config.useDeprecatedSynchronousErrorHandling) {
    var isRoot = !context;
    if (isRoot) {
      context = { errorThrown: false, error: null };
    }
    cb();
    if (isRoot) {
      var _a = context, errorThrown = _a.errorThrown, error = _a.error;
      context = null;
      if (errorThrown) {
        throw error;
      }
    }
  } else {
    cb();
  }
}
function captureError(err) {
  if (config.useDeprecatedSynchronousErrorHandling && context) {
    context.errorThrown = true;
    context.error = err;
  }
}

// node_modules/rxjs/dist/esm5/internal/Subscriber.js
var Subscriber = (function(_super) {
  __extends(Subscriber2, _super);
  function Subscriber2(destination) {
    var _this = _super.call(this) || this;
    _this.isStopped = false;
    if (destination) {
      _this.destination = destination;
      if (isSubscription(destination)) {
        destination.add(_this);
      }
    } else {
      _this.destination = EMPTY_OBSERVER;
    }
    return _this;
  }
  Subscriber2.create = function(next, error, complete) {
    return new SafeSubscriber(next, error, complete);
  };
  Subscriber2.prototype.next = function(value) {
    if (this.isStopped) {
      handleStoppedNotification(nextNotification(value), this);
    } else {
      this._next(value);
    }
  };
  Subscriber2.prototype.error = function(err) {
    if (this.isStopped) {
      handleStoppedNotification(errorNotification(err), this);
    } else {
      this.isStopped = true;
      this._error(err);
    }
  };
  Subscriber2.prototype.complete = function() {
    if (this.isStopped) {
      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
    } else {
      this.isStopped = true;
      this._complete();
    }
  };
  Subscriber2.prototype.unsubscribe = function() {
    if (!this.closed) {
      this.isStopped = true;
      _super.prototype.unsubscribe.call(this);
      this.destination = null;
    }
  };
  Subscriber2.prototype._next = function(value) {
    this.destination.next(value);
  };
  Subscriber2.prototype._error = function(err) {
    try {
      this.destination.error(err);
    } finally {
      this.unsubscribe();
    }
  };
  Subscriber2.prototype._complete = function() {
    try {
      this.destination.complete();
    } finally {
      this.unsubscribe();
    }
  };
  return Subscriber2;
})(Subscription);
var _bind = Function.prototype.bind;
function bind(fn, thisArg) {
  return _bind.call(fn, thisArg);
}
var ConsumerObserver = (function() {
  function ConsumerObserver2(partialObserver) {
    this.partialObserver = partialObserver;
  }
  ConsumerObserver2.prototype.next = function(value) {
    var partialObserver = this.partialObserver;
    if (partialObserver.next) {
      try {
        partialObserver.next(value);
      } catch (error) {
        handleUnhandledError(error);
      }
    }
  };
  ConsumerObserver2.prototype.error = function(err) {
    var partialObserver = this.partialObserver;
    if (partialObserver.error) {
      try {
        partialObserver.error(err);
      } catch (error) {
        handleUnhandledError(error);
      }
    } else {
      handleUnhandledError(err);
    }
  };
  ConsumerObserver2.prototype.complete = function() {
    var partialObserver = this.partialObserver;
    if (partialObserver.complete) {
      try {
        partialObserver.complete();
      } catch (error) {
        handleUnhandledError(error);
      }
    }
  };
  return ConsumerObserver2;
})();
var SafeSubscriber = (function(_super) {
  __extends(SafeSubscriber2, _super);
  function SafeSubscriber2(observerOrNext, error, complete) {
    var _this = _super.call(this) || this;
    var partialObserver;
    if (isFunction(observerOrNext) || !observerOrNext) {
      partialObserver = {
        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
        error: error !== null && error !== void 0 ? error : void 0,
        complete: complete !== null && complete !== void 0 ? complete : void 0
      };
    } else {
      var context_1;
      if (_this && config.useDeprecatedNextContext) {
        context_1 = Object.create(observerOrNext);
        context_1.unsubscribe = function() {
          return _this.unsubscribe();
        };
        partialObserver = {
          next: observerOrNext.next && bind(observerOrNext.next, context_1),
          error: observerOrNext.error && bind(observerOrNext.error, context_1),
          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
        };
      } else {
        partialObserver = observerOrNext;
      }
    }
    _this.destination = new ConsumerObserver(partialObserver);
    return _this;
  }
  return SafeSubscriber2;
})(Subscriber);
function handleUnhandledError(error) {
  if (config.useDeprecatedSynchronousErrorHandling) {
    captureError(error);
  } else {
    reportUnhandledError(error);
  }
}
function defaultErrorHandler(err) {
  throw err;
}
function handleStoppedNotification(notification, subscriber) {
  var onStoppedNotification = config.onStoppedNotification;
  onStoppedNotification && timeoutProvider.setTimeout(function() {
    return onStoppedNotification(notification, subscriber);
  });
}
var EMPTY_OBSERVER = {
  closed: true,
  next: noop,
  error: defaultErrorHandler,
  complete: noop
};

// node_modules/rxjs/dist/esm5/internal/symbol/observable.js
var observable = (function() {
  return typeof Symbol === "function" && Symbol.observable || "@@observable";
})();

// node_modules/rxjs/dist/esm5/internal/util/identity.js
function identity(x2) {
  return x2;
}

// node_modules/rxjs/dist/esm5/internal/util/pipe.js
function pipe() {
  var fns = [];
  for (var _i = 0; _i < arguments.length; _i++) {
    fns[_i] = arguments[_i];
  }
  return pipeFromArray(fns);
}
function pipeFromArray(fns) {
  if (fns.length === 0) {
    return identity;
  }
  if (fns.length === 1) {
    return fns[0];
  }
  return function piped(input) {
    return fns.reduce(function(prev, fn) {
      return fn(prev);
    }, input);
  };
}

// node_modules/rxjs/dist/esm5/internal/Observable.js
var Observable = (function() {
  function Observable2(subscribe) {
    if (subscribe) {
      this._subscribe = subscribe;
    }
  }
  Observable2.prototype.lift = function(operator) {
    var observable2 = new Observable2();
    observable2.source = this;
    observable2.operator = operator;
    return observable2;
  };
  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
    var _this = this;
    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
    errorContext(function() {
      var _a = _this, operator = _a.operator, source = _a.source;
      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
    });
    return subscriber;
  };
  Observable2.prototype._trySubscribe = function(sink) {
    try {
      return this._subscribe(sink);
    } catch (err) {
      sink.error(err);
    }
  };
  Observable2.prototype.forEach = function(next, promiseCtor) {
    var _this = this;
    promiseCtor = getPromiseCtor(promiseCtor);
    return new promiseCtor(function(resolve, reject) {
      var subscriber = new SafeSubscriber({
        next: function(value) {
          try {
            next(value);
          } catch (err) {
            reject(err);
            subscriber.unsubscribe();
          }
        },
        error: reject,
        complete: resolve
      });
      _this.subscribe(subscriber);
    });
  };
  Observable2.prototype._subscribe = function(subscriber) {
    var _a;
    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
  };
  Observable2.prototype[observable] = function() {
    return this;
  };
  Observable2.prototype.pipe = function() {
    var operations = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      operations[_i] = arguments[_i];
    }
    return pipeFromArray(operations)(this);
  };
  Observable2.prototype.toPromise = function(promiseCtor) {
    var _this = this;
    promiseCtor = getPromiseCtor(promiseCtor);
    return new promiseCtor(function(resolve, reject) {
      var value;
      _this.subscribe(function(x2) {
        return value = x2;
      }, function(err) {
        return reject(err);
      }, function() {
        return resolve(value);
      });
    });
  };
  Observable2.create = function(subscribe) {
    return new Observable2(subscribe);
  };
  return Observable2;
})();
function getPromiseCtor(promiseCtor) {
  var _a;
  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
}
function isObserver(value) {
  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
}
function isSubscriber(value) {
  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
}

// node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
function isInteropObservable(input) {
  return isFunction(input[observable]);
}

// node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
function isAsyncIterable(obj) {
  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
}

// node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
function createInvalidObservableTypeError(input) {
  return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
}

// node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
function getSymbolIterator() {
  if (typeof Symbol !== "function" || !Symbol.iterator) {
    return "@@iterator";
  }
  return Symbol.iterator;
}
var iterator = getSymbolIterator();

// node_modules/rxjs/dist/esm5/internal/util/isIterable.js
function isIterable(input) {
  return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
}

// node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
function readableStreamLikeToAsyncGenerator(readableStream) {
  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
    var reader, _a, value, done;
    return __generator(this, function(_b) {
      switch (_b.label) {
        case 0:
          reader = readableStream.getReader();
          _b.label = 1;
        case 1:
          _b.trys.push([1, , 9, 10]);
          _b.label = 2;
        case 2:
          if (false) return [3, 8];
          return [4, __await(reader.read())];
        case 3:
          _a = _b.sent(), value = _a.value, done = _a.done;
          if (!done) return [3, 5];
          return [4, __await(void 0)];
        case 4:
          return [2, _b.sent()];
        case 5:
          return [4, __await(value)];
        case 6:
          return [4, _b.sent()];
        case 7:
          _b.sent();
          return [3, 2];
        case 8:
          return [3, 10];
        case 9:
          reader.releaseLock();
          return [7];
        case 10:
          return [2];
      }
    });
  });
}
function isReadableStreamLike(obj) {
  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
}

// node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
function innerFrom(input) {
  if (input instanceof Observable) {
    return input;
  }
  if (input != null) {
    if (isInteropObservable(input)) {
      return fromInteropObservable(input);
    }
    if (isArrayLike(input)) {
      return fromArrayLike(input);
    }
    if (isPromise(input)) {
      return fromPromise(input);
    }
    if (isAsyncIterable(input)) {
      return fromAsyncIterable(input);
    }
    if (isIterable(input)) {
      return fromIterable(input);
    }
    if (isReadableStreamLike(input)) {
      return fromReadableStreamLike(input);
    }
  }
  throw createInvalidObservableTypeError(input);
}
function fromInteropObservable(obj) {
  return new Observable(function(subscriber) {
    var obs = obj[observable]();
    if (isFunction(obs.subscribe)) {
      return obs.subscribe(subscriber);
    }
    throw new TypeError("Provided object does not correctly implement Symbol.observable");
  });
}
function fromArrayLike(array) {
  return new Observable(function(subscriber) {
    for (var i = 0; i < array.length && !subscriber.closed; i++) {
      subscriber.next(array[i]);
    }
    subscriber.complete();
  });
}
function fromPromise(promise) {
  return new Observable(function(subscriber) {
    promise.then(function(value) {
      if (!subscriber.closed) {
        subscriber.next(value);
        subscriber.complete();
      }
    }, function(err) {
      return subscriber.error(err);
    }).then(null, reportUnhandledError);
  });
}
function fromIterable(iterable) {
  return new Observable(function(subscriber) {
    var e_1, _a;
    try {
      for (var iterable_1 = __values2(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
        var value = iterable_1_1.value;
        subscriber.next(value);
        if (subscriber.closed) {
          return;
        }
      }
    } catch (e_1_1) {
      e_1 = { error: e_1_1 };
    } finally {
      try {
        if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }
    subscriber.complete();
  });
}
function fromAsyncIterable(asyncIterable) {
  return new Observable(function(subscriber) {
    process2(asyncIterable, subscriber).catch(function(err) {
      return subscriber.error(err);
    });
  });
}
function fromReadableStreamLike(readableStream) {
  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
}
function process2(asyncIterable, subscriber) {
  var asyncIterable_1, asyncIterable_1_1;
  var e_2, _a;
  return __awaiter(this, void 0, void 0, function() {
    var value, e_2_1;
    return __generator(this, function(_b) {
      switch (_b.label) {
        case 0:
          _b.trys.push([0, 5, 6, 11]);
          asyncIterable_1 = __asyncValues(asyncIterable);
          _b.label = 1;
        case 1:
          return [4, asyncIterable_1.next()];
        case 2:
          if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
          value = asyncIterable_1_1.value;
          subscriber.next(value);
          if (subscriber.closed) {
            return [2];
          }
          _b.label = 3;
        case 3:
          return [3, 1];
        case 4:
          return [3, 11];
        case 5:
          e_2_1 = _b.sent();
          e_2 = { error: e_2_1 };
          return [3, 11];
        case 6:
          _b.trys.push([6, , 9, 10]);
          if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
          return [4, _a.call(asyncIterable_1)];
        case 7:
          _b.sent();
          _b.label = 8;
        case 8:
          return [3, 10];
        case 9:
          if (e_2) throw e_2.error;
          return [7];
        case 10:
          return [7];
        case 11:
          subscriber.complete();
          return [2];
      }
    });
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
}
var OperatorSubscriber = (function(_super) {
  __extends(OperatorSubscriber2, _super);
  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
    var _this = _super.call(this, destination) || this;
    _this.onFinalize = onFinalize;
    _this.shouldUnsubscribe = shouldUnsubscribe;
    _this._next = onNext ? function(value) {
      try {
        onNext(value);
      } catch (err) {
        destination.error(err);
      }
    } : _super.prototype._next;
    _this._error = onError ? function(err) {
      try {
        onError(err);
      } catch (err2) {
        destination.error(err2);
      } finally {
        this.unsubscribe();
      }
    } : _super.prototype._error;
    _this._complete = onComplete ? function() {
      try {
        onComplete();
      } catch (err) {
        destination.error(err);
      } finally {
        this.unsubscribe();
      }
    } : _super.prototype._complete;
    return _this;
  }
  OperatorSubscriber2.prototype.unsubscribe = function() {
    var _a;
    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
      var closed_1 = this.closed;
      _super.prototype.unsubscribe.call(this);
      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
    }
  };
  return OperatorSubscriber2;
})(Subscriber);

// node_modules/rxjs/dist/esm5/internal/scheduler/Action.js
var Action = (function(_super) {
  __extends(Action2, _super);
  function Action2(scheduler, work) {
    return _super.call(this) || this;
  }
  Action2.prototype.schedule = function(state, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    return this;
  };
  return Action2;
})(Subscription);

// node_modules/rxjs/dist/esm5/internal/scheduler/intervalProvider.js
var intervalProvider = {
  setInterval: function(handler, timeout2) {
    var args = [];
    for (var _i = 2; _i < arguments.length; _i++) {
      args[_i - 2] = arguments[_i];
    }
    var delegate = intervalProvider.delegate;
    if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
      return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
    }
    return setInterval.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
  },
  clearInterval: function(handle) {
    var delegate = intervalProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncAction.js
var AsyncAction = (function(_super) {
  __extends(AsyncAction2, _super);
  function AsyncAction2(scheduler, work) {
    var _this = _super.call(this, scheduler, work) || this;
    _this.scheduler = scheduler;
    _this.work = work;
    _this.pending = false;
    return _this;
  }
  AsyncAction2.prototype.schedule = function(state, delay2) {
    var _a;
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (this.closed) {
      return this;
    }
    this.state = state;
    var id = this.id;
    var scheduler = this.scheduler;
    if (id != null) {
      this.id = this.recycleAsyncId(scheduler, id, delay2);
    }
    this.pending = true;
    this.delay = delay2;
    this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay2);
    return this;
  };
  AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay2);
  };
  AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 != null && this.delay === delay2 && this.pending === false) {
      return id;
    }
    if (id != null) {
      intervalProvider.clearInterval(id);
    }
    return void 0;
  };
  AsyncAction2.prototype.execute = function(state, delay2) {
    if (this.closed) {
      return new Error("executing a cancelled action");
    }
    this.pending = false;
    var error = this._execute(state, delay2);
    if (error) {
      return error;
    } else if (this.pending === false && this.id != null) {
      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
    }
  };
  AsyncAction2.prototype._execute = function(state, _delay) {
    var errored = false;
    var errorValue;
    try {
      this.work(state);
    } catch (e) {
      errored = true;
      errorValue = e ? e : new Error("Scheduled action threw falsy error");
    }
    if (errored) {
      this.unsubscribe();
      return errorValue;
    }
  };
  AsyncAction2.prototype.unsubscribe = function() {
    if (!this.closed) {
      var _a = this, id = _a.id, scheduler = _a.scheduler;
      var actions = scheduler.actions;
      this.work = this.state = this.scheduler = null;
      this.pending = false;
      arrRemove(actions, this);
      if (id != null) {
        this.id = this.recycleAsyncId(scheduler, id, null);
      }
      this.delay = null;
      _super.prototype.unsubscribe.call(this);
    }
  };
  return AsyncAction2;
})(Action);

// node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
var dateTimestampProvider = {
  now: function() {
    return (dateTimestampProvider.delegate || Date).now();
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/Scheduler.js
var Scheduler = (function() {
  function Scheduler2(schedulerActionCtor, now) {
    if (now === void 0) {
      now = Scheduler2.now;
    }
    this.schedulerActionCtor = schedulerActionCtor;
    this.now = now;
  }
  Scheduler2.prototype.schedule = function(work, delay2, state) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    return new this.schedulerActionCtor(this, work).schedule(state, delay2);
  };
  Scheduler2.now = dateTimestampProvider.now;
  return Scheduler2;
})();

// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncScheduler.js
var AsyncScheduler = (function(_super) {
  __extends(AsyncScheduler2, _super);
  function AsyncScheduler2(SchedulerAction, now) {
    if (now === void 0) {
      now = Scheduler.now;
    }
    var _this = _super.call(this, SchedulerAction, now) || this;
    _this.actions = [];
    _this._active = false;
    return _this;
  }
  AsyncScheduler2.prototype.flush = function(action) {
    var actions = this.actions;
    if (this._active) {
      actions.push(action);
      return;
    }
    var error;
    this._active = true;
    do {
      if (error = action.execute(action.state, action.delay)) {
        break;
      }
    } while (action = actions.shift());
    this._active = false;
    if (error) {
      while (action = actions.shift()) {
        action.unsubscribe();
      }
      throw error;
    }
  };
  return AsyncScheduler2;
})(Scheduler);

// node_modules/rxjs/dist/esm5/internal/scheduler/async.js
var asyncScheduler = new AsyncScheduler(AsyncAction);

// node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
function isScheduler(value) {
  return value && isFunction(value.schedule);
}

// node_modules/rxjs/dist/esm5/internal/util/args.js
function last(arr) {
  return arr[arr.length - 1];
}
function popScheduler(args) {
  return isScheduler(last(args)) ? args.pop() : void 0;
}

// node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
function executeSchedule(parentSubscription, scheduler, work, delay2, repeat2) {
  if (delay2 === void 0) {
    delay2 = 0;
  }
  if (repeat2 === void 0) {
    repeat2 = false;
  }
  var scheduleSubscription = scheduler.schedule(function() {
    work();
    if (repeat2) {
      parentSubscription.add(this.schedule(null, delay2));
    } else {
      this.unsubscribe();
    }
  }, delay2);
  parentSubscription.add(scheduleSubscription);
  if (!repeat2) {
    return scheduleSubscription;
  }
}

// node_modules/rxjs/dist/esm5/internal/operators/catchError.js
function catchError(selector) {
  return operate(function(source, subscriber) {
    var innerSub = null;
    var syncUnsub = false;
    var handledResult;
    innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
      handledResult = innerFrom(selector(err, catchError(selector)(source)));
      if (innerSub) {
        innerSub.unsubscribe();
        innerSub = null;
        handledResult.subscribe(subscriber);
      } else {
        syncUnsub = true;
      }
    }));
    if (syncUnsub) {
      innerSub.unsubscribe();
      innerSub = null;
      handledResult.subscribe(subscriber);
    }
  });
}

// node_modules/rxjs/dist/esm5/internal/util/argsArgArrayOrObject.js
var objectProto = Object.prototype;

// node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
function observeOn(scheduler, delay2) {
  if (delay2 === void 0) {
    delay2 = 0;
  }
  return operate(function(source, subscriber) {
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      return executeSchedule(subscriber, scheduler, function() {
        return subscriber.next(value);
      }, delay2);
    }, function() {
      return executeSchedule(subscriber, scheduler, function() {
        return subscriber.complete();
      }, delay2);
    }, function(err) {
      return executeSchedule(subscriber, scheduler, function() {
        return subscriber.error(err);
      }, delay2);
    }));
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js
function subscribeOn(scheduler, delay2) {
  if (delay2 === void 0) {
    delay2 = 0;
  }
  return operate(function(source, subscriber) {
    subscriber.add(scheduler.schedule(function() {
      return source.subscribe(subscriber);
    }, delay2));
  });
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js
function scheduleObservable(input, scheduler) {
  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}

// node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js
function schedulePromise(input, scheduler) {
  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js
function scheduleArray(input, scheduler) {
  return new Observable(function(subscriber) {
    var i = 0;
    return scheduler.schedule(function() {
      if (i === input.length) {
        subscriber.complete();
      } else {
        subscriber.next(input[i++]);
        if (!subscriber.closed) {
          this.schedule();
        }
      }
    });
  });
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js
function scheduleIterable(input, scheduler) {
  return new Observable(function(subscriber) {
    var iterator2;
    executeSchedule(subscriber, scheduler, function() {
      iterator2 = input[iterator]();
      executeSchedule(subscriber, scheduler, function() {
        var _a;
        var value;
        var done;
        try {
          _a = iterator2.next(), value = _a.value, done = _a.done;
        } catch (err) {
          subscriber.error(err);
          return;
        }
        if (done) {
          subscriber.complete();
        } else {
          subscriber.next(value);
        }
      }, 0, true);
    });
    return function() {
      return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
    };
  });
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js
function scheduleAsyncIterable(input, scheduler) {
  if (!input) {
    throw new Error("Iterable cannot be null");
  }
  return new Observable(function(subscriber) {
    executeSchedule(subscriber, scheduler, function() {
      var iterator2 = input[Symbol.asyncIterator]();
      executeSchedule(subscriber, scheduler, function() {
        iterator2.next().then(function(result) {
          if (result.done) {
            subscriber.complete();
          } else {
            subscriber.next(result.value);
          }
        });
      }, 0, true);
    });
  });
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js
function scheduleReadableStreamLike(input, scheduler) {
  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
}

// node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js
function scheduled(input, scheduler) {
  if (input != null) {
    if (isInteropObservable(input)) {
      return scheduleObservable(input, scheduler);
    }
    if (isArrayLike(input)) {
      return scheduleArray(input, scheduler);
    }
    if (isPromise(input)) {
      return schedulePromise(input, scheduler);
    }
    if (isAsyncIterable(input)) {
      return scheduleAsyncIterable(input, scheduler);
    }
    if (isIterable(input)) {
      return scheduleIterable(input, scheduler);
    }
    if (isReadableStreamLike(input)) {
      return scheduleReadableStreamLike(input, scheduler);
    }
  }
  throw createInvalidObservableTypeError(input);
}

// node_modules/rxjs/dist/esm5/internal/observable/from.js
function from(input, scheduler) {
  return scheduler ? scheduled(input, scheduler) : innerFrom(input);
}

// node_modules/rxjs/dist/esm5/internal/operators/map.js
function map(project, thisArg) {
  return operate(function(source, subscriber) {
    var index = 0;
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      subscriber.next(project.call(thisArg, value, index++));
    }));
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js
function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand2, innerSubScheduler, additionalFinalizer) {
  var buffer2 = [];
  var active = 0;
  var index = 0;
  var isComplete = false;
  var checkComplete = function() {
    if (isComplete && !buffer2.length && !active) {
      subscriber.complete();
    }
  };
  var outerNext = function(value) {
    return active < concurrent ? doInnerSub(value) : buffer2.push(value);
  };
  var doInnerSub = function(value) {
    expand2 && subscriber.next(value);
    active++;
    var innerComplete = false;
    innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function(innerValue) {
      onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
      if (expand2) {
        outerNext(innerValue);
      } else {
        subscriber.next(innerValue);
      }
    }, function() {
      innerComplete = true;
    }, void 0, function() {
      if (innerComplete) {
        try {
          active--;
          var _loop_1 = function() {
            var bufferedValue = buffer2.shift();
            if (innerSubScheduler) {
              executeSchedule(subscriber, innerSubScheduler, function() {
                return doInnerSub(bufferedValue);
              });
            } else {
              doInnerSub(bufferedValue);
            }
          };
          while (buffer2.length && active < concurrent) {
            _loop_1();
          }
          checkComplete();
        } catch (err) {
          subscriber.error(err);
        }
      }
    }));
  };
  source.subscribe(createOperatorSubscriber(subscriber, outerNext, function() {
    isComplete = true;
    checkComplete();
  }));
  return function() {
    additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
  };
}

// node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js
function mergeMap(project, resultSelector, concurrent) {
  if (concurrent === void 0) {
    concurrent = Infinity;
  }
  if (isFunction(resultSelector)) {
    return mergeMap(function(a, i) {
      return map(function(b, ii) {
        return resultSelector(a, b, i, ii);
      })(innerFrom(project(a, i)));
    }, concurrent);
  } else if (typeof resultSelector === "number") {
    concurrent = resultSelector;
  }
  return operate(function(source, subscriber) {
    return mergeInternals(source, subscriber, project, concurrent);
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js
function mergeAll(concurrent) {
  if (concurrent === void 0) {
    concurrent = Infinity;
  }
  return mergeMap(identity, concurrent);
}

// node_modules/rxjs/dist/esm5/internal/operators/concatMap.js
function concatMap(project, resultSelector) {
  return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
}

// node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
var ObjectUnsubscribedError = createErrorClass(function(_super) {
  return function ObjectUnsubscribedErrorImpl() {
    _super(this);
    this.name = "ObjectUnsubscribedError";
    this.message = "object unsubscribed";
  };
});

// node_modules/rxjs/dist/esm5/internal/Subject.js
var Subject = (function(_super) {
  __extends(Subject2, _super);
  function Subject2() {
    var _this = _super.call(this) || this;
    _this.closed = false;
    _this.currentObservers = null;
    _this.observers = [];
    _this.isStopped = false;
    _this.hasError = false;
    _this.thrownError = null;
    return _this;
  }
  Subject2.prototype.lift = function(operator) {
    var subject = new AnonymousSubject(this, this);
    subject.operator = operator;
    return subject;
  };
  Subject2.prototype._throwIfClosed = function() {
    if (this.closed) {
      throw new ObjectUnsubscribedError();
    }
  };
  Subject2.prototype.next = function(value) {
    var _this = this;
    errorContext(function() {
      var e_1, _a;
      _this._throwIfClosed();
      if (!_this.isStopped) {
        if (!_this.currentObservers) {
          _this.currentObservers = Array.from(_this.observers);
        }
        try {
          for (var _b = __values2(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
            var observer = _c.value;
            observer.next(value);
          }
        } catch (e_1_1) {
          e_1 = { error: e_1_1 };
        } finally {
          try {
            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          } finally {
            if (e_1) throw e_1.error;
          }
        }
      }
    });
  };
  Subject2.prototype.error = function(err) {
    var _this = this;
    errorContext(function() {
      _this._throwIfClosed();
      if (!_this.isStopped) {
        _this.hasError = _this.isStopped = true;
        _this.thrownError = err;
        var observers = _this.observers;
        while (observers.length) {
          observers.shift().error(err);
        }
      }
    });
  };
  Subject2.prototype.complete = function() {
    var _this = this;
    errorContext(function() {
      _this._throwIfClosed();
      if (!_this.isStopped) {
        _this.isStopped = true;
        var observers = _this.observers;
        while (observers.length) {
          observers.shift().complete();
        }
      }
    });
  };
  Subject2.prototype.unsubscribe = function() {
    this.isStopped = this.closed = true;
    this.observers = this.currentObservers = null;
  };
  Object.defineProperty(Subject2.prototype, "observed", {
    get: function() {
      var _a;
      return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
    },
    enumerable: false,
    configurable: true
  });
  Subject2.prototype._trySubscribe = function(subscriber) {
    this._throwIfClosed();
    return _super.prototype._trySubscribe.call(this, subscriber);
  };
  Subject2.prototype._subscribe = function(subscriber) {
    this._throwIfClosed();
    this._checkFinalizedStatuses(subscriber);
    return this._innerSubscribe(subscriber);
  };
  Subject2.prototype._innerSubscribe = function(subscriber) {
    var _this = this;
    var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
    if (hasError || isStopped) {
      return EMPTY_SUBSCRIPTION;
    }
    this.currentObservers = null;
    observers.push(subscriber);
    return new Subscription(function() {
      _this.currentObservers = null;
      arrRemove(observers, subscriber);
    });
  };
  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
    var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
    if (hasError) {
      subscriber.error(thrownError);
    } else if (isStopped) {
      subscriber.complete();
    }
  };
  Subject2.prototype.asObservable = function() {
    var observable2 = new Observable();
    observable2.source = this;
    return observable2;
  };
  Subject2.create = function(destination, source) {
    return new AnonymousSubject(destination, source);
  };
  return Subject2;
})(Observable);
var AnonymousSubject = (function(_super) {
  __extends(AnonymousSubject2, _super);
  function AnonymousSubject2(destination, source) {
    var _this = _super.call(this) || this;
    _this.destination = destination;
    _this.source = source;
    return _this;
  }
  AnonymousSubject2.prototype.next = function(value) {
    var _a, _b;
    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
  };
  AnonymousSubject2.prototype.error = function(err) {
    var _a, _b;
    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
  };
  AnonymousSubject2.prototype.complete = function() {
    var _a, _b;
    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
  };
  AnonymousSubject2.prototype._subscribe = function(subscriber) {
    var _a, _b;
    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
  };
  return AnonymousSubject2;
})(Subject);

// node_modules/rxjs/dist/esm5/internal/operators/defaultIfEmpty.js
function defaultIfEmpty(defaultValue) {
  return operate(function(source, subscriber) {
    var hasValue = false;
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      hasValue = true;
      subscriber.next(value);
    }, function() {
      if (!hasValue) {
        subscriber.next(defaultValue);
      }
      subscriber.complete();
    }));
  });
}

// node_modules/rxjs/dist/esm5/internal/observable/empty.js
var EMPTY = new Observable(function(subscriber) {
  return subscriber.complete();
});

// node_modules/rxjs/dist/esm5/internal/observable/of.js
function of() {
  var args = [];
  for (var _i = 0; _i < arguments.length; _i++) {
    args[_i] = arguments[_i];
  }
  var scheduler = popScheduler(args);
  return from(args, scheduler);
}

// node_modules/rxjs/dist/esm5/internal/observable/throwError.js
function throwError(errorOrErrorFactory, scheduler) {
  var errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
    return errorOrErrorFactory;
  };
  var init = function(subscriber) {
    return subscriber.error(errorFactory());
  };
  return new Observable(scheduler ? function(subscriber) {
    return scheduler.schedule(init, 0, subscriber);
  } : init);
}

// node_modules/rxjs/dist/esm5/internal/Notification.js
var NotificationKind;
(function(NotificationKind2) {
  NotificationKind2["NEXT"] = "N";
  NotificationKind2["ERROR"] = "E";
  NotificationKind2["COMPLETE"] = "C";
})(NotificationKind || (NotificationKind = {}));
var Notification = (function() {
  function Notification2(kind, value, error) {
    this.kind = kind;
    this.value = value;
    this.error = error;
    this.hasValue = kind === "N";
  }
  Notification2.prototype.observe = function(observer) {
    return observeNotification(this, observer);
  };
  Notification2.prototype.do = function(nextHandler, errorHandler, completeHandler) {
    var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
    return kind === "N" ? nextHandler === null || nextHandler === void 0 ? void 0 : nextHandler(value) : kind === "E" ? errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(error) : completeHandler === null || completeHandler === void 0 ? void 0 : completeHandler();
  };
  Notification2.prototype.accept = function(nextOrObserver, error, complete) {
    var _a;
    return isFunction((_a = nextOrObserver) === null || _a === void 0 ? void 0 : _a.next) ? this.observe(nextOrObserver) : this.do(nextOrObserver, error, complete);
  };
  Notification2.prototype.toObservable = function() {
    var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
    var result = kind === "N" ? of(value) : kind === "E" ? throwError(function() {
      return error;
    }) : kind === "C" ? EMPTY : 0;
    if (!result) {
      throw new TypeError("Unexpected notification kind " + kind);
    }
    return result;
  };
  Notification2.createNext = function(value) {
    return new Notification2("N", value);
  };
  Notification2.createError = function(err) {
    return new Notification2("E", void 0, err);
  };
  Notification2.createComplete = function() {
    return Notification2.completeNotification;
  };
  Notification2.completeNotification = new Notification2("C");
  return Notification2;
})();
function observeNotification(notification, observer) {
  var _a, _b, _c;
  var _d = notification, kind = _d.kind, value = _d.value, error = _d.error;
  if (typeof kind !== "string") {
    throw new TypeError('Invalid notification, missing "kind"');
  }
  kind === "N" ? (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, value) : kind === "E" ? (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, error) : (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
}

// node_modules/rxjs/dist/esm5/internal/util/ArgumentOutOfRangeError.js
var ArgumentOutOfRangeError = createErrorClass(function(_super) {
  return function ArgumentOutOfRangeErrorImpl() {
    _super(this);
    this.name = "ArgumentOutOfRangeError";
    this.message = "argument out of range";
  };
});

// node_modules/rxjs/dist/esm5/internal/operators/filter.js
function filter(predicate, thisArg) {
  return operate(function(source, subscriber) {
    var index = 0;
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      return predicate.call(thisArg, value, index++) && subscriber.next(value);
    }));
  });
}

// node_modules/rxjs/dist/esm5/internal/util/EmptyError.js
var EmptyError = createErrorClass(function(_super) {
  return function EmptyErrorImpl() {
    _super(this);
    this.name = "EmptyError";
    this.message = "no elements in sequence";
  };
});

// node_modules/rxjs/dist/esm5/internal/operators/finalize.js
function finalize(callback) {
  return operate(function(source, subscriber) {
    try {
      source.subscribe(subscriber);
    } finally {
      subscriber.add(callback);
    }
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/refCount.js
function refCount() {
  return operate(function(source, subscriber) {
    var connection = null;
    source._refCount++;
    var refCounter = createOperatorSubscriber(subscriber, void 0, void 0, void 0, function() {
      if (!source || source._refCount <= 0 || 0 < --source._refCount) {
        connection = null;
        return;
      }
      var sharedConnection = source._connection;
      var conn = connection;
      connection = null;
      if (sharedConnection && (!conn || sharedConnection === conn)) {
        sharedConnection.unsubscribe();
      }
      subscriber.unsubscribe();
    });
    source.subscribe(refCounter);
    if (!refCounter.closed) {
      connection = source.connect();
    }
  });
}

// node_modules/rxjs/dist/esm5/internal/observable/ConnectableObservable.js
var ConnectableObservable = (function(_super) {
  __extends(ConnectableObservable2, _super);
  function ConnectableObservable2(source, subjectFactory) {
    var _this = _super.call(this) || this;
    _this.source = source;
    _this.subjectFactory = subjectFactory;
    _this._subject = null;
    _this._refCount = 0;
    _this._connection = null;
    if (hasLift(source)) {
      _this.lift = source.lift;
    }
    return _this;
  }
  ConnectableObservable2.prototype._subscribe = function(subscriber) {
    return this.getSubject().subscribe(subscriber);
  };
  ConnectableObservable2.prototype.getSubject = function() {
    var subject = this._subject;
    if (!subject || subject.isStopped) {
      this._subject = this.subjectFactory();
    }
    return this._subject;
  };
  ConnectableObservable2.prototype._teardown = function() {
    this._refCount = 0;
    var _connection = this._connection;
    this._subject = this._connection = null;
    _connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
  };
  ConnectableObservable2.prototype.connect = function() {
    var _this = this;
    var connection = this._connection;
    if (!connection) {
      connection = this._connection = new Subscription();
      var subject_1 = this.getSubject();
      connection.add(this.source.subscribe(createOperatorSubscriber(subject_1, void 0, function() {
        _this._teardown();
        subject_1.complete();
      }, function(err) {
        _this._teardown();
        subject_1.error(err);
      }, function() {
        return _this._teardown();
      })));
      if (connection.closed) {
        this._connection = null;
        connection = Subscription.EMPTY;
      }
    }
    return connection;
  };
  ConnectableObservable2.prototype.refCount = function() {
    return refCount()(this);
  };
  return ConnectableObservable2;
})(Observable);

// node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js
var BehaviorSubject = (function(_super) {
  __extends(BehaviorSubject2, _super);
  function BehaviorSubject2(_value) {
    var _this = _super.call(this) || this;
    _this._value = _value;
    return _this;
  }
  Object.defineProperty(BehaviorSubject2.prototype, "value", {
    get: function() {
      return this.getValue();
    },
    enumerable: false,
    configurable: true
  });
  BehaviorSubject2.prototype._subscribe = function(subscriber) {
    var subscription = _super.prototype._subscribe.call(this, subscriber);
    !subscription.closed && subscriber.next(this._value);
    return subscription;
  };
  BehaviorSubject2.prototype.getValue = function() {
    var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
    if (hasError) {
      throw thrownError;
    }
    this._throwIfClosed();
    return _value;
  };
  BehaviorSubject2.prototype.next = function(value) {
    _super.prototype.next.call(this, this._value = value);
  };
  return BehaviorSubject2;
})(Subject);

// node_modules/rxjs/dist/esm5/internal/AsyncSubject.js
var AsyncSubject = (function(_super) {
  __extends(AsyncSubject2, _super);
  function AsyncSubject2() {
    var _this = _super !== null && _super.apply(this, arguments) || this;
    _this._value = null;
    _this._hasValue = false;
    _this._isComplete = false;
    return _this;
  }
  AsyncSubject2.prototype._checkFinalizedStatuses = function(subscriber) {
    var _a = this, hasError = _a.hasError, _hasValue = _a._hasValue, _value = _a._value, thrownError = _a.thrownError, isStopped = _a.isStopped, _isComplete = _a._isComplete;
    if (hasError) {
      subscriber.error(thrownError);
    } else if (isStopped || _isComplete) {
      _hasValue && subscriber.next(_value);
      subscriber.complete();
    }
  };
  AsyncSubject2.prototype.next = function(value) {
    if (!this.isStopped) {
      this._value = value;
      this._hasValue = true;
    }
  };
  AsyncSubject2.prototype.complete = function() {
    var _a = this, _hasValue = _a._hasValue, _value = _a._value, _isComplete = _a._isComplete;
    if (!_isComplete) {
      this._isComplete = true;
      _hasValue && _super.prototype.next.call(this, _value);
      _super.prototype.complete.call(this);
    }
  };
  return AsyncSubject2;
})(Subject);

// node_modules/rxjs/dist/esm5/internal/ReplaySubject.js
var ReplaySubject = (function(_super) {
  __extends(ReplaySubject2, _super);
  function ReplaySubject2(_bufferSize, _windowTime, _timestampProvider) {
    if (_bufferSize === void 0) {
      _bufferSize = Infinity;
    }
    if (_windowTime === void 0) {
      _windowTime = Infinity;
    }
    if (_timestampProvider === void 0) {
      _timestampProvider = dateTimestampProvider;
    }
    var _this = _super.call(this) || this;
    _this._bufferSize = _bufferSize;
    _this._windowTime = _windowTime;
    _this._timestampProvider = _timestampProvider;
    _this._buffer = [];
    _this._infiniteTimeWindow = true;
    _this._infiniteTimeWindow = _windowTime === Infinity;
    _this._bufferSize = Math.max(1, _bufferSize);
    _this._windowTime = Math.max(1, _windowTime);
    return _this;
  }
  ReplaySubject2.prototype.next = function(value) {
    var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
    if (!isStopped) {
      _buffer.push(value);
      !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
    }
    this._trimBuffer();
    _super.prototype.next.call(this, value);
  };
  ReplaySubject2.prototype._subscribe = function(subscriber) {
    this._throwIfClosed();
    this._trimBuffer();
    var subscription = this._innerSubscribe(subscriber);
    var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
    var copy = _buffer.slice();
    for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
      subscriber.next(copy[i]);
    }
    this._checkFinalizedStatuses(subscriber);
    return subscription;
  };
  ReplaySubject2.prototype._trimBuffer = function() {
    var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
    var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
    _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
    if (!_infiniteTimeWindow) {
      var now = _timestampProvider.now();
      var last3 = 0;
      for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
        last3 = i;
      }
      last3 && _buffer.splice(0, last3 + 1);
    }
  };
  return ReplaySubject2;
})(Subject);

// node_modules/rxjs/dist/esm5/internal/util/SequenceError.js
var SequenceError = createErrorClass(function(_super) {
  return function SequenceErrorImpl(message) {
    _super(this);
    this.name = "SequenceError";
    this.message = message;
  };
});

// node_modules/rxjs/dist/esm5/internal/util/NotFoundError.js
var NotFoundError = createErrorClass(function(_super) {
  return function NotFoundErrorImpl(message) {
    _super(this);
    this.name = "NotFoundError";
    this.message = message;
  };
});

// node_modules/rxjs/dist/esm5/internal/operators/switchMap.js
function switchMap(project, resultSelector) {
  return operate(function(source, subscriber) {
    var innerSubscriber = null;
    var index = 0;
    var isComplete = false;
    var checkComplete = function() {
      return isComplete && !innerSubscriber && subscriber.complete();
    };
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
      var innerIndex = 0;
      var outerIndex = index++;
      innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, function(innerValue) {
        return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue);
      }, function() {
        innerSubscriber = null;
        checkComplete();
      }));
    }, function() {
      isComplete = true;
      checkComplete();
    }));
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js
function takeUntil(notifier) {
  return operate(function(source, subscriber) {
    innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
      return subscriber.complete();
    }, noop));
    !subscriber.closed && source.subscribe(subscriber);
  });
}

// node_modules/rxjs/dist/esm5/internal/operators/tap.js
function tap(observerOrNext, error, complete) {
  var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
  return tapObserver ? operate(function(source, subscriber) {
    var _a;
    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
    var isUnsub = true;
    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
      var _a2;
      (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value);
      subscriber.next(value);
    }, function() {
      var _a2;
      isUnsub = false;
      (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
      subscriber.complete();
    }, function(err) {
      var _a2;
      isUnsub = false;
      (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
      subscriber.error(err);
    }, function() {
      var _a2, _b;
      if (isUnsub) {
        (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
      }
      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
    }));
  }) : identity;
}

// node_modules/rxjs/dist/esm5/internal/operators/timeout.js
var TimeoutError = createErrorClass(function(_super) {
  return function TimeoutErrorImpl(info) {
    if (info === void 0) {
      info = null;
    }
    _super(this);
    this.message = "Timeout has occurred";
    this.name = "TimeoutError";
    this.info = info;
  };
});

// node_modules/rxjs/dist/esm5/internal/scheduler/performanceTimestampProvider.js
var performanceTimestampProvider = {
  now: function() {
    return (performanceTimestampProvider.delegate || performance).now();
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/scheduler/animationFrameProvider.js
var animationFrameProvider = {
  schedule: function(callback) {
    var request = requestAnimationFrame;
    var cancel = cancelAnimationFrame;
    var delegate = animationFrameProvider.delegate;
    if (delegate) {
      request = delegate.requestAnimationFrame;
      cancel = delegate.cancelAnimationFrame;
    }
    var handle = request(function(timestamp2) {
      cancel = void 0;
      callback(timestamp2);
    });
    return new Subscription(function() {
      return cancel === null || cancel === void 0 ? void 0 : cancel(handle);
    });
  },
  requestAnimationFrame: function() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }
    var delegate = animationFrameProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
  },
  cancelAnimationFrame: function() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }
    var delegate = animationFrameProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.cancelAnimationFrame) || cancelAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/observable/dom/animationFrames.js
function animationFramesFactory(timestampProvider) {
  return new Observable(function(subscriber) {
    var provider = timestampProvider || performanceTimestampProvider;
    var start = provider.now();
    var id = 0;
    var run = function() {
      if (!subscriber.closed) {
        id = animationFrameProvider.requestAnimationFrame(function(timestamp2) {
          id = 0;
          var now = provider.now();
          subscriber.next({
            timestamp: timestampProvider ? now : timestamp2,
            elapsed: now - start
          });
          run();
        });
      }
    };
    run();
    return function() {
      if (id) {
        animationFrameProvider.cancelAnimationFrame(id);
      }
    };
  });
}
var DEFAULT_ANIMATION_FRAMES = animationFramesFactory();

// node_modules/rxjs/dist/esm5/internal/util/Immediate.js
var nextHandle = 1;
var resolved;
var activeHandles = {};
function findAndClearHandle(handle) {
  if (handle in activeHandles) {
    delete activeHandles[handle];
    return true;
  }
  return false;
}
var Immediate = {
  setImmediate: function(cb) {
    var handle = nextHandle++;
    activeHandles[handle] = true;
    if (!resolved) {
      resolved = Promise.resolve();
    }
    resolved.then(function() {
      return findAndClearHandle(handle) && cb();
    });
    return handle;
  },
  clearImmediate: function(handle) {
    findAndClearHandle(handle);
  }
};

// node_modules/rxjs/dist/esm5/internal/scheduler/immediateProvider.js
var setImmediate = Immediate.setImmediate;
var clearImmediate = Immediate.clearImmediate;
var immediateProvider = {
  setImmediate: function() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }
    var delegate = immediateProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate).apply(void 0, __spreadArray([], __read(args)));
  },
  clearImmediate: function(handle) {
    var delegate = immediateProvider.delegate;
    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearImmediate) || clearImmediate)(handle);
  },
  delegate: void 0
};

// node_modules/rxjs/dist/esm5/internal/scheduler/AsapAction.js
var AsapAction = (function(_super) {
  __extends(AsapAction2, _super);
  function AsapAction2(scheduler, work) {
    var _this = _super.call(this, scheduler, work) || this;
    _this.scheduler = scheduler;
    _this.work = work;
    return _this;
  }
  AsapAction2.prototype.requestAsyncId = function(scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 !== null && delay2 > 0) {
      return _super.prototype.requestAsyncId.call(this, scheduler, id, delay2);
    }
    scheduler.actions.push(this);
    return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, void 0)));
  };
  AsapAction2.prototype.recycleAsyncId = function(scheduler, id, delay2) {
    var _a;
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 != null ? delay2 > 0 : this.delay > 0) {
      return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay2);
    }
    var actions = scheduler.actions;
    if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
      immediateProvider.clearImmediate(id);
      if (scheduler._scheduled === id) {
        scheduler._scheduled = void 0;
      }
    }
    return void 0;
  };
  return AsapAction2;
})(AsyncAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/AsapScheduler.js
var AsapScheduler = (function(_super) {
  __extends(AsapScheduler2, _super);
  function AsapScheduler2() {
    return _super !== null && _super.apply(this, arguments) || this;
  }
  AsapScheduler2.prototype.flush = function(action) {
    this._active = true;
    var flushId = this._scheduled;
    this._scheduled = void 0;
    var actions = this.actions;
    var error;
    action = action || actions.shift();
    do {
      if (error = action.execute(action.state, action.delay)) {
        break;
      }
    } while ((action = actions[0]) && action.id === flushId && actions.shift());
    this._active = false;
    if (error) {
      while ((action = actions[0]) && action.id === flushId && actions.shift()) {
        action.unsubscribe();
      }
      throw error;
    }
  };
  return AsapScheduler2;
})(AsyncScheduler);

// node_modules/rxjs/dist/esm5/internal/scheduler/asap.js
var asapScheduler = new AsapScheduler(AsapAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/QueueAction.js
var QueueAction = (function(_super) {
  __extends(QueueAction2, _super);
  function QueueAction2(scheduler, work) {
    var _this = _super.call(this, scheduler, work) || this;
    _this.scheduler = scheduler;
    _this.work = work;
    return _this;
  }
  QueueAction2.prototype.schedule = function(state, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 > 0) {
      return _super.prototype.schedule.call(this, state, delay2);
    }
    this.delay = delay2;
    this.state = state;
    this.scheduler.flush(this);
    return this;
  };
  QueueAction2.prototype.execute = function(state, delay2) {
    return delay2 > 0 || this.closed ? _super.prototype.execute.call(this, state, delay2) : this._execute(state, delay2);
  };
  QueueAction2.prototype.requestAsyncId = function(scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 != null && delay2 > 0 || delay2 == null && this.delay > 0) {
      return _super.prototype.requestAsyncId.call(this, scheduler, id, delay2);
    }
    scheduler.flush(this);
    return 0;
  };
  return QueueAction2;
})(AsyncAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/QueueScheduler.js
var QueueScheduler = (function(_super) {
  __extends(QueueScheduler2, _super);
  function QueueScheduler2() {
    return _super !== null && _super.apply(this, arguments) || this;
  }
  return QueueScheduler2;
})(AsyncScheduler);

// node_modules/rxjs/dist/esm5/internal/scheduler/queue.js
var queueScheduler = new QueueScheduler(QueueAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/AnimationFrameAction.js
var AnimationFrameAction = (function(_super) {
  __extends(AnimationFrameAction2, _super);
  function AnimationFrameAction2(scheduler, work) {
    var _this = _super.call(this, scheduler, work) || this;
    _this.scheduler = scheduler;
    _this.work = work;
    return _this;
  }
  AnimationFrameAction2.prototype.requestAsyncId = function(scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 !== null && delay2 > 0) {
      return _super.prototype.requestAsyncId.call(this, scheduler, id, delay2);
    }
    scheduler.actions.push(this);
    return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(function() {
      return scheduler.flush(void 0);
    }));
  };
  AnimationFrameAction2.prototype.recycleAsyncId = function(scheduler, id, delay2) {
    var _a;
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (delay2 != null ? delay2 > 0 : this.delay > 0) {
      return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay2);
    }
    var actions = scheduler.actions;
    if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
      animationFrameProvider.cancelAnimationFrame(id);
      scheduler._scheduled = void 0;
    }
    return void 0;
  };
  return AnimationFrameAction2;
})(AsyncAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/AnimationFrameScheduler.js
var AnimationFrameScheduler = (function(_super) {
  __extends(AnimationFrameScheduler2, _super);
  function AnimationFrameScheduler2() {
    return _super !== null && _super.apply(this, arguments) || this;
  }
  AnimationFrameScheduler2.prototype.flush = function(action) {
    this._active = true;
    var flushId = this._scheduled;
    this._scheduled = void 0;
    var actions = this.actions;
    var error;
    action = action || actions.shift();
    do {
      if (error = action.execute(action.state, action.delay)) {
        break;
      }
    } while ((action = actions[0]) && action.id === flushId && actions.shift());
    this._active = false;
    if (error) {
      while ((action = actions[0]) && action.id === flushId && actions.shift()) {
        action.unsubscribe();
      }
      throw error;
    }
  };
  return AnimationFrameScheduler2;
})(AsyncScheduler);

// node_modules/rxjs/dist/esm5/internal/scheduler/animationFrame.js
var animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);

// node_modules/rxjs/dist/esm5/internal/scheduler/VirtualTimeScheduler.js
var VirtualTimeScheduler = (function(_super) {
  __extends(VirtualTimeScheduler2, _super);
  function VirtualTimeScheduler2(schedulerActionCtor, maxFrames) {
    if (schedulerActionCtor === void 0) {
      schedulerActionCtor = VirtualAction;
    }
    if (maxFrames === void 0) {
      maxFrames = Infinity;
    }
    var _this = _super.call(this, schedulerActionCtor, function() {
      return _this.frame;
    }) || this;
    _this.maxFrames = maxFrames;
    _this.frame = 0;
    _this.index = -1;
    return _this;
  }
  VirtualTimeScheduler2.prototype.flush = function() {
    var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
    var error;
    var action;
    while ((action = actions[0]) && action.delay <= maxFrames) {
      actions.shift();
      this.frame = action.delay;
      if (error = action.execute(action.state, action.delay)) {
        break;
      }
    }
    if (error) {
      while (action = actions.shift()) {
        action.unsubscribe();
      }
      throw error;
    }
  };
  VirtualTimeScheduler2.frameTimeFactor = 10;
  return VirtualTimeScheduler2;
})(AsyncScheduler);
var VirtualAction = (function(_super) {
  __extends(VirtualAction2, _super);
  function VirtualAction2(scheduler, work, index) {
    if (index === void 0) {
      index = scheduler.index += 1;
    }
    var _this = _super.call(this, scheduler, work) || this;
    _this.scheduler = scheduler;
    _this.work = work;
    _this.index = index;
    _this.active = true;
    _this.index = scheduler.index = index;
    return _this;
  }
  VirtualAction2.prototype.schedule = function(state, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    if (Number.isFinite(delay2)) {
      if (!this.id) {
        return _super.prototype.schedule.call(this, state, delay2);
      }
      this.active = false;
      var action = new VirtualAction2(this.scheduler, this.work);
      this.add(action);
      return action.schedule(state, delay2);
    } else {
      return Subscription.EMPTY;
    }
  };
  VirtualAction2.prototype.requestAsyncId = function(scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    this.delay = scheduler.frame + delay2;
    var actions = scheduler.actions;
    actions.push(this);
    actions.sort(VirtualAction2.sortActions);
    return 1;
  };
  VirtualAction2.prototype.recycleAsyncId = function(scheduler, id, delay2) {
    if (delay2 === void 0) {
      delay2 = 0;
    }
    return void 0;
  };
  VirtualAction2.prototype._execute = function(state, delay2) {
    if (this.active === true) {
      return _super.prototype._execute.call(this, state, delay2);
    }
  };
  VirtualAction2.sortActions = function(a, b) {
    if (a.delay === b.delay) {
      if (a.index === b.index) {
        return 0;
      } else if (a.index > b.index) {
        return 1;
      } else {
        return -1;
      }
    } else if (a.delay > b.delay) {
      return 1;
    } else {
      return -1;
    }
  };
  return VirtualAction2;
})(AsyncAction);

// node_modules/rxjs/dist/esm5/internal/lastValueFrom.js
function lastValueFrom(source, config2) {
  var hasConfig = typeof config2 === "object";
  return new Promise(function(resolve, reject) {
    var _hasValue = false;
    var _value;
    source.subscribe({
      next: function(value) {
        _value = value;
        _hasValue = true;
      },
      error: reject,
      complete: function() {
        if (_hasValue) {
          resolve(_value);
        } else if (hasConfig) {
          resolve(config2.defaultValue);
        } else {
          reject(new EmptyError());
        }
      }
    });
  });
}

// node_modules/rxjs/dist/esm5/internal/observable/defer.js
function defer(observableFactory) {
  return new Observable(function(subscriber) {
    innerFrom(observableFactory()).subscribe(subscriber);
  });
}

// node_modules/rxjs/dist/esm5/internal/observable/never.js
var NEVER = new Observable(noop);

// node_modules/uuid/dist/esm-browser/regex.js
var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

// node_modules/uuid/dist/esm-browser/validate.js
function validate(uuid) {
  return typeof uuid === "string" && regex_default.test(uuid);
}
var validate_default = validate;

// node_modules/uuid/dist/esm-browser/parse.js
function parse(uuid) {
  if (!validate_default(uuid)) {
    throw TypeError("Invalid UUID");
  }
  let v;
  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
}
var parse_default = parse;

// node_modules/uuid/dist/esm-browser/stringify.js
var byteToHex = [];
for (let i = 0; i < 256; ++i) {
  byteToHex.push((i + 256).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
}

// node_modules/uuid/dist/esm-browser/rng.js
var getRandomValues;
var rnds8 = new Uint8Array(16);
function rng() {
  if (!getRandomValues) {
    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
    }
    getRandomValues = crypto.getRandomValues.bind(crypto);
  }
  return getRandomValues(rnds8);
}

// node_modules/uuid/dist/esm-browser/md5.js
function md5(bytes) {
  const words = uint8ToUint32(bytes);
  const md5Bytes = wordsToMd5(words, bytes.length * 8);
  return uint32ToUint8(md5Bytes);
}
function uint32ToUint8(input) {
  const bytes = new Uint8Array(input.length * 4);
  for (let i = 0; i < input.length * 4; i++) {
    bytes[i] = input[i >> 2] >>> i % 4 * 8 & 255;
  }
  return bytes;
}
function getOutputLength(inputLength8) {
  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
}
function wordsToMd5(x2, len) {
  const xpad = new Uint32Array(getOutputLength(len)).fill(0);
  xpad.set(x2);
  xpad[len >> 5] |= 128 << len % 32;
  xpad[xpad.length - 1] = len;
  x2 = xpad;
  let a = 1732584193;
  let b = -271733879;
  let c = -1732584194;
  let d = 271733878;
  for (let i = 0; i < x2.length; i += 16) {
    const olda = a;
    const oldb = b;
    const oldc = c;
    const oldd = d;
    a = md5ff(a, b, c, d, x2[i], 7, -680876936);
    d = md5ff(d, a, b, c, x2[i + 1], 12, -389564586);
    c = md5ff(c, d, a, b, x2[i + 2], 17, 606105819);
    b = md5ff(b, c, d, a, x2[i + 3], 22, -1044525330);
    a = md5ff(a, b, c, d, x2[i + 4], 7, -176418897);
    d = md5ff(d, a, b, c, x2[i + 5], 12, 1200080426);
    c = md5ff(c, d, a, b, x2[i + 6], 17, -1473231341);
    b = md5ff(b, c, d, a, x2[i + 7], 22, -45705983);
    a = md5ff(a, b, c, d, x2[i + 8], 7, 1770035416);
    d = md5ff(d, a, b, c, x2[i + 9], 12, -1958414417);
    c = md5ff(c, d, a, b, x2[i + 10], 17, -42063);
    b = md5ff(b, c, d, a, x2[i + 11], 22, -1990404162);
    a = md5ff(a, b, c, d, x2[i + 12], 7, 1804603682);
    d = md5ff(d, a, b, c, x2[i + 13], 12, -40341101);
    c = md5ff(c, d, a, b, x2[i + 14], 17, -1502002290);
    b = md5ff(b, c, d, a, x2[i + 15], 22, 1236535329);
    a = md5gg(a, b, c, d, x2[i + 1], 5, -165796510);
    d = md5gg(d, a, b, c, x2[i + 6], 9, -1069501632);
    c = md5gg(c, d, a, b, x2[i + 11], 14, 643717713);
    b = md5gg(b, c, d, a, x2[i], 20, -373897302);
    a = md5gg(a, b, c, d, x2[i + 5], 5, -701558691);
    d = md5gg(d, a, b, c, x2[i + 10], 9, 38016083);
    c = md5gg(c, d, a, b, x2[i + 15], 14, -660478335);
    b = md5gg(b, c, d, a, x2[i + 4], 20, -405537848);
    a = md5gg(a, b, c, d, x2[i + 9], 5, 568446438);
    d = md5gg(d, a, b, c, x2[i + 14], 9, -1019803690);
    c = md5gg(c, d, a, b, x2[i + 3], 14, -187363961);
    b = md5gg(b, c, d, a, x2[i + 8], 20, 1163531501);
    a = md5gg(a, b, c, d, x2[i + 13], 5, -1444681467);
    d = md5gg(d, a, b, c, x2[i + 2], 9, -51403784);
    c = md5gg(c, d, a, b, x2[i + 7], 14, 1735328473);
    b = md5gg(b, c, d, a, x2[i + 12], 20, -1926607734);
    a = md5hh(a, b, c, d, x2[i + 5], 4, -378558);
    d = md5hh(d, a, b, c, x2[i + 8], 11, -2022574463);
    c = md5hh(c, d, a, b, x2[i + 11], 16, 1839030562);
    b = md5hh(b, c, d, a, x2[i + 14], 23, -35309556);
    a = md5hh(a, b, c, d, x2[i + 1], 4, -1530992060);
    d = md5hh(d, a, b, c, x2[i + 4], 11, 1272893353);
    c = md5hh(c, d, a, b, x2[i + 7], 16, -155497632);
    b = md5hh(b, c, d, a, x2[i + 10], 23, -1094730640);
    a = md5hh(a, b, c, d, x2[i + 13], 4, 681279174);
    d = md5hh(d, a, b, c, x2[i], 11, -358537222);
    c = md5hh(c, d, a, b, x2[i + 3], 16, -722521979);
    b = md5hh(b, c, d, a, x2[i + 6], 23, 76029189);
    a = md5hh(a, b, c, d, x2[i + 9], 4, -640364487);
    d = md5hh(d, a, b, c, x2[i + 12], 11, -421815835);
    c = md5hh(c, d, a, b, x2[i + 15], 16, 530742520);
    b = md5hh(b, c, d, a, x2[i + 2], 23, -995338651);
    a = md5ii(a, b, c, d, x2[i], 6, -198630844);
    d = md5ii(d, a, b, c, x2[i + 7], 10, 1126891415);
    c = md5ii(c, d, a, b, x2[i + 14], 15, -1416354905);
    b = md5ii(b, c, d, a, x2[i + 5], 21, -57434055);
    a = md5ii(a, b, c, d, x2[i + 12], 6, 1700485571);
    d = md5ii(d, a, b, c, x2[i + 3], 10, -1894986606);
    c = md5ii(c, d, a, b, x2[i + 10], 15, -1051523);
    b = md5ii(b, c, d, a, x2[i + 1], 21, -2054922799);
    a = md5ii(a, b, c, d, x2[i + 8], 6, 1873313359);
    d = md5ii(d, a, b, c, x2[i + 15], 10, -30611744);
    c = md5ii(c, d, a, b, x2[i + 6], 15, -1560198380);
    b = md5ii(b, c, d, a, x2[i + 13], 21, 1309151649);
    a = md5ii(a, b, c, d, x2[i + 4], 6, -145523070);
    d = md5ii(d, a, b, c, x2[i + 11], 10, -1120210379);
    c = md5ii(c, d, a, b, x2[i + 2], 15, 718787259);
    b = md5ii(b, c, d, a, x2[i + 9], 21, -343485551);
    a = safeAdd(a, olda);
    b = safeAdd(b, oldb);
    c = safeAdd(c, oldc);
    d = safeAdd(d, oldd);
  }
  return Uint32Array.of(a, b, c, d);
}
function uint8ToUint32(input) {
  if (input.length === 0) {
    return new Uint32Array();
  }
  const output = new Uint32Array(getOutputLength(input.length * 8)).fill(0);
  for (let i = 0; i < input.length; i++) {
    output[i >> 2] |= (input[i] & 255) << i % 4 * 8;
  }
  return output;
}
function safeAdd(x2, y2) {
  const lsw = (x2 & 65535) + (y2 & 65535);
  const msw = (x2 >> 16) + (y2 >> 16) + (lsw >> 16);
  return msw << 16 | lsw & 65535;
}
function bitRotateLeft(num, cnt) {
  return num << cnt | num >>> 32 - cnt;
}
function md5cmn(q, a, b, x2, s, t) {
  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x2, t)), s), b);
}
function md5ff(a, b, c, d, x2, s, t) {
  return md5cmn(b & c | ~b & d, a, b, x2, s, t);
}
function md5gg(a, b, c, d, x2, s, t) {
  return md5cmn(b & d | c & ~d, a, b, x2, s, t);
}
function md5hh(a, b, c, d, x2, s, t) {
  return md5cmn(b ^ c ^ d, a, b, x2, s, t);
}
function md5ii(a, b, c, d, x2, s, t) {
  return md5cmn(c ^ (b | ~d), a, b, x2, s, t);
}
var md5_default = md5;

// node_modules/uuid/dist/esm-browser/v35.js
function stringToBytes(str) {
  str = unescape(encodeURIComponent(str));
  const bytes = new Uint8Array(str.length);
  for (let i = 0; i < str.length; ++i) {
    bytes[i] = str.charCodeAt(i);
  }
  return bytes;
}
var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
var URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
function v35(version, hash, value, namespace, buf, offset) {
  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
  if (typeof namespace === "string") {
    namespace = parse_default(namespace);
  }
  if ((namespace == null ? void 0 : namespace.length) !== 16) {
    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
  }
  let bytes = new Uint8Array(16 + valueBytes.length);
  bytes.set(namespaceBytes);
  bytes.set(valueBytes, namespaceBytes.length);
  bytes = hash(bytes);
  bytes[6] = bytes[6] & 15 | version;
  bytes[8] = bytes[8] & 63 | 128;
  if (buf) {
    offset = offset || 0;
    for (let i = 0; i < 16; ++i) {
      buf[offset + i] = bytes[i];
    }
    return buf;
  }
  return unsafeStringify(bytes);
}

// node_modules/uuid/dist/esm-browser/v3.js
function v3(value, namespace, buf, offset) {
  return v35(48, md5_default, value, namespace, buf, offset);
}
v3.DNS = DNS;
v3.URL = URL;

// node_modules/uuid/dist/esm-browser/native.js
var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
var native_default = { randomUUID };

// node_modules/uuid/dist/esm-browser/v4.js
function v4(options, buf, offset) {
  var _a;
  if (native_default.randomUUID && !buf && !options) {
    return native_default.randomUUID();
  }
  options = options || {};
  const rnds = options.random ?? ((_a = options.rng) == null ? void 0 : _a.call(options)) ?? rng();
  if (rnds.length < 16) {
    throw new Error("Random bytes length must be >= 16");
  }
  rnds[6] = rnds[6] & 15 | 64;
  rnds[8] = rnds[8] & 63 | 128;
  if (buf) {
    offset = offset || 0;
    if (offset < 0 || offset + 16 > buf.length) {
      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
    }
    for (let i = 0; i < 16; ++i) {
      buf[offset + i] = rnds[i];
    }
    return buf;
  }
  return unsafeStringify(rnds);
}
var v4_default = v4;

// node_modules/uuid/dist/esm-browser/sha1.js
function f(s, x2, y2, z2) {
  switch (s) {
    case 0:
      return x2 & y2 ^ ~x2 & z2;
    case 1:
      return x2 ^ y2 ^ z2;
    case 2:
      return x2 & y2 ^ x2 & z2 ^ y2 & z2;
    case 3:
      return x2 ^ y2 ^ z2;
  }
}
function ROTL(x2, n) {
  return x2 << n | x2 >>> 32 - n;
}
function sha1(bytes) {
  const K2 = [1518500249, 1859775393, 2400959708, 3395469782];
  const H = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
  const newBytes = new Uint8Array(bytes.length + 1);
  newBytes.set(bytes);
  newBytes[bytes.length] = 128;
  bytes = newBytes;
  const l = bytes.length / 4 + 2;
  const N2 = Math.ceil(l / 16);
  const M = new Array(N2);
  for (let i = 0; i < N2; ++i) {
    const arr = new Uint32Array(16);
    for (let j2 = 0; j2 < 16; ++j2) {
      arr[j2] = bytes[i * 64 + j2 * 4] << 24 | bytes[i * 64 + j2 * 4 + 1] << 16 | bytes[i * 64 + j2 * 4 + 2] << 8 | bytes[i * 64 + j2 * 4 + 3];
    }
    M[i] = arr;
  }
  M[N2 - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
  M[N2 - 1][14] = Math.floor(M[N2 - 1][14]);
  M[N2 - 1][15] = (bytes.length - 1) * 8 & 4294967295;
  for (let i = 0; i < N2; ++i) {
    const W2 = new Uint32Array(80);
    for (let t = 0; t < 16; ++t) {
      W2[t] = M[i][t];
    }
    for (let t = 16; t < 80; ++t) {
      W2[t] = ROTL(W2[t - 3] ^ W2[t - 8] ^ W2[t - 14] ^ W2[t - 16], 1);
    }
    let a = H[0];
    let b = H[1];
    let c = H[2];
    let d = H[3];
    let e = H[4];
    for (let t = 0; t < 80; ++t) {
      const s = Math.floor(t / 20);
      const T = ROTL(a, 5) + f(s, b, c, d) + e + K2[s] + W2[t] >>> 0;
      e = d;
      d = c;
      c = ROTL(b, 30) >>> 0;
      b = a;
      a = T;
    }
    H[0] = H[0] + a >>> 0;
    H[1] = H[1] + b >>> 0;
    H[2] = H[2] + c >>> 0;
    H[3] = H[3] + d >>> 0;
    H[4] = H[4] + e >>> 0;
  }
  return Uint8Array.of(H[0] >> 24, H[0] >> 16, H[0] >> 8, H[0], H[1] >> 24, H[1] >> 16, H[1] >> 8, H[1], H[2] >> 24, H[2] >> 16, H[2] >> 8, H[2], H[3] >> 24, H[3] >> 16, H[3] >> 8, H[3], H[4] >> 24, H[4] >> 16, H[4] >> 8, H[4]);
}
var sha1_default = sha1;

// node_modules/uuid/dist/esm-browser/v5.js
function v5(value, namespace, buf, offset) {
  return v35(80, sha1_default, value, namespace, buf, offset);
}
v5.DNS = DNS;
v5.URL = URL;

// node_modules/fast-json-patch/module/core.mjs
var core_exports = {};
__export(core_exports, {
  JsonPatchError: () => JsonPatchError,
  _areEquals: () => _areEquals,
  applyOperation: () => applyOperation,
  applyPatch: () => applyPatch,
  applyReducer: () => applyReducer,
  deepClone: () => deepClone,
  getValueByPointer: () => getValueByPointer,
  validate: () => validate2,
  validator: () => validator
});

// node_modules/fast-json-patch/module/helpers.mjs
var __extends2 = /* @__PURE__ */ (function() {
  var extendStatics = function(d, b) {
    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
      d2.__proto__ = b2;
    } || function(d2, b2) {
      for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
    };
    return extendStatics(d, b);
  };
  return function(d, b) {
    extendStatics(d, b);
    function __() {
      this.constructor = d;
    }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
})();
var _hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwnProperty(obj, key) {
  return _hasOwnProperty.call(obj, key);
}
function _objectKeys(obj) {
  if (Array.isArray(obj)) {
    var keys_1 = new Array(obj.length);
    for (var k2 = 0; k2 < keys_1.length; k2++) {
      keys_1[k2] = "" + k2;
    }
    return keys_1;
  }
  if (Object.keys) {
    return Object.keys(obj);
  }
  var keys = [];
  for (var i in obj) {
    if (hasOwnProperty(obj, i)) {
      keys.push(i);
    }
  }
  return keys;
}
function _deepClone(obj) {
  switch (typeof obj) {
    case "object":
      return JSON.parse(JSON.stringify(obj));
    //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
    case "undefined":
      return null;
    //this is how JSON.stringify behaves for array items
    default:
      return obj;
  }
}
function isInteger(str) {
  var i = 0;
  var len = str.length;
  var charCode;
  while (i < len) {
    charCode = str.charCodeAt(i);
    if (charCode >= 48 && charCode <= 57) {
      i++;
      continue;
    }
    return false;
  }
  return true;
}
function escapePathComponent(path) {
  if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
    return path;
  return path.replace(/~/g, "~0").replace(/\//g, "~1");
}
function unescapePathComponent(path) {
  return path.replace(/~1/g, "/").replace(/~0/g, "~");
}
function hasUndefined(obj) {
  if (obj === void 0) {
    return true;
  }
  if (obj) {
    if (Array.isArray(obj)) {
      for (var i_1 = 0, len = obj.length; i_1 < len; i_1++) {
        if (hasUndefined(obj[i_1])) {
          return true;
        }
      }
    } else if (typeof obj === "object") {
      var objKeys = _objectKeys(obj);
      var objKeysLength = objKeys.length;
      for (var i = 0; i < objKeysLength; i++) {
        if (hasUndefined(obj[objKeys[i]])) {
          return true;
        }
      }
    }
  }
  return false;
}
function patchErrorMessageFormatter(message, args) {
  var messageParts = [message];
  for (var key in args) {
    var value = typeof args[key] === "object" ? JSON.stringify(args[key], null, 2) : args[key];
    if (typeof value !== "undefined") {
      messageParts.push(key + ": " + value);
    }
  }
  return messageParts.join("\n");
}
var PatchError = (
  /** @class */
  (function(_super) {
    __extends2(PatchError2, _super);
    function PatchError2(message, name, index, operation, tree) {
      var _newTarget = this.constructor;
      var _this = _super.call(this, patchErrorMessageFormatter(message, { name, index, operation, tree })) || this;
      _this.name = name;
      _this.index = index;
      _this.operation = operation;
      _this.tree = tree;
      Object.setPrototypeOf(_this, _newTarget.prototype);
      _this.message = patchErrorMessageFormatter(message, { name, index, operation, tree });
      return _this;
    }
    return PatchError2;
  })(Error)
);

// node_modules/fast-json-patch/module/core.mjs
var JsonPatchError = PatchError;
var deepClone = _deepClone;
var objOps = {
  add: function(obj, key, document) {
    obj[key] = this.value;
    return { newDocument: document };
  },
  remove: function(obj, key, document) {
    var removed = obj[key];
    delete obj[key];
    return { newDocument: document, removed };
  },
  replace: function(obj, key, document) {
    var removed = obj[key];
    obj[key] = this.value;
    return { newDocument: document, removed };
  },
  move: function(obj, key, document) {
    var removed = getValueByPointer(document, this.path);
    if (removed) {
      removed = _deepClone(removed);
    }
    var originalValue = applyOperation(document, { op: "remove", path: this.from }).removed;
    applyOperation(document, { op: "add", path: this.path, value: originalValue });
    return { newDocument: document, removed };
  },
  copy: function(obj, key, document) {
    var valueToCopy = getValueByPointer(document, this.from);
    applyOperation(document, { op: "add", path: this.path, value: _deepClone(valueToCopy) });
    return { newDocument: document };
  },
  test: function(obj, key, document) {
    return { newDocument: document, test: _areEquals(obj[key], this.value) };
  },
  _get: function(obj, key, document) {
    this.value = obj[key];
    return { newDocument: document };
  }
};
var arrOps = {
  add: function(arr, i, document) {
    if (isInteger(i)) {
      arr.splice(i, 0, this.value);
    } else {
      arr[i] = this.value;
    }
    return { newDocument: document, index: i };
  },
  remove: function(arr, i, document) {
    var removedList = arr.splice(i, 1);
    return { newDocument: document, removed: removedList[0] };
  },
  replace: function(arr, i, document) {
    var removed = arr[i];
    arr[i] = this.value;
    return { newDocument: document, removed };
  },
  move: objOps.move,
  copy: objOps.copy,
  test: objOps.test,
  _get: objOps._get
};
function getValueByPointer(document, pointer) {
  if (pointer == "") {
    return document;
  }
  var getOriginalDestination = { op: "_get", path: pointer };
  applyOperation(document, getOriginalDestination);
  return getOriginalDestination.value;
}
function applyOperation(document, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
  if (validateOperation === void 0) {
    validateOperation = false;
  }
  if (mutateDocument === void 0) {
    mutateDocument = true;
  }
  if (banPrototypeModifications === void 0) {
    banPrototypeModifications = true;
  }
  if (index === void 0) {
    index = 0;
  }
  if (validateOperation) {
    if (typeof validateOperation == "function") {
      validateOperation(operation, 0, document, operation.path);
    } else {
      validator(operation, 0);
    }
  }
  if (operation.path === "") {
    var returnValue = { newDocument: document };
    if (operation.op === "add") {
      returnValue.newDocument = operation.value;
      return returnValue;
    } else if (operation.op === "replace") {
      returnValue.newDocument = operation.value;
      returnValue.removed = document;
      return returnValue;
    } else if (operation.op === "move" || operation.op === "copy") {
      returnValue.newDocument = getValueByPointer(document, operation.from);
      if (operation.op === "move") {
        returnValue.removed = document;
      }
      return returnValue;
    } else if (operation.op === "test") {
      returnValue.test = _areEquals(document, operation.value);
      if (returnValue.test === false) {
        throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
      }
      returnValue.newDocument = document;
      return returnValue;
    } else if (operation.op === "remove") {
      returnValue.removed = document;
      returnValue.newDocument = null;
      return returnValue;
    } else if (operation.op === "_get") {
      operation.value = document;
      return returnValue;
    } else {
      if (validateOperation) {
        throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
      } else {
        return returnValue;
      }
    }
  } else {
    if (!mutateDocument) {
      document = _deepClone(document);
    }
    var path = operation.path || "";
    var keys = path.split("/");
    var obj = document;
    var t = 1;
    var len = keys.length;
    var existingPathFragment = void 0;
    var key = void 0;
    var validateFunction = void 0;
    if (typeof validateOperation == "function") {
      validateFunction = validateOperation;
    } else {
      validateFunction = validator;
    }
    while (true) {
      key = keys[t];
      if (key && key.indexOf("~") != -1) {
        key = unescapePathComponent(key);
      }
      if (banPrototypeModifications && (key == "__proto__" || key == "prototype" && t > 0 && keys[t - 1] == "constructor")) {
        throw new TypeError("JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README");
      }
      if (validateOperation) {
        if (existingPathFragment === void 0) {
          if (obj[key] === void 0) {
            existingPathFragment = keys.slice(0, t).join("/");
          } else if (t == len - 1) {
            existingPathFragment = operation.path;
          }
          if (existingPathFragment !== void 0) {
            validateFunction(operation, 0, document, existingPathFragment);
          }
        }
      }
      t++;
      if (Array.isArray(obj)) {
        if (key === "-") {
          key = obj.length;
        } else {
          if (validateOperation && !isInteger(key)) {
            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
          } else if (isInteger(key)) {
            key = ~~key;
          }
        }
        if (t >= len) {
          if (validateOperation && operation.op === "add" && key > obj.length) {
            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
          }
          var returnValue = arrOps[operation.op].call(operation, obj, key, document);
          if (returnValue.test === false) {
            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
          }
          return returnValue;
        }
      } else {
        if (t >= len) {
          var returnValue = objOps[operation.op].call(operation, obj, key, document);
          if (returnValue.test === false) {
            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
          }
          return returnValue;
        }
      }
      obj = obj[key];
      if (validateOperation && t < len && (!obj || typeof obj !== "object")) {
        throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
      }
    }
  }
}
function applyPatch(document, patch, validateOperation, mutateDocument, banPrototypeModifications) {
  if (mutateDocument === void 0) {
    mutateDocument = true;
  }
  if (banPrototypeModifications === void 0) {
    banPrototypeModifications = true;
  }
  if (validateOperation) {
    if (!Array.isArray(patch)) {
      throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
    }
  }
  if (!mutateDocument) {
    document = _deepClone(document);
  }
  var results = new Array(patch.length);
  for (var i = 0, length_1 = patch.length; i < length_1; i++) {
    results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
    document = results[i].newDocument;
  }
  results.newDocument = document;
  return results;
}
function applyReducer(document, operation, index) {
  var operationResult = applyOperation(document, operation);
  if (operationResult.test === false) {
    throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
  }
  return operationResult.newDocument;
}
function validator(operation, index, document, existingPathFragment) {
  if (typeof operation !== "object" || operation === null || Array.isArray(operation)) {
    throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document);
  } else if (!objOps[operation.op]) {
    throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
  } else if (typeof operation.path !== "string") {
    throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document);
  } else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) {
    throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document);
  } else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") {
    throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document);
  } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) {
    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document);
  } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) {
    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document);
  } else if (document) {
    if (operation.op == "add") {
      var pathLen = operation.path.split("/").length;
      var existingPathLen = existingPathFragment.split("/").length;
      if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
        throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document);
      }
    } else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
      if (operation.path !== existingPathFragment) {
        throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
      }
    } else if (operation.op === "move" || operation.op === "copy") {
      var existingValue = { op: "_get", path: operation.from, value: void 0 };
      var error = validate2([existingValue], document);
      if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") {
        throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document);
      }
    }
  }
}
function validate2(sequence, document, externalValidator) {
  try {
    if (!Array.isArray(sequence)) {
      throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
    }
    if (document) {
      applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
    } else {
      externalValidator = externalValidator || validator;
      for (var i = 0; i < sequence.length; i++) {
        externalValidator(sequence[i], i, document, void 0);
      }
    }
  } catch (e) {
    if (e instanceof JsonPatchError) {
      return e;
    } else {
      throw e;
    }
  }
}
function _areEquals(a, b) {
  if (a === b)
    return true;
  if (a && b && typeof a == "object" && typeof b == "object") {
    var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
    if (arrA && arrB) {
      length = a.length;
      if (length != b.length)
        return false;
      for (i = length; i-- !== 0; )
        if (!_areEquals(a[i], b[i]))
          return false;
      return true;
    }
    if (arrA != arrB)
      return false;
    var keys = Object.keys(a);
    length = keys.length;
    if (length !== Object.keys(b).length)
      return false;
    for (i = length; i-- !== 0; )
      if (!b.hasOwnProperty(keys[i]))
        return false;
    for (i = length; i-- !== 0; ) {
      key = keys[i];
      if (!_areEquals(a[key], b[key]))
        return false;
    }
    return true;
  }
  return a !== a && b !== b;
}

// node_modules/fast-json-patch/module/duplex.mjs
var duplex_exports = {};
__export(duplex_exports, {
  compare: () => compare,
  generate: () => generate2,
  observe: () => observe,
  unobserve: () => unobserve
});
var beforeDict = /* @__PURE__ */ new WeakMap();
var Mirror = (
  /** @class */
  /* @__PURE__ */ (function() {
    function Mirror2(obj) {
      this.observers = /* @__PURE__ */ new Map();
      this.obj = obj;
    }
    return Mirror2;
  })()
);
var ObserverInfo = (
  /** @class */
  /* @__PURE__ */ (function() {
    function ObserverInfo2(callback, observer) {
      this.callback = callback;
      this.observer = observer;
    }
    return ObserverInfo2;
  })()
);
function getMirror(obj) {
  return beforeDict.get(obj);
}
function getObserverFromMirror(mirror, callback) {
  return mirror.observers.get(callback);
}
function removeObserverFromMirror(mirror, observer) {
  mirror.observers.delete(observer.callback);
}
function unobserve(root, observer) {
  observer.unobserve();
}
function observe(obj, callback) {
  var patches = [];
  var observer;
  var mirror = getMirror(obj);
  if (!mirror) {
    mirror = new Mirror(obj);
    beforeDict.set(obj, mirror);
  } else {
    var observerInfo = getObserverFromMirror(mirror, callback);
    observer = observerInfo && observerInfo.observer;
  }
  if (observer) {
    return observer;
  }
  observer = {};
  mirror.value = _deepClone(obj);
  if (callback) {
    observer.callback = callback;
    observer.next = null;
    var dirtyCheck = function() {
      generate2(observer);
    };
    var fastCheck = function() {
      clearTimeout(observer.next);
      observer.next = setTimeout(dirtyCheck);
    };
    if (typeof window !== "undefined") {
      window.addEventListener("mouseup", fastCheck);
      window.addEventListener("keyup", fastCheck);
      window.addEventListener("mousedown", fastCheck);
      window.addEventListener("keydown", fastCheck);
      window.addEventListener("change", fastCheck);
    }
  }
  observer.patches = patches;
  observer.object = obj;
  observer.unobserve = function() {
    generate2(observer);
    clearTimeout(observer.next);
    removeObserverFromMirror(mirror, observer);
    if (typeof window !== "undefined") {
      window.removeEventListener("mouseup", fastCheck);
      window.removeEventListener("keyup", fastCheck);
      window.removeEventListener("mousedown", fastCheck);
      window.removeEventListener("keydown", fastCheck);
      window.removeEventListener("change", fastCheck);
    }
  };
  mirror.observers.set(callback, new ObserverInfo(callback, observer));
  return observer;
}
function generate2(observer, invertible) {
  if (invertible === void 0) {
    invertible = false;
  }
  var mirror = beforeDict.get(observer.object);
  _generate(mirror.value, observer.object, observer.patches, "", invertible);
  if (observer.patches.length) {
    applyPatch(mirror.value, observer.patches);
  }
  var temp = observer.patches;
  if (temp.length > 0) {
    observer.patches = [];
    if (observer.callback) {
      observer.callback(temp);
    }
  }
  return temp;
}
function _generate(mirror, obj, patches, path, invertible) {
  if (obj === mirror) {
    return;
  }
  if (typeof obj.toJSON === "function") {
    obj = obj.toJSON();
  }
  var newKeys = _objectKeys(obj);
  var oldKeys = _objectKeys(mirror);
  var changed = false;
  var deleted = false;
  for (var t = oldKeys.length - 1; t >= 0; t--) {
    var key = oldKeys[t];
    var oldVal = mirror[key];
    if (hasOwnProperty(obj, key) && !(obj[key] === void 0 && oldVal !== void 0 && Array.isArray(obj) === false)) {
      var newVal = obj[key];
      if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) {
        _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
      } else {
        if (oldVal !== newVal) {
          changed = true;
          if (invertible) {
            patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
          }
          patches.push({ op: "replace", path: path + "/" + escapePathComponent(key), value: _deepClone(newVal) });
        }
      }
    } else if (Array.isArray(mirror) === Array.isArray(obj)) {
      if (invertible) {
        patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
      }
      patches.push({ op: "remove", path: path + "/" + escapePathComponent(key) });
      deleted = true;
    } else {
      if (invertible) {
        patches.push({ op: "test", path, value: mirror });
      }
      patches.push({ op: "replace", path, value: obj });
      changed = true;
    }
  }
  if (!deleted && newKeys.length == oldKeys.length) {
    return;
  }
  for (var t = 0; t < newKeys.length; t++) {
    var key = newKeys[t];
    if (!hasOwnProperty(mirror, key) && obj[key] !== void 0) {
      patches.push({ op: "add", path: path + "/" + escapePathComponent(key), value: _deepClone(obj[key]) });
    }
  }
}
function compare(tree1, tree2, invertible) {
  if (invertible === void 0) {
    invertible = false;
  }
  var patches = [];
  _generate(tree1, tree2, patches, "", invertible);
  return patches;
}

// node_modules/fast-json-patch/index.mjs
var fast_json_patch_default = Object.assign({}, core_exports, duplex_exports, {
  JsonPatchError: PatchError,
  deepClone: _deepClone,
  escapePathComponent,
  unescapePathComponent
});

// node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
function varint64read() {
  let lowBits = 0;
  let highBits = 0;
  for (let shift = 0; shift < 28; shift += 7) {
    let b = this.buf[this.pos++];
    lowBits |= (b & 127) << shift;
    if ((b & 128) == 0) {
      this.assertBounds();
      return [lowBits, highBits];
    }
  }
  let middleByte = this.buf[this.pos++];
  lowBits |= (middleByte & 15) << 28;
  highBits = (middleByte & 112) >> 4;
  if ((middleByte & 128) == 0) {
    this.assertBounds();
    return [lowBits, highBits];
  }
  for (let shift = 3; shift <= 31; shift += 7) {
    let b = this.buf[this.pos++];
    highBits |= (b & 127) << shift;
    if ((b & 128) == 0) {
      this.assertBounds();
      return [lowBits, highBits];
    }
  }
  throw new Error("invalid varint");
}
function varint64write(lo, hi, bytes) {
  for (let i = 0; i < 28; i = i + 7) {
    const shift = lo >>> i;
    const hasNext = !(shift >>> 7 == 0 && hi == 0);
    const byte = (hasNext ? shift | 128 : shift) & 255;
    bytes.push(byte);
    if (!hasNext) {
      return;
    }
  }
  const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
  const hasMoreBits = !(hi >> 3 == 0);
  bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
  if (!hasMoreBits) {
    return;
  }
  for (let i = 3; i < 31; i = i + 7) {
    const shift = hi >>> i;
    const hasNext = !(shift >>> 7 == 0);
    const byte = (hasNext ? shift | 128 : shift) & 255;
    bytes.push(byte);
    if (!hasNext) {
      return;
    }
  }
  bytes.push(hi >>> 31 & 1);
}
var TWO_PWR_32_DBL = 4294967296;
function int64FromString(dec) {
  const minus = dec[0] === "-";
  if (minus) {
    dec = dec.slice(1);
  }
  const base = 1e6;
  let lowBits = 0;
  let highBits = 0;
  function add1e6digit(begin, end) {
    const digit1e6 = Number(dec.slice(begin, end));
    highBits *= base;
    lowBits = lowBits * base + digit1e6;
    if (lowBits >= TWO_PWR_32_DBL) {
      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
      lowBits = lowBits % TWO_PWR_32_DBL;
    }
  }
  add1e6digit(-24, -18);
  add1e6digit(-18, -12);
  add1e6digit(-12, -6);
  add1e6digit(-6);
  return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
}
function int64ToString(lo, hi) {
  let bits = newBits(lo, hi);
  const negative = bits.hi & 2147483648;
  if (negative) {
    bits = negate(bits.lo, bits.hi);
  }
  const result = uInt64ToString(bits.lo, bits.hi);
  return negative ? "-" + result : result;
}
function uInt64ToString(lo, hi) {
  ({ lo, hi } = toUnsigned(lo, hi));
  if (hi <= 2097151) {
    return String(TWO_PWR_32_DBL * hi + lo);
  }
  const low = lo & 16777215;
  const mid = (lo >>> 24 | hi << 8) & 16777215;
  const high = hi >> 16 & 65535;
  let digitA = low + mid * 6777216 + high * 6710656;
  let digitB = mid + high * 8147497;
  let digitC = high * 2;
  const base = 1e7;
  if (digitA >= base) {
    digitB += Math.floor(digitA / base);
    digitA %= base;
  }
  if (digitB >= base) {
    digitC += Math.floor(digitB / base);
    digitB %= base;
  }
  return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
}
function toUnsigned(lo, hi) {
  return { lo: lo >>> 0, hi: hi >>> 0 };
}
function newBits(lo, hi) {
  return { lo: lo | 0, hi: hi | 0 };
}
function negate(lowBits, highBits) {
  highBits = ~highBits;
  if (lowBits) {
    lowBits = ~lowBits + 1;
  } else {
    highBits += 1;
  }
  return newBits(lowBits, highBits);
}
var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
  const partial = String(digit1e7);
  return "0000000".slice(partial.length) + partial;
};
function varint32write(value, bytes) {
  if (value >= 0) {
    while (value > 127) {
      bytes.push(value & 127 | 128);
      value = value >>> 7;
    }
    bytes.push(value);
  } else {
    for (let i = 0; i < 9; i++) {
      bytes.push(value & 127 | 128);
      value = value >> 7;
    }
    bytes.push(1);
  }
}
function varint32read() {
  let b = this.buf[this.pos++];
  let result = b & 127;
  if ((b & 128) == 0) {
    this.assertBounds();
    return result;
  }
  b = this.buf[this.pos++];
  result |= (b & 127) << 7;
  if ((b & 128) == 0) {
    this.assertBounds();
    return result;
  }
  b = this.buf[this.pos++];
  result |= (b & 127) << 14;
  if ((b & 128) == 0) {
    this.assertBounds();
    return result;
  }
  b = this.buf[this.pos++];
  result |= (b & 127) << 21;
  if ((b & 128) == 0) {
    this.assertBounds();
    return result;
  }
  b = this.buf[this.pos++];
  result |= (b & 15) << 28;
  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
    b = this.buf[this.pos++];
  if ((b & 128) != 0)
    throw new Error("invalid varint");
  this.assertBounds();
  return result >>> 0;
}

// node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
var protoInt64 = makeInt64Support();
function makeInt64Support() {
  const dv = new DataView(new ArrayBuffer(8));
  const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
  if (ok) {
    const MIN = BigInt("-9223372036854775808");
    const MAX = BigInt("9223372036854775807");
    const UMIN = BigInt("0");
    const UMAX = BigInt("18446744073709551615");
    return {
      zero: BigInt(0),
      supported: true,
      parse(value) {
        const bi = typeof value == "bigint" ? value : BigInt(value);
        if (bi > MAX || bi < MIN) {
          throw new Error(`invalid int64: ${value}`);
        }
        return bi;
      },
      uParse(value) {
        const bi = typeof value == "bigint" ? value : BigInt(value);
        if (bi > UMAX || bi < UMIN) {
          throw new Error(`invalid uint64: ${value}`);
        }
        return bi;
      },
      enc(value) {
        dv.setBigInt64(0, this.parse(value), true);
        return {
          lo: dv.getInt32(0, true),
          hi: dv.getInt32(4, true)
        };
      },
      uEnc(value) {
        dv.setBigInt64(0, this.uParse(value), true);
        return {
          lo: dv.getInt32(0, true),
          hi: dv.getInt32(4, true)
        };
      },
      dec(lo, hi) {
        dv.setInt32(0, lo, true);
        dv.setInt32(4, hi, true);
        return dv.getBigInt64(0, true);
      },
      uDec(lo, hi) {
        dv.setInt32(0, lo, true);
        dv.setInt32(4, hi, true);
        return dv.getBigUint64(0, true);
      }
    };
  }
  return {
    zero: "0",
    supported: false,
    parse(value) {
      if (typeof value != "string") {
        value = value.toString();
      }
      assertInt64String(value);
      return value;
    },
    uParse(value) {
      if (typeof value != "string") {
        value = value.toString();
      }
      assertUInt64String(value);
      return value;
    },
    enc(value) {
      if (typeof value != "string") {
        value = value.toString();
      }
      assertInt64String(value);
      return int64FromString(value);
    },
    uEnc(value) {
      if (typeof value != "string") {
        value = value.toString();
      }
      assertUInt64String(value);
      return int64FromString(value);
    },
    dec(lo, hi) {
      return int64ToString(lo, hi);
    },
    uDec(lo, hi) {
      return uInt64ToString(lo, hi);
    }
  };
}
function assertInt64String(value) {
  if (!/^-?[0-9]+$/.test(value)) {
    throw new Error("invalid int64: " + value);
  }
}
function assertUInt64String(value) {
  if (!/^[0-9]+$/.test(value)) {
    throw new Error("invalid uint64: " + value);
  }
}

// node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
var symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
function getTextEncoding() {
  if (globalThis[symbol] == void 0) {
    const te2 = new globalThis.TextEncoder();
    const td = new globalThis.TextDecoder();
    globalThis[symbol] = {
      encodeUtf8(text) {
        return te2.encode(text);
      },
      decodeUtf8(bytes) {
        return td.decode(bytes);
      },
      checkUtf8(text) {
        try {
          encodeURIComponent(text);
          return true;
        } catch (_) {
          return false;
        }
      }
    };
  }
  return globalThis[symbol];
}

// node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
var WireType;
(function(WireType2) {
  WireType2[WireType2["Varint"] = 0] = "Varint";
  WireType2[WireType2["Bit64"] = 1] = "Bit64";
  WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
  WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
  WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
  WireType2[WireType2["Bit32"] = 5] = "Bit32";
})(WireType || (WireType = {}));
var FLOAT32_MAX = 34028234663852886e22;
var FLOAT32_MIN = -34028234663852886e22;
var UINT32_MAX = 4294967295;
var INT32_MAX = 2147483647;
var INT32_MIN = -2147483648;
var BinaryWriter = class {
  constructor(encodeUtf8 = getTextEncoding().encodeUtf8) {
    this.encodeUtf8 = encodeUtf8;
    this.stack = [];
    this.chunks = [];
    this.buf = [];
  }
  /**
   * Return all bytes written and reset this writer.
   */
  finish() {
    if (this.buf.length) {
      this.chunks.push(new Uint8Array(this.buf));
      this.buf = [];
    }
    let len = 0;
    for (let i = 0; i < this.chunks.length; i++)
      len += this.chunks[i].length;
    let bytes = new Uint8Array(len);
    let offset = 0;
    for (let i = 0; i < this.chunks.length; i++) {
      bytes.set(this.chunks[i], offset);
      offset += this.chunks[i].length;
    }
    this.chunks = [];
    return bytes;
  }
  /**
   * Start a new fork for length-delimited data like a message
   * or a packed repeated field.
   *
   * Must be joined later with `join()`.
   */
  fork() {
    this.stack.push({ chunks: this.chunks, buf: this.buf });
    this.chunks = [];
    this.buf = [];
    return this;
  }
  /**
   * Join the last fork. Write its length and bytes, then
   * return to the previous state.
   */
  join() {
    let chunk = this.finish();
    let prev = this.stack.pop();
    if (!prev)
      throw new Error("invalid state, fork stack empty");
    this.chunks = prev.chunks;
    this.buf = prev.buf;
    this.uint32(chunk.byteLength);
    return this.raw(chunk);
  }
  /**
   * Writes a tag (field number and wire type).
   *
   * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
   *
   * Generated code should compute the tag ahead of time and call `uint32()`.
   */
  tag(fieldNo, type) {
    return this.uint32((fieldNo << 3 | type) >>> 0);
  }
  /**
   * Write a chunk of raw bytes.
   */
  raw(chunk) {
    if (this.buf.length) {
      this.chunks.push(new Uint8Array(this.buf));
      this.buf = [];
    }
    this.chunks.push(chunk);
    return this;
  }
  /**
   * Write a `uint32` value, an unsigned 32 bit varint.
   */
  uint32(value) {
    assertUInt32(value);
    while (value > 127) {
      this.buf.push(value & 127 | 128);
      value = value >>> 7;
    }
    this.buf.push(value);
    return this;
  }
  /**
   * Write a `int32` value, a signed 32 bit varint.
   */
  int32(value) {
    assertInt32(value);
    varint32write(value, this.buf);
    return this;
  }
  /**
   * Write a `bool` value, a variant.
   */
  bool(value) {
    this.buf.push(value ? 1 : 0);
    return this;
  }
  /**
   * Write a `bytes` value, length-delimited arbitrary data.
   */
  bytes(value) {
    this.uint32(value.byteLength);
    return this.raw(value);
  }
  /**
   * Write a `string` value, length-delimited data converted to UTF-8 text.
   */
  string(value) {
    let chunk = this.encodeUtf8(value);
    this.uint32(chunk.byteLength);
    return this.raw(chunk);
  }
  /**
   * Write a `float` value, 32-bit floating point number.
   */
  float(value) {
    assertFloat32(value);
    let chunk = new Uint8Array(4);
    new DataView(chunk.buffer).setFloat32(0, value, true);
    return this.raw(chunk);
  }
  /**
   * Write a `double` value, a 64-bit floating point number.
   */
  double(value) {
    let chunk = new Uint8Array(8);
    new DataView(chunk.buffer).setFloat64(0, value, true);
    return this.raw(chunk);
  }
  /**
   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
   */
  fixed32(value) {
    assertUInt32(value);
    let chunk = new Uint8Array(4);
    new DataView(chunk.buffer).setUint32(0, value, true);
    return this.raw(chunk);
  }
  /**
   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
   */
  sfixed32(value) {
    assertInt32(value);
    let chunk = new Uint8Array(4);
    new DataView(chunk.buffer).setInt32(0, value, true);
    return this.raw(chunk);
  }
  /**
   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
   */
  sint32(value) {
    assertInt32(value);
    value = (value << 1 ^ value >> 31) >>> 0;
    varint32write(value, this.buf);
    return this;
  }
  /**
   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
   */
  sfixed64(value) {
    let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
    view.setInt32(0, tc.lo, true);
    view.setInt32(4, tc.hi, true);
    return this.raw(chunk);
  }
  /**
   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
   */
  fixed64(value) {
    let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
    view.setInt32(0, tc.lo, true);
    view.setInt32(4, tc.hi, true);
    return this.raw(chunk);
  }
  /**
   * Write a `int64` value, a signed 64-bit varint.
   */
  int64(value) {
    let tc = protoInt64.enc(value);
    varint64write(tc.lo, tc.hi, this.buf);
    return this;
  }
  /**
   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
   */
  sint64(value) {
    const tc = protoInt64.enc(value), sign = tc.hi >> 31, lo = tc.lo << 1 ^ sign, hi = (tc.hi << 1 | tc.lo >>> 31) ^ sign;
    varint64write(lo, hi, this.buf);
    return this;
  }
  /**
   * Write a `uint64` value, an unsigned 64-bit varint.
   */
  uint64(value) {
    const tc = protoInt64.uEnc(value);
    varint64write(tc.lo, tc.hi, this.buf);
    return this;
  }
};
var BinaryReader = class {
  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
    this.decodeUtf8 = decodeUtf8;
    this.varint64 = varint64read;
    this.uint32 = varint32read;
    this.buf = buf;
    this.len = buf.length;
    this.pos = 0;
    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  }
  /**
   * Reads a tag - field number and wire type.
   */
  tag() {
    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
    return [fieldNo, wireType];
  }
  /**
   * Skip one element and return the skipped data.
   *
   * When skipping StartGroup, provide the tags field number to check for
   * matching field number in the EndGroup tag.
   */
  skip(wireType, fieldNo) {
    let start = this.pos;
    switch (wireType) {
      case WireType.Varint:
        while (this.buf[this.pos++] & 128) {
        }
        break;
      // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
      case WireType.Bit64:
        this.pos += 4;
      case WireType.Bit32:
        this.pos += 4;
        break;
      case WireType.LengthDelimited:
        let len = this.uint32();
        this.pos += len;
        break;
      case WireType.StartGroup:
        for (; ; ) {
          const [fn, wt] = this.tag();
          if (wt === WireType.EndGroup) {
            if (fieldNo !== void 0 && fn !== fieldNo) {
              throw new Error("invalid end group tag");
            }
            break;
          }
          this.skip(wt, fn);
        }
        break;
      default:
        throw new Error("cant skip wire type " + wireType);
    }
    this.assertBounds();
    return this.buf.subarray(start, this.pos);
  }
  /**
   * Throws error if position in byte array is out of range.
   */
  assertBounds() {
    if (this.pos > this.len)
      throw new RangeError("premature EOF");
  }
  /**
   * Read a `int32` field, a signed 32 bit varint.
   */
  int32() {
    return this.uint32() | 0;
  }
  /**
   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
   */
  sint32() {
    let zze = this.uint32();
    return zze >>> 1 ^ -(zze & 1);
  }
  /**
   * Read a `int64` field, a signed 64-bit varint.
   */
  int64() {
    return protoInt64.dec(...this.varint64());
  }
  /**
   * Read a `uint64` field, an unsigned 64-bit varint.
   */
  uint64() {
    return protoInt64.uDec(...this.varint64());
  }
  /**
   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
   */
  sint64() {
    let [lo, hi] = this.varint64();
    let s = -(lo & 1);
    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
    hi = hi >>> 1 ^ s;
    return protoInt64.dec(lo, hi);
  }
  /**
   * Read a `bool` field, a variant.
   */
  bool() {
    let [lo, hi] = this.varint64();
    return lo !== 0 || hi !== 0;
  }
  /**
   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
   */
  fixed32() {
    return this.view.getUint32((this.pos += 4) - 4, true);
  }
  /**
   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
   */
  sfixed32() {
    return this.view.getInt32((this.pos += 4) - 4, true);
  }
  /**
   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
   */
  fixed64() {
    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
  }
  /**
   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
   */
  sfixed64() {
    return protoInt64.dec(this.sfixed32(), this.sfixed32());
  }
  /**
   * Read a `float` field, 32-bit floating point number.
   */
  float() {
    return this.view.getFloat32((this.pos += 4) - 4, true);
  }
  /**
   * Read a `double` field, a 64-bit floating point number.
   */
  double() {
    return this.view.getFloat64((this.pos += 8) - 8, true);
  }
  /**
   * Read a `bytes` field, length-delimited arbitrary data.
   */
  bytes() {
    let len = this.uint32(), start = this.pos;
    this.pos += len;
    this.assertBounds();
    return this.buf.subarray(start, start + len);
  }
  /**
   * Read a `string` field, length-delimited data converted to UTF-8 text.
   */
  string() {
    return this.decodeUtf8(this.bytes());
  }
};
function assertInt32(arg) {
  if (typeof arg == "string") {
    arg = Number(arg);
  } else if (typeof arg != "number") {
    throw new Error("invalid int32: " + typeof arg);
  }
  if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
    throw new Error("invalid int32: " + arg);
}
function assertUInt32(arg) {
  if (typeof arg == "string") {
    arg = Number(arg);
  } else if (typeof arg != "number") {
    throw new Error("invalid uint32: " + typeof arg);
  }
  if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
    throw new Error("invalid uint32: " + arg);
}
function assertFloat32(arg) {
  if (typeof arg == "string") {
    const o = arg;
    arg = Number(arg);
    if (Number.isNaN(arg) && o !== "NaN") {
      throw new Error("invalid float32: " + o);
    }
  } else if (typeof arg != "number") {
    throw new Error("invalid float32: " + typeof arg);
  }
  if (Number.isFinite(arg) && (arg > FLOAT32_MAX || arg < FLOAT32_MIN))
    throw new Error("invalid float32: " + arg);
}

// node_modules/@bufbuild/protobuf/dist/esm/descriptors.js
var ScalarType;
(function(ScalarType2) {
  ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
  ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
  ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
  ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
  ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
  ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
  ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
  ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
  ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
  ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
  ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
  ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
  ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
  ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
  ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
})(ScalarType || (ScalarType = {}));

// node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js
var unsafeLocal = Symbol.for("reflect unsafe local");

// node_modules/@bufbuild/protobuf/dist/esm/create.js
var tokenZeroMessageField = Symbol();

// node_modules/@ag-ui/proto/dist/index.mjs
function createBaseStruct() {
  return { fields: {} };
}
var Struct = {
  encode(message, writer = new BinaryWriter()) {
    Object.entries(message.fields).forEach(([key, value]) => {
      if (value !== void 0) {
        Struct_FieldsEntry.encode({ key, value }, writer.uint32(10).fork()).join();
      }
    });
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStruct();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
          if (entry1.value !== void 0) {
            message.fields[entry1.key] = entry1.value;
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return Struct.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseStruct();
    message.fields = Object.entries((_a = object.fields) != null ? _a : {}).reduce(
      (acc, [key, value]) => {
        if (value !== void 0) {
          acc[key] = value;
        }
        return acc;
      },
      {}
    );
    return message;
  },
  wrap(object) {
    const struct = createBaseStruct();
    if (object !== void 0) {
      for (const key of Object.keys(object)) {
        struct.fields[key] = object[key];
      }
    }
    return struct;
  },
  unwrap(message) {
    const object = {};
    if (message.fields) {
      for (const key of Object.keys(message.fields)) {
        object[key] = message.fields[key];
      }
    }
    return object;
  }
};
function createBaseStruct_FieldsEntry() {
  return { key: "", value: void 0 };
}
var Struct_FieldsEntry = {
  encode(message, writer = new BinaryWriter()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== void 0) {
      Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStruct_FieldsEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return Struct_FieldsEntry.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseStruct_FieldsEntry();
    message.key = (_a = object.key) != null ? _a : "";
    message.value = (_b = object.value) != null ? _b : void 0;
    return message;
  }
};
function createBaseValue() {
  return {
    nullValue: void 0,
    numberValue: void 0,
    stringValue: void 0,
    boolValue: void 0,
    structValue: void 0,
    listValue: void 0
  };
}
var Value = {
  encode(message, writer = new BinaryWriter()) {
    if (message.nullValue !== void 0) {
      writer.uint32(8).int32(message.nullValue);
    }
    if (message.numberValue !== void 0) {
      writer.uint32(17).double(message.numberValue);
    }
    if (message.stringValue !== void 0) {
      writer.uint32(26).string(message.stringValue);
    }
    if (message.boolValue !== void 0) {
      writer.uint32(32).bool(message.boolValue);
    }
    if (message.structValue !== void 0) {
      Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join();
    }
    if (message.listValue !== void 0) {
      ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseValue();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.nullValue = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 17) {
            break;
          }
          message.numberValue = reader.double();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.stringValue = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }
          message.boolValue = reader.bool();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }
          message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return Value.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c, _d, _e, _f;
    const message = createBaseValue();
    message.nullValue = (_a = object.nullValue) != null ? _a : void 0;
    message.numberValue = (_b = object.numberValue) != null ? _b : void 0;
    message.stringValue = (_c = object.stringValue) != null ? _c : void 0;
    message.boolValue = (_d = object.boolValue) != null ? _d : void 0;
    message.structValue = (_e = object.structValue) != null ? _e : void 0;
    message.listValue = (_f = object.listValue) != null ? _f : void 0;
    return message;
  },
  wrap(value) {
    const result = createBaseValue();
    if (value === null) {
      result.nullValue = 0;
    } else if (typeof value === "boolean") {
      result.boolValue = value;
    } else if (typeof value === "number") {
      result.numberValue = value;
    } else if (typeof value === "string") {
      result.stringValue = value;
    } else if (globalThis.Array.isArray(value)) {
      result.listValue = value;
    } else if (typeof value === "object") {
      result.structValue = value;
    } else if (typeof value !== "undefined") {
      throw new globalThis.Error("Unsupported any value type: " + typeof value);
    }
    return result;
  },
  unwrap(message) {
    if (message.stringValue !== void 0) {
      return message.stringValue;
    } else if ((message == null ? void 0 : message.numberValue) !== void 0) {
      return message.numberValue;
    } else if ((message == null ? void 0 : message.boolValue) !== void 0) {
      return message.boolValue;
    } else if ((message == null ? void 0 : message.structValue) !== void 0) {
      return message.structValue;
    } else if ((message == null ? void 0 : message.listValue) !== void 0) {
      return message.listValue;
    } else if ((message == null ? void 0 : message.nullValue) !== void 0) {
      return null;
    }
    return void 0;
  }
};
function createBaseListValue() {
  return { values: [] };
}
var ListValue = {
  encode(message, writer = new BinaryWriter()) {
    for (const v of message.values) {
      Value.encode(Value.wrap(v), writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListValue();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ListValue.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseListValue();
    message.values = ((_a = object.values) == null ? void 0 : _a.map((e) => e)) || [];
    return message;
  },
  wrap(array) {
    const result = createBaseListValue();
    result.values = array != null ? array : [];
    return result;
  },
  unwrap(message) {
    if ((message == null ? void 0 : message.hasOwnProperty("values")) && globalThis.Array.isArray(message.values)) {
      return message.values;
    } else {
      return message;
    }
  }
};
var JsonPatchOperationType = ((JsonPatchOperationType2) => {
  JsonPatchOperationType2[JsonPatchOperationType2["ADD"] = 0] = "ADD";
  JsonPatchOperationType2[JsonPatchOperationType2["REMOVE"] = 1] = "REMOVE";
  JsonPatchOperationType2[JsonPatchOperationType2["REPLACE"] = 2] = "REPLACE";
  JsonPatchOperationType2[JsonPatchOperationType2["MOVE"] = 3] = "MOVE";
  JsonPatchOperationType2[JsonPatchOperationType2["COPY"] = 4] = "COPY";
  JsonPatchOperationType2[JsonPatchOperationType2["TEST"] = 5] = "TEST";
  JsonPatchOperationType2[JsonPatchOperationType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return JsonPatchOperationType2;
})(JsonPatchOperationType || {});
function createBaseJsonPatchOperation() {
  return { op: 0, path: "", from: void 0, value: void 0 };
}
var JsonPatchOperation = {
  encode(message, writer = new BinaryWriter()) {
    if (message.op !== 0) {
      writer.uint32(8).int32(message.op);
    }
    if (message.path !== "") {
      writer.uint32(18).string(message.path);
    }
    if (message.from !== void 0) {
      writer.uint32(26).string(message.from);
    }
    if (message.value !== void 0) {
      Value.encode(Value.wrap(message.value), writer.uint32(34).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseJsonPatchOperation();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.op = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.path = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.from = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return JsonPatchOperation.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c, _d;
    const message = createBaseJsonPatchOperation();
    message.op = (_a = object.op) != null ? _a : 0;
    message.path = (_b = object.path) != null ? _b : "";
    message.from = (_c = object.from) != null ? _c : void 0;
    message.value = (_d = object.value) != null ? _d : void 0;
    return message;
  }
};
function createBaseToolCall() {
  return { id: "", type: "", function: void 0 };
}
var ToolCall = {
  encode(message, writer = new BinaryWriter()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.type !== "") {
      writer.uint32(18).string(message.type);
    }
    if (message.function !== void 0) {
      ToolCall_Function.encode(message.function, writer.uint32(26).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCall();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.type = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.function = ToolCall_Function.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCall.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseToolCall();
    message.id = (_a = object.id) != null ? _a : "";
    message.type = (_b = object.type) != null ? _b : "";
    message.function = object.function !== void 0 && object.function !== null ? ToolCall_Function.fromPartial(object.function) : void 0;
    return message;
  }
};
function createBaseToolCall_Function() {
  return { name: "", arguments: "" };
}
var ToolCall_Function = {
  encode(message, writer = new BinaryWriter()) {
    if (message.name !== "") {
      writer.uint32(10).string(message.name);
    }
    if (message.arguments !== "") {
      writer.uint32(18).string(message.arguments);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCall_Function();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.name = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.arguments = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCall_Function.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseToolCall_Function();
    message.name = (_a = object.name) != null ? _a : "";
    message.arguments = (_b = object.arguments) != null ? _b : "";
    return message;
  }
};
function createBaseMessage() {
  return {
    id: "",
    role: "",
    content: void 0,
    name: void 0,
    toolCalls: [],
    toolCallId: void 0,
    error: void 0
  };
}
var Message = {
  encode(message, writer = new BinaryWriter()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.role !== "") {
      writer.uint32(18).string(message.role);
    }
    if (message.content !== void 0) {
      writer.uint32(26).string(message.content);
    }
    if (message.name !== void 0) {
      writer.uint32(34).string(message.name);
    }
    for (const v of message.toolCalls) {
      ToolCall.encode(v, writer.uint32(42).fork()).join();
    }
    if (message.toolCallId !== void 0) {
      writer.uint32(50).string(message.toolCallId);
    }
    if (message.error !== void 0) {
      writer.uint32(58).string(message.error);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseMessage();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.role = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.content = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.name = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.toolCalls.push(ToolCall.decode(reader, reader.uint32()));
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }
          message.toolCallId = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }
          message.error = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return Message.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c, _d, _e, _f, _g;
    const message = createBaseMessage();
    message.id = (_a = object.id) != null ? _a : "";
    message.role = (_b = object.role) != null ? _b : "";
    message.content = (_c = object.content) != null ? _c : void 0;
    message.name = (_d = object.name) != null ? _d : void 0;
    message.toolCalls = ((_e = object.toolCalls) == null ? void 0 : _e.map((e) => ToolCall.fromPartial(e))) || [];
    message.toolCallId = (_f = object.toolCallId) != null ? _f : void 0;
    message.error = (_g = object.error) != null ? _g : void 0;
    return message;
  }
};
var EventType2 = ((EventType3) => {
  EventType3[EventType3["TEXT_MESSAGE_START"] = 0] = "TEXT_MESSAGE_START";
  EventType3[EventType3["TEXT_MESSAGE_CONTENT"] = 1] = "TEXT_MESSAGE_CONTENT";
  EventType3[EventType3["TEXT_MESSAGE_END"] = 2] = "TEXT_MESSAGE_END";
  EventType3[EventType3["TOOL_CALL_START"] = 3] = "TOOL_CALL_START";
  EventType3[EventType3["TOOL_CALL_ARGS"] = 4] = "TOOL_CALL_ARGS";
  EventType3[EventType3["TOOL_CALL_END"] = 5] = "TOOL_CALL_END";
  EventType3[EventType3["STATE_SNAPSHOT"] = 6] = "STATE_SNAPSHOT";
  EventType3[EventType3["STATE_DELTA"] = 7] = "STATE_DELTA";
  EventType3[EventType3["MESSAGES_SNAPSHOT"] = 8] = "MESSAGES_SNAPSHOT";
  EventType3[EventType3["RAW"] = 9] = "RAW";
  EventType3[EventType3["CUSTOM"] = 10] = "CUSTOM";
  EventType3[EventType3["RUN_STARTED"] = 11] = "RUN_STARTED";
  EventType3[EventType3["RUN_FINISHED"] = 12] = "RUN_FINISHED";
  EventType3[EventType3["RUN_ERROR"] = 13] = "RUN_ERROR";
  EventType3[EventType3["STEP_STARTED"] = 14] = "STEP_STARTED";
  EventType3[EventType3["STEP_FINISHED"] = 15] = "STEP_FINISHED";
  EventType3[EventType3["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return EventType3;
})(EventType2 || {});
function createBaseBaseEvent() {
  return { type: 0, timestamp: void 0, rawEvent: void 0 };
}
var BaseEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.type !== 0) {
      writer.uint32(8).int32(message.type);
    }
    if (message.timestamp !== void 0) {
      writer.uint32(16).int64(message.timestamp);
    }
    if (message.rawEvent !== void 0) {
      Value.encode(Value.wrap(message.rawEvent), writer.uint32(26).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBaseEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.type = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }
          message.timestamp = longToNumber(reader.int64());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.rawEvent = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return BaseEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c;
    const message = createBaseBaseEvent();
    message.type = (_a = object.type) != null ? _a : 0;
    message.timestamp = (_b = object.timestamp) != null ? _b : void 0;
    message.rawEvent = (_c = object.rawEvent) != null ? _c : void 0;
    return message;
  }
};
function createBaseTextMessageStartEvent() {
  return { baseEvent: void 0, messageId: "", role: void 0 };
}
var TextMessageStartEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.messageId !== "") {
      writer.uint32(18).string(message.messageId);
    }
    if (message.role !== void 0) {
      writer.uint32(26).string(message.role);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTextMessageStartEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.messageId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.role = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return TextMessageStartEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseTextMessageStartEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.messageId = (_a = object.messageId) != null ? _a : "";
    message.role = (_b = object.role) != null ? _b : void 0;
    return message;
  }
};
function createBaseTextMessageContentEvent() {
  return { baseEvent: void 0, messageId: "", delta: "" };
}
var TextMessageContentEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.messageId !== "") {
      writer.uint32(18).string(message.messageId);
    }
    if (message.delta !== "") {
      writer.uint32(26).string(message.delta);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTextMessageContentEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.messageId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.delta = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return TextMessageContentEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseTextMessageContentEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.messageId = (_a = object.messageId) != null ? _a : "";
    message.delta = (_b = object.delta) != null ? _b : "";
    return message;
  }
};
function createBaseTextMessageEndEvent() {
  return { baseEvent: void 0, messageId: "" };
}
var TextMessageEndEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.messageId !== "") {
      writer.uint32(18).string(message.messageId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTextMessageEndEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.messageId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return TextMessageEndEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseTextMessageEndEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.messageId = (_a = object.messageId) != null ? _a : "";
    return message;
  }
};
function createBaseToolCallStartEvent() {
  return { baseEvent: void 0, toolCallId: "", toolCallName: "", parentMessageId: void 0 };
}
var ToolCallStartEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.toolCallId !== "") {
      writer.uint32(18).string(message.toolCallId);
    }
    if (message.toolCallName !== "") {
      writer.uint32(26).string(message.toolCallName);
    }
    if (message.parentMessageId !== void 0) {
      writer.uint32(34).string(message.parentMessageId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCallStartEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.toolCallId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.toolCallName = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.parentMessageId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCallStartEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c;
    const message = createBaseToolCallStartEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
    message.toolCallName = (_b = object.toolCallName) != null ? _b : "";
    message.parentMessageId = (_c = object.parentMessageId) != null ? _c : void 0;
    return message;
  }
};
function createBaseToolCallArgsEvent() {
  return { baseEvent: void 0, toolCallId: "", delta: "" };
}
var ToolCallArgsEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.toolCallId !== "") {
      writer.uint32(18).string(message.toolCallId);
    }
    if (message.delta !== "") {
      writer.uint32(26).string(message.delta);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCallArgsEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.toolCallId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.delta = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCallArgsEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseToolCallArgsEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
    message.delta = (_b = object.delta) != null ? _b : "";
    return message;
  }
};
function createBaseToolCallEndEvent() {
  return { baseEvent: void 0, toolCallId: "" };
}
var ToolCallEndEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.toolCallId !== "") {
      writer.uint32(18).string(message.toolCallId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCallEndEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.toolCallId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCallEndEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseToolCallEndEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
    return message;
  }
};
function createBaseStateSnapshotEvent() {
  return { baseEvent: void 0, snapshot: void 0 };
}
var StateSnapshotEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.snapshot !== void 0) {
      Value.encode(Value.wrap(message.snapshot), writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStateSnapshotEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.snapshot = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return StateSnapshotEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseStateSnapshotEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.snapshot = (_a = object.snapshot) != null ? _a : void 0;
    return message;
  }
};
function createBaseStateDeltaEvent() {
  return { baseEvent: void 0, delta: [] };
}
var StateDeltaEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    for (const v of message.delta) {
      JsonPatchOperation.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStateDeltaEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.delta.push(JsonPatchOperation.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return StateDeltaEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseStateDeltaEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.delta = ((_a = object.delta) == null ? void 0 : _a.map((e) => JsonPatchOperation.fromPartial(e))) || [];
    return message;
  }
};
function createBaseMessagesSnapshotEvent() {
  return { baseEvent: void 0, messages: [] };
}
var MessagesSnapshotEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    for (const v of message.messages) {
      Message.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseMessagesSnapshotEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.messages.push(Message.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return MessagesSnapshotEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseMessagesSnapshotEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.messages = ((_a = object.messages) == null ? void 0 : _a.map((e) => Message.fromPartial(e))) || [];
    return message;
  }
};
function createBaseRawEvent() {
  return { baseEvent: void 0, event: void 0, source: void 0 };
}
var RawEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.event !== void 0) {
      Value.encode(Value.wrap(message.event), writer.uint32(18).fork()).join();
    }
    if (message.source !== void 0) {
      writer.uint32(26).string(message.source);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRawEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.event = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.source = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return RawEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseRawEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.event = (_a = object.event) != null ? _a : void 0;
    message.source = (_b = object.source) != null ? _b : void 0;
    return message;
  }
};
function createBaseCustomEvent() {
  return { baseEvent: void 0, name: "", value: void 0 };
}
var CustomEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.name !== "") {
      writer.uint32(18).string(message.name);
    }
    if (message.value !== void 0) {
      Value.encode(Value.wrap(message.value), writer.uint32(26).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseCustomEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.name = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return CustomEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseCustomEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.name = (_a = object.name) != null ? _a : "";
    message.value = (_b = object.value) != null ? _b : void 0;
    return message;
  }
};
function createBaseRunStartedEvent() {
  return { baseEvent: void 0, threadId: "", runId: "" };
}
var RunStartedEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.threadId !== "") {
      writer.uint32(18).string(message.threadId);
    }
    if (message.runId !== "") {
      writer.uint32(26).string(message.runId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRunStartedEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.threadId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.runId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return RunStartedEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseRunStartedEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.threadId = (_a = object.threadId) != null ? _a : "";
    message.runId = (_b = object.runId) != null ? _b : "";
    return message;
  }
};
function createBaseRunFinishedEvent() {
  return { baseEvent: void 0, threadId: "", runId: "", result: void 0 };
}
var RunFinishedEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.threadId !== "") {
      writer.uint32(18).string(message.threadId);
    }
    if (message.runId !== "") {
      writer.uint32(26).string(message.runId);
    }
    if (message.result !== void 0) {
      Value.encode(Value.wrap(message.result), writer.uint32(34).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRunFinishedEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.threadId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.runId = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.result = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return RunFinishedEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c;
    const message = createBaseRunFinishedEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.threadId = (_a = object.threadId) != null ? _a : "";
    message.runId = (_b = object.runId) != null ? _b : "";
    message.result = (_c = object.result) != null ? _c : void 0;
    return message;
  }
};
function createBaseRunErrorEvent() {
  return { baseEvent: void 0, code: void 0, message: "" };
}
var RunErrorEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.code !== void 0) {
      writer.uint32(18).string(message.code);
    }
    if (message.message !== "") {
      writer.uint32(26).string(message.message);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRunErrorEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.code = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.message = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return RunErrorEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseRunErrorEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.code = (_a = object.code) != null ? _a : void 0;
    message.message = (_b = object.message) != null ? _b : "";
    return message;
  }
};
function createBaseStepStartedEvent() {
  return { baseEvent: void 0, stepName: "" };
}
var StepStartedEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.stepName !== "") {
      writer.uint32(18).string(message.stepName);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStepStartedEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.stepName = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return StepStartedEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseStepStartedEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.stepName = (_a = object.stepName) != null ? _a : "";
    return message;
  }
};
function createBaseStepFinishedEvent() {
  return { baseEvent: void 0, stepName: "" };
}
var StepFinishedEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.stepName !== "") {
      writer.uint32(18).string(message.stepName);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStepFinishedEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.stepName = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return StepFinishedEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseStepFinishedEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.stepName = (_a = object.stepName) != null ? _a : "";
    return message;
  }
};
function createBaseTextMessageChunkEvent() {
  return { baseEvent: void 0, messageId: void 0, role: void 0, delta: void 0 };
}
var TextMessageChunkEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.messageId !== void 0) {
      writer.uint32(18).string(message.messageId);
    }
    if (message.role !== void 0) {
      writer.uint32(26).string(message.role);
    }
    if (message.delta !== void 0) {
      writer.uint32(34).string(message.delta);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTextMessageChunkEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.messageId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.role = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.delta = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return TextMessageChunkEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c;
    const message = createBaseTextMessageChunkEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.messageId = (_a = object.messageId) != null ? _a : void 0;
    message.role = (_b = object.role) != null ? _b : void 0;
    message.delta = (_c = object.delta) != null ? _c : void 0;
    return message;
  }
};
function createBaseToolCallChunkEvent() {
  return {
    baseEvent: void 0,
    toolCallId: void 0,
    toolCallName: void 0,
    parentMessageId: void 0,
    delta: void 0
  };
}
var ToolCallChunkEvent = {
  encode(message, writer = new BinaryWriter()) {
    if (message.baseEvent !== void 0) {
      BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
    }
    if (message.toolCallId !== void 0) {
      writer.uint32(18).string(message.toolCallId);
    }
    if (message.toolCallName !== void 0) {
      writer.uint32(26).string(message.toolCallName);
    }
    if (message.parentMessageId !== void 0) {
      writer.uint32(34).string(message.parentMessageId);
    }
    if (message.delta !== void 0) {
      writer.uint32(42).string(message.delta);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseToolCallChunkEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.baseEvent = BaseEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.toolCallId = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.toolCallName = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.parentMessageId = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.delta = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return ToolCallChunkEvent.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    var _a, _b, _c, _d;
    const message = createBaseToolCallChunkEvent();
    message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
    message.toolCallId = (_a = object.toolCallId) != null ? _a : void 0;
    message.toolCallName = (_b = object.toolCallName) != null ? _b : void 0;
    message.parentMessageId = (_c = object.parentMessageId) != null ? _c : void 0;
    message.delta = (_d = object.delta) != null ? _d : void 0;
    return message;
  }
};
function createBaseEvent() {
  return {
    textMessageStart: void 0,
    textMessageContent: void 0,
    textMessageEnd: void 0,
    toolCallStart: void 0,
    toolCallArgs: void 0,
    toolCallEnd: void 0,
    stateSnapshot: void 0,
    stateDelta: void 0,
    messagesSnapshot: void 0,
    raw: void 0,
    custom: void 0,
    runStarted: void 0,
    runFinished: void 0,
    runError: void 0,
    stepStarted: void 0,
    stepFinished: void 0,
    textMessageChunk: void 0,
    toolCallChunk: void 0
  };
}
var Event = {
  encode(message, writer = new BinaryWriter()) {
    if (message.textMessageStart !== void 0) {
      TextMessageStartEvent.encode(message.textMessageStart, writer.uint32(10).fork()).join();
    }
    if (message.textMessageContent !== void 0) {
      TextMessageContentEvent.encode(message.textMessageContent, writer.uint32(18).fork()).join();
    }
    if (message.textMessageEnd !== void 0) {
      TextMessageEndEvent.encode(message.textMessageEnd, writer.uint32(26).fork()).join();
    }
    if (message.toolCallStart !== void 0) {
      ToolCallStartEvent.encode(message.toolCallStart, writer.uint32(34).fork()).join();
    }
    if (message.toolCallArgs !== void 0) {
      ToolCallArgsEvent.encode(message.toolCallArgs, writer.uint32(42).fork()).join();
    }
    if (message.toolCallEnd !== void 0) {
      ToolCallEndEvent.encode(message.toolCallEnd, writer.uint32(50).fork()).join();
    }
    if (message.stateSnapshot !== void 0) {
      StateSnapshotEvent.encode(message.stateSnapshot, writer.uint32(58).fork()).join();
    }
    if (message.stateDelta !== void 0) {
      StateDeltaEvent.encode(message.stateDelta, writer.uint32(66).fork()).join();
    }
    if (message.messagesSnapshot !== void 0) {
      MessagesSnapshotEvent.encode(message.messagesSnapshot, writer.uint32(74).fork()).join();
    }
    if (message.raw !== void 0) {
      RawEvent.encode(message.raw, writer.uint32(82).fork()).join();
    }
    if (message.custom !== void 0) {
      CustomEvent.encode(message.custom, writer.uint32(90).fork()).join();
    }
    if (message.runStarted !== void 0) {
      RunStartedEvent.encode(message.runStarted, writer.uint32(98).fork()).join();
    }
    if (message.runFinished !== void 0) {
      RunFinishedEvent.encode(message.runFinished, writer.uint32(106).fork()).join();
    }
    if (message.runError !== void 0) {
      RunErrorEvent.encode(message.runError, writer.uint32(114).fork()).join();
    }
    if (message.stepStarted !== void 0) {
      StepStartedEvent.encode(message.stepStarted, writer.uint32(122).fork()).join();
    }
    if (message.stepFinished !== void 0) {
      StepFinishedEvent.encode(message.stepFinished, writer.uint32(130).fork()).join();
    }
    if (message.textMessageChunk !== void 0) {
      TextMessageChunkEvent.encode(message.textMessageChunk, writer.uint32(138).fork()).join();
    }
    if (message.toolCallChunk !== void 0) {
      ToolCallChunkEvent.encode(message.toolCallChunk, writer.uint32(146).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseEvent();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.textMessageStart = TextMessageStartEvent.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.textMessageContent = TextMessageContentEvent.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.textMessageEnd = TextMessageEndEvent.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.toolCallStart = ToolCallStartEvent.decode(reader, reader.uint32());
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.toolCallArgs = ToolCallArgsEvent.decode(reader, reader.uint32());
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }
          message.toolCallEnd = ToolCallEndEvent.decode(reader, reader.uint32());
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }
          message.stateSnapshot = StateSnapshotEvent.decode(reader, reader.uint32());
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }
          message.stateDelta = StateDeltaEvent.decode(reader, reader.uint32());
          continue;
        }
        case 9: {
          if (tag !== 74) {
            break;
          }
          message.messagesSnapshot = MessagesSnapshotEvent.decode(reader, reader.uint32());
          continue;
        }
        case 10: {
          if (tag !== 82) {
            break;
          }
          message.raw = RawEvent.decode(reader, reader.uint32());
          continue;
        }
        case 11: {
          if (tag !== 90) {
            break;
          }
          message.custom = CustomEvent.decode(reader, reader.uint32());
          continue;
        }
        case 12: {
          if (tag !== 98) {
            break;
          }
          message.runStarted = RunStartedEvent.decode(reader, reader.uint32());
          continue;
        }
        case 13: {
          if (tag !== 106) {
            break;
          }
          message.runFinished = RunFinishedEvent.decode(reader, reader.uint32());
          continue;
        }
        case 14: {
          if (tag !== 114) {
            break;
          }
          message.runError = RunErrorEvent.decode(reader, reader.uint32());
          continue;
        }
        case 15: {
          if (tag !== 122) {
            break;
          }
          message.stepStarted = StepStartedEvent.decode(reader, reader.uint32());
          continue;
        }
        case 16: {
          if (tag !== 130) {
            break;
          }
          message.stepFinished = StepFinishedEvent.decode(reader, reader.uint32());
          continue;
        }
        case 17: {
          if (tag !== 138) {
            break;
          }
          message.textMessageChunk = TextMessageChunkEvent.decode(reader, reader.uint32());
          continue;
        }
        case 18: {
          if (tag !== 146) {
            break;
          }
          message.toolCallChunk = ToolCallChunkEvent.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  create(base) {
    return Event.fromPartial(base != null ? base : {});
  },
  fromPartial(object) {
    const message = createBaseEvent();
    message.textMessageStart = object.textMessageStart !== void 0 && object.textMessageStart !== null ? TextMessageStartEvent.fromPartial(object.textMessageStart) : void 0;
    message.textMessageContent = object.textMessageContent !== void 0 && object.textMessageContent !== null ? TextMessageContentEvent.fromPartial(object.textMessageContent) : void 0;
    message.textMessageEnd = object.textMessageEnd !== void 0 && object.textMessageEnd !== null ? TextMessageEndEvent.fromPartial(object.textMessageEnd) : void 0;
    message.toolCallStart = object.toolCallStart !== void 0 && object.toolCallStart !== null ? ToolCallStartEvent.fromPartial(object.toolCallStart) : void 0;
    message.toolCallArgs = object.toolCallArgs !== void 0 && object.toolCallArgs !== null ? ToolCallArgsEvent.fromPartial(object.toolCallArgs) : void 0;
    message.toolCallEnd = object.toolCallEnd !== void 0 && object.toolCallEnd !== null ? ToolCallEndEvent.fromPartial(object.toolCallEnd) : void 0;
    message.stateSnapshot = object.stateSnapshot !== void 0 && object.stateSnapshot !== null ? StateSnapshotEvent.fromPartial(object.stateSnapshot) : void 0;
    message.stateDelta = object.stateDelta !== void 0 && object.stateDelta !== null ? StateDeltaEvent.fromPartial(object.stateDelta) : void 0;
    message.messagesSnapshot = object.messagesSnapshot !== void 0 && object.messagesSnapshot !== null ? MessagesSnapshotEvent.fromPartial(object.messagesSnapshot) : void 0;
    message.raw = object.raw !== void 0 && object.raw !== null ? RawEvent.fromPartial(object.raw) : void 0;
    message.custom = object.custom !== void 0 && object.custom !== null ? CustomEvent.fromPartial(object.custom) : void 0;
    message.runStarted = object.runStarted !== void 0 && object.runStarted !== null ? RunStartedEvent.fromPartial(object.runStarted) : void 0;
    message.runFinished = object.runFinished !== void 0 && object.runFinished !== null ? RunFinishedEvent.fromPartial(object.runFinished) : void 0;
    message.runError = object.runError !== void 0 && object.runError !== null ? RunErrorEvent.fromPartial(object.runError) : void 0;
    message.stepStarted = object.stepStarted !== void 0 && object.stepStarted !== null ? StepStartedEvent.fromPartial(object.stepStarted) : void 0;
    message.stepFinished = object.stepFinished !== void 0 && object.stepFinished !== null ? StepFinishedEvent.fromPartial(object.stepFinished) : void 0;
    message.textMessageChunk = object.textMessageChunk !== void 0 && object.textMessageChunk !== null ? TextMessageChunkEvent.fromPartial(object.textMessageChunk) : void 0;
    message.toolCallChunk = object.toolCallChunk !== void 0 && object.toolCallChunk !== null ? ToolCallChunkEvent.fromPartial(object.toolCallChunk) : void 0;
    return message;
  }
};
function longToNumber(int64) {
  const num = globalThis.Number(int64.toString());
  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
  }
  return num;
}
function decode(data) {
  var _a;
  const event = Event.decode(data);
  const decoded = Object.values(event).find((value) => value !== void 0);
  if (!decoded) {
    throw new Error("Invalid event");
  }
  decoded.type = EventType2[decoded.baseEvent.type];
  decoded.timestamp = decoded.baseEvent.timestamp;
  decoded.rawEvent = decoded.baseEvent.rawEvent;
  if (decoded.type === EventType.MESSAGES_SNAPSHOT) {
    for (const message of decoded.messages) {
      const untypedMessage = message;
      if (((_a = untypedMessage.toolCalls) == null ? void 0 : _a.length) === 0) {
        untypedMessage.toolCalls = void 0;
      }
    }
  }
  if (decoded.type === EventType.STATE_DELTA) {
    for (const operation of decoded.delta) {
      operation.op = JsonPatchOperationType[operation.op].toLowerCase();
      Object.keys(operation).forEach((key) => {
        if (operation[key] === void 0) {
          delete operation[key];
        }
      });
    }
  }
  Object.keys(decoded).forEach((key) => {
    if (decoded[key] === void 0) {
      delete decoded[key];
    }
  });
  return EventSchemas.parse(decoded);
}
var AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";

// node_modules/compare-versions/lib/esm/utils.js
var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
var validateAndParse = (version) => {
  if (typeof version !== "string") {
    throw new TypeError("Invalid argument expected string");
  }
  const match = version.match(semver);
  if (!match) {
    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
  }
  match.shift();
  return match;
};
var isWildcard = (s) => s === "*" || s === "x" || s === "X";
var tryParse = (v) => {
  const n = parseInt(v, 10);
  return isNaN(n) ? v : n;
};
var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
var compareStrings = (a, b) => {
  if (isWildcard(a) || isWildcard(b))
    return 0;
  const [ap, bp] = forceType(tryParse(a), tryParse(b));
  if (ap > bp)
    return 1;
  if (ap < bp)
    return -1;
  return 0;
};
var compareSegments = (a, b) => {
  for (let i = 0; i < Math.max(a.length, b.length); i++) {
    const r = compareStrings(a[i] || "0", b[i] || "0");
    if (r !== 0)
      return r;
  }
  return 0;
};

// node_modules/compare-versions/lib/esm/compareVersions.js
var compareVersions = (v1, v2) => {
  const n1 = validateAndParse(v1);
  const n2 = validateAndParse(v2);
  const p1 = n1.pop();
  const p2 = n2.pop();
  const r = compareSegments(n1, n2);
  if (r !== 0)
    return r;
  if (p1 && p2) {
    return compareSegments(p1.split("."), p2.split("."));
  } else if (p1 || p2) {
    return p1 ? -1 : 1;
  }
  return 0;
};

// node_modules/compare-versions/lib/esm/compare.js
var operatorResMap = {
  ">": [1],
  ">=": [0, 1],
  "=": [0],
  "<=": [-1, 0],
  "<": [-1],
  "!=": [-1, 1]
};
var allowedOperators = Object.keys(operatorResMap);

// node_modules/@ag-ui/client/dist/index.mjs
var xt = Object.defineProperty;
var _t = Object.defineProperties;
var Nt = Object.getOwnPropertyDescriptors;
var Y = Object.getOwnPropertySymbols;
var it = Object.prototype.hasOwnProperty;
var lt = Object.prototype.propertyIsEnumerable;
var rt = (l, a, e) => a in l ? xt(l, a, { enumerable: true, configurable: true, writable: true, value: e }) : l[a] = e;
var N = (l, a) => {
  for (var e in a || (a = {})) it.call(a, e) && rt(l, e, a[e]);
  if (Y) for (var e of Y(a)) lt.call(a, e) && rt(l, e, a[e]);
  return l;
};
var G = (l, a) => _t(l, Nt(a));
var gt = (l, a) => {
  var e = {};
  for (var n in l) it.call(l, n) && a.indexOf(n) < 0 && (e[n] = l[n]);
  if (l != null && Y) for (var n of Y(l)) a.indexOf(n) < 0 && lt.call(l, n) && (e[n] = l[n]);
  return e;
};
var y = (l) => {
  if (typeof structuredClone == "function") return structuredClone(l);
  try {
    return JSON.parse(JSON.stringify(l));
  } catch (a) {
    return N({}, l);
  }
};
function Re() {
  return v4_default();
}
async function x(l, a, e, n) {
  let t = a, s = e, r;
  for (let o of l) try {
    let i = await n(o, y(t), y(s));
    if (i === void 0) continue;
    if (i.messages !== void 0 && (t = i.messages), i.state !== void 0 && (s = i.state), r = i.stopPropagation, r === true) break;
  } catch (i) {
    process.env.JEST_WORKER_ID !== void 0 || console.error("Subscriber error:", i);
    continue;
  }
  return N(N(N({}, JSON.stringify(t) !== JSON.stringify(a) ? { messages: t } : {}), JSON.stringify(s) !== JSON.stringify(e) ? { state: s } : {}), r !== void 0 ? { stopPropagation: r } : {});
}
var $ = (l, a, e, n) => {
  let t = y(e.messages), s = y(l.state), r = {}, o = (d) => {
    d.messages !== void 0 && (t = d.messages, r.messages = d.messages), d.state !== void 0 && (s = d.state, r.state = d.state);
  }, i = () => {
    let d = y(r);
    return r = {}, d.messages !== void 0 || d.state !== void 0 ? of(d) : EMPTY;
  };
  return a.pipe(concatMap(async (d) => {
    var T, v, c, b, U;
    let I = await x(n, t, s, (E, g, p) => {
      var m;
      return (m = E.onEvent) == null ? void 0 : m.call(E, { event: d, agent: e, input: l, messages: g, state: p });
    });
    if (o(I), I.stopPropagation === true) return i();
    switch (d.type) {
      case EventType.TEXT_MESSAGE_START: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onTextMessageStartEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { messageId: g, role: p = "assistant" } = d, m = { id: g, role: p, content: "" };
          t.push(m), o({ messages: t });
        }
        return i();
      }
      case EventType.TEXT_MESSAGE_CONTENT: {
        let { messageId: E, delta: g } = d, p = t.find((u) => u.id === E);
        if (!p) return console.warn(`TEXT_MESSAGE_CONTENT: No message found with ID '${E}'`), i();
        let m = await x(n, t, s, (u, A, h) => {
          var _;
          return (_ = u.onTextMessageContentEvent) == null ? void 0 : _.call(u, { event: d, messages: A, state: h, agent: e, input: l, textMessageBuffer: typeof p.content == "string" ? p.content : "" });
        });
        if (o(m), m.stopPropagation !== true) {
          let u = typeof p.content == "string" ? p.content : "";
          p.content = `${u}${g}`, o({ messages: t });
        }
        return i();
      }
      case EventType.TEXT_MESSAGE_END: {
        let { messageId: E } = d, g = t.find((m) => m.id === E);
        if (!g) return console.warn(`TEXT_MESSAGE_END: No message found with ID '${E}'`), i();
        let p = await x(n, t, s, (m, u, A) => {
          var h;
          return (h = m.onTextMessageEndEvent) == null ? void 0 : h.call(m, { event: d, messages: u, state: A, agent: e, input: l, textMessageBuffer: typeof g.content == "string" ? g.content : "" });
        });
        return o(p), await Promise.all(n.map((m) => {
          var u;
          (u = m.onNewMessage) == null || u.call(m, { message: g, messages: t, state: s, agent: e, input: l });
        })), i();
      }
      case EventType.TOOL_CALL_START: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onToolCallStartEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { toolCallId: g, toolCallName: p, parentMessageId: m } = d, u;
          m && t.length > 0 && t[t.length - 1].id === m ? u = t[t.length - 1] : (u = { id: m || g, role: "assistant", toolCalls: [] }, t.push(u)), (T = u.toolCalls) != null || (u.toolCalls = []), u.toolCalls.push({ id: g, type: "function", function: { name: p, arguments: "" } }), o({ messages: t });
        }
        return i();
      }
      case EventType.TOOL_CALL_ARGS: {
        let { toolCallId: E, delta: g } = d, p = t.find((A) => {
          var h;
          return (h = A.toolCalls) == null ? void 0 : h.some((_) => _.id === E);
        });
        if (!p) return console.warn(`TOOL_CALL_ARGS: No message found containing tool call with ID '${E}'`), i();
        let m = p.toolCalls.find((A) => A.id === E);
        if (!m) return console.warn(`TOOL_CALL_ARGS: No tool call found with ID '${E}'`), i();
        let u = await x(n, t, s, (A, h, _) => {
          var Z;
          let H = m.function.arguments, F = m.function.name, X = {};
          try {
            X = untruncateJson(H);
          } catch (ye) {
          }
          return (Z = A.onToolCallArgsEvent) == null ? void 0 : Z.call(A, { event: d, messages: h, state: _, agent: e, input: l, toolCallBuffer: H, toolCallName: F, partialToolCallArgs: X });
        });
        return o(u), u.stopPropagation !== true && (m.function.arguments += g, o({ messages: t })), i();
      }
      case EventType.TOOL_CALL_END: {
        let { toolCallId: E } = d, g = t.find((u) => {
          var A;
          return (A = u.toolCalls) == null ? void 0 : A.some((h) => h.id === E);
        });
        if (!g) return console.warn(`TOOL_CALL_END: No message found containing tool call with ID '${E}'`), i();
        let p = g.toolCalls.find((u) => u.id === E);
        if (!p) return console.warn(`TOOL_CALL_END: No tool call found with ID '${E}'`), i();
        let m = await x(n, t, s, (u, A, h) => {
          var X;
          let _ = p.function.arguments, H = p.function.name, F = {};
          try {
            F = JSON.parse(_);
          } catch (Z) {
          }
          return (X = u.onToolCallEndEvent) == null ? void 0 : X.call(u, { event: d, messages: A, state: h, agent: e, input: l, toolCallName: H, toolCallArgs: F });
        });
        return o(m), await Promise.all(n.map((u) => {
          var A;
          (A = u.onNewToolCall) == null || A.call(u, { toolCall: p, messages: t, state: s, agent: e, input: l });
        })), i();
      }
      case EventType.TOOL_CALL_RESULT: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onToolCallResultEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { messageId: g, toolCallId: p, content: m, role: u } = d, A = { id: g, toolCallId: p, role: u || "tool", content: m };
          t.push(A), await Promise.all(n.map((h) => {
            var _;
            (_ = h.onNewMessage) == null || _.call(h, { message: A, messages: t, state: s, agent: e, input: l });
          })), o({ messages: t });
        }
        return i();
      }
      case EventType.STATE_SNAPSHOT: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onStateSnapshotEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { snapshot: g } = d;
          s = g, o({ state: s });
        }
        return i();
      }
      case EventType.STATE_DELTA: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onStateDeltaEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { delta: g } = d;
          try {
            s = applyPatch(s, g, true, false).newDocument, o({ state: s });
          } catch (p) {
            let m = p instanceof Error ? p.message : String(p);
            console.warn(`Failed to apply state patch:
Current state: ${JSON.stringify(s, null, 2)}
Patch operations: ${JSON.stringify(g, null, 2)}
Error: ${m}`);
          }
        }
        return i();
      }
      case EventType.MESSAGES_SNAPSHOT: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onMessagesSnapshotEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let { messages: g } = d;
          t = g, o({ messages: t });
        }
        return i();
      }
      case EventType.ACTIVITY_SNAPSHOT: {
        let E = d, g = t.findIndex((h) => h.id === E.messageId), p = g >= 0 ? t[g] : void 0, m = (p == null ? void 0 : p.role) === "activity" ? p : void 0, u = (v = E.replace) != null ? v : true, A = await x(n, t, s, (h, _, H) => {
          var F;
          return (F = h.onActivitySnapshotEvent) == null ? void 0 : F.call(h, { event: E, messages: _, state: H, agent: e, input: l, activityMessage: m, existingMessage: p });
        });
        if (o(A), A.stopPropagation !== true) {
          let h = { id: E.messageId, role: "activity", activityType: E.activityType, content: y(E.content) }, _;
          g === -1 ? (t.push(h), _ = h) : m ? u && (t[g] = G(N({}, m), { activityType: E.activityType, content: y(E.content) })) : u && (t[g] = h, _ = h), o({ messages: t }), _ && await Promise.all(n.map((H) => {
            var F;
            return (F = H.onNewMessage) == null ? void 0 : F.call(H, { message: _, messages: t, state: s, agent: e, input: l });
          }));
        }
        return i();
      }
      case EventType.ACTIVITY_DELTA: {
        let E = d, g = t.findIndex((A) => A.id === E.messageId);
        if (g === -1) return console.warn(`ACTIVITY_DELTA: No message found with ID '${E.messageId}' to apply patch`), i();
        let p = t[g];
        if (p.role !== "activity") return console.warn(`ACTIVITY_DELTA: Message '${E.messageId}' is not an activity message`), i();
        let m = p, u = await x(n, t, s, (A, h, _) => {
          var H;
          return (H = A.onActivityDeltaEvent) == null ? void 0 : H.call(A, { event: E, messages: h, state: _, agent: e, input: l, activityMessage: m });
        });
        if (o(u), u.stopPropagation !== true) try {
          let A = y((c = m.content) != null ? c : {}), _ = applyPatch(A, (b = E.patch) != null ? b : [], true, false).newDocument;
          t[g] = G(N({}, m), { content: y(_), activityType: E.activityType }), o({ messages: t });
        } catch (A) {
          let h = A instanceof Error ? A.message : String(A);
          console.warn(`Failed to apply activity patch for '${E.messageId}': ${h}`);
        }
        return i();
      }
      case EventType.RAW: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onRawEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        return o(E), i();
      }
      case EventType.CUSTOM: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onCustomEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        return o(E), i();
      }
      case EventType.RUN_STARTED: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onRunStartedEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        if (o(E), E.stopPropagation !== true) {
          let g = d;
          if ((U = g.input) != null && U.messages) {
            for (let p of g.input.messages) t.find((u) => u.id === p.id) || t.push(p);
            o({ messages: t });
          }
        }
        return i();
      }
      case EventType.RUN_FINISHED: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onRunFinishedEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l, result: d.result });
        });
        return o(E), i();
      }
      case EventType.RUN_ERROR: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onRunErrorEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        return o(E), i();
      }
      case EventType.STEP_STARTED: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onStepStartedEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        return o(E), i();
      }
      case EventType.STEP_FINISHED: {
        let E = await x(n, t, s, (g, p, m) => {
          var u;
          return (u = g.onStepFinishedEvent) == null ? void 0 : u.call(g, { event: d, messages: p, state: m, agent: e, input: l });
        });
        return o(E), i();
      }
      case EventType.TEXT_MESSAGE_CHUNK:
        throw new Error("TEXT_MESSAGE_CHUNK must be tranformed before being applied");
      case EventType.TOOL_CALL_CHUNK:
        throw new Error("TOOL_CALL_CHUNK must be tranformed before being applied");
      case EventType.THINKING_START:
        return i();
      case EventType.THINKING_END:
        return i();
      case EventType.THINKING_TEXT_MESSAGE_START:
        return i();
      case EventType.THINKING_TEXT_MESSAGE_CONTENT:
        return i();
      case EventType.THINKING_TEXT_MESSAGE_END:
        return i();
    }
    let S = d.type;
    return i();
  }), mergeAll(), n.length > 0 ? defaultIfEmpty({}) : (d) => d);
};
var z = (l) => (a) => {
  let e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), t = false, s = false, r = false, o = /* @__PURE__ */ new Map(), i = false, d = false, I = false, S = () => {
    e.clear(), n.clear(), o.clear(), i = false, d = false, t = false, s = false, I = true;
  };
  return a.pipe(mergeMap((T) => {
    let v = T.type;
    if (l && console.debug("[VERIFY]:", JSON.stringify(T)), s) return throwError(() => new AGUIError(`Cannot send event type '${v}': The run has already errored with 'RUN_ERROR'. No further events can be sent.`));
    if (t && v !== EventType.RUN_ERROR && v !== EventType.RUN_STARTED) return throwError(() => new AGUIError(`Cannot send event type '${v}': The run has already finished with 'RUN_FINISHED'. Start a new run with 'RUN_STARTED'.`));
    if (r) {
      if (v === EventType.RUN_STARTED) {
        if (I && !t) return throwError(() => new AGUIError("Cannot send 'RUN_STARTED' while a run is still active. The previous run must be finished with 'RUN_FINISHED' before starting a new run."));
        t && S();
      }
    } else if (r = true, v !== EventType.RUN_STARTED && v !== EventType.RUN_ERROR) return throwError(() => new AGUIError("First event must be 'RUN_STARTED'"));
    switch (v) {
      case EventType.TEXT_MESSAGE_START: {
        let c = T.messageId;
        return e.has(c) ? throwError(() => new AGUIError(`Cannot send 'TEXT_MESSAGE_START' event: A text message with ID '${c}' is already in progress. Complete it with 'TEXT_MESSAGE_END' first.`)) : (e.set(c, true), of(T));
      }
      case EventType.TEXT_MESSAGE_CONTENT: {
        let c = T.messageId;
        return e.has(c) ? of(T) : throwError(() => new AGUIError(`Cannot send 'TEXT_MESSAGE_CONTENT' event: No active text message found with ID '${c}'. Start a text message with 'TEXT_MESSAGE_START' first.`));
      }
      case EventType.TEXT_MESSAGE_END: {
        let c = T.messageId;
        return e.has(c) ? (e.delete(c), of(T)) : throwError(() => new AGUIError(`Cannot send 'TEXT_MESSAGE_END' event: No active text message found with ID '${c}'. A 'TEXT_MESSAGE_START' event must be sent first.`));
      }
      case EventType.TOOL_CALL_START: {
        let c = T.toolCallId;
        return n.has(c) ? throwError(() => new AGUIError(`Cannot send 'TOOL_CALL_START' event: A tool call with ID '${c}' is already in progress. Complete it with 'TOOL_CALL_END' first.`)) : (n.set(c, true), of(T));
      }
      case EventType.TOOL_CALL_ARGS: {
        let c = T.toolCallId;
        return n.has(c) ? of(T) : throwError(() => new AGUIError(`Cannot send 'TOOL_CALL_ARGS' event: No active tool call found with ID '${c}'. Start a tool call with 'TOOL_CALL_START' first.`));
      }
      case EventType.TOOL_CALL_END: {
        let c = T.toolCallId;
        return n.has(c) ? (n.delete(c), of(T)) : throwError(() => new AGUIError(`Cannot send 'TOOL_CALL_END' event: No active tool call found with ID '${c}'. A 'TOOL_CALL_START' event must be sent first.`));
      }
      case EventType.STEP_STARTED: {
        let c = T.stepName;
        return o.has(c) ? throwError(() => new AGUIError(`Step "${c}" is already active for 'STEP_STARTED'`)) : (o.set(c, true), of(T));
      }
      case EventType.STEP_FINISHED: {
        let c = T.stepName;
        return o.has(c) ? (o.delete(c), of(T)) : throwError(() => new AGUIError(`Cannot send 'STEP_FINISHED' for step "${c}" that was not started`));
      }
      case EventType.RUN_STARTED:
        return I = true, of(T);
      case EventType.RUN_FINISHED: {
        if (o.size > 0) {
          let c = Array.from(o.keys()).join(", ");
          return throwError(() => new AGUIError(`Cannot send 'RUN_FINISHED' while steps are still active: ${c}`));
        }
        if (e.size > 0) {
          let c = Array.from(e.keys()).join(", ");
          return throwError(() => new AGUIError(`Cannot send 'RUN_FINISHED' while text messages are still active: ${c}`));
        }
        if (n.size > 0) {
          let c = Array.from(n.keys()).join(", ");
          return throwError(() => new AGUIError(`Cannot send 'RUN_FINISHED' while tool calls are still active: ${c}`));
        }
        return t = true, of(T);
      }
      case EventType.RUN_ERROR:
        return s = true, of(T);
      case EventType.CUSTOM:
        return of(T);
      case EventType.THINKING_TEXT_MESSAGE_START:
        return i ? d ? throwError(() => new AGUIError("Cannot send 'THINKING_TEXT_MESSAGE_START' event: A thinking message is already in progress. Complete it with 'THINKING_TEXT_MESSAGE_END' first.")) : (d = true, of(T)) : throwError(() => new AGUIError("Cannot send 'THINKING_TEXT_MESSAGE_START' event: A thinking step is not in progress. Create one with 'THINKING_START' first."));
      case EventType.THINKING_TEXT_MESSAGE_CONTENT:
        return d ? of(T) : throwError(() => new AGUIError("Cannot send 'THINKING_TEXT_MESSAGE_CONTENT' event: No active thinking message found. Start a message with 'THINKING_TEXT_MESSAGE_START' first."));
      case EventType.THINKING_TEXT_MESSAGE_END:
        return d ? (d = false, of(T)) : throwError(() => new AGUIError("Cannot send 'THINKING_TEXT_MESSAGE_END' event: No active thinking message found. A 'THINKING_TEXT_MESSAGE_START' event must be sent first."));
      case EventType.THINKING_START:
        return i ? throwError(() => new AGUIError("Cannot send 'THINKING_START' event: A thinking step is already in progress. End it with 'THINKING_END' first.")) : (i = true, of(T));
      case EventType.THINKING_END:
        return i ? (i = false, of(T)) : throwError(() => new AGUIError("Cannot send 'THINKING_END' event: No active thinking step found. A 'THINKING_START' event must be sent first."));
      default:
        return of(T);
    }
  }));
};
var tt = (l, a) => defer(() => from(fetch(l, a))).pipe(switchMap((e) => {
  var s;
  if (!e.ok) {
    let r = e.headers.get("content-type") || "";
    return from(e.text()).pipe(mergeMap((o) => {
      let i = o;
      if (r.includes("application/json")) try {
        i = JSON.parse(o);
      } catch (I) {
      }
      let d = new Error(`HTTP ${e.status}: ${typeof i == "string" ? i : JSON.stringify(i)}`);
      return d.status = e.status, d.payload = i, throwError(() => d);
    }));
  }
  let n = { type: "headers", status: e.status, headers: e.headers }, t = (s = e.body) == null ? void 0 : s.getReader();
  return t ? new Observable((r) => (r.next(n), (async () => {
    try {
      for (; ; ) {
        let { done: o, value: i } = await t.read();
        if (o) break;
        let d = { type: "data", data: i };
        r.next(d);
      }
      r.complete();
    } catch (o) {
      r.error(o);
    }
  })(), () => {
    t.cancel().catch((o) => {
      if ((o == null ? void 0 : o.name) !== "AbortError") throw o;
    });
  })) : throwError(() => new Error("Failed to getReader() from response"));
}));
var et = (l) => {
  let a = new Subject(), e = new TextDecoder("utf-8", { fatal: false }), n = "";
  l.subscribe({ next: (s) => {
    if (s.type !== "headers" && s.type === "data" && s.data) {
      let r = e.decode(s.data, { stream: true });
      n += r;
      let o = n.split(/\n\n/);
      n = o.pop() || "";
      for (let i of o) t(i);
    }
  }, error: (s) => a.error(s), complete: () => {
    n && (n += e.decode(), t(n)), a.complete();
  } });
  function t(s) {
    let r = s.split(`
`), o = [];
    for (let i of r) i.startsWith("data: ") && o.push(i.slice(6));
    if (o.length > 0) try {
      let i = o.join(`
`), d = JSON.parse(i);
      a.next(d);
    } catch (i) {
      a.error(i);
    }
  }
  return a.asObservable();
};
var nt = (l) => {
  let a = new Subject(), e = new Uint8Array(0);
  l.subscribe({ next: (t) => {
    if (t.type !== "headers" && t.type === "data" && t.data) {
      let s = new Uint8Array(e.length + t.data.length);
      s.set(e, 0), s.set(t.data, e.length), e = s, n();
    }
  }, error: (t) => a.error(t), complete: () => {
    if (e.length > 0) try {
      n();
    } catch (t) {
      console.warn("Incomplete or invalid protocol buffer data at stream end");
    }
    a.complete();
  } });
  function n() {
    for (; e.length >= 4; ) {
      let r = 4 + new DataView(e.buffer, e.byteOffset, 4).getUint32(0, false);
      if (e.length < r) break;
      try {
        let o = e.slice(4, r), i = decode(o);
        a.next(i), e = e.slice(r);
      } catch (o) {
        let i = o instanceof Error ? o.message : String(o);
        a.error(new Error(`Failed to decode protocol buffer message: ${i}`));
        return;
      }
    }
  }
  return a.asObservable();
};
var st = (l) => {
  let a = new Subject(), e = new ReplaySubject(), n = false;
  return l.subscribe({ next: (t) => {
    e.next(t), t.type === "headers" && !n ? (n = true, t.headers.get("content-type") === AGUI_MEDIA_TYPE ? nt(e).subscribe({ next: (r) => a.next(r), error: (r) => a.error(r), complete: () => a.complete() }) : et(e).subscribe({ next: (r) => {
      try {
        let o = EventSchemas.parse(r);
        a.next(o);
      } catch (o) {
        a.error(o);
      }
    }, error: (r) => {
      if ((r == null ? void 0 : r.name) === "AbortError") {
        a.next({ type: EventType.RUN_ERROR, rawEvent: r }), a.complete();
        return;
      }
      return a.error(r);
    }, complete: () => a.complete() })) : n || a.error(new Error("No headers event received before data events"));
  }, error: (t) => {
    e.error(t), a.error(t);
  }, complete: () => {
    e.complete();
  } }), a.asObservable();
};
var C = external_exports.enum(["TextMessageStart", "TextMessageContent", "TextMessageEnd", "ActionExecutionStart", "ActionExecutionArgs", "ActionExecutionEnd", "ActionExecutionResult", "AgentStateMessage", "MetaEvent", "RunStarted", "RunFinished", "RunError", "NodeStarted", "NodeFinished"]);
var Vt = external_exports.enum(["LangGraphInterruptEvent", "PredictState", "Exit"]);
var Wt = external_exports.object({ type: external_exports.literal(C.enum.TextMessageStart), messageId: external_exports.string(), parentMessageId: external_exports.string().optional(), role: external_exports.string().optional() });
var Yt = external_exports.object({ type: external_exports.literal(C.enum.TextMessageContent), messageId: external_exports.string(), content: external_exports.string() });
var qt = external_exports.object({ type: external_exports.literal(C.enum.TextMessageEnd), messageId: external_exports.string() });
var Qt = external_exports.object({ type: external_exports.literal(C.enum.ActionExecutionStart), actionExecutionId: external_exports.string(), actionName: external_exports.string(), parentMessageId: external_exports.string().optional() });
var Zt = external_exports.object({ type: external_exports.literal(C.enum.ActionExecutionArgs), actionExecutionId: external_exports.string(), args: external_exports.string() });
var te = external_exports.object({ type: external_exports.literal(C.enum.ActionExecutionEnd), actionExecutionId: external_exports.string() });
var ee = external_exports.object({ type: external_exports.literal(C.enum.ActionExecutionResult), actionName: external_exports.string(), actionExecutionId: external_exports.string(), result: external_exports.string() });
var ne = external_exports.object({ type: external_exports.literal(C.enum.AgentStateMessage), threadId: external_exports.string(), agentName: external_exports.string(), nodeName: external_exports.string(), runId: external_exports.string(), active: external_exports.boolean(), role: external_exports.string(), state: external_exports.string(), running: external_exports.boolean() });
var se = external_exports.object({ type: external_exports.literal(C.enum.MetaEvent), name: Vt, value: external_exports.any() });
var ae = external_exports.object({ type: external_exports.literal(C.enum.RunError), message: external_exports.string(), code: external_exports.string().optional() });
var Qn = external_exports.discriminatedUnion("type", [Wt, Yt, qt, Qt, Zt, te, ee, ne, se, ae]);
var Zn = external_exports.object({ id: external_exports.string(), role: external_exports.string(), content: external_exports.string(), parentMessageId: external_exports.string().optional() });
var ts = external_exports.object({ id: external_exports.string(), name: external_exports.string(), arguments: external_exports.any(), parentMessageId: external_exports.string().optional() });
var es = external_exports.object({ id: external_exports.string(), result: external_exports.any(), actionExecutionId: external_exports.string(), actionName: external_exports.string() });
var le = (l) => {
  if (typeof l == "string") return l;
  if (!Array.isArray(l)) return;
  let a = l.filter((e) => e.type === "text").map((e) => e.text).filter((e) => e.length > 0);
  if (a.length !== 0) return a.join(`
`);
};
var at = (l, a, e) => (n) => {
  let t = {}, s = true, r = true, o = "", i = null, d = null, I = [], S = {}, T = (v) => {
    typeof v == "object" && v !== null && ("messages" in v && delete v.messages, t = v);
  };
  return n.pipe(mergeMap((v) => {
    switch (v.type) {
      case EventType.TEXT_MESSAGE_START: {
        let c = v;
        return [{ type: C.enum.TextMessageStart, messageId: c.messageId, role: c.role }];
      }
      case EventType.TEXT_MESSAGE_CONTENT: {
        let c = v;
        return [{ type: C.enum.TextMessageContent, messageId: c.messageId, content: c.delta }];
      }
      case EventType.TEXT_MESSAGE_END: {
        let c = v;
        return [{ type: C.enum.TextMessageEnd, messageId: c.messageId }];
      }
      case EventType.TOOL_CALL_START: {
        let c = v;
        return I.push({ id: c.toolCallId, type: "function", function: { name: c.toolCallName, arguments: "" } }), r = true, S[c.toolCallId] = c.toolCallName, [{ type: C.enum.ActionExecutionStart, actionExecutionId: c.toolCallId, actionName: c.toolCallName, parentMessageId: c.parentMessageId }];
      }
      case EventType.TOOL_CALL_ARGS: {
        let c = v, b = I.find((E) => E.id === c.toolCallId);
        if (!b) return console.warn(`TOOL_CALL_ARGS: No tool call found with ID '${c.toolCallId}'`), [];
        b.function.arguments += c.delta;
        let U = false;
        if (d) {
          let E = d.find((g) => g.tool == b.function.name);
          if (E) try {
            let g = JSON.parse(untruncateJson(b.function.arguments));
            E.tool_argument && E.tool_argument in g ? (T(G(N({}, t), { [E.state_key]: g[E.tool_argument] })), U = true) : E.tool_argument || (T(G(N({}, t), { [E.state_key]: g })), U = true);
          } catch (g) {
          }
        }
        return [{ type: C.enum.ActionExecutionArgs, actionExecutionId: c.toolCallId, args: c.delta }, ...U ? [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(t), active: r }] : []];
      }
      case EventType.TOOL_CALL_END: {
        let c = v;
        return [{ type: C.enum.ActionExecutionEnd, actionExecutionId: c.toolCallId }];
      }
      case EventType.TOOL_CALL_RESULT: {
        let c = v;
        return [{ type: C.enum.ActionExecutionResult, actionExecutionId: c.toolCallId, result: c.content, actionName: S[c.toolCallId] || "unknown" }];
      }
      case EventType.RAW:
        return [];
      case EventType.CUSTOM: {
        let c = v;
        switch (c.name) {
          case "Exit":
            s = false;
            break;
          case "PredictState":
            d = c.value;
            break;
        }
        return [{ type: C.enum.MetaEvent, name: c.name, value: c.value }];
      }
      case EventType.STATE_SNAPSHOT:
        return T(v.snapshot), [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(t), active: r }];
      case EventType.STATE_DELTA: {
        let b = applyPatch(t, v.delta, true, false);
        return b ? (T(b.newDocument), [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(t), active: r }]) : [];
      }
      case EventType.MESSAGES_SNAPSHOT:
        return i = v.messages, [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(N(N({}, t), i ? { messages: i } : {})), active: true }];
      case EventType.RUN_STARTED:
        return [];
      case EventType.RUN_FINISHED:
        return i && (t.messages = i), Object.keys(t).length === 0 ? [] : [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(N(N({}, t), i ? { messages: ge(i) } : {})), active: false }];
      case EventType.RUN_ERROR: {
        let c = v;
        return [{ type: C.enum.RunError, message: c.message, code: c.code }];
      }
      case EventType.STEP_STARTED:
        return o = v.stepName, I = [], d = null, [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(t), active: true }];
      case EventType.STEP_FINISHED:
        return I = [], d = null, [{ type: C.enum.AgentStateMessage, threadId: l, agentName: e, nodeName: o, runId: a, running: s, role: "assistant", state: JSON.stringify(t), active: false }];
      default:
        return [];
    }
  }));
};
function ge(l) {
  var e;
  let a = [];
  for (let n of l) if (n.role === "assistant" || n.role === "user" || n.role === "system") {
    let t = le(n.content);
    if (t) {
      let s = { id: n.id, role: n.role, content: t };
      a.push(s);
    }
    if (n.role === "assistant" && n.toolCalls && n.toolCalls.length > 0) for (let s of n.toolCalls) {
      let r = { id: s.id, name: s.function.name, arguments: JSON.parse(s.function.arguments), parentMessageId: n.id };
      a.push(r);
    }
  } else if (n.role === "tool") {
    let t = "unknown";
    for (let r of l) if (r.role === "assistant" && ((e = r.toolCalls) != null && e.length)) {
      for (let o of r.toolCalls) if (o.id === n.toolCallId) {
        t = o.function.name;
        break;
      }
    }
    let s = { id: n.id, result: n.content, actionExecutionId: n.toolCallId, actionName: t };
    a.push(s);
  }
  return a;
}
var j = (l) => (a) => {
  let e, n, t, s = () => {
    if (!e || t !== "text") throw new Error("No text message to close");
    let i = { type: EventType.TEXT_MESSAGE_END, messageId: e.messageId };
    return t = void 0, e = void 0, l && console.debug("[TRANSFORM]: TEXT_MESSAGE_END", JSON.stringify(i)), i;
  }, r = () => {
    if (!n || t !== "tool") throw new Error("No tool call to close");
    let i = { type: EventType.TOOL_CALL_END, toolCallId: n.toolCallId };
    return t = void 0, n = void 0, l && console.debug("[TRANSFORM]: TOOL_CALL_END", JSON.stringify(i)), i;
  }, o = () => t === "text" ? [s()] : t === "tool" ? [r()] : [];
  return a.pipe(mergeMap((i) => {
    switch (i.type) {
      case EventType.TEXT_MESSAGE_START:
      case EventType.TEXT_MESSAGE_CONTENT:
      case EventType.TEXT_MESSAGE_END:
      case EventType.TOOL_CALL_START:
      case EventType.TOOL_CALL_ARGS:
      case EventType.TOOL_CALL_END:
      case EventType.TOOL_CALL_RESULT:
      case EventType.STATE_SNAPSHOT:
      case EventType.STATE_DELTA:
      case EventType.MESSAGES_SNAPSHOT:
      case EventType.CUSTOM:
      case EventType.RUN_STARTED:
      case EventType.RUN_FINISHED:
      case EventType.RUN_ERROR:
      case EventType.STEP_STARTED:
      case EventType.STEP_FINISHED:
      case EventType.THINKING_START:
      case EventType.THINKING_END:
      case EventType.THINKING_TEXT_MESSAGE_START:
      case EventType.THINKING_TEXT_MESSAGE_CONTENT:
      case EventType.THINKING_TEXT_MESSAGE_END:
        return [...o(), i];
      case EventType.RAW:
      case EventType.ACTIVITY_SNAPSHOT:
      case EventType.ACTIVITY_DELTA:
        return [i];
      case EventType.TEXT_MESSAGE_CHUNK:
        let I = i, S = [];
        if ((t !== "text" || I.messageId !== void 0 && I.messageId !== (e == null ? void 0 : e.messageId)) && S.push(...o()), t !== "text") {
          if (I.messageId === void 0) throw new Error("First TEXT_MESSAGE_CHUNK must have a messageId");
          e = { messageId: I.messageId }, t = "text";
          let c = { type: EventType.TEXT_MESSAGE_START, messageId: I.messageId, role: I.role || "assistant" };
          S.push(c), l && console.debug("[TRANSFORM]: TEXT_MESSAGE_START", JSON.stringify(c));
        }
        if (I.delta !== void 0) {
          let c = { type: EventType.TEXT_MESSAGE_CONTENT, messageId: e.messageId, delta: I.delta };
          S.push(c), l && console.debug("[TRANSFORM]: TEXT_MESSAGE_CONTENT", JSON.stringify(c));
        }
        return S;
      case EventType.TOOL_CALL_CHUNK:
        let T = i, v = [];
        if ((t !== "tool" || T.toolCallId !== void 0 && T.toolCallId !== (n == null ? void 0 : n.toolCallId)) && v.push(...o()), t !== "tool") {
          if (T.toolCallId === void 0) throw new Error("First TOOL_CALL_CHUNK must have a toolCallId");
          if (T.toolCallName === void 0) throw new Error("First TOOL_CALL_CHUNK must have a toolCallName");
          n = { toolCallId: T.toolCallId, toolCallName: T.toolCallName, parentMessageId: T.parentMessageId }, t = "tool";
          let c = { type: EventType.TOOL_CALL_START, toolCallId: T.toolCallId, toolCallName: T.toolCallName, parentMessageId: T.parentMessageId };
          v.push(c), l && console.debug("[TRANSFORM]: TOOL_CALL_START", JSON.stringify(c));
        }
        if (T.delta !== void 0) {
          let c = { type: EventType.TOOL_CALL_ARGS, toolCallId: n.toolCallId, delta: T.delta };
          v.push(c), l && console.debug("[TRANSFORM]: TOOL_CALL_ARGS", JSON.stringify(c));
        }
        return v;
    }
    let d = i.type;
    return [];
  }), finalize(() => {
    o();
  }));
};
var k = class {
  runNext(a, e) {
    return e.run(a).pipe(j(false));
  }
  runNextWithState(a, e) {
    let n = y(a.messages || []), t = y(a.state || {}), s = new ReplaySubject();
    return $(a, s, e, []).subscribe((o) => {
      o.messages !== void 0 && (n = o.messages), o.state !== void 0 && (t = o.state);
    }), this.runNext(a, e).pipe(concatMap(async (o) => (s.next(o), await new Promise((i) => setTimeout(i, 0)), { event: o, messages: y(n), state: y(t) })));
  }
};
var K = class extends k {
  constructor(e) {
    super();
    this.fn = e;
  }
  run(e, n) {
    return this.fn(e, n);
  }
};
var Q = class extends k {
  constructor(e) {
    super();
    this.blockedToolCallIds = /* @__PURE__ */ new Set();
    if (e.allowedToolCalls && e.disallowedToolCalls) throw new Error("Cannot specify both allowedToolCalls and disallowedToolCalls");
    if (!e.allowedToolCalls && !e.disallowedToolCalls) throw new Error("Must specify either allowedToolCalls or disallowedToolCalls");
    e.allowedToolCalls ? this.allowedTools = new Set(e.allowedToolCalls) : e.disallowedToolCalls && (this.disallowedTools = new Set(e.disallowedToolCalls));
  }
  run(e, n) {
    return this.runNext(e, n).pipe(filter((t) => {
      if (t.type === EventType.TOOL_CALL_START) {
        let s = t;
        return this.shouldFilterTool(s.toolCallName) ? (this.blockedToolCallIds.add(s.toolCallId), false) : true;
      }
      if (t.type === EventType.TOOL_CALL_ARGS) {
        let s = t;
        return !this.blockedToolCallIds.has(s.toolCallId);
      }
      if (t.type === EventType.TOOL_CALL_END) {
        let s = t;
        return !this.blockedToolCallIds.has(s.toolCallId);
      }
      if (t.type === EventType.TOOL_CALL_RESULT) {
        let s = t;
        return this.blockedToolCallIds.has(s.toolCallId) ? (this.blockedToolCallIds.delete(s.toolCallId), false) : true;
      }
      return true;
    }));
  }
  shouldFilterTool(e) {
    return this.allowedTools ? !this.allowedTools.has(e) : this.disallowedTools ? this.disallowedTools.has(e) : false;
  }
};
function me(l) {
  let a = l.content;
  if (Array.isArray(a)) {
    let e = a.filter((n) => typeof n == "object" && n !== null && "type" in n && n.type === "text" && typeof n.text == "string").map((n) => n.text).join("");
    return G(N({}, l), { content: e });
  }
  return typeof a == "string" ? l : G(N({}, l), { content: "" });
}
var J = class extends k {
  run(a, e) {
    let r = a, { parentRunId: n } = r, t = gt(r, ["parentRunId"]), s = G(N({}, t), { messages: t.messages.map(me) });
    return this.runNext(s, e);
  }
};
var mt = { name: "@ag-ui/client", author: "Markus Ecker <markus.ecker@gmail.com>", version: "0.0.42", private: false, publishConfig: { access: "public" }, main: "./dist/index.js", module: "./dist/index.mjs", types: "./dist/index.d.ts", sideEffects: false, files: ["dist/**", "README.md"], scripts: { build: "tsup", dev: "tsup --watch", clean: "rm -rf dist .turbo node_modules", typecheck: "tsc --noEmit", test: "jest", "link:global": "pnpm link --global", "unlink:global": "pnpm unlink --global" }, dependencies: { "@ag-ui/core": "workspace:*", "@ag-ui/encoder": "workspace:*", "@ag-ui/proto": "workspace:*", "@types/uuid": "^10.0.0", "compare-versions": "^6.1.1", "fast-json-patch": "^3.1.1", rxjs: "7.8.1", "untruncate-json": "^0.0.1", uuid: "^11.1.0", zod: "^3.22.4" }, devDependencies: { "@types/jest": "^29.5.14", "@types/node": "^20.11.19", jest: "^29.7.0", "ts-jest": "^29.1.2", tsup: "^8.0.2", typescript: "^5.3.3" } };
var W = class {
  constructor({ agentId: a, description: e, threadId: n, initialMessages: t, initialState: s, debug: r } = {}) {
    this.debug = false;
    this.subscribers = [];
    this.isRunning = false;
    this.middlewares = [];
    this.agentId = a, this.description = e != null ? e : "", this.threadId = n != null ? n : v4_default(), this.messages = y(t != null ? t : []), this.state = y(s != null ? s : {}), this.debug = r != null ? r : false, compareVersions(this.maxVersion, "0.0.39") <= 0 && this.middlewares.unshift(new J());
  }
  get maxVersion() {
    return mt.version;
  }
  subscribe(a) {
    return this.subscribers.push(a), { unsubscribe: () => {
      this.subscribers = this.subscribers.filter((e) => e !== a);
    } };
  }
  use(...a) {
    let e = a.map((n) => typeof n == "function" ? new K(n) : n);
    return this.middlewares.push(...e), this;
  }
  async runAgent(a, e) {
    var n;
    try {
      this.isRunning = true, this.agentId = (n = this.agentId) != null ? n : v4_default();
      let t = this.prepareRunAgentInput(a), s, r = new Set(this.messages.map((S) => S.id)), o = [{ onRunFinishedEvent: (S) => {
        s = S.result;
      } }, ...this.subscribers, e != null ? e : {}];
      await this.onInitialize(t, o), this.activeRunDetach$ = new Subject();
      let i;
      this.activeRunCompletionPromise = new Promise((S) => {
        i = S;
      });
      let d = pipe(() => this.middlewares.length === 0 ? this.run(t) : this.middlewares.reduceRight((T, v) => ({ run: (c) => v.run(c, T) }), this).run(t), j(this.debug), z(this.debug), (S) => S.pipe(takeUntil(this.activeRunDetach$)), (S) => this.apply(t, S, o), (S) => this.processApplyEvents(t, S, o), catchError((S) => (this.isRunning = false, this.onError(t, S, o))), finalize(() => {
        this.isRunning = false, this.onFinalize(t, o), i == null || i(), i = void 0, this.activeRunCompletionPromise = void 0, this.activeRunDetach$ = void 0;
      }));
      await lastValueFrom(d(of(null)));
      let I = y(this.messages).filter((S) => !r.has(S.id));
      return { result: s, newMessages: I };
    } finally {
      this.isRunning = false;
    }
  }
  connect(a) {
    throw new AGUIConnectNotImplementedError();
  }
  async connectAgent(a, e) {
    var n;
    try {
      this.isRunning = true, this.agentId = (n = this.agentId) != null ? n : v4_default();
      let t = this.prepareRunAgentInput(a), s, r = new Set(this.messages.map((S) => S.id)), o = [{ onRunFinishedEvent: (S) => {
        s = S.result;
      } }, ...this.subscribers, e != null ? e : {}];
      await this.onInitialize(t, o), this.activeRunDetach$ = new Subject();
      let i;
      this.activeRunCompletionPromise = new Promise((S) => {
        i = S;
      });
      let d = pipe(() => this.connect(t), j(this.debug), z(this.debug), (S) => S.pipe(takeUntil(this.activeRunDetach$)), (S) => this.apply(t, S, o), (S) => this.processApplyEvents(t, S, o), catchError((S) => (this.isRunning = false, S instanceof AGUIConnectNotImplementedError ? EMPTY : this.onError(t, S, o))), finalize(() => {
        this.isRunning = false, this.onFinalize(t, o), i == null || i(), i = void 0, this.activeRunCompletionPromise = void 0, this.activeRunDetach$ = void 0;
      }));
      await lastValueFrom(d(of(null)));
      let I = y(this.messages).filter((S) => !r.has(S.id));
      return { result: s, newMessages: I };
    } finally {
      this.isRunning = false;
    }
  }
  abortRun() {
  }
  async detachActiveRun() {
    var e, n;
    if (!this.activeRunDetach$) return;
    let a = (e = this.activeRunCompletionPromise) != null ? e : Promise.resolve();
    this.activeRunDetach$.next(), (n = this.activeRunDetach$) == null || n.complete(), await a;
  }
  apply(a, e, n) {
    return $(a, e, this, n);
  }
  processApplyEvents(a, e, n) {
    return e.pipe(tap((t) => {
      t.messages && (this.messages = t.messages, n.forEach((s) => {
        var r;
        (r = s.onMessagesChanged) == null || r.call(s, { messages: this.messages, state: this.state, agent: this, input: a });
      })), t.state && (this.state = t.state, n.forEach((s) => {
        var r;
        (r = s.onStateChanged) == null || r.call(s, { state: this.state, messages: this.messages, agent: this, input: a });
      }));
    }));
  }
  prepareRunAgentInput(a) {
    var t, s, r;
    let n = y(this.messages).filter((o) => o.role !== "activity");
    return { threadId: this.threadId, runId: (a == null ? void 0 : a.runId) || v4_default(), tools: y((t = a == null ? void 0 : a.tools) != null ? t : []), context: y((s = a == null ? void 0 : a.context) != null ? s : []), forwardedProps: y((r = a == null ? void 0 : a.forwardedProps) != null ? r : {}), state: y(this.state), messages: n };
  }
  async onInitialize(a, e) {
    let n = await x(e, this.messages, this.state, (t, s, r) => {
      var o;
      return (o = t.onRunInitialized) == null ? void 0 : o.call(t, { messages: s, state: r, agent: this, input: a });
    });
    (n.messages !== void 0 || n.state !== void 0) && (n.messages && (this.messages = n.messages, a.messages = n.messages, e.forEach((t) => {
      var s;
      (s = t.onMessagesChanged) == null || s.call(t, { messages: this.messages, state: this.state, agent: this, input: a });
    })), n.state && (this.state = n.state, a.state = n.state, e.forEach((t) => {
      var s;
      (s = t.onStateChanged) == null || s.call(t, { state: this.state, messages: this.messages, agent: this, input: a });
    })));
  }
  onError(a, e, n) {
    return from(x(n, this.messages, this.state, (t, s, r) => {
      var o;
      return (o = t.onRunFailed) == null ? void 0 : o.call(t, { error: e, messages: s, state: r, agent: this, input: a });
    })).pipe(map((t) => {
      let s = t;
      if ((s.messages !== void 0 || s.state !== void 0) && (s.messages !== void 0 && (this.messages = s.messages, n.forEach((r) => {
        var o;
        (o = r.onMessagesChanged) == null || o.call(r, { messages: this.messages, state: this.state, agent: this, input: a });
      })), s.state !== void 0 && (this.state = s.state, n.forEach((r) => {
        var o;
        (o = r.onStateChanged) == null || o.call(r, { state: this.state, messages: this.messages, agent: this, input: a });
      }))), s.stopPropagation !== true) throw console.error("Agent execution failed:", e), e;
      return {};
    }));
  }
  async onFinalize(a, e) {
    let n = await x(e, this.messages, this.state, (t, s, r) => {
      var o;
      return (o = t.onRunFinalized) == null ? void 0 : o.call(t, { messages: s, state: r, agent: this, input: a });
    });
    (n.messages !== void 0 || n.state !== void 0) && (n.messages !== void 0 && (this.messages = n.messages, e.forEach((t) => {
      var s;
      (s = t.onMessagesChanged) == null || s.call(t, { messages: this.messages, state: this.state, agent: this, input: a });
    })), n.state !== void 0 && (this.state = n.state, e.forEach((t) => {
      var s;
      (s = t.onStateChanged) == null || s.call(t, { state: this.state, messages: this.messages, agent: this, input: a });
    })));
  }
  clone() {
    let a = Object.create(Object.getPrototypeOf(this));
    return a.agentId = this.agentId, a.description = this.description, a.threadId = this.threadId, a.messages = y(this.messages), a.state = y(this.state), a.debug = this.debug, a.isRunning = this.isRunning, a.subscribers = [...this.subscribers], a.middlewares = [...this.middlewares], a;
  }
  addMessage(a) {
    this.messages.push(a), (async () => {
      var e, n, t;
      for (let s of this.subscribers) await ((e = s.onNewMessage) == null ? void 0 : e.call(s, { message: a, messages: this.messages, state: this.state, agent: this }));
      if (a.role === "assistant" && a.toolCalls) for (let s of a.toolCalls) for (let r of this.subscribers) await ((n = r.onNewToolCall) == null ? void 0 : n.call(r, { toolCall: s, messages: this.messages, state: this.state, agent: this }));
      for (let s of this.subscribers) await ((t = s.onMessagesChanged) == null ? void 0 : t.call(s, { messages: this.messages, state: this.state, agent: this }));
    })();
  }
  addMessages(a) {
    this.messages.push(...a), (async () => {
      var e, n, t;
      for (let s of a) {
        for (let r of this.subscribers) await ((e = r.onNewMessage) == null ? void 0 : e.call(r, { message: s, messages: this.messages, state: this.state, agent: this }));
        if (s.role === "assistant" && s.toolCalls) for (let r of s.toolCalls) for (let o of this.subscribers) await ((n = o.onNewToolCall) == null ? void 0 : n.call(o, { toolCall: r, messages: this.messages, state: this.state, agent: this }));
      }
      for (let s of this.subscribers) await ((t = s.onMessagesChanged) == null ? void 0 : t.call(s, { messages: this.messages, state: this.state, agent: this }));
    })();
  }
  setMessages(a) {
    this.messages = y(a), (async () => {
      var e;
      for (let n of this.subscribers) await ((e = n.onMessagesChanged) == null ? void 0 : e.call(n, { messages: this.messages, state: this.state, agent: this }));
    })();
  }
  setState(a) {
    this.state = y(a), (async () => {
      var e;
      for (let n of this.subscribers) await ((e = n.onStateChanged) == null ? void 0 : e.call(n, { messages: this.messages, state: this.state, agent: this }));
    })();
  }
  legacy_to_be_removed_runAgentBridged(a) {
    var t;
    this.agentId = (t = this.agentId) != null ? t : v4_default();
    let e = this.prepareRunAgentInput(a);
    return (this.middlewares.length === 0 ? this.run(e) : this.middlewares.reduceRight((r, o) => ({ run: (i) => o.run(i, r) }), this).run(e)).pipe(j(this.debug), z(this.debug), at(this.threadId, e.runId, this.agentId), (s) => s.pipe(map((r) => (this.debug && console.debug("[LEGACY]:", JSON.stringify(r)), r))));
  }
};
var ot = class extends W {
  constructor(e) {
    var n;
    super(e);
    this.abortController = new AbortController();
    this.url = e.url, this.headers = y((n = e.headers) != null ? n : {});
  }
  requestInit(e) {
    return { method: "POST", headers: G(N({}, this.headers), { "Content-Type": "application/json", Accept: "text/event-stream" }), body: JSON.stringify(e), signal: this.abortController.signal };
  }
  runAgent(e, n) {
    var t;
    return this.abortController = (t = e == null ? void 0 : e.abortController) != null ? t : new AbortController(), super.runAgent(e, n);
  }
  abortRun() {
    this.abortController.abort(), super.abortRun();
  }
  run(e) {
    let n = tt(this.url, this.requestInit(e));
    return st(n);
  }
  clone() {
    var s;
    let e = super.clone();
    e.url = this.url, e.headers = y((s = this.headers) != null ? s : {});
    let n = new AbortController(), t = this.abortController.signal;
    return t.aborted && n.abort(t.reason), e.abortController = n, e;
  }
};
function he(l) {
  let a = [], e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
  for (let t of l) if (t.type === EventType.TEXT_MESSAGE_START) {
    let s = t, r = s.messageId;
    e.has(r) || e.set(r, { contents: [], otherEvents: [] });
    let o = e.get(r);
    o.start = s;
  } else if (t.type === EventType.TEXT_MESSAGE_CONTENT) {
    let s = t, r = s.messageId;
    e.has(r) || e.set(r, { contents: [], otherEvents: [] }), e.get(r).contents.push(s);
  } else if (t.type === EventType.TEXT_MESSAGE_END) {
    let s = t, r = s.messageId;
    e.has(r) || e.set(r, { contents: [], otherEvents: [] });
    let o = e.get(r);
    o.end = s, Rt(r, o, a), e.delete(r);
  } else if (t.type === EventType.TOOL_CALL_START) {
    let s = t, r = s.toolCallId;
    n.has(r) || n.set(r, { args: [], otherEvents: [] });
    let o = n.get(r);
    o.start = s;
  } else if (t.type === EventType.TOOL_CALL_ARGS) {
    let s = t, r = s.toolCallId;
    n.has(r) || n.set(r, { args: [], otherEvents: [] }), n.get(r).args.push(s);
  } else if (t.type === EventType.TOOL_CALL_END) {
    let s = t, r = s.toolCallId;
    n.has(r) || n.set(r, { args: [], otherEvents: [] });
    let o = n.get(r);
    o.end = s, It(r, o, a), n.delete(r);
  } else {
    let s = false;
    for (let [r, o] of e) if (o.start && !o.end) {
      o.otherEvents.push(t), s = true;
      break;
    }
    if (!s) {
      for (let [r, o] of n) if (o.start && !o.end) {
        o.otherEvents.push(t), s = true;
        break;
      }
    }
    s || a.push(t);
  }
  for (let [t, s] of e) Rt(t, s, a);
  for (let [t, s] of n) It(t, s, a);
  return a;
}
function Rt(l, a, e) {
  if (a.start && e.push(a.start), a.contents.length > 0) {
    let n = a.contents.map((s) => s.delta).join(""), t = { type: EventType.TEXT_MESSAGE_CONTENT, messageId: l, delta: n };
    e.push(t);
  }
  a.end && e.push(a.end);
  for (let n of a.otherEvents) e.push(n);
}
function It(l, a, e) {
  if (a.start && e.push(a.start), a.args.length > 0) {
    let n = a.args.map((s) => s.delta).join(""), t = { type: EventType.TOOL_CALL_ARGS, toolCallId: l, delta: n };
    e.push(t);
  }
  a.end && e.push(a.end);
  for (let n of a.otherEvents) e.push(n);
}

export {
  FunctionCallSchema,
  ToolCallSchema,
  BaseMessageSchema,
  TextInputContentSchema,
  BinaryInputContentSchema,
  InputContentSchema,
  DeveloperMessageSchema,
  SystemMessageSchema,
  AssistantMessageSchema,
  UserMessageSchema,
  ToolMessageSchema,
  ActivityMessageSchema,
  MessageSchema,
  RoleSchema,
  ContextSchema,
  ToolSchema,
  RunAgentInputSchema,
  StateSchema,
  AGUIError,
  AGUIConnectNotImplementedError,
  EventType,
  BaseEventSchema,
  TextMessageStartEventSchema,
  TextMessageContentEventSchema,
  TextMessageEndEventSchema,
  TextMessageChunkEventSchema,
  ThinkingTextMessageStartEventSchema,
  ThinkingTextMessageContentEventSchema,
  ThinkingTextMessageEndEventSchema,
  ToolCallStartEventSchema,
  ToolCallArgsEventSchema,
  ToolCallEndEventSchema,
  ToolCallResultEventSchema,
  ToolCallChunkEventSchema,
  ThinkingStartEventSchema,
  ThinkingEndEventSchema,
  StateSnapshotEventSchema,
  StateDeltaEventSchema,
  MessagesSnapshotEventSchema,
  ActivitySnapshotEventSchema,
  ActivityDeltaEventSchema,
  RawEventSchema,
  CustomEventSchema,
  RunStartedEventSchema,
  RunFinishedEventSchema,
  RunErrorEventSchema,
  StepStartedEventSchema,
  StepFinishedEventSchema,
  EventSchemas,
  from,
  y,
  Re,
  $,
  z,
  tt,
  et,
  nt,
  st,
  at,
  j,
  k,
  K,
  Q,
  J,
  W,
  ot,
  he
};
/*! Bundled license information:

fast-json-patch/module/helpers.mjs:
  (*!
   * https://github.com/Starcounter-Jack/JSON-Patch
   * (c) 2017-2022 Joachim Wester
   * MIT licensed
   *)

fast-json-patch/module/duplex.mjs:
  (*!
   * https://github.com/Starcounter-Jack/JSON-Patch
   * (c) 2017-2021 Joachim Wester
   * MIT license
   *)
*/
//# sourceMappingURL=chunk-IILPD2DB.js.map