@explorable-viz/fluid 0.11.0 → 0.11.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
| 
         @@ -11523,7 +11523,7 @@ var assertPresent = (v) => (v1) => { 
     | 
|
| 
       11523 
11523 
     | 
    
         
             
                    }
         
     | 
| 
       11524 
11524 
     | 
    
         
             
                    fail();
         
     | 
| 
       11525 
11525 
     | 
    
         
             
                  })();
         
     | 
| 
       11526 
     | 
    
         
            -
                  return assertWhen( 
     | 
| 
      
 11526 
     | 
    
         
            +
                  return assertWhen(false)($0 + " is an existing vertex")((v2) => present)(() => $Step("Loop", $1))();
         
     | 
| 
       11527 
11527 
     | 
    
         
             
                };
         
     | 
| 
       11528 
11528 
     | 
    
         
             
              }
         
     | 
| 
       11529 
11529 
     | 
    
         
             
              fail();
         
     | 
| 
         @@ -11809,7 +11809,7 @@ var runWithGraphT = (dictMonad) => { 
     | 
|
| 
       11809 
11809 
     | 
    
         
             
                const freezeGraph2 = freezeGraph1(dictGraph);
         
     | 
| 
       11810 
11810 
     | 
    
         
             
                return (m) => (\u03B1s) => dictMonad.Bind1().bind(freezeGraph2(m)(\u03B1s))((v) => {
         
     | 
| 
       11811 
11811 
     | 
    
         
             
                  const $0 = v._1;
         
     | 
| 
       11812 
     | 
    
         
            -
                  return assertWhen( 
     | 
| 
      
 11812 
     | 
    
         
            +
                  return assertWhen(false)("edgeListGC")((v1) => dictGraph.Eq0().eq($0)(dictGraph.fromEdgeList(Leaf2)(toEdgeList(dictGraph)($0))))(dictMonad.Applicative0().pure($Tuple(
         
     | 
| 
       11813 
11813 
     | 
    
         
             
                    $0,
         
     | 
| 
       11814 
11814 
     | 
    
         
             
                    v._2
         
     | 
| 
       11815 
11815 
     | 
    
         
             
                  )));
         
     | 
| 
         @@ -11886,7 +11886,7 @@ var fwdSlice = (dictGraph) => { 
     | 
|
| 
       11886 
11886 
     | 
    
         
             
                    return pure($Step("Loop", { pending: insert(ordVertex)(v1.es._1._1)(\u03B2s)(v1.pending), es: v1.es._2 }));
         
     | 
| 
       11887 
11887 
     | 
    
         
             
                  }
         
     | 
| 
       11888 
11888 
     | 
    
         
             
                  fail();
         
     | 
| 
       11889 
     | 
    
         
            -
                })({ pending: Leaf2, es: inEdges(dictGraph)($0)($1) }))(assertWhen( 
     | 
| 
      
 11889 
     | 
    
         
            +
                })({ pending: Leaf2, es: inEdges(dictGraph)($0)($1) }))(assertWhen(false)("inputs are sinks")((v$1) => difference2(ordVertex)($1)(dictGraph.sinks($0)).tag === "Leaf")(map(ordDVertex$p)((\u03B1) => $Tuple(
         
     | 
| 
       11890 
11890 
     | 
    
         
             
                  \u03B1,
         
     | 
| 
       11891 
11891 
     | 
    
         
             
                  dictGraph.vertexData($0)(\u03B1)
         
     | 
| 
       11892 
11892 
     | 
    
         
             
                ))($1)))._1;
         
     | 
| 
         @@ -11930,7 +11930,7 @@ var bwdSlice = (dictGraph) => { 
     | 
|
| 
       11930 
11930 
     | 
    
         
             
                  fail();
         
     | 
| 
       11931 
11931 
     | 
    
         
             
                })({
         
     | 
| 
       11932 
11932 
     | 
    
         
             
                  visited: Leaf2,
         
     | 
| 
       11933 
     | 
    
         
            -
                  "\u03B1s": fromFoldable8(assertWhen( 
     | 
| 
      
 11933 
     | 
    
         
            +
                  "\u03B1s": fromFoldable8(assertWhen(false)("inputs are sinks")((v$1) => difference2(ordVertex)($1)(addresses2($0)).tag === "Leaf")($1)),
         
     | 
| 
       11934 
11934 
     | 
    
         
             
                  pending: Nil
         
     | 
| 
       11935 
11935 
     | 
    
         
             
                }))(Leaf2)._1;
         
     | 
| 
       11936 
11936 
     | 
    
         
             
              };
         
     | 
| 
         @@ -19517,6 +19517,7 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       19517 
19517 
     | 
    
         
             
              const monadAffState1 = monadAffState(monadAffState2);
         
     | 
| 
       19518 
19518 
     | 
    
         
             
              const $1 = monadAffState2.MonadEffect0().Monad0();
         
     | 
| 
       19519 
19519 
     | 
    
         
             
              const $2 = dictMonadAff.MonadEffect0().Monad0();
         
     | 
| 
      
 19520 
     | 
    
         
            +
              const applicativeStateT2 = applicativeStateT(Monad0);
         
     | 
| 
       19520 
19521 
     | 
    
         
             
              return (dictMonadReader) => {
         
     | 
| 
       19521 
19522 
     | 
    
         
             
                const monadReaderStateT2 = monadReaderStateT(monadReaderStateT(dictMonadReader));
         
     | 
| 
       19522 
19523 
     | 
    
         
             
                return (dictLoadFile) => (dictMonadError) => {
         
     | 
| 
         @@ -19532,7 +19533,6 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       19532 
19533 
     | 
    
         
             
                      }
         
     | 
| 
       19533 
19534 
     | 
    
         
             
                    };
         
     | 
| 
       19534 
19535 
     | 
    
         
             
                  })());
         
     | 
| 
       19535 
     | 
    
         
            -
                  const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
         
     | 
| 
       19536 
19536 
     | 
    
         
             
                  return (v) => (e) => {
         
     | 
| 
       19537 
19537 
     | 
    
         
             
                    const $3 = v["\u03B3"];
         
     | 
| 
       19538 
19538 
     | 
    
         
             
                    const $4 = spyFunWhen(false)("fwdSlice")((x) => $Tuple(showVertices(x._1), showEdgeList(toEdgeList(graphGraphImpl)(x._2))))(showGraph(graphGraphImpl))(fwdSlice2);
         
     | 
| 
         @@ -19543,10 +19543,7 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       19543 
19543 
     | 
    
         
             
                    ))))((v1) => {
         
     | 
| 
       19544 
19544 
     | 
    
         
             
                      const $6 = v1._1;
         
     | 
| 
       19545 
19545 
     | 
    
         
             
                      const $7 = v1._2;
         
     | 
| 
       19546 
     | 
    
         
            -
                      return bindStateT2.bind( 
     | 
| 
       19547 
     | 
    
         
            -
                        $6,
         
     | 
| 
       19548 
     | 
    
         
            -
                        $Tuple($EnvExpr($3, e\u03B1), $7)
         
     | 
| 
       19549 
     | 
    
         
            -
                      )));
         
     | 
| 
      
 19546 
     | 
    
         
            +
                      return bindStateT2.bind(applicativeStateT2.pure())(() => applicativeStateT2.pure($Tuple($6, $Tuple($EnvExpr($3, e\u03B1), $7))));
         
     | 
| 
       19550 
19547 
     | 
    
         
             
                    })))(v.n))((v1) => Monad0.Applicative0().pure({
         
     | 
| 
       19551 
19548 
     | 
    
         
             
                      g: v1._2._2._1,
         
     | 
| 
       19552 
19549 
     | 
    
         
             
                      graph_fwd: (a) => (b) => $4($Tuple(a, b)),
         
     | 
| 
         @@ -45306,7 +45306,7 @@ var assertPresent = (v) => (v1) => { 
     | 
|
| 
       45306 
45306 
     | 
    
         
             
                    }
         
     | 
| 
       45307 
45307 
     | 
    
         
             
                    fail();
         
     | 
| 
       45308 
45308 
     | 
    
         
             
                  })();
         
     | 
| 
       45309 
     | 
    
         
            -
                  return assertWhen( 
     | 
| 
      
 45309 
     | 
    
         
            +
                  return assertWhen(false)($0 + " is an existing vertex")((v2) => present)(() => $Step("Loop", $1))();
         
     | 
| 
       45310 
45310 
     | 
    
         
             
                };
         
     | 
| 
       45311 
45311 
     | 
    
         
             
              }
         
     | 
| 
       45312 
45312 
     | 
    
         
             
              fail();
         
     | 
| 
         @@ -45592,7 +45592,7 @@ var runWithGraphT = (dictMonad) => { 
     | 
|
| 
       45592 
45592 
     | 
    
         
             
                const freezeGraph2 = freezeGraph1(dictGraph);
         
     | 
| 
       45593 
45593 
     | 
    
         
             
                return (m) => (\u03B1s) => dictMonad.Bind1().bind(freezeGraph2(m)(\u03B1s))((v) => {
         
     | 
| 
       45594 
45594 
     | 
    
         
             
                  const $0 = v._1;
         
     | 
| 
       45595 
     | 
    
         
            -
                  return assertWhen( 
     | 
| 
      
 45595 
     | 
    
         
            +
                  return assertWhen(false)("edgeListGC")((v1) => dictGraph.Eq0().eq($0)(dictGraph.fromEdgeList(Leaf2)(toEdgeList(dictGraph)($0))))(dictMonad.Applicative0().pure($Tuple(
         
     | 
| 
       45596 
45596 
     | 
    
         
             
                    $0,
         
     | 
| 
       45597 
45597 
     | 
    
         
             
                    v._2
         
     | 
| 
       45598 
45598 
     | 
    
         
             
                  )));
         
     | 
| 
         @@ -45669,7 +45669,7 @@ var fwdSlice = (dictGraph) => { 
     | 
|
| 
       45669 
45669 
     | 
    
         
             
                    return pure2($Step("Loop", { pending: insert3(ordVertex)(v1.es._1._1)(\u03B2s)(v1.pending), es: v1.es._2 }));
         
     | 
| 
       45670 
45670 
     | 
    
         
             
                  }
         
     | 
| 
       45671 
45671 
     | 
    
         
             
                  fail();
         
     | 
| 
       45672 
     | 
    
         
            -
                })({ pending: Leaf2, es: inEdges(dictGraph)($0)($1) }))(assertWhen( 
     | 
| 
      
 45672 
     | 
    
         
            +
                })({ pending: Leaf2, es: inEdges(dictGraph)($0)($1) }))(assertWhen(false)("inputs are sinks")((v$1) => difference2(ordVertex)($1)(dictGraph.sinks($0)).tag === "Leaf")(map2(ordDVertex$p)((\u03B1) => $Tuple(
         
     | 
| 
       45673 
45673 
     | 
    
         
             
                  \u03B1,
         
     | 
| 
       45674 
45674 
     | 
    
         
             
                  dictGraph.vertexData($0)(\u03B1)
         
     | 
| 
       45675 
45675 
     | 
    
         
             
                ))($1)))._1;
         
     | 
| 
         @@ -45713,7 +45713,7 @@ var bwdSlice = (dictGraph) => { 
     | 
|
| 
       45713 
45713 
     | 
    
         
             
                  fail();
         
     | 
| 
       45714 
45714 
     | 
    
         
             
                })({
         
     | 
| 
       45715 
45715 
     | 
    
         
             
                  visited: Leaf2,
         
     | 
| 
       45716 
     | 
    
         
            -
                  "\u03B1s": fromFoldable18(assertWhen( 
     | 
| 
      
 45716 
     | 
    
         
            +
                  "\u03B1s": fromFoldable18(assertWhen(false)("inputs are sinks")((v$1) => difference2(ordVertex)($1)(addresses2($0)).tag === "Leaf")($1)),
         
     | 
| 
       45717 
45717 
     | 
    
         
             
                  pending: Nil
         
     | 
| 
       45718 
45718 
     | 
    
         
             
                }))(Leaf2)._1;
         
     | 
| 
       45719 
45719 
     | 
    
         
             
              };
         
     | 
| 
         @@ -46488,6 +46488,7 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       46488 
46488 
     | 
    
         
             
              const monadAffState1 = monadAffState(monadAffState2);
         
     | 
| 
       46489 
46489 
     | 
    
         
             
              const $1 = monadAffState2.MonadEffect0().Monad0();
         
     | 
| 
       46490 
46490 
     | 
    
         
             
              const $2 = dictMonadAff.MonadEffect0().Monad0();
         
     | 
| 
      
 46491 
     | 
    
         
            +
              const applicativeStateT2 = applicativeStateT(Monad0);
         
     | 
| 
       46491 
46492 
     | 
    
         
             
              return (dictMonadReader) => {
         
     | 
| 
       46492 
46493 
     | 
    
         
             
                const monadReaderStateT2 = monadReaderStateT(monadReaderStateT(dictMonadReader));
         
     | 
| 
       46493 
46494 
     | 
    
         
             
                return (dictLoadFile) => (dictMonadError) => {
         
     | 
| 
         @@ -46503,7 +46504,6 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       46503 
46504 
     | 
    
         
             
                      }
         
     | 
| 
       46504 
46505 
     | 
    
         
             
                    };
         
     | 
| 
       46505 
46506 
     | 
    
         
             
                  })());
         
     | 
| 
       46506 
     | 
    
         
            -
                  const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
         
     | 
| 
       46507 
46507 
     | 
    
         
             
                  return (v) => (e) => {
         
     | 
| 
       46508 
46508 
     | 
    
         
             
                    const $3 = v["\u03B3"];
         
     | 
| 
       46509 
46509 
     | 
    
         
             
                    const $4 = spyFunWhen(false)("fwdSlice")((x2) => $Tuple(showVertices(x2._1), showEdgeList(toEdgeList(graphGraphImpl)(x2._2))))(showGraph(graphGraphImpl))(fwdSlice2);
         
     | 
| 
         @@ -46514,10 +46514,7 @@ var graphEval = (dictMonadAff) => { 
     | 
|
| 
       46514 
46514 
     | 
    
         
             
                    ))))((v1) => {
         
     | 
| 
       46515 
46515 
     | 
    
         
             
                      const $6 = v1._1;
         
     | 
| 
       46516 
46516 
     | 
    
         
             
                      const $7 = v1._2;
         
     | 
| 
       46517 
     | 
    
         
            -
                      return bindStateT2.bind( 
     | 
| 
       46518 
     | 
    
         
            -
                        $6,
         
     | 
| 
       46519 
     | 
    
         
            -
                        $Tuple($EnvExpr($3, e\u03B1), $7)
         
     | 
| 
       46520 
     | 
    
         
            -
                      )));
         
     | 
| 
      
 46517 
     | 
    
         
            +
                      return bindStateT2.bind(applicativeStateT2.pure())(() => applicativeStateT2.pure($Tuple($6, $Tuple($EnvExpr($3, e\u03B1), $7))));
         
     | 
| 
       46521 
46518 
     | 
    
         
             
                    })))(v.n))((v1) => Monad0.Applicative0().pure({
         
     | 
| 
       46522 
46519 
     | 
    
         
             
                      g: v1._2._2._1,
         
     | 
| 
       46523 
46520 
     | 
    
         
             
                      graph_fwd: (a) => (b) => $4($Tuple(a, b)),
         
     | 
    
        package/package.json
    CHANGED
    
    | 
         @@ -1,6 +1,6 @@ 
     | 
|
| 
       1 
1 
     | 
    
         
             
            {
         
     | 
| 
       2 
2 
     | 
    
         
             
              "name": "@explorable-viz/fluid",
         
     | 
| 
       3 
     | 
    
         
            -
              "version": "0.11. 
     | 
| 
      
 3 
     | 
    
         
            +
              "version": "0.11.1",
         
     | 
| 
       4 
4 
     | 
    
         
             
              "description": "A functional programming language which integrates a bidirectional dynamic analysis, connecting outputs to data sources in a fine-grained way. Fluid is implemented in PureScript and runs in the browser.",
         
     | 
| 
       5 
5 
     | 
    
         
             
              "main": "index.js",
         
     | 
| 
       6 
6 
     | 
    
         
             
              "repository": {
         
     |