{"version":3,"file":"silentium.min.mjs","sources":["../src/helpers/guards.ts","../src/base/Destroyable.ts","../src/base/DestroyContainer.ts","../src/base/Rejections.ts","../src/base/Silence.ts","../src/helpers/ensures.ts","../src/base/Message.ts","../src/base/Of.ts","../src/base/Actual.ts","../src/base/Connected.ts","../src/base/Local.ts","../src/base/Locals.ts","../src/base/New.ts","../src/base/Source.ts","../src/base/SourceComputed.ts","../src/base/Void.ts","../src/components/All.ts","../src/components/Any.ts","../src/components/Applied.ts","../src/components/Primitive.ts","../src/components/Shared.ts","../src/components/Late.ts","../src/components/Catch.ts","../src/components/Chain.ts","../src/components/Destructured.ts","../src/components/Computed.ts","../src/components/Context.ts","../src/components/ContextChain.ts","../src/components/ContextOf.ts","../src/components/Default.ts","../src/components/Empty.ts","../src/components/ExecutorApplied.ts","../src/components/Filtered.ts","../src/components/Fold.ts","../src/components/Freeze.ts","../src/components/FromEvent.ts","../src/components/Lazy.ts","../src/components/Map.ts","../src/components/Once.ts","../src/components/Piped.ts","../src/components/Process.ts","../src/components/Promisify.ts","../src/components/Race.ts","../src/components/Sequence.ts","../src/components/Stream.ts","../src/components/Trackable.ts","../src/components/Value.ts","../src/helpers/DevTools.ts"],"sourcesContent":["import { DestroyableType, DestroyedType } from \"types/DestroyableType\";\nimport { MessageType } from \"types/MessageType\";\nimport { SourceType } from \"types/SourceType\";\n\n/**\n * Checks that the value is neither undefined nor null\n */\nexport const isFilled = <T>(\n  value?: T,\n): value is Exclude<T, null | undefined> => {\n  return value !== undefined && value !== null;\n};\n\n/**\n * Checks that the object is an message\n */\nexport function isMessage(o: unknown): o is MessageType {\n  return (\n    o !== null &&\n    typeof o === \"object\" &&\n    \"then\" in o &&\n    typeof (o as any).then === \"function\"\n  );\n}\n\n/**\n * Checks that the object is an message\n */\nexport function isSource(o: unknown): o is SourceType {\n  return (\n    o !== null &&\n    typeof o === \"object\" &&\n    \"use\" in o &&\n    typeof (o as any).use === \"function\"\n  );\n}\n\n/**\n * Checks that the object is destroyable\n */\nexport function isDestroyable(o: unknown): o is DestroyableType {\n  return (\n    o !== null &&\n    typeof o === \"object\" &&\n    \"destroy\" in o &&\n    typeof (o as any).destroy === \"function\"\n  );\n}\n\n/**\n * Checks that the object can indicate whether it has been destroyed or not\n */\nexport function isDestroyed(o: unknown): o is DestroyedType {\n  return (\n    o !== null &&\n    typeof o === \"object\" &&\n    \"destroyed\" in o &&\n    typeof (o as any).destroyed === \"function\"\n  );\n}\n","import { isDestroyable } from \"helpers/guards\";\nimport { DestroyableType } from \"types/DestroyableType\";\n\n/**\n * Allows creating an object that definitely has a destructor,\n * useful to avoid creating unnecessary conditions\n */\nexport function Destroyable<T>(base: T) {\n  return new DestroyableImpl(base);\n}\n\nexport class DestroyableImpl<T> implements DestroyableType {\n  public constructor(private base: T) {}\n\n  public destroy(): this {\n    if (isDestroyable(this.base)) {\n      this.base.destroy();\n    }\n\n    if (typeof this.base === \"function\") {\n      this.base();\n    }\n\n    return this;\n  }\n}\n","import { Destroyable } from \"base/Destroyable\";\nimport { DestroyableType } from \"types/DestroyableType\";\n\n/**\n * An object that allows collecting all disposable objects and\n * disposing them later all together\n */\nexport function DestroyContainer() {\n  return new DestroyContainerImpl();\n}\n\nexport class DestroyContainerImpl implements DestroyableType {\n  private destructors: DestroyableType[] = [];\n  private _destroyed = false;\n\n  /**\n   * Add one destroyable\n   * @param e\n   * @returns\n   */\n  public add<R>(e: R): R {\n    this.destructors.push(Destroyable(e));\n    return e;\n  }\n\n  /**\n   * Add many destroyable objects\n   * @param destroyableList\n   * @returns\n   */\n  public many(destroyableList: unknown[]) {\n    const destroyMany = (d: unknown) => {\n      this.add(d);\n    };\n    destroyableList.forEach(destroyMany);\n    return this;\n  }\n\n  public destroy() {\n    this._destroyed = true;\n    this.destructors.forEach(function dcDestroy(d) {\n      d.destroy();\n    });\n    this.destructors.length = 0;\n    return this;\n  }\n\n  public destroyed() {\n    return this._destroyed;\n  }\n\n  public destructor() {\n    return this.destroy.bind(this);\n  }\n}\n","import { ConstructorType } from \"types/ConstructorType\";\n\n/**\n * Handles rejections collection\n */\nexport function Rejections() {\n  return new RejectionsImpl();\n}\n\n/**\n * Implementation of rejections collection\n */\nexport class RejectionsImpl {\n  private catchers: ConstructorType<[unknown]>[] = [];\n  private lastRejectReason: unknown = null;\n\n  public static globalCatch?: ConstructorType<[unknown]>;\n\n  public reject: (reason: unknown) => void;\n\n  public constructor() {\n    const rejectionsRejectHandler = (reason: unknown) => {\n      this.lastRejectReason = reason;\n      this.catchers.forEach(function rejectionsRejectCatchers(catcher) {\n        catcher(reason);\n      });\n      if (RejectionsImpl.globalCatch) {\n        RejectionsImpl.globalCatch(reason);\n      } else if (this.catchers.length === 0) {\n        console.error([\"Unhandled Message Rejection:\", reason].join(\" \"));\n      }\n    };\n    this.reject = rejectionsRejectHandler;\n  }\n\n  public catch(rejected: ConstructorType<[unknown]>) {\n    if (this.lastRejectReason !== null) {\n      rejected(this.lastRejectReason);\n    }\n    this.catchers.push(rejected);\n    return this;\n  }\n\n  public destroy() {\n    this.catchers.length = 0;\n    return this;\n  }\n}\n","import { isFilled } from \"helpers/guards\";\nimport { ConstructorType } from \"types/ConstructorType\";\n\nexport const ResetSilenceCache = Symbol(\"reset-silence-cache\");\n\n/**\n * Silence is null or undefined\n * Everything else is not silence\n *\n * @url https://silentium.pw/article/silence/view\n */\nexport function Silence<T>(resolve: ConstructorType<[T]>) {\n  let lastValue: T | undefined;\n  return function SilenceImpl(v: T | undefined) {\n    if (v === ResetSilenceCache) {\n      lastValue = undefined;\n      v = undefined;\n    }\n    if (isFilled(v) && v !== lastValue) {\n      lastValue = v;\n      resolve(v);\n    }\n  };\n}\n\n/**\n * Silence rule when new value comes\n */\nexport function SilenceUse() {\n  let lastValue: unknown = null;\n  return {\n    use(value: unknown, cb: (v: unknown) => unknown) {\n      if (lastValue === null) {\n        lastValue = value;\n        cb(value);\n        return;\n      }\n      if (lastValue !== value) {\n        lastValue = value;\n        cb(value);\n        return;\n      }\n      lastValue = value;\n      return;\n    },\n  };\n}\n","import { isMessage } from \"helpers/guards\";\n\nexport function ensureFunction(v: unknown, label: string) {\n  if (typeof v !== \"function\") {\n    throw new Error(`${label}: is not function`);\n  }\n}\n\nexport function ensureMessage(v: unknown, label: string) {\n  if (!isMessage(v)) {\n    throw new Error(`${label}: is not message`);\n  }\n}\n","import { DestroyContainer } from \"base/DestroyContainer\";\nimport { Rejections } from \"base/Rejections\";\nimport { Silence } from \"base/Silence\";\nimport { ensureFunction } from \"helpers/ensures\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { DestroyableType } from \"types/DestroyableType\";\nimport { MessageType } from \"types/MessageType\";\n\nexport type MessageExecutorType<T> = (\n  resolve: ConstructorType<[T]>,\n  reject: ConstructorType<[unknown]>,\n  name?: string,\n) => MessageType | (() => void) | void;\n\n/**\n * A message created from an executor function.\n * The executor function can return a message destruction function.\n *\n * @url https://silentium.pw/article/message/view\n */\nexport function Message<T>(executor: MessageExecutorType<T>) {\n  return new MessageImpl<T>(executor);\n}\n\n/**\n * Reactive message implementation\n *\n * @url https://silentium.pw/article/message/view\n */\nexport class MessageImpl<T> implements MessageType<T>, DestroyableType {\n  private myName = \"unknown\";\n\n  public constructor(\n    private executor: MessageExecutorType<T>,\n    private rejections = Rejections(),\n    private dc = DestroyContainer(),\n  ) {\n    ensureFunction(executor, \"Message: executor\");\n  }\n\n  public then(\n    resolve: ConstructorType<[T]>,\n    rejected?: ConstructorType<[unknown]>,\n  ) {\n    if (this.dc.destroyed()) {\n      return this;\n    }\n    const newMessageRejections = Rejections();\n    if (rejected) {\n      newMessageRejections.catch(rejected);\n    }\n    const newMessageDc = DestroyContainer();\n    const newMessage = new MessageImpl(\n      this.executor,\n      newMessageRejections,\n      newMessageDc,\n    );\n    newMessage.catch(this.rejections.reject);\n    this.dc.add(newMessage);\n    try {\n      const mbDestructor = this.executor(\n        Silence(function messageResolver(value: T) {\n          if (!newMessageDc.destroyed()) {\n            resolve(value);\n          }\n        }),\n        newMessageRejections.reject,\n        this.myName,\n      );\n      newMessageDc.add(mbDestructor);\n    } catch (e: any) {\n      newMessageRejections.reject(e);\n    }\n    return newMessage;\n  }\n\n  public catch(rejected: ConstructorType<[unknown]>) {\n    if (this.dc.destroyed()) {\n      return this;\n    }\n    this.rejections.catch(rejected);\n    return this;\n  }\n\n  public destroy() {\n    try {\n      this.dc.destroy();\n      this.rejections.destroy();\n    } catch (e) {\n      this.rejections.reject(e);\n    }\n    return this;\n  }\n\n  public destroyed() {\n    return this.dc.destroyed();\n  }\n\n  public name(newName: string) {\n    this.myName = newName;\n    return this;\n  }\n}\n","import { Message } from \"base/Message\";\n\n/**\n * Helps convert a value into a message\n */\nexport function Of<T>(value: T) {\n  return Message<T>(function OfImpl(r) {\n    r(value);\n  });\n}\n","import { Of } from \"base/Of\";\nimport { isMessage } from \"helpers/guards\";\nimport { MaybeMessage, MessageType } from \"types/MessageType\";\n\n/**\n * A function that helps to ensure that\n * the message is indeed a message object\n * and not just a value\n *\n * @url https://silentium.pw/article/actual/view\n */\nexport function Actual<T>(message: MaybeMessage<T>): MessageType<T> {\n  return isMessage(message) ? message : Of(message);\n}\n","import { DestroyContainer } from \"base/DestroyContainer\";\nimport { Message } from \"base/Message\";\nimport { isMessage } from \"helpers/guards\";\nimport { MaybeMessage, MessageType } from \"types/MessageType\";\n\n/**\n * First message - is main\n * others will be destroyed when first\n * will be destroyed\n *\n * @url https://silentium.pw/article/connected/view\n */\nexport function Connected<T>(main: MessageType, ...m: MaybeMessage[]) {\n  const dc = DestroyContainer();\n  dc.add(main);\n  dc.many(m);\n  return Message<T>(function ConnectedImpl(resolve, reject) {\n    (main as MessageType<T>).catch(reject).then(resolve);\n    m.forEach(function connectedMessagesForEach(other) {\n      if (isMessage(other)) {\n        other.catch(reject);\n      }\n    });\n    return dc.destructor();\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * Create local copy of source what can be destroyed\n */\nexport function Local<T>(_base: MaybeMessage<T>) {\n  const $base = Actual(_base);\n  return Message<T>(function LocalImpl(resolve, reject) {\n    let destroyed = false;\n    $base.then(function localBaseSub(v) {\n      if (!destroyed) {\n        resolve(v);\n      }\n    });\n    $base.catch(reject);\n    return function localDestructor() {\n      destroyed = true;\n    };\n  });\n}\n","import { Local } from \"base/Local\";\nimport { MaybeMessage } from \"types/MessageType\";\n\nexport function Props(...messages: MaybeMessage[]) {\n  return messages.map(function propsMap(m) {\n    return Local(m);\n  });\n}\n","import { Message } from \"base/Message\";\nimport { ConstructorType } from \"types/ConstructorType\";\n\n/**\n * A component that, on each access, returns a new instance\n * of a reference type based on the constructor function\n *\n * @url https://silentium.pw/article/new-component/view\n */\nexport function New<T>(construct: ConstructorType<[], T>) {\n  return Message<T>(function NewImpl(resolve) {\n    resolve(construct());\n  });\n}\n","import { Message, MessageExecutorType, MessageImpl } from \"base/Message\";\nimport { SilenceUse } from \"base/Silence\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MessageType } from \"types/MessageType\";\nimport { MessageSourceType } from \"types/SourceType\";\n\n/**\n * Base message source object, the message what can\n * accept new values\n *\n * @url https://silentium.pw/article/source/view\n */\nexport function Source<T>(\n  messageExecutor: MessageExecutorType<T>,\n  sourceExecutor: ConstructorType<[T]>,\n) {\n  return new SourceImpl(messageExecutor, sourceExecutor);\n}\n\nexport class SourceImpl<T> implements MessageSourceType<T> {\n  private message: MessageImpl<T>;\n  private silenceUse: ReturnType<typeof SilenceUse>;\n\n  public constructor(\n    messageExecutor: MessageExecutorType<T>,\n    private sourceExecutor: ConstructorType<[T]>,\n  ) {\n    this.message = Message(messageExecutor);\n    this.silenceUse = SilenceUse();\n  }\n\n  public use(value: T): this {\n    if (!this.message.destroyed()) {\n      const sourceSilenceUse = (v: unknown) => {\n        this.sourceExecutor(v as T);\n      };\n      this.silenceUse.use(value, sourceSilenceUse);\n    }\n    return this;\n  }\n\n  public then(resolved: ConstructorType<[T]>): this {\n    this.message.then(resolved);\n    return this;\n  }\n\n  public catch(rejected: ConstructorType<[unknown]>): this {\n    this.message.catch(rejected);\n    return this;\n  }\n\n  public destroy() {\n    this.message.destroy();\n    return this;\n  }\n\n  public chain(m: MessageType<T>) {\n    return m.then(this.use.bind(this));\n  }\n}\n","import { Source } from \"base/Source\";\nimport { MessageType } from \"types/MessageType\";\nimport { SourceType } from \"types/SourceType\";\n\nexport function SourceComputed<T>(\n  message: MessageType<T>,\n  source: SourceType<T>,\n) {\n  return Source<T>(\n    function sourceComputedMsgExecutor(resolve, reject) {\n      return message.then(resolve).catch(reject);\n    },\n    function sourceComputedSrcExecutor(v) {\n      source.use(v);\n    },\n  );\n}\n","/**\n * Resolver that does nothing with the passed value,\n * needed for silent message triggering\n */\nexport function Void() {\n  return () => {};\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MaybeMessage } from \"types/MessageType\";\n\ntype ExtractTypeS<T> = T extends MaybeMessage<infer U> ? U : never;\n\ntype ExtractTypesFromArrayS<T extends MaybeMessage<any>[]> = {\n  [K in keyof T]: ExtractTypeS<T[K]>;\n};\n\nconst isAllFilled = (keysFilled: Set<string>, keysKnown: Set<string>) => {\n  return keysFilled.size > 0 && keysFilled.size === keysKnown.size;\n};\n\n/**\n * A message that represents values from\n * all provided messages as an array.\n * When all messages emit their values,\n * the combined value will be returned.\n * If at least one message later emits a new\n * value, the updated array with the new value\n * will be emitted by All.\n *\n * @url https://silentium.pw/article/all-component/view\n */\nexport function All<const T extends MaybeMessage[]>(...messages: T) {\n  const $messages = messages.map(Actual);\n  return Message<ExtractTypesFromArrayS<T>>(function AllImpl(resolve, reject) {\n    const known = new Set<string>(Object.keys(messages));\n    const filled = new Set<string>();\n    const result: unknown[] = [];\n    if (known.size === 0) {\n      resolve([] as ExtractTypesFromArrayS<T>);\n      return;\n    }\n    $messages.map(function allMessagesMap(m, key) {\n      m.catch(reject);\n      m.then(function allMessageSub(v) {\n        filled.add(key.toString());\n        result[key] = v;\n        if (isAllFilled(filled, known)) {\n          resolve(result.slice() as ExtractTypesFromArrayS<T>);\n        }\n      });\n    });\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * A message that emits values received from\n * any of its bound messages\n *\n * @url https://silentium.pw/article/any-component/view\n */\nexport function Any<const T>(...messages: MaybeMessage<T>[]) {\n  const $messages = messages.map(Actual);\n  return Message<T>(function AnyImpl(resolve, reject) {\n    $messages.forEach(function anyMessagesSub(message) {\n      message.catch(reject);\n      message.then(resolve);\n    });\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { DestroyContainer } from \"base/DestroyContainer\";\nimport { Message } from \"base/Message\";\nimport { isMessage } from \"helpers/guards\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * An message that applies a function\n * to the value of the base message\n *\n * @url https://silentium.pw/article/applied/view\n */\nexport function Applied<const T, R>(\n  base: MaybeMessage<T>,\n  applier: ConstructorType<[T], MaybeMessage<R>>,\n) {\n  const $base = Actual(base);\n  return Message<R>(function AppliedImpl(resolve, reject) {\n    const dc = DestroyContainer();\n    $base.catch(reject);\n    $base.then(function appliedBaseSub(v) {\n      const result = applier(v);\n      if (isMessage(result)) {\n        dc.destroy();\n        dc.add(result);\n        result.catch(reject).then(resolve);\n      } else {\n        resolve(result);\n      }\n    });\n  });\n}\n","import { MessageType } from \"types/MessageType\";\n\n/**\n * Helps represent an message as a primitive type, which can be useful\n * for cases when you need to always have a reference to the current value\n * without updating the shared value when the current one changes.\n * For example, this could be used when passing an authorization token.\n * It can also be useful for testing or logging purposes.\n *\n * @url https://silentium.pw/article/primitive/view\n */\nexport function Primitive<T>($base: MessageType<T>, theValue: T | null = null) {\n  return new PrimitiveImpl<T>($base, theValue);\n}\n\nexport class PrimitiveImpl<T> {\n  private touched = false;\n\n  public constructor(\n    private $base: MessageType<T>,\n    private theValue: T | null = null,\n  ) {}\n\n  private ensureTouched() {\n    if (!this.touched) {\n      const primitiveBaseSub = (v: T) => {\n        this.theValue = v;\n      };\n      this.$base.then(primitiveBaseSub);\n    }\n    this.touched = true;\n  }\n\n  public [Symbol.toPrimitive]() {\n    this.ensureTouched();\n    return this.theValue;\n  }\n\n  public primitive() {\n    this.ensureTouched();\n    return this.theValue;\n  }\n\n  public primitiveWithException() {\n    this.ensureTouched();\n    if (this.theValue === null) {\n      throw new Error(\"Primitive value is null\");\n    }\n    return this.theValue;\n  }\n}\n","import { Message, MessageExecutorType, MessageImpl } from \"base/Message\";\nimport { SilenceUse } from \"base/Silence\";\nimport { Primitive } from \"components/Primitive\";\nimport { isDestroyable, isFilled, isSource } from \"helpers/guards\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MessageType } from \"types/MessageType\";\nimport { MessageSourceType, SourceType } from \"types/SourceType\";\n\n/**\n * An information object that helps multiple owners access\n * a single another information object\n *\n * @url https://silentium.pw/article/shared/view\n */\nexport function Shared<T>($base: MessageType<T> | MessageSourceType<T>) {\n  return new SharedImpl<T>($base);\n}\n\nexport class SharedImpl<T> implements MessageSourceType<T> {\n  private resolver = function sharedImplResolver(this: SharedImpl<T>, v: T) {\n    this.lastV = v;\n    this.resolvers.forEach(function sharedImplResolversForEach(r) {\n      r(v);\n    });\n  }.bind(this);\n  private lastV: T | undefined;\n  private resolvers = new Set<ConstructorType<[T]>>();\n  private source?: SourceType<T>;\n  private isDestroyed = false;\n  private silenceUse: ReturnType<typeof SilenceUse>;\n\n  public constructor(private $base: MessageType<T> | MessageSourceType<T>) {\n    if (isSource($base)) {\n      this.source = $base;\n    }\n    this.silenceUse = SilenceUse();\n  }\n\n  public then(\n    resolved: ConstructorType<[T]>,\n    rejected?: ConstructorType<[unknown]>,\n  ): MessageImpl<T> {\n    const sharedMsgExecutor: MessageExecutorType<T> = (res, rej) => {\n      this.resolvers.add(res);\n      if (this.resolvers.size === 1) {\n        this.$base.then(this.resolver, rej);\n      } else if (isFilled(this.lastV)) {\n        res(this.lastV);\n      }\n      return function sharedMsgDestructor(this: SharedImpl<T>) {\n        this.resolvers.delete(res);\n      }.bind(this);\n    };\n    const msg$ = Message<T>(sharedMsgExecutor).then(resolved);\n\n    if (rejected) {\n      msg$.catch(rejected);\n    }\n\n    return msg$;\n  }\n\n  public use(value: T) {\n    const sharedUse = (v: unknown) => {\n      if (this.source) {\n        this.source.use(v as T);\n      } else {\n        this.resolver(v as T);\n      }\n    };\n    this.silenceUse.use(value, sharedUse);\n    return this;\n  }\n\n  public catch(rejected: ConstructorType<[unknown]>) {\n    this.$base.catch(rejected);\n    return this;\n  }\n\n  public destroy() {\n    this.isDestroyed = true;\n    this.resolvers.clear();\n    if (isDestroyable(this.$base)) {\n      this.$base.destroy();\n    }\n    return this;\n  }\n\n  public destroyed() {\n    return this.isDestroyed;\n  }\n\n  public value() {\n    return Primitive(this);\n  }\n\n  public chain(m: MessageType<T>) {\n    return m.then(this.use.bind(this));\n  }\n}\n","import { Rejections } from \"base/Rejections\";\nimport { Silence, SilenceUse } from \"base/Silence\";\nimport { Shared } from \"components/Shared\";\nimport { isFilled } from \"helpers/guards\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MessageType } from \"types/MessageType\";\nimport { MessageSourceType } from \"types/SourceType\";\n\n/**\n * A component that allows creating linked objects of information and its owner\n * in such a way that if a new value is assigned to the owner, this value\n * will become the value of the linked information source\n *\n * @url https://silentium.pw/article/late/view\n */\nexport function Late<T>(v?: T) {\n  return Shared(new LateImpl<T>(v));\n}\n\nexport class LateImpl<T> implements MessageSourceType<T> {\n  private rejections = Rejections();\n  private lateR: ConstructorType<[T]> | null = null;\n  private notify() {\n    if (isFilled(this.v) && this.lateR) {\n      try {\n        this.lateR(this.v);\n      } catch (e: any) {\n        this.rejections.reject(e);\n      }\n    }\n  }\n  private silenceUse: ReturnType<typeof SilenceUse>;\n\n  public constructor(private v?: T) {\n    this.silenceUse = SilenceUse();\n  }\n\n  public then(r: ConstructorType<[T]>): this {\n    if (this.lateR) {\n      throw new Error(\n        \"Late component gets new resolver, when another was already connected!\",\n      );\n    }\n    this.lateR = Silence(r);\n    this.notify();\n    return this;\n  }\n\n  public use(value: T): this {\n    const silenceUseLateExecutor = (v: unknown) => {\n      this.v = v as T;\n      this.notify();\n    };\n    this.silenceUse.use(value, silenceUseLateExecutor);\n    return this;\n  }\n\n  public catch(rejected: ConstructorType<[unknown]>) {\n    this.rejections.catch(rejected);\n    return this;\n  }\n\n  public chain(m: MessageType<T>) {\n    return m.then(this.use.bind(this));\n  }\n\n  public destroy() {\n    this.lateR = null;\n    return this;\n  }\n}\n","import { Rejections } from \"base/Rejections\";\nimport { Late } from \"components/Late\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * Message with error caught\n * inside another message\n *\n * @url https://silentium.pw/article/catch/view\n */\nexport function Catch<T>($base: MessageType) {\n  const rejections = Rejections();\n  $base.catch(rejections.reject);\n  const $error = Late<T>();\n  rejections.catch(function catchErrorSub(e) {\n    $error.use(e as T);\n  });\n  return $error;\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MessageType, MessageTypeValue } from \"types/MessageType\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype Last<T extends readonly any[]> = T extends readonly [...infer _, infer L]\n  ? L\n  : never;\n\n/**\n * Chains messages together and triggers\n * the last message only when all previous messages\n * have emitted their values. The value of Chain will be the value\n * of the last message. If any messages\n * emit a value again after the overall Chain response was already returned,\n * then Chain emits again with the value of the last message.\n */\nexport function Chain<T extends readonly MessageType[]>(...messages: T) {\n  const $messages = messages.map(Actual);\n  return Message<MessageTypeValue<Last<T>>>(\n    function ChainImpl(resolve, reject) {\n      let $latest: MessageTypeValue<Last<T>> | undefined;\n      const handleMessage = (index: number) => {\n        const message = $messages[index] as Last<T>;\n        message.catch(reject);\n        const next = $messages[index + 1] as Last<T> | undefined;\n        message.then(function chainMessageSub(v) {\n          oneMessage(v as MessageTypeValue<Last<T>>, next, index);\n        });\n      };\n      function oneMessage(\n        v: MessageTypeValue<Last<T>>,\n        next: Last<T> | undefined,\n        index: number,\n      ) {\n        if (!next) {\n          $latest = v as MessageTypeValue<Last<T>>;\n        }\n        if ($latest) {\n          resolve($latest);\n        }\n        if (next && !$latest) {\n          handleMessage(index + 1);\n        }\n      }\n      handleMessage(0);\n    },\n  );\n}\n","import { Applied } from \"components/Applied\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * Allows applying variables from an message that passes an array to a function,\n * where each element of the array will be passed as a separate argument\n *\n * @url https://silentium.pw/article/destructured/view\n */\nexport function Destructured<const T extends any[], R>(\n  $base: MaybeMessage<T>,\n  applier: ConstructorType<any[], R>,\n) {\n  return Applied($base, function DestructuredImpl(args) {\n    return applier(...args);\n  });\n}\n","import { All } from \"components/All\";\nimport { Destructured } from \"components/Destructured\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * Component what helps to compute\n * poor functions, and represent result\n * as message\n *\n * @url https://silentium.pw/article/computed/view\n */\nexport function Computed<const T extends MaybeMessage<any>[], R>(\n  applier: ConstructorType<any[], R>,\n  ...messages: T\n) {\n  return Destructured(All(...messages), applier);\n}\n","import { Actual } from \"base/Actual\";\nimport { Source } from \"base/Source\";\nimport { All } from \"components/All\";\nimport { Destructured } from \"components/Destructured\";\nimport { Primitive } from \"components/Primitive\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { ContextType } from \"types/ContextType\";\nimport { MaybeMessage } from \"types/MessageType\";\n\nContext.transport = new Map<any, ConstructorType<[ContextType]>>();\n\n/**\n * The ability to call an external system through\n * sending a message in a standardized format\n * ContextType, the list of transport should be defined via\n * the Context.transport map object\n *\n * @url https://silentium.pw/article/context/view\n */\nexport function Context<T>(\n  name: MaybeMessage<string | symbol>,\n  params: MaybeMessage<ContextType[\"params\"]> = {},\n) {\n  const $msg = Destructured(\n    All(Actual(name), Actual(params)),\n    function contextMsgNormalize(name, params) {\n      return {\n        transport: name,\n        params,\n        result: undefined,\n        error: undefined,\n      } as ContextType;\n    },\n  );\n  return Source<T>(\n    function contextMsgImpl(resolve, reject) {\n      $msg.then(function contextMsgSub(message) {\n        const transport = Context.transport.get(message.transport);\n        if (transport === undefined) {\n          throw new Error(`Context: unknown transport ${message.transport}`);\n        }\n        if (!message.result) {\n          message.result = resolve;\n        }\n        if (!message.error) {\n          message.error = reject;\n        }\n        try {\n          transport(message);\n        } catch (error) {\n          reject(error);\n        }\n      });\n    },\n    function contextSrcImpl(value) {\n      const msg = Primitive($msg).primitive();\n      if (msg === null) {\n        throw new Error(\"Context: sourcing impossible message not existed\");\n      }\n      const transport = Context.transport.get(msg.transport);\n      if (transport === undefined) {\n        throw new Error(`Context: sourcing unknown transport ${msg.transport}`);\n      }\n      transport({\n        ...msg,\n        value,\n      });\n    },\n  );\n}\n","import { Actual } from \"base/Actual\";\nimport { MaybeMessage } from \"types/MessageType\";\nimport { ContextType } from \"types/ContextType\";\nimport { isSource } from \"helpers/guards\";\n\n/**\n * Connects an external message to an Context message chain\n *\n * @url https://silentium.pw/article/context/view\n */\nexport function ContextChain(base: MaybeMessage) {\n  const $base = Actual(base);\n  return function contextChainHandler(context: ContextType) {\n    if (context.value && isSource(base)) {\n      base.use(context.value);\n      return;\n    }\n    if (!context.result) {\n      throw new Error(\"ContextChain did not find result field in message\");\n    }\n    $base.then(context.result);\n  };\n}\n","import { Message } from \"base/Message\";\nimport { Context } from \"components/Context\";\nimport { Late } from \"components/Late\";\nimport { ContextType } from \"types/ContextType\";\n\n/**\n * Message for the arrival of a specific Context message\n * for specific transport\n *\n * @url https://silentium.pw/article/context/view\n */\nexport function ContextOf(transport: string) {\n  const $msg = Late<ContextType>();\n  Context.transport.set(transport, $msg.use.bind($msg));\n  return Message<ContextType>(function contextOfImpl(resolve, reject) {\n    $msg.catch(reject);\n    $msg.then(resolve);\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { Applied } from \"components/Applied\";\nimport { Catch } from \"components/Catch\";\nimport { MaybeMessage, MessageType } from \"types/MessageType\";\n\n/**\n * If base returns error then\n * default will return default value\n *\n * @url https://silentium.pw/article/default/view\n */\nexport function Default<T>(\n  $base: MessageType<T>,\n  _default: MaybeMessage<unknown>,\n) {\n  const $default = Actual(_default);\n  const $defaultAfterError = Applied(Catch($base), () => $default);\n  return Message<T>(function DefaultImpl(resolve) {\n    $base.then(resolve);\n    $defaultAfterError.then(resolve as any);\n  });\n}\n","import { Message } from \"base/Message\";\nimport { Primitive } from \"components/Primitive\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * When someone asks message for value\n * if there is no value in message return Error\n * if message exists return value\n *\n * @url https://silentium.pw/article/empty/view\n */\nexport function Empty<T>($base: MessageType<T>, after?: MessageType) {\n  return Message<T>(function EmptyImpl(resolve, reject) {\n    const p = Primitive($base);\n    try {\n      $base.then(resolve).catch(reject);\n      if (!after) {\n        p.primitiveWithException();\n      }\n      after?.then(function emptyAfterSub() {\n        try {\n          p.primitiveWithException();\n        } catch {\n          reject(\"Empty: no value after message!\");\n        }\n      });\n    } catch {\n      reject(\"Empty: no value in base message!\");\n    }\n  });\n}\n","import { Destroyable } from \"base/Destroyable\";\nimport { Message } from \"base/Message\";\nimport { MessageType } from \"types/MessageType\";\n\ntype ExecutorApplier<T> = (executor: (v: T) => void) => (v: T) => void;\n\n/**\n * Applies a value transfer function to the resolver\n * and returns the same value transfer function for the resolver\n * Useful for applying functions like debounced or throttle\n */\nexport function ExecutorApplied<T>(\n  $base: MessageType<T>,\n  applier: ExecutorApplier<T>,\n) {\n  return Message<T>(function ExecutorAppliedImpl(resolve, reject) {\n    $base.catch(reject);\n    const sub = Destroyable($base.then(applier(resolve)));\n    return function executorAppliedDestroy() {\n      sub.destroy();\n    };\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MaybeMessage, MessageType } from \"types/MessageType\";\n\n/**\n * Filters values from the source message based on a predicate function,\n * optionally providing a default value when the predicate fails.\n */\nexport function Filtered<T>(\n  base: MaybeMessage<T>,\n  predicate: ConstructorType<[T], boolean>,\n  defaultValue?: T,\n): MessageType<T> {\n  const $base = Actual(base);\n  return Message<T>(function FilteredImpl(resolve, reject) {\n    $base.catch(reject);\n    $base.then(function filteredBaseSub(v) {\n      if (predicate(v)) {\n        resolve(v);\n      } else if (defaultValue !== undefined) {\n        resolve(defaultValue);\n      }\n    });\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Computed } from \"components/Computed\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * Reduces values of message data to one common value\n */\nexport function Fold<T extends any[], TG>(\n  data: MaybeMessage<T>,\n  reducer: (acc: TG, item: T[number], index: number) => TG,\n  initial: MaybeMessage<TG>,\n) {\n  const $data = Actual(data);\n  const $initial = Actual(initial);\n  return Computed(\n    function foldComputed(data, initial) {\n      return data.reduce(reducer, initial);\n    },\n    $data,\n    $initial,\n  );\n}\n","import { Message } from \"base/Message\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * Message what freezes first known value\n */\nexport function Freeze<T>($base: MessageType<T>, $invalidate?: MessageType<T>) {\n  let freezedValue: T | null = null;\n  return Message<T>(function FreezeImpl(resolve, reject) {\n    $base.catch(reject);\n    $base.then(function freezeBaseSub(v) {\n      if (freezedValue === null) {\n        freezedValue = v;\n      }\n      resolve(freezedValue as T);\n    });\n    $invalidate?.then(function freezeInvalidateSub() {\n      freezedValue = null;\n    });\n  });\n}\n","import { MaybeMessage } from \"types/MessageType\";\nimport { All } from \"components/All\";\nimport { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { ConstructorType } from \"types/ConstructorType\";\n\n/**\n * A message derived from event with a different\n * method call interface, based on callbacks.\n * Allows attaching a custom handler to an existing event source\n * and presenting it as a silentium message\n */\nexport function FromEvent<T>(\n  emitter: MaybeMessage<any>,\n  eventName: MaybeMessage<string>,\n  subscribeMethod: MaybeMessage<string>,\n  unsubscribeMethod?: MaybeMessage<string>,\n) {\n  const $emitter = Actual(emitter);\n  const $eventName = Actual(eventName);\n  const $subscribeMethod = Actual(subscribeMethod);\n  const $unsubscribeMethod = Actual(unsubscribeMethod);\n  return Message<T>(function FromEventImpl(resolve, reject) {\n    $emitter.catch(reject);\n    $eventName.catch(reject);\n    $subscribeMethod.catch(reject);\n    $unsubscribeMethod.catch(reject);\n    let lastR: ConstructorType<[T]> | null = null;\n    const handler = (v: T) => {\n      if (lastR) {\n        lastR(v);\n      }\n    };\n    All($emitter, $eventName, $subscribeMethod).then(function fromEventAllSub([\n      emitter,\n      eventName,\n      subscribe,\n    ]) {\n      lastR = resolve;\n      if (!emitter?.[subscribe]) {\n        return;\n      }\n      emitter[subscribe](eventName, handler);\n    });\n    return function fromEventDestroy() {\n      lastR = null;\n      if (!$unsubscribeMethod) {\n        return;\n      }\n      All($emitter, $eventName, $unsubscribeMethod).then(\n        function fromEventDestroyAllSub([emitter, eventName, unsubscribe]) {\n          emitter?.[unsubscribe as string]?.(eventName, handler);\n        },\n      );\n    };\n  });\n}\n","import { Message } from \"base/Message\";\nimport { isDestroyable } from \"helpers/guards\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * Ability to create new messages when they will be needed\n *\n * @url https://silentium.pw/article/lazy/view\n */\nexport function Lazy<T>(constructor: () => MessageType<T>) {\n  return Message<T>(function LazyImpl(resolve, reject) {\n    const inst = constructor();\n    inst.catch(reject).then(resolve);\n    return function LazyDestroy() {\n      if (isDestroyable(inst)) {\n        inst.destroy();\n      }\n    };\n  });\n}\n","import { MaybeMessage, MessageType } from \"types/MessageType\";\nimport { All } from \"components/All\";\nimport { isMessage } from \"helpers/guards\";\nimport { Of } from \"base/Of\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { Message } from \"base/Message\";\nimport { Actual } from \"base/Actual\";\nimport { DestroyContainer } from \"base/DestroyContainer\";\n\n/**\n * Component that applies an info object constructor to each data item,\n * producing an information source with new values\n *\n * @url https://silentium.pw/article/map/view\n */\nexport function Map<T, TG>(\n  base: MaybeMessage<T[]>,\n  target: ConstructorType<[any], MessageType<TG>>,\n) {\n  const $base = Actual(base);\n  return Message<TG[]>(function MapImpl(resolve, reject) {\n    $base.catch(reject);\n    const infos: MessageType<TG>[] = [];\n    const dc = DestroyContainer();\n    $base.then(function mapBaseSub(v) {\n      infos.length = 0;\n      dc.destroy();\n      v.forEach(function mapValueForEach(val) {\n        let $val: MessageType<T> | T = val;\n        if (!isMessage($val as object)) {\n          $val = Of($val);\n        }\n        const info = target($val);\n        dc.add(info);\n        infos.push(info);\n      });\n      All(...infos).then(resolve);\n    });\n  });\n}\n","import { Message } from \"base/Message\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * Limits the number of values from the information source\n * to a single value - once the first value is emitted, no more\n * values are delivered from the source\n *\n * @url https://silentium.pw/article/once/view\n */\nexport function Once<T>($base: MessageType<T>) {\n  return Message<T>(function OnceImpl(resolve, reject) {\n    let isFilled = false;\n    $base.catch(reject);\n    $base.then(function onceBaseSub(v) {\n      if (!isFilled) {\n        isFilled = true;\n        resolve(v);\n      }\n    });\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype Last<T extends readonly any[]> = T extends readonly [...infer _, infer L]\n  ? L extends (...args: any) => any\n    ? L\n    : never\n  : never;\n\n/**\n * Helps to pipe actors or functions to one common actor\n *\n * @url https://silentium.pw/article/piped/view\n */\nexport function Piped<T extends ((...vars: any) => MaybeMessage)[]>(\n  $m: MaybeMessage,\n  ...c: T\n) {\n  return c.reduce(function pipedReduce(msg, Constructor) {\n    return Actual(Constructor(msg));\n  }, Actual($m)) as ReturnType<Last<T>>;\n}\n","import { DestroyContainer } from \"base/DestroyContainer\";\nimport { Message } from \"base/Message\";\nimport { Late } from \"components/Late\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { MessageType } from \"types/MessageType\";\n\nexport function Process<T, R = unknown>(\n  $base: MessageType<T>,\n  builder: ConstructorType<[T], MessageType<R>>,\n) {\n  return Message<R>(function ProcessImpl(resolve, reject) {\n    const $res = Late<R>();\n    const dc = DestroyContainer();\n    $base.then(function processBaseSub(v) {\n      dc.destroy();\n      const $msg = builder(v);\n      dc.add($msg);\n      $res.chain($msg);\n      $msg.catch(reject);\n    });\n    $base.catch(reject);\n    $res.then(resolve);\n    return function processDestructor() {\n      dc.destroy();\n    };\n  });\n}\n","import { MessageType } from \"types/MessageType\";\n\n/**\n * Convert message to promise\n */\nexport function Promisify<T>($message: MessageType<T>) {\n  return new Promise(function promisifyExecutor(resolve, reject) {\n    $message.then(resolve, reject);\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * First responded message\n *\n * @url https://silentium.pw/article/race/view\n */\nexport function Race<const T extends MaybeMessage[]>(...messages: T) {\n  const $messages = messages.map(Actual);\n  return Message(function RaceImpl(resolve, reject) {\n    let responded = false;\n    $messages.forEach(function raceMessagesForEach($message) {\n      $message.catch(reject).then(function raceMessageSub(v) {\n        if (responded === false) {\n          responded = true;\n          resolve(v);\n        }\n      });\n    });\n  });\n}\n","import { Message } from \"base/Message\";\nimport { MessageType } from \"types/MessageType\";\n\n/**\n * Creates a sequence that accumulates all values from the source into an array,\n * emitting the growing array with each new value.\n */\nexport function Sequence<T>($base: MessageType<T>) {\n  return Message<T[]>(function SequenceImpl(resolve, reject) {\n    const result: T[] = [];\n    $base.catch(reject);\n    $base.then(function sequenceBaseSub(v) {\n      result.push(v);\n      resolve(result.slice());\n    });\n  });\n}\n","import { Actual } from \"base/Actual\";\nimport { Message } from \"base/Message\";\nimport { MaybeMessage } from \"types/MessageType\";\n\n/**\n * Component that receives a data array and yields values one by one\n */\nexport function Stream<T>(base: MaybeMessage<T[]>) {\n  const $base = Actual(base);\n  return Message<T>(function StreamImpl(resolve, reject) {\n    $base.catch(reject);\n    $base.then(function streamBaseSub(v) {\n      v.forEach(function streamBaseForEach(cv) {\n        resolve(cv);\n      });\n    });\n  });\n}\n","import { Void } from \"base/Void\";\nimport { Context } from \"components/Context\";\nimport { isMessage } from \"helpers/guards\";\n\n/**\n * Track creation and destruction of components\n * uses Context component to send messages\n * when created sends action=created\n * when destroyed sends action=destroyed\n *\n * @url https://silentium.pw/article/trackable/view\n */\nexport function Trackable<T>(name: string, target: T): T {\n  Context(\"trackable\", { name, action: \"created\" }).then(Void());\n  if (isMessage(target)) {\n    target.then(function trackableTargetSub(value) {\n      Context(\"trackable\", { name, action: \"value\", value }).then(Void());\n    });\n  }\n  return new Proxy(target as object, {\n    get(target, prop, receiver) {\n      if (prop === \"then\") {\n        Context(\"trackable\", { name, action: \"executed\" }).then(Void());\n      }\n      if (prop === \"destroy\") {\n        Context(\"trackable\", { name, action: \"destroyed\" }).then(Void());\n      }\n      return Reflect.get(target, prop, receiver);\n    },\n  }) as T;\n}\n","import { Primitive } from \"components/Primitive\";\nimport { MessageType } from \"types/MessageType\";\n\nexport interface PassiveType<T> {\n  value: T | null;\n}\n\n/**\n * Component what will return same proxied object\n * but with value property\n *\n * @url https://silentium.pw/article/value/view\n */\nexport function Value<T>(\n  target: MessageType<T>,\n): MessageType<T> & PassiveType<T> {\n  const p = Primitive(target);\n  return new Proxy(target, {\n    get(target, prop, receiver) {\n      if (prop === \"value\") {\n        return p.primitive();\n      }\n      return Reflect.get(target, prop, receiver);\n    },\n  }) as MessageType<T> & PassiveType<T>;\n}\n","import { All } from \"components/All\";\nimport { Applied } from \"components/Applied\";\nimport { Primitive } from \"components/Primitive\";\nimport { Shared } from \"components/Shared\";\nimport { ConstructorType } from \"types/ConstructorType\";\nimport { DestroyableType } from \"types/DestroyableType\";\nimport { MessageType } from \"types/MessageType\";\n\ndeclare global {\n  interface SilentiumDebug {\n    value: ($message: MessageType) => unknown;\n    print: (...messages: MessageType[]) => void;\n    destroyable: (onDestroy: () => void) => MessageType<any> & DestroyableType;\n  }\n\n  interface GlobalThis {\n    silentiumDebug: SilentiumDebug;\n  }\n\n  // @ts-expect-error global variable\n  const silentiumDebug: SilentiumDebug;\n}\n\n/**\n * Helps to print message value\n */\nconst silentiumPrint = (...messages: MessageType[]) => {\n  Applied(\n    All(\n      ...messages.map(function silentiumPrintAllMap(e) {\n        return Shared(e);\n      }),\n    ),\n    JSON.stringify,\n  ).then(console.log);\n};\n\n/**\n * Helps to debug current value of message\n */\nconst silentiumValue = ($message: MessageType) =>\n  Primitive($message).primitive();\n\nexport class MessageDestroyable implements MessageType<any>, DestroyableType {\n  public constructor(private onDestroy: () => void) {}\n\n  public then(resolve: ConstructorType<[string]>) {\n    resolve(`Wait destroy ${Date.now()}`);\n    return this;\n  }\n\n  public catch() {\n    return this;\n  }\n\n  public destroy() {\n    this.onDestroy();\n    return this;\n  }\n}\n\n/**\n * Helps to debug destroying\n */\nconst silentiumDestroyable = (onDestroy: () => void) =>\n  new MessageDestroyable(onDestroy);\n\n/**\n * global functions for debuging\n * silentium programs\n */\nexport function DevTools() {\n  if (typeof globalThis !== \"undefined\") {\n    (globalThis as any).silentiumDebug = {\n      value: silentiumValue,\n      print: silentiumPrint,\n      destroyable: silentiumDestroyable,\n    };\n  }\n}\n"],"names":["isFilled","value","isMessage","o","then","isSource","use","isDestroyable","destroy","isDestroyed","destroyed","Destroyable","base","DestroyableImpl","constructor","this","DestroyContainer","DestroyContainerImpl","__publicField","add","e","destructors","push","many","destroyableList","forEach","d","_destroyed","length","destructor","bind","Rejections","RejectionsImpl","_RejectionsImpl","reject","reason","lastRejectReason","catchers","catcher","globalCatch","console","error","join","rejected","ResetSilenceCache","Symbol","Silence","resolve","lastValue","v","SilenceUse","cb","ensureFunction","label","Error","ensureMessage","Message","executor","MessageImpl","rejections","dc","newMessageRejections","catch","newMessageDc","newMessage","mbDestructor","myName","name","newName","Of","r","Actual","message","Connected","main","m","other","Local","_base","$base","Props","messages","map","New","construct","Source","messageExecutor","sourceExecutor","SourceImpl","silenceUse","sourceSilenceUse","resolved","chain","SourceComputed","source","Void","All","$messages","known","Set","Object","keys","filled","result","size","key","keysFilled","keysKnown","toString","slice","Any","Applied","applier","Primitive","theValue","PrimitiveImpl","ensureTouched","touched","primitiveBaseSub","toPrimitive","primitive","primitiveWithException","Shared","SharedImpl","lastV","resolvers","msg$","res","rej","resolver","delete","clear","Late","LateImpl","notify","lateR","Catch","$error","Chain","$latest","handleMessage","index","next","oneMessage","Destructured","args","Computed","Context","params","$msg","transport","get","msg","ContextChain","context","ContextOf","set","Default","_default","$default","$defaultAfterError","Empty","after","p","ExecutorApplied","sub","Filtered","predicate","defaultValue","Fold","data","reducer","initial","reduce","Freeze","$invalidate","freezedValue","FromEvent","emitter","eventName","subscribeMethod","unsubscribeMethod","$emitter","$eventName","$subscribeMethod","$unsubscribeMethod","lastR","handler","subscribe","unsubscribe","Lazy","inst","Map","target","infos","val","$val","info","Once","Piped","$m","c","Constructor","Process","builder","$res","Promisify","$message","Promise","Race","responded","Sequence","Stream","cv","Trackable","action","Proxy","prop","receiver","Reflect","Value","silentiumPrint","JSON","stringify","log","silentiumValue","MessageDestroyable","onDestroy","Date","now","silentiumDestroyable","DevTools","globalThis","silentiumDebug","print","destroyable"],"mappings":"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"}