silentium-components 0.0.26 → 0.0.28

package/dist/silentium-components.cjs

@@ -2,97 +2,139 @@
 
 var silentium = require('silentium');
 
-const dirty = (baseEntitySource, alwaysKeep = [], excludeKeys = []) => {
-  const [comparing, co] = silentium.of();
-  const comparingDetached = silentium.applied(
-    comparing,
-    (value) => JSON.parse(JSON.stringify(value))
-  );
-  const i = (o) => {
-    silentium.all(
-      comparingDetached,
-      baseEntitySource
-    )(([comparing2, base]) => {
-      if (!comparing2) {
-        return;
-      }
-      o(
-        Object.fromEntries(
-          Object.entries(comparing2).filter(([key, value]) => {
-            if (alwaysKeep.includes(key)) {
-              return true;
-            }
-            if (excludeKeys.includes(key)) {
-              return false;
-            }
-            return value !== base[key];
-          })
-        )
-      );
-    });
-  };
-  return [i, co];
-};
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+class Dirty extends silentium.TheInformation {
+  constructor(baseEntitySource, alwaysKeep = [], excludeKeys = []) {
+    super([baseEntitySource]);
+    this.baseEntitySource = baseEntitySource;
+    this.alwaysKeep = alwaysKeep;
+    this.excludeKeys = excludeKeys;
+    __publicField$1(this, "comparingSrc", new silentium.Late());
+  }
+  value(o) {
+    const comparingDetached = new silentium.Applied(
+      this.comparingSrc,
+      (value) => JSON.parse(JSON.stringify(value))
+    );
+    const allSrc = new silentium.All(comparingDetached, this.baseEntitySource).value(
+      new silentium.From(([comparing, base]) => {
+        if (!comparing) {
+          return;
+        }
+        o.give(
+          Object.fromEntries(
+            Object.entries(comparing).filter(([key, value]) => {
+              if (this.alwaysKeep.includes(key)) {
+                return true;
+              }
+              if (this.excludeKeys.includes(key)) {
+                return false;
+              }
+              return value !== base[key];
+            })
+          )
+        );
+      })
+    );
+    this.addDep(allSrc);
+    return this;
+  }
+  owner() {
+    return this.comparingSrc.owner();
+  }
+}
 
-const loading = (loadingStartSource, loadingFinishSource) => {
-  return (o) => {
-    loadingStartSource(() => {
-      o(true);
-    });
-    loadingFinishSource(() => {
-      o(false);
-    });
-  };
-};
+class Loading extends silentium.TheInformation {
+  constructor(loadingStartSrc, loadingFinishSrc) {
+    super(loadingFinishSrc, loadingStartSrc);
+    this.loadingStartSrc = loadingStartSrc;
+    this.loadingFinishSrc = loadingFinishSrc;
+  }
+  value(o) {
+    this.loadingStartSrc.value(
+      new silentium.From(() => {
+        o.give(true);
+      })
+    );
+    this.loadingFinishSrc.value(
+      new silentium.From(() => {
+        o.give(false);
+      })
+    );
+    return this;
+  }
+}
 
-const path = (baseSrc, keySrc) => {
-  return (o) => {
-    silentium.all(
-      baseSrc,
-      keySrc
-    )(([base, key]) => {
-      const keyChunks = key.split(".");
-      let value = base;
-      keyChunks.forEach((keyChunk) => {
-        value = value[keyChunk];
-      });
-      if (value !== void 0 && value !== base) {
-        o(value);
-      }
-    });
-  };
-};
+class Path extends silentium.TheInformation {
+  constructor(baseSrc, keySrc) {
+    super(baseSrc, keySrc);
+    this.baseSrc = baseSrc;
+    this.keySrc = keySrc;
+  }
+  value(o) {
+    const allSrc = new silentium.All(this.baseSrc, this.keySrc).value(
+      new silentium.From(([base, key]) => {
+        const keyChunks = key.split(".");
+        let value = base;
+        keyChunks.forEach((keyChunk) => {
+          value = value[keyChunk];
+        });
+        if (value !== void 0 && value !== base) {
+          o.give(value);
+        }
+      })
+    );
+    this.addDep(allSrc);
+    return this;
+  }
+}
 
-const deadline = (error, baseSrc, timeoutSrc) => {
-  let timerHead = null;
-  return (o) => {
-    const [baseShared, pool] = silentium.sharedStateless(baseSrc);
-    timeoutSrc((timeout) => {
-      if (timerHead) {
-        clearTimeout(timerHead);
-      }
-      let timeoutReached = false;
-      timerHead = setTimeout(() => {
-        if (timeoutReached) {
-          return;
+class Deadline extends silentium.TheInformation {
+  constructor(error, baseSrc, timeoutSrc) {
+    super([error, baseSrc, timeoutSrc]);
+    this.error = error;
+    this.baseSrc = baseSrc;
+    this.timeoutSrc = timeoutSrc;
+  }
+  value(o) {
+    let timerHead = null;
+    const s = new silentium.Shared(this.baseSrc, true);
+    this.addDep(s);
+    this.timeoutSrc.value(
+      new silentium.From((timeout) => {
+        if (timerHead) {
+          clearTimeout(timerHead);
         }
-        timeoutReached = true;
-        error(new Error("Timeout reached in Deadline class"));
-      }, timeout);
-      const f = silentium.filtered(baseShared, () => !timeoutReached);
-      f(o);
-      baseShared(() => {
-        timeoutReached = true;
-      });
-    });
-    return () => {
-      pool.destroy();
-    };
-  };
-};
+        let timeoutReached = false;
+        timerHead = setTimeout(() => {
+          if (timeoutReached) {
+            return;
+          }
+          timeoutReached = true;
+          this.error.give(new Error("Timeout reached in Deadline class"));
+        }, timeout);
+        const f = new silentium.Filtered(s, () => !timeoutReached);
+        this.addDep(f);
+        f.value(o);
+        s.value(
+          new silentium.From(() => {
+            timeoutReached = true;
+          })
+        );
+      })
+    );
+    return this;
+  }
+}
 
-const tick = (baseSrc) => {
-  return (o) => {
+class Tick extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
     let microtaskScheduled = false;
     let lastValue = null;
     const scheduleMicrotask = () => {
@@ -100,290 +142,476 @@ const tick = (baseSrc) => {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          o(lastValue);
+          o.give(lastValue);
           lastValue = null;
         }
       });
     };
-    baseSrc((v) => {
-      lastValue = v;
-      if (!microtaskScheduled) {
-        scheduleMicrotask();
-      }
-    });
-  };
-};
+    this.baseSrc.value(
+      new silentium.From((v) => {
+        lastValue = v;
+        if (!microtaskScheduled) {
+          scheduleMicrotask();
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const sync = (base) => {
-  let value;
-  base((v) => {
-    value = v;
-  });
-  return {
-    value() {
-      if (value === void 0) {
-        throw new Error("no value in sync");
-      }
-      return value;
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Sync extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+    __publicField(this, "theValue");
+    __publicField(this, "isInit", false);
+  }
+  value(o) {
+    this.baseSrc.value(o);
+    return this;
+  }
+  valueExisted() {
+    this.initOwner();
+    return silentium.isFilled(this.theValue);
+  }
+  valueSync() {
+    this.initOwner();
+    if (!silentium.isFilled(this.theValue)) {
+      throw new Error("no value in sync");
+    }
+    return this.theValue;
+  }
+  initOwner() {
+    if (!this.isInit) {
+      this.isInit = true;
+      this.value(
+        new silentium.From((v) => {
+          this.theValue = v;
+        })
+      );
     }
-  };
-};
+    return this;
+  }
+}
 
-const deferred = (baseSrc, triggerSrc) => {
-  return (o) => {
-    const baseSync = sync(baseSrc);
-    triggerSrc(() => {
-      if (silentium.isFilled(baseSync.value())) {
-        o(baseSync.value());
-      }
-    });
-  };
-};
+class Deferred extends silentium.TheInformation {
+  constructor(baseSrc, triggerSrc) {
+    super();
+    this.baseSrc = baseSrc;
+    this.triggerSrc = triggerSrc;
+  }
+  value(o) {
+    const baseSync = new Sync(this.baseSrc).initOwner();
+    this.triggerSrc.value(
+      new silentium.From(() => {
+        if (silentium.isFilled(baseSync.valueSync())) {
+          o.give(baseSync.valueSync());
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const branch = (condition, left, right) => {
-  return (o) => {
-    const leftSync = sync(left);
+class Branch extends silentium.TheInformation {
+  constructor(conditionSrc, leftSrc, rightSrc) {
+    super([conditionSrc, leftSrc, rightSrc]);
+    this.conditionSrc = conditionSrc;
+    this.leftSrc = leftSrc;
+    this.rightSrc = rightSrc;
+  }
+  value(o) {
+    const leftSync = new Sync(this.leftSrc).initOwner();
     let rightSync;
-    if (right !== void 0) {
-      rightSync = sync(right);
+    if (this.rightSrc !== void 0) {
+      rightSync = new Sync(this.rightSrc).initOwner();
     }
-    condition((v) => {
-      if (v) {
-        o(leftSync.value());
-      } else if (rightSync) {
-        o(rightSync.value());
-      }
-    });
-  };
-};
+    this.conditionSrc.value(
+      new silentium.From((v) => {
+        if (v) {
+          o.give(leftSync.valueSync());
+        } else if (rightSync) {
+          o.give(rightSync.valueSync());
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const memo = (baseSrc) => {
-  let lastValue = null;
-  return (o) => {
-    baseSrc((v) => {
-      if (v !== lastValue) {
-        o(v);
-        lastValue = v;
-      }
-    });
-  };
-};
+class Memo extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
+    let lastValue = null;
+    this.baseSrc.value(
+      new silentium.From((v) => {
+        if (v !== lastValue) {
+          o.give(v);
+          lastValue = v;
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const lock = (baseSrc, lockSrc) => {
-  let locked = false;
-  const i = silentium.filtered(baseSrc, () => !locked);
-  return (o) => {
-    lockSrc((newLock) => {
-      locked = newLock;
-    });
-    i(o);
-  };
-};
+class Lock extends silentium.TheInformation {
+  constructor(baseSrc, lockSrc) {
+    super(baseSrc, lockSrc);
+    this.baseSrc = baseSrc;
+    this.lockSrc = lockSrc;
+  }
+  value(o) {
+    let locked = false;
+    this.lockSrc.value(
+      new silentium.From((newLock) => {
+        locked = newLock;
+      })
+    );
+    const i = new silentium.Filtered(this.baseSrc, () => !locked);
+    this.addDep(i);
+    i.value(o);
+    return this;
+  }
+}
 
-const shot = (targetSrc, triggerSrc) => {
-  return (o) => {
-    const targetSync = sync(targetSrc);
-    triggerSrc(() => {
-      if (silentium.isFilled(targetSync.value())) {
-        o(targetSync.value());
-      }
-    });
-  };
-};
+class Shot extends silentium.TheInformation {
+  constructor(targetSrc, triggerSrc) {
+    super(targetSrc, triggerSrc);
+    this.targetSrc = targetSrc;
+    this.triggerSrc = triggerSrc;
+  }
+  value(o) {
+    const targetSync = new Sync(this.targetSrc);
+    targetSync.initOwner();
+    this.triggerSrc.value(
+      new silentium.From(() => {
+        if (targetSync.valueExisted()) {
+          o.give(targetSync.valueSync());
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const onlyChanged = (baseSrc) => {
-  let firstValue = false;
-  return (o) => {
-    baseSrc((v) => {
-      if (firstValue === false) {
-        firstValue = true;
-      } else {
-        o(v);
-      }
-    });
-  };
-};
+class OnlyChanged extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
+    let firstValue = false;
+    this.baseSrc.value(
+      new silentium.From((v) => {
+        if (firstValue === false) {
+          firstValue = true;
+        } else {
+          o.give(v);
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const hashTable = (base) => {
-  return (o) => {
+class HashTable extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
     const record = {};
-    base(([key, value]) => {
-      record[key] = value;
-      o(record);
-    });
-  };
-};
+    this.baseSrc.value(
+      new silentium.From(([key, value]) => {
+        record[key] = value;
+        o.give(record);
+      })
+    );
+    return this;
+  }
+}
 
-const record = (recordSrc) => {
-  return (o) => {
-    const keys = Object.keys(recordSrc);
-    silentium.all(...Object.values(recordSrc))((entries) => {
-      const record2 = {};
-      entries.forEach((entry, index) => {
-        record2[keys[index]] = entry;
-      });
-      o(record2);
-    });
-  };
-};
+class RecordOf extends silentium.TheInformation {
+  constructor(recordSrc) {
+    super(...Object.values(recordSrc));
+    this.recordSrc = recordSrc;
+  }
+  value(o) {
+    const keys = Object.keys(this.recordSrc);
+    new silentium.All(...Object.values(this.recordSrc)).value(
+      new silentium.From((entries) => {
+        const record = {};
+        entries.forEach((entry, index) => {
+          record[keys[index]] = entry;
+        });
+        o.give(record);
+      })
+    );
+    return this;
+  }
+}
 
-const concatenated = (sources, joinPartSrc = silentium.i("")) => {
-  return (o) => {
-    silentium.all(
-      joinPartSrc,
-      ...sources
-    )(([joinPart, ...strings]) => {
-      o(strings.join(joinPart));
-    });
-  };
-};
+class Concatenated extends silentium.TheInformation {
+  constructor(sources, joinPartSrc = new silentium.Of("")) {
+    super(...sources, joinPartSrc);
+    this.sources = sources;
+    this.joinPartSrc = joinPartSrc;
+  }
+  value(o) {
+    new silentium.All(this.joinPartSrc, ...this.sources).value(
+      new silentium.From(([joinPart, ...strings]) => {
+        o.give(strings.join(joinPart));
+      })
+    );
+    return this;
+  }
+}
 
-const regexpMatched = (patternSrc, valueSrc, flagsSrc = silentium.i("")) => (o) => {
-  silentium.all(
-    patternSrc,
-    valueSrc,
-    flagsSrc
-  )(([pattern, value, flags]) => {
-    o(new RegExp(pattern, flags).test(value));
-  });
-};
+class RegexpMatched extends silentium.TheInformation {
+  constructor(patternSrc, valueSrc, flagsSrc = new silentium.Of("")) {
+    super(patternSrc, valueSrc, flagsSrc);
+    this.patternSrc = patternSrc;
+    this.valueSrc = valueSrc;
+    this.flagsSrc = flagsSrc;
+  }
+  value(o) {
+    new silentium.All(this.patternSrc, this.valueSrc, this.flagsSrc).value(
+      new silentium.From(([pattern, value, flags]) => {
+        o.give(new RegExp(pattern, flags).test(value));
+      })
+    );
+    return this;
+  }
+}
 
-const router = (urlSrc, routesSrc, defaultSrc) => {
-  return (o) => {
-    routesSrc((routes) => {
-      silentium.any(
-        silentium.chain(urlSrc, defaultSrc),
-        ...routes.map((r) => {
-          return branch(
-            regexpMatched(
-              silentium.i(r.pattern),
-              urlSrc,
-              r.patternFlags ? silentium.i(r.patternFlags) : void 0
-            ),
-            typeof r.template === "function" ? r.template : silentium.i(r.template)
-          );
-        })
-      )(o);
-    });
-  };
-};
+class RegexpReplaced extends silentium.TheInformation {
+  constructor(valueSrc, patternSrc, replaceValueSrc, flagsSrc = new silentium.Of("")) {
+    super(valueSrc, patternSrc, replaceValueSrc, flagsSrc);
+    this.valueSrc = valueSrc;
+    this.patternSrc = patternSrc;
+    this.replaceValueSrc = replaceValueSrc;
+    this.flagsSrc = flagsSrc;
+  }
+  value(o) {
+    new silentium.All(
+      this.patternSrc,
+      this.valueSrc,
+      this.replaceValueSrc,
+      this.flagsSrc
+    ).value(
+      new silentium.From(([pattern, value, replaceValue, flags]) => {
+        o.give(String(value).replace(new RegExp(pattern, flags), replaceValue));
+      })
+    );
+    return this;
+  }
+}
 
-const regexpReplaced = (valueSrc, patternSrc, replaceValueSrc, flagsSrc = silentium.i("")) => (o) => {
-  silentium.all(
-    patternSrc,
-    valueSrc,
-    replaceValueSrc,
-    flagsSrc
-  )(([pattern, value, replaceValue, flags]) => {
-    o(String(value).replace(new RegExp(pattern, flags), replaceValue));
-  });
-};
+class RegexpMatch extends silentium.TheInformation {
+  constructor(patternSrc, valueSrc, flagsSrc = new silentium.Of("")) {
+    super(patternSrc, valueSrc, flagsSrc);
+    this.patternSrc = patternSrc;
+    this.valueSrc = valueSrc;
+    this.flagsSrc = flagsSrc;
+  }
+  value(o) {
+    new silentium.All(this.patternSrc, this.valueSrc, this.flagsSrc).value(
+      new silentium.From(([pattern, value, flags]) => {
+        const result = new RegExp(pattern, flags).exec(value);
+        o.give(result ?? []);
+      })
+    );
+    return this;
+  }
+}
 
-const regexpMatch = (patternSrc, valueSrc, flagsSrc = silentium.i("")) => (o) => {
-  silentium.all(
-    patternSrc,
-    valueSrc,
-    flagsSrc
-  )(([pattern, value, flags]) => {
-    const result = new RegExp(pattern, flags).exec(value);
-    o(result ?? []);
-  });
-};
+class Set extends silentium.TheInformation {
+  constructor(baseSrc, keySrc, valueSrc) {
+    super(baseSrc, keySrc, valueSrc);
+    this.baseSrc = baseSrc;
+    this.keySrc = keySrc;
+    this.valueSrc = valueSrc;
+  }
+  value(o) {
+    new silentium.All(this.baseSrc, this.keySrc, this.valueSrc).value(
+      new silentium.From(([base, key, value]) => {
+        base[key] = value;
+        o.give(base);
+      })
+    );
+    return this;
+  }
+}
 
-const set = (baseSrc, keySrc, valueSrc) => {
-  return (o) => {
-    silentium.all(
-      baseSrc,
-      keySrc,
-      valueSrc
-    )(([base, key, value]) => {
-      base[key] = value;
-      o(base);
-    });
-  };
-};
+class Router extends silentium.TheInformation {
+  constructor(urlSrc, routesSrc, defaultSrc) {
+    super(urlSrc, routesSrc, defaultSrc);
+    this.urlSrc = urlSrc;
+    this.routesSrc = routesSrc;
+    this.defaultSrc = defaultSrc;
+  }
+  value(o) {
+    this.routesSrc.value(
+      new silentium.From((routes) => {
+        new silentium.Any(
+          new silentium.Chain(this.urlSrc, this.defaultSrc),
+          ...routes.map((r) => {
+            return new Branch(
+              new RegexpMatched(
+                new silentium.Of(r.pattern),
+                this.urlSrc,
+                r.patternFlags ? new silentium.Of(r.patternFlags) : void 0
+              ),
+              r.template instanceof silentium.TheInformation ? r.template : new silentium.Of(r.template)
+            );
+          })
+        ).value(o);
+      })
+    );
+    return this;
+  }
+}
 
-const and = (oneSrc, twoSrc) => {
-  return (o) => {
-    silentium.all(
-      oneSrc,
-      twoSrc
-    )(([one, two]) => {
-      o(one && two);
-    });
-  };
-};
+class And extends silentium.TheInformation {
+  constructor(oneSrc, twoSrc) {
+    super(oneSrc, twoSrc);
+    this.oneSrc = oneSrc;
+    this.twoSrc = twoSrc;
+  }
+  value(o) {
+    new silentium.All(this.oneSrc, this.twoSrc).value(
+      new silentium.From(([one, two]) => {
+        o.give(one && two);
+      })
+    );
+    return this;
+  }
+}
 
-const or = (oneSrc, twoSrc) => {
-  return (o) => {
-    silentium.all(
-      oneSrc,
-      twoSrc
-    )(([one, two]) => {
-      o(one || two);
-    });
-  };
-};
+class Or extends silentium.TheInformation {
+  constructor(oneSrc, twoSrc) {
+    super(oneSrc, twoSrc);
+    this.oneSrc = oneSrc;
+    this.twoSrc = twoSrc;
+  }
+  value(o) {
+    new silentium.All(this.oneSrc, this.twoSrc).value(
+      new silentium.From(([one, two]) => {
+        o.give(one || two);
+      })
+    );
+    return this;
+  }
+}
 
-const not = (baseSrc) => {
-  return (o) => {
-    baseSrc((v) => {
-      o(!v);
-    });
-  };
-};
+class Not extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
+    this.baseSrc.value(
+      new silentium.From((v) => {
+        o.give(!v);
+      })
+    );
+    return this;
+  }
+}
 
-const fromJson = (jsonSrc, errorOwner) => {
-  return (o) => {
-    jsonSrc((json) => {
-      try {
-        o(JSON.parse(json));
-      } catch (error) {
-        errorOwner?.(new Error(`Failed to parse JSON: ${error}`));
-      }
-    });
-  };
-};
+class Bool extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
+    new silentium.Applied(this.baseSrc, Boolean).value(o);
+    return this;
+  }
+}
 
-const toJson = (dataSrc, errorOwner) => {
-  return (o) => {
-    dataSrc((data) => {
-      try {
-        o(JSON.stringify(data));
-      } catch {
-        errorOwner?.(new Error("Failed to convert to JSON"));
-      }
-    });
-  };
-};
+class FromJson extends silentium.TheInformation {
+  constructor(jsonSrc, errorOwner) {
+    super(jsonSrc);
+    this.jsonSrc = jsonSrc;
+    this.errorOwner = errorOwner;
+  }
+  value(o) {
+    this.jsonSrc.value(
+      new silentium.From((json) => {
+        try {
+          o.give(JSON.parse(json));
+        } catch (error) {
+          this.errorOwner?.give(new Error(`Failed to parse JSON: ${error}`));
+        }
+      })
+    );
+    return this;
+  }
+}
+
+class ToJson extends silentium.TheInformation {
+  constructor(dataSrc, errorOwner) {
+    super(dataSrc);
+    this.dataSrc = dataSrc;
+    this.errorOwner = errorOwner;
+  }
+  value(o) {
+    this.dataSrc.value(
+      new silentium.From((data) => {
+        try {
+          o.give(JSON.stringify(data));
+        } catch {
+          this.errorOwner?.give(new Error("Failed to convert to JSON"));
+        }
+      })
+    );
+    return this;
+  }
+}
 
-const first = (baseSrc) => {
-  return silentium.applied(baseSrc, (a) => a[0]);
-};
+class First extends silentium.TheInformation {
+  constructor(baseSrc) {
+    super(baseSrc);
+    this.baseSrc = baseSrc;
+  }
+  value(o) {
+    new silentium.Applied(this.baseSrc, (a) => a[0]).value(o);
+    return this;
+  }
+}
 
-exports.and = and;
-exports.branch = branch;
-exports.concatenated = concatenated;
-exports.deadline = deadline;
-exports.deferred = deferred;
-exports.dirty = dirty;
-exports.first = first;
-exports.fromJson = fromJson;
-exports.hashTable = hashTable;
-exports.loading = loading;
-exports.lock = lock;
-exports.memo = memo;
-exports.not = not;
-exports.onlyChanged = onlyChanged;
-exports.or = or;
-exports.path = path;
-exports.record = record;
-exports.regexpMatch = regexpMatch;
-exports.regexpMatched = regexpMatched;
-exports.regexpReplaced = regexpReplaced;
-exports.router = router;
-exports.set = set;
-exports.shot = shot;
-exports.tick = tick;
-exports.toJson = toJson;
+exports.And = And;
+exports.Bool = Bool;
+exports.Branch = Branch;
+exports.Concatenated = Concatenated;
+exports.Deadline = Deadline;
+exports.Deferred = Deferred;
+exports.Dirty = Dirty;
+exports.First = First;
+exports.FromJson = FromJson;
+exports.HashTable = HashTable;
+exports.Loading = Loading;
+exports.Lock = Lock;
+exports.Memo = Memo;
+exports.Not = Not;
+exports.OnlyChanged = OnlyChanged;
+exports.Or = Or;
+exports.Path = Path;
+exports.RecordOf = RecordOf;
+exports.RegexpMatch = RegexpMatch;
+exports.RegexpMatched = RegexpMatched;
+exports.RegexpReplaced = RegexpReplaced;
+exports.Router = Router;
+exports.Set = Set;
+exports.Shot = Shot;
+exports.Tick = Tick;
+exports.ToJson = ToJson;
 //# sourceMappingURL=silentium-components.cjs.map