@ozdao/prometheus-framework 0.2.330 → 0.2.331

package/dist/node_modules/dijkstrajs/dijkstra.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"dijkstra.cjs","sources":["../../../../node_modules/dijkstrajs/dijkstra.js"],"sourcesContent":["'use strict';\n\n/******************************************************************************\n * Created 2008-08-19.\n *\n * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n *\n * Copyright (C) 2008\n *   Wyatt Baldwin <self@wyattbaldwin.com>\n *   All rights reserved\n *\n * Licensed under the MIT license.\n *\n *   http://www.opensource.org/licenses/mit-license.php\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *****************************************************************************/\nvar dijkstra = {\n  single_source_shortest_paths: function(graph, s, d) {\n    // Predecessor map for each node that has been encountered.\n    // node ID => predecessor node ID\n    var predecessors = {};\n\n    // Costs of shortest paths from s to all nodes encountered.\n    // node ID => cost\n    var costs = {};\n    costs[s] = 0;\n\n    // Costs of shortest paths from s to all nodes encountered; differs from\n    // `costs` in that it provides easy access to the node that currently has\n    // the known shortest path from s.\n    // XXX: Do we actually need both `costs` and `open`?\n    var open = dijkstra.PriorityQueue.make();\n    open.push(s, 0);\n\n    var closest,\n        u, v,\n        cost_of_s_to_u,\n        adjacent_nodes,\n        cost_of_e,\n        cost_of_s_to_u_plus_cost_of_e,\n        cost_of_s_to_v,\n        first_visit;\n    while (!open.empty()) {\n      // In the nodes remaining in graph that have a known cost from s,\n      // find the node, u, that currently has the shortest path from s.\n      closest = open.pop();\n      u = closest.value;\n      cost_of_s_to_u = closest.cost;\n\n      // Get nodes adjacent to u...\n      adjacent_nodes = graph[u] || {};\n\n      // ...and explore the edges that connect u to those nodes, updating\n      // the cost of the shortest paths to any or all of those nodes as\n      // necessary. v is the node across the current edge from u.\n      for (v in adjacent_nodes) {\n        if (adjacent_nodes.hasOwnProperty(v)) {\n          // Get the cost of the edge running from u to v.\n          cost_of_e = adjacent_nodes[v];\n\n          // Cost of s to u plus the cost of u to v across e--this is *a*\n          // cost from s to v that may or may not be less than the current\n          // known cost to v.\n          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n\n          // If we haven't visited v yet OR if the current known cost from s to\n          // v is greater than the new cost we just found (cost of s to u plus\n          // cost of u to v across e), update v's cost in the cost list and\n          // update v's predecessor in the predecessor list (it's now u).\n          cost_of_s_to_v = costs[v];\n          first_visit = (typeof costs[v] === 'undefined');\n          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n            predecessors[v] = u;\n          }\n        }\n      }\n    }\n\n    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n      throw new Error(msg);\n    }\n\n    return predecessors;\n  },\n\n  extract_shortest_path_from_predecessor_list: function(predecessors, d) {\n    var nodes = [];\n    var u = d;\n    var predecessor;\n    while (u) {\n      nodes.push(u);\n      predecessor = predecessors[u];\n      u = predecessors[u];\n    }\n    nodes.reverse();\n    return nodes;\n  },\n\n  find_path: function(graph, s, d) {\n    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n    return dijkstra.extract_shortest_path_from_predecessor_list(\n      predecessors, d);\n  },\n\n  /**\n   * A very naive priority queue implementation.\n   */\n  PriorityQueue: {\n    make: function (opts) {\n      var T = dijkstra.PriorityQueue,\n          t = {},\n          key;\n      opts = opts || {};\n      for (key in T) {\n        if (T.hasOwnProperty(key)) {\n          t[key] = T[key];\n        }\n      }\n      t.queue = [];\n      t.sorter = opts.sorter || T.default_sorter;\n      return t;\n    },\n\n    default_sorter: function (a, b) {\n      return a.cost - b.cost;\n    },\n\n    /**\n     * Add a new item to the queue and ensure the highest priority element\n     * is at the front of the queue.\n     */\n    push: function (value, cost) {\n      var item = {value: value, cost: cost};\n      this.queue.push(item);\n      this.queue.sort(this.sorter);\n    },\n\n    /**\n     * Return the highest priority element in the queue.\n     */\n    pop: function () {\n      return this.queue.shift();\n    },\n\n    empty: function () {\n      return this.queue.length === 0;\n    }\n  }\n};\n\n\n// node.js module exports\nif (typeof module !== 'undefined') {\n  module.exports = dijkstra;\n}\n"],"names":["dijkstra","module"],"mappings":";;;;AAuBA,MAAIA,YAAW;AAAA,IACb,8BAA8B,SAAS,OAAO,GAAG,GAAG;AAGlD,UAAI,eAAe,CAAA;AAInB,UAAI,QAAQ,CAAA;AACZ,YAAM,CAAC,IAAI;AAMX,UAAI,OAAOA,UAAS,cAAc,KAAI;AACtC,WAAK,KAAK,GAAG,CAAC;AAEd,UAAI,SACA,GAAG,GACH,gBACA,gBACA,WACA,+BACA,gBACA;AACJ,aAAO,CAAC,KAAK,SAAS;AAGpB,kBAAU,KAAK;AACf,YAAI,QAAQ;AACZ,yBAAiB,QAAQ;AAGzB,yBAAiB,MAAM,CAAC,KAAK;AAK7B,aAAK,KAAK,gBAAgB;AACxB,cAAI,eAAe,eAAe,CAAC,GAAG;AAEpC,wBAAY,eAAe,CAAC;AAK5B,4CAAgC,iBAAiB;AAMjD,6BAAiB,MAAM,CAAC;AACxB,0BAAe,OAAO,MAAM,CAAC,MAAM;AACnC,gBAAI,eAAe,iBAAiB,+BAA+B;AACjE,oBAAM,CAAC,IAAI;AACX,mBAAK,KAAK,GAAG,6BAA6B;AAC1C,2BAAa,CAAC,IAAI;AAAA,YACnB;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAED,UAAI,OAAO,MAAM,eAAe,OAAO,MAAM,CAAC,MAAM,aAAa;AAC/D,YAAI,MAAM,CAAC,+BAA+B,GAAG,QAAQ,GAAG,GAAG,EAAE,KAAK,EAAE;AACpE,cAAM,IAAI,MAAM,GAAG;AAAA,MACpB;AAED,aAAO;AAAA,IACR;AAAA,IAED,6CAA6C,SAAS,cAAc,GAAG;AACrE,UAAI,QAAQ,CAAA;AACZ,UAAI,IAAI;AAER,aAAO,GAAG;AACR,cAAM,KAAK,CAAC;AACE,qBAAa,CAAC;AAC5B,YAAI,aAAa,CAAC;AAAA,MACnB;AACD,YAAM,QAAO;AACb,aAAO;AAAA,IACR;AAAA,IAED,WAAW,SAAS,OAAO,GAAG,GAAG;AAC/B,UAAI,eAAeA,UAAS,6BAA6B,OAAO,GAAG,CAAC;AACpE,aAAOA,UAAS;AAAA,QACd;AAAA,QAAc;AAAA,MAAC;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA,IAKD,eAAe;AAAA,MACb,MAAM,SAAU,MAAM;AACpB,YAAI,IAAIA,UAAS,eACb,IAAI,CAAE,GACN;AACJ,eAAO,QAAQ;AACf,aAAK,OAAO,GAAG;AACb,cAAI,EAAE,eAAe,GAAG,GAAG;AACzB,cAAE,GAAG,IAAI,EAAE,GAAG;AAAA,UACf;AAAA,QACF;AACD,UAAE,QAAQ;AACV,UAAE,SAAS,KAAK,UAAU,EAAE;AAC5B,eAAO;AAAA,MACR;AAAA,MAED,gBAAgB,SAAU,GAAG,GAAG;AAC9B,eAAO,EAAE,OAAO,EAAE;AAAA,MACnB;AAAA;AAAA;AAAA;AAAA;AAAA,MAMD,MAAM,SAAU,OAAO,MAAM;AAC3B,YAAI,OAAO,EAAC,OAAc,KAAU;AACpC,aAAK,MAAM,KAAK,IAAI;AACpB,aAAK,MAAM,KAAK,KAAK,MAAM;AAAA,MAC5B;AAAA;AAAA;AAAA;AAAA,MAKD,KAAK,WAAY;AACf,eAAO,KAAK,MAAM;MACnB;AAAA,MAED,OAAO,WAAY;AACjB,eAAO,KAAK,MAAM,WAAW;AAAA,MAC9B;AAAA,IACF;AAAA,EACH;AAImC;AACjC,IAAAC,QAAA,UAAiBD;AAAA,EACnB;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"dijkstra.cjs","sources":["../../../../node_modules/dijkstrajs/dijkstra.js"],"sourcesContent":["'use strict';\n\n/******************************************************************************\n * Created 2008-08-19.\n *\n * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n *\n * Copyright (C) 2008\n *   Wyatt Baldwin <self@wyattbaldwin.com>\n *   All rights reserved\n *\n * Licensed under the MIT license.\n *\n *   http://www.opensource.org/licenses/mit-license.php\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *****************************************************************************/\nvar dijkstra = {\n  single_source_shortest_paths: function(graph, s, d) {\n    // Predecessor map for each node that has been encountered.\n    // node ID => predecessor node ID\n    var predecessors = {};\n\n    // Costs of shortest paths from s to all nodes encountered.\n    // node ID => cost\n    var costs = {};\n    costs[s] = 0;\n\n    // Costs of shortest paths from s to all nodes encountered; differs from\n    // `costs` in that it provides easy access to the node that currently has\n    // the known shortest path from s.\n    // XXX: Do we actually need both `costs` and `open`?\n    var open = dijkstra.PriorityQueue.make();\n    open.push(s, 0);\n\n    var closest,\n        u, v,\n        cost_of_s_to_u,\n        adjacent_nodes,\n        cost_of_e,\n        cost_of_s_to_u_plus_cost_of_e,\n        cost_of_s_to_v,\n        first_visit;\n    while (!open.empty()) {\n      // In the nodes remaining in graph that have a known cost from s,\n      // find the node, u, that currently has the shortest path from s.\n      closest = open.pop();\n      u = closest.value;\n      cost_of_s_to_u = closest.cost;\n\n      // Get nodes adjacent to u...\n      adjacent_nodes = graph[u] || {};\n\n      // ...and explore the edges that connect u to those nodes, updating\n      // the cost of the shortest paths to any or all of those nodes as\n      // necessary. v is the node across the current edge from u.\n      for (v in adjacent_nodes) {\n        if (adjacent_nodes.hasOwnProperty(v)) {\n          // Get the cost of the edge running from u to v.\n          cost_of_e = adjacent_nodes[v];\n\n          // Cost of s to u plus the cost of u to v across e--this is *a*\n          // cost from s to v that may or may not be less than the current\n          // known cost to v.\n          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n\n          // If we haven't visited v yet OR if the current known cost from s to\n          // v is greater than the new cost we just found (cost of s to u plus\n          // cost of u to v across e), update v's cost in the cost list and\n          // update v's predecessor in the predecessor list (it's now u).\n          cost_of_s_to_v = costs[v];\n          first_visit = (typeof costs[v] === 'undefined');\n          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n            predecessors[v] = u;\n          }\n        }\n      }\n    }\n\n    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n      throw new Error(msg);\n    }\n\n    return predecessors;\n  },\n\n  extract_shortest_path_from_predecessor_list: function(predecessors, d) {\n    var nodes = [];\n    var u = d;\n    var predecessor;\n    while (u) {\n      nodes.push(u);\n      predecessor = predecessors[u];\n      u = predecessors[u];\n    }\n    nodes.reverse();\n    return nodes;\n  },\n\n  find_path: function(graph, s, d) {\n    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n    return dijkstra.extract_shortest_path_from_predecessor_list(\n      predecessors, d);\n  },\n\n  /**\n   * A very naive priority queue implementation.\n   */\n  PriorityQueue: {\n    make: function (opts) {\n      var T = dijkstra.PriorityQueue,\n          t = {},\n          key;\n      opts = opts || {};\n      for (key in T) {\n        if (T.hasOwnProperty(key)) {\n          t[key] = T[key];\n        }\n      }\n      t.queue = [];\n      t.sorter = opts.sorter || T.default_sorter;\n      return t;\n    },\n\n    default_sorter: function (a, b) {\n      return a.cost - b.cost;\n    },\n\n    /**\n     * Add a new item to the queue and ensure the highest priority element\n     * is at the front of the queue.\n     */\n    push: function (value, cost) {\n      var item = {value: value, cost: cost};\n      this.queue.push(item);\n      this.queue.sort(this.sorter);\n    },\n\n    /**\n     * Return the highest priority element in the queue.\n     */\n    pop: function () {\n      return this.queue.shift();\n    },\n\n    empty: function () {\n      return this.queue.length === 0;\n    }\n  }\n};\n\n\n// node.js module exports\nif (typeof module !== 'undefined') {\n  module.exports = dijkstra;\n}\n"],"names":["dijkstra","module"],"mappings":";;;;;;;;AAuBA,QAAIA,YAAW;AAAA,MACb,8BAA8B,SAAS,OAAO,GAAG,GAAG;AAGlD,YAAI,eAAe,CAAE;AAIrB,YAAI,QAAQ,CAAE;AACd,cAAM,CAAC,IAAI;AAMX,YAAI,OAAOA,UAAS,cAAc,KAAM;AACxC,aAAK,KAAK,GAAG,CAAC;AAEd,YAAI,SACA,GAAG,GACH,gBACA,gBACA,WACA,+BACA,gBACA;AACJ,eAAO,CAAC,KAAK,SAAS;AAGpB,oBAAU,KAAK,IAAK;AACpB,cAAI,QAAQ;AACZ,2BAAiB,QAAQ;AAGzB,2BAAiB,MAAM,CAAC,KAAK,CAAE;AAK/B,eAAK,KAAK,gBAAgB;AACxB,gBAAI,eAAe,eAAe,CAAC,GAAG;AAEpC,0BAAY,eAAe,CAAC;AAK5B,8CAAgC,iBAAiB;AAMjD,+BAAiB,MAAM,CAAC;AACxB,4BAAe,OAAO,MAAM,CAAC,MAAM;AACnC,kBAAI,eAAe,iBAAiB,+BAA+B;AACjE,sBAAM,CAAC,IAAI;AACX,qBAAK,KAAK,GAAG,6BAA6B;AAC1C,6BAAa,CAAC,IAAI;AAAA,cAC9B;AAAA,YACA;AAAA,UACA;AAAA,QACA;AAEI,YAAI,OAAO,MAAM,eAAe,OAAO,MAAM,CAAC,MAAM,aAAa;AAC/D,cAAI,MAAM,CAAC,+BAA+B,GAAG,QAAQ,GAAG,GAAG,EAAE,KAAK,EAAE;AACpE,gBAAM,IAAI,MAAM,GAAG;AAAA,QACzB;AAEI,eAAO;AAAA,MACR;AAAA,MAED,6CAA6C,SAAS,cAAc,GAAG;AACrE,YAAI,QAAQ,CAAE;AACd,YAAI,IAAI;AAER,eAAO,GAAG;AACR,gBAAM,KAAK,CAAC;AACE,uBAAa,CAAC;AAC5B,cAAI,aAAa,CAAC;AAAA,QACxB;AACI,cAAM,QAAS;AACf,eAAO;AAAA,MACR;AAAA,MAED,WAAW,SAAS,OAAO,GAAG,GAAG;AAC/B,YAAI,eAAeA,UAAS,6BAA6B,OAAO,GAAG,CAAC;AACpE,eAAOA,UAAS;AAAA,UACd;AAAA,UAAc;AAAA,QAAC;AAAA,MAClB;AAAA;AAAA;AAAA;AAAA,MAKD,eAAe;AAAA,QACb,MAAM,SAAU,MAAM;AACpB,cAAI,IAAIA,UAAS,eACb,IAAI,CAAE,GACN;AACJ,iBAAO,QAAQ,CAAE;AACjB,eAAK,OAAO,GAAG;AACb,gBAAI,EAAE,eAAe,GAAG,GAAG;AACzB,gBAAE,GAAG,IAAI,EAAE,GAAG;AAAA,YACxB;AAAA,UACA;AACM,YAAE,QAAQ,CAAE;AACZ,YAAE,SAAS,KAAK,UAAU,EAAE;AAC5B,iBAAO;AAAA,QACR;AAAA,QAED,gBAAgB,SAAU,GAAG,GAAG;AAC9B,iBAAO,EAAE,OAAO,EAAE;AAAA,QACnB;AAAA;AAAA;AAAA;AAAA;AAAA,QAMD,MAAM,SAAU,OAAO,MAAM;AAC3B,cAAI,OAAO,EAAC,OAAc,KAAU;AACpC,eAAK,MAAM,KAAK,IAAI;AACpB,eAAK,MAAM,KAAK,KAAK,MAAM;AAAA,QAC5B;AAAA;AAAA;AAAA;AAAA,QAKD,KAAK,WAAY;AACf,iBAAO,KAAK,MAAM,MAAO;AAAA,QAC1B;AAAA,QAED,OAAO,WAAY;AACjB,iBAAO,KAAK,MAAM,WAAW;AAAA,QACnC;AAAA,MACA;AAAA,IACC;AAIkC;AACjC,MAAAC,kBAAiBD;AAAA,IACnB;AAAA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/dijkstrajs/dijkstra.js

@@ -1,101 +1,106 @@
 import { __module as dijkstra } from "../../_virtual/dijkstra.js";
-(function(module) {
-  var dijkstra2 = {
-    single_source_shortest_paths: function(graph, s, d) {
-      var predecessors = {};
-      var costs = {};
-      costs[s] = 0;
-      var open = dijkstra2.PriorityQueue.make();
-      open.push(s, 0);
-      var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
-      while (!open.empty()) {
-        closest = open.pop();
-        u = closest.value;
-        cost_of_s_to_u = closest.cost;
-        adjacent_nodes = graph[u] || {};
-        for (v in adjacent_nodes) {
-          if (adjacent_nodes.hasOwnProperty(v)) {
-            cost_of_e = adjacent_nodes[v];
-            cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
-            cost_of_s_to_v = costs[v];
-            first_visit = typeof costs[v] === "undefined";
-            if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
-              costs[v] = cost_of_s_to_u_plus_cost_of_e;
-              open.push(v, cost_of_s_to_u_plus_cost_of_e);
-              predecessors[v] = u;
+var hasRequiredDijkstra;
+function requireDijkstra() {
+  if (hasRequiredDijkstra) return dijkstra.exports;
+  hasRequiredDijkstra = 1;
+  (function(module) {
+    var dijkstra2 = {
+      single_source_shortest_paths: function(graph, s, d) {
+        var predecessors = {};
+        var costs = {};
+        costs[s] = 0;
+        var open = dijkstra2.PriorityQueue.make();
+        open.push(s, 0);
+        var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
+        while (!open.empty()) {
+          closest = open.pop();
+          u = closest.value;
+          cost_of_s_to_u = closest.cost;
+          adjacent_nodes = graph[u] || {};
+          for (v in adjacent_nodes) {
+            if (adjacent_nodes.hasOwnProperty(v)) {
+              cost_of_e = adjacent_nodes[v];
+              cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
+              cost_of_s_to_v = costs[v];
+              first_visit = typeof costs[v] === "undefined";
+              if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
+                costs[v] = cost_of_s_to_u_plus_cost_of_e;
+                open.push(v, cost_of_s_to_u_plus_cost_of_e);
+                predecessors[v] = u;
+              }
             }
           }
         }
-      }
-      if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
-        var msg = ["Could not find a path from ", s, " to ", d, "."].join("");
-        throw new Error(msg);
-      }
-      return predecessors;
-    },
-    extract_shortest_path_from_predecessor_list: function(predecessors, d) {
-      var nodes = [];
-      var u = d;
-      while (u) {
-        nodes.push(u);
-        predecessors[u];
-        u = predecessors[u];
-      }
-      nodes.reverse();
-      return nodes;
-    },
-    find_path: function(graph, s, d) {
-      var predecessors = dijkstra2.single_source_shortest_paths(graph, s, d);
-      return dijkstra2.extract_shortest_path_from_predecessor_list(
-        predecessors,
-        d
-      );
-    },
-    /**
-     * A very naive priority queue implementation.
-     */
-    PriorityQueue: {
-      make: function(opts) {
-        var T = dijkstra2.PriorityQueue, t = {}, key;
-        opts = opts || {};
-        for (key in T) {
-          if (T.hasOwnProperty(key)) {
-            t[key] = T[key];
-          }
+        if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
+          var msg = ["Could not find a path from ", s, " to ", d, "."].join("");
+          throw new Error(msg);
         }
-        t.queue = [];
-        t.sorter = opts.sorter || T.default_sorter;
-        return t;
+        return predecessors;
       },
-      default_sorter: function(a, b) {
-        return a.cost - b.cost;
+      extract_shortest_path_from_predecessor_list: function(predecessors, d) {
+        var nodes = [];
+        var u = d;
+        while (u) {
+          nodes.push(u);
+          predecessors[u];
+          u = predecessors[u];
+        }
+        nodes.reverse();
+        return nodes;
       },
-      /**
-       * Add a new item to the queue and ensure the highest priority element
-       * is at the front of the queue.
-       */
-      push: function(value, cost) {
-        var item = { value, cost };
-        this.queue.push(item);
-        this.queue.sort(this.sorter);
+      find_path: function(graph, s, d) {
+        var predecessors = dijkstra2.single_source_shortest_paths(graph, s, d);
+        return dijkstra2.extract_shortest_path_from_predecessor_list(
+          predecessors,
+          d
+        );
       },
       /**
-       * Return the highest priority element in the queue.
+       * A very naive priority queue implementation.
        */
-      pop: function() {
-        return this.queue.shift();
-      },
-      empty: function() {
-        return this.queue.length === 0;
+      PriorityQueue: {
+        make: function(opts) {
+          var T = dijkstra2.PriorityQueue, t = {}, key;
+          opts = opts || {};
+          for (key in T) {
+            if (T.hasOwnProperty(key)) {
+              t[key] = T[key];
+            }
+          }
+          t.queue = [];
+          t.sorter = opts.sorter || T.default_sorter;
+          return t;
+        },
+        default_sorter: function(a, b) {
+          return a.cost - b.cost;
+        },
+        /**
+         * Add a new item to the queue and ensure the highest priority element
+         * is at the front of the queue.
+         */
+        push: function(value, cost) {
+          var item = { value, cost };
+          this.queue.push(item);
+          this.queue.sort(this.sorter);
+        },
+        /**
+         * Return the highest priority element in the queue.
+         */
+        pop: function() {
+          return this.queue.shift();
+        },
+        empty: function() {
+          return this.queue.length === 0;
+        }
       }
+    };
+    {
+      module.exports = dijkstra2;
     }
-  };
-  {
-    module.exports = dijkstra2;
-  }
-})(dijkstra);
-var dijkstraExports = dijkstra.exports;
+  })(dijkstra);
+  return dijkstra.exports;
+}
 export {
-  dijkstraExports as d
+  requireDijkstra as __require
 };
 //# sourceMappingURL=dijkstra.js.map

package/dist/node_modules/dijkstrajs/dijkstra.js.map

@@ -1 +1 @@
-{"version":3,"file":"dijkstra.js","sources":["../../../../node_modules/dijkstrajs/dijkstra.js"],"sourcesContent":["'use strict';\n\n/******************************************************************************\n * Created 2008-08-19.\n *\n * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n *\n * Copyright (C) 2008\n *   Wyatt Baldwin <self@wyattbaldwin.com>\n *   All rights reserved\n *\n * Licensed under the MIT license.\n *\n *   http://www.opensource.org/licenses/mit-license.php\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *****************************************************************************/\nvar dijkstra = {\n  single_source_shortest_paths: function(graph, s, d) {\n    // Predecessor map for each node that has been encountered.\n    // node ID => predecessor node ID\n    var predecessors = {};\n\n    // Costs of shortest paths from s to all nodes encountered.\n    // node ID => cost\n    var costs = {};\n    costs[s] = 0;\n\n    // Costs of shortest paths from s to all nodes encountered; differs from\n    // `costs` in that it provides easy access to the node that currently has\n    // the known shortest path from s.\n    // XXX: Do we actually need both `costs` and `open`?\n    var open = dijkstra.PriorityQueue.make();\n    open.push(s, 0);\n\n    var closest,\n        u, v,\n        cost_of_s_to_u,\n        adjacent_nodes,\n        cost_of_e,\n        cost_of_s_to_u_plus_cost_of_e,\n        cost_of_s_to_v,\n        first_visit;\n    while (!open.empty()) {\n      // In the nodes remaining in graph that have a known cost from s,\n      // find the node, u, that currently has the shortest path from s.\n      closest = open.pop();\n      u = closest.value;\n      cost_of_s_to_u = closest.cost;\n\n      // Get nodes adjacent to u...\n      adjacent_nodes = graph[u] || {};\n\n      // ...and explore the edges that connect u to those nodes, updating\n      // the cost of the shortest paths to any or all of those nodes as\n      // necessary. v is the node across the current edge from u.\n      for (v in adjacent_nodes) {\n        if (adjacent_nodes.hasOwnProperty(v)) {\n          // Get the cost of the edge running from u to v.\n          cost_of_e = adjacent_nodes[v];\n\n          // Cost of s to u plus the cost of u to v across e--this is *a*\n          // cost from s to v that may or may not be less than the current\n          // known cost to v.\n          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n\n          // If we haven't visited v yet OR if the current known cost from s to\n          // v is greater than the new cost we just found (cost of s to u plus\n          // cost of u to v across e), update v's cost in the cost list and\n          // update v's predecessor in the predecessor list (it's now u).\n          cost_of_s_to_v = costs[v];\n          first_visit = (typeof costs[v] === 'undefined');\n          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n            predecessors[v] = u;\n          }\n        }\n      }\n    }\n\n    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n      throw new Error(msg);\n    }\n\n    return predecessors;\n  },\n\n  extract_shortest_path_from_predecessor_list: function(predecessors, d) {\n    var nodes = [];\n    var u = d;\n    var predecessor;\n    while (u) {\n      nodes.push(u);\n      predecessor = predecessors[u];\n      u = predecessors[u];\n    }\n    nodes.reverse();\n    return nodes;\n  },\n\n  find_path: function(graph, s, d) {\n    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n    return dijkstra.extract_shortest_path_from_predecessor_list(\n      predecessors, d);\n  },\n\n  /**\n   * A very naive priority queue implementation.\n   */\n  PriorityQueue: {\n    make: function (opts) {\n      var T = dijkstra.PriorityQueue,\n          t = {},\n          key;\n      opts = opts || {};\n      for (key in T) {\n        if (T.hasOwnProperty(key)) {\n          t[key] = T[key];\n        }\n      }\n      t.queue = [];\n      t.sorter = opts.sorter || T.default_sorter;\n      return t;\n    },\n\n    default_sorter: function (a, b) {\n      return a.cost - b.cost;\n    },\n\n    /**\n     * Add a new item to the queue and ensure the highest priority element\n     * is at the front of the queue.\n     */\n    push: function (value, cost) {\n      var item = {value: value, cost: cost};\n      this.queue.push(item);\n      this.queue.sort(this.sorter);\n    },\n\n    /**\n     * Return the highest priority element in the queue.\n     */\n    pop: function () {\n      return this.queue.shift();\n    },\n\n    empty: function () {\n      return this.queue.length === 0;\n    }\n  }\n};\n\n\n// node.js module exports\nif (typeof module !== 'undefined') {\n  module.exports = dijkstra;\n}\n"],"names":["dijkstra"],"mappings":";;AAuBA,MAAIA,YAAW;AAAA,IACb,8BAA8B,SAAS,OAAO,GAAG,GAAG;AAGlD,UAAI,eAAe,CAAA;AAInB,UAAI,QAAQ,CAAA;AACZ,YAAM,CAAC,IAAI;AAMX,UAAI,OAAOA,UAAS,cAAc,KAAI;AACtC,WAAK,KAAK,GAAG,CAAC;AAEd,UAAI,SACA,GAAG,GACH,gBACA,gBACA,WACA,+BACA,gBACA;AACJ,aAAO,CAAC,KAAK,SAAS;AAGpB,kBAAU,KAAK;AACf,YAAI,QAAQ;AACZ,yBAAiB,QAAQ;AAGzB,yBAAiB,MAAM,CAAC,KAAK;AAK7B,aAAK,KAAK,gBAAgB;AACxB,cAAI,eAAe,eAAe,CAAC,GAAG;AAEpC,wBAAY,eAAe,CAAC;AAK5B,4CAAgC,iBAAiB;AAMjD,6BAAiB,MAAM,CAAC;AACxB,0BAAe,OAAO,MAAM,CAAC,MAAM;AACnC,gBAAI,eAAe,iBAAiB,+BAA+B;AACjE,oBAAM,CAAC,IAAI;AACX,mBAAK,KAAK,GAAG,6BAA6B;AAC1C,2BAAa,CAAC,IAAI;AAAA,YACnB;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAED,UAAI,OAAO,MAAM,eAAe,OAAO,MAAM,CAAC,MAAM,aAAa;AAC/D,YAAI,MAAM,CAAC,+BAA+B,GAAG,QAAQ,GAAG,GAAG,EAAE,KAAK,EAAE;AACpE,cAAM,IAAI,MAAM,GAAG;AAAA,MACpB;AAED,aAAO;AAAA,IACR;AAAA,IAED,6CAA6C,SAAS,cAAc,GAAG;AACrE,UAAI,QAAQ,CAAA;AACZ,UAAI,IAAI;AAER,aAAO,GAAG;AACR,cAAM,KAAK,CAAC;AACE,qBAAa,CAAC;AAC5B,YAAI,aAAa,CAAC;AAAA,MACnB;AACD,YAAM,QAAO;AACb,aAAO;AAAA,IACR;AAAA,IAED,WAAW,SAAS,OAAO,GAAG,GAAG;AAC/B,UAAI,eAAeA,UAAS,6BAA6B,OAAO,GAAG,CAAC;AACpE,aAAOA,UAAS;AAAA,QACd;AAAA,QAAc;AAAA,MAAC;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA,IAKD,eAAe;AAAA,MACb,MAAM,SAAU,MAAM;AACpB,YAAI,IAAIA,UAAS,eACb,IAAI,CAAE,GACN;AACJ,eAAO,QAAQ;AACf,aAAK,OAAO,GAAG;AACb,cAAI,EAAE,eAAe,GAAG,GAAG;AACzB,cAAE,GAAG,IAAI,EAAE,GAAG;AAAA,UACf;AAAA,QACF;AACD,UAAE,QAAQ;AACV,UAAE,SAAS,KAAK,UAAU,EAAE;AAC5B,eAAO;AAAA,MACR;AAAA,MAED,gBAAgB,SAAU,GAAG,GAAG;AAC9B,eAAO,EAAE,OAAO,EAAE;AAAA,MACnB;AAAA;AAAA;AAAA;AAAA;AAAA,MAMD,MAAM,SAAU,OAAO,MAAM;AAC3B,YAAI,OAAO,EAAC,OAAc,KAAU;AACpC,aAAK,MAAM,KAAK,IAAI;AACpB,aAAK,MAAM,KAAK,KAAK,MAAM;AAAA,MAC5B;AAAA;AAAA;AAAA;AAAA,MAKD,KAAK,WAAY;AACf,eAAO,KAAK,MAAM;MACnB;AAAA,MAED,OAAO,WAAY;AACjB,eAAO,KAAK,MAAM,WAAW;AAAA,MAC9B;AAAA,IACF;AAAA,EACH;AAImC;AACjC,WAAA,UAAiBA;AAAA,EACnB;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"dijkstra.js","sources":["../../../../node_modules/dijkstrajs/dijkstra.js"],"sourcesContent":["'use strict';\n\n/******************************************************************************\n * Created 2008-08-19.\n *\n * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n *\n * Copyright (C) 2008\n *   Wyatt Baldwin <self@wyattbaldwin.com>\n *   All rights reserved\n *\n * Licensed under the MIT license.\n *\n *   http://www.opensource.org/licenses/mit-license.php\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *****************************************************************************/\nvar dijkstra = {\n  single_source_shortest_paths: function(graph, s, d) {\n    // Predecessor map for each node that has been encountered.\n    // node ID => predecessor node ID\n    var predecessors = {};\n\n    // Costs of shortest paths from s to all nodes encountered.\n    // node ID => cost\n    var costs = {};\n    costs[s] = 0;\n\n    // Costs of shortest paths from s to all nodes encountered; differs from\n    // `costs` in that it provides easy access to the node that currently has\n    // the known shortest path from s.\n    // XXX: Do we actually need both `costs` and `open`?\n    var open = dijkstra.PriorityQueue.make();\n    open.push(s, 0);\n\n    var closest,\n        u, v,\n        cost_of_s_to_u,\n        adjacent_nodes,\n        cost_of_e,\n        cost_of_s_to_u_plus_cost_of_e,\n        cost_of_s_to_v,\n        first_visit;\n    while (!open.empty()) {\n      // In the nodes remaining in graph that have a known cost from s,\n      // find the node, u, that currently has the shortest path from s.\n      closest = open.pop();\n      u = closest.value;\n      cost_of_s_to_u = closest.cost;\n\n      // Get nodes adjacent to u...\n      adjacent_nodes = graph[u] || {};\n\n      // ...and explore the edges that connect u to those nodes, updating\n      // the cost of the shortest paths to any or all of those nodes as\n      // necessary. v is the node across the current edge from u.\n      for (v in adjacent_nodes) {\n        if (adjacent_nodes.hasOwnProperty(v)) {\n          // Get the cost of the edge running from u to v.\n          cost_of_e = adjacent_nodes[v];\n\n          // Cost of s to u plus the cost of u to v across e--this is *a*\n          // cost from s to v that may or may not be less than the current\n          // known cost to v.\n          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n\n          // If we haven't visited v yet OR if the current known cost from s to\n          // v is greater than the new cost we just found (cost of s to u plus\n          // cost of u to v across e), update v's cost in the cost list and\n          // update v's predecessor in the predecessor list (it's now u).\n          cost_of_s_to_v = costs[v];\n          first_visit = (typeof costs[v] === 'undefined');\n          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n            predecessors[v] = u;\n          }\n        }\n      }\n    }\n\n    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n      throw new Error(msg);\n    }\n\n    return predecessors;\n  },\n\n  extract_shortest_path_from_predecessor_list: function(predecessors, d) {\n    var nodes = [];\n    var u = d;\n    var predecessor;\n    while (u) {\n      nodes.push(u);\n      predecessor = predecessors[u];\n      u = predecessors[u];\n    }\n    nodes.reverse();\n    return nodes;\n  },\n\n  find_path: function(graph, s, d) {\n    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n    return dijkstra.extract_shortest_path_from_predecessor_list(\n      predecessors, d);\n  },\n\n  /**\n   * A very naive priority queue implementation.\n   */\n  PriorityQueue: {\n    make: function (opts) {\n      var T = dijkstra.PriorityQueue,\n          t = {},\n          key;\n      opts = opts || {};\n      for (key in T) {\n        if (T.hasOwnProperty(key)) {\n          t[key] = T[key];\n        }\n      }\n      t.queue = [];\n      t.sorter = opts.sorter || T.default_sorter;\n      return t;\n    },\n\n    default_sorter: function (a, b) {\n      return a.cost - b.cost;\n    },\n\n    /**\n     * Add a new item to the queue and ensure the highest priority element\n     * is at the front of the queue.\n     */\n    push: function (value, cost) {\n      var item = {value: value, cost: cost};\n      this.queue.push(item);\n      this.queue.sort(this.sorter);\n    },\n\n    /**\n     * Return the highest priority element in the queue.\n     */\n    pop: function () {\n      return this.queue.shift();\n    },\n\n    empty: function () {\n      return this.queue.length === 0;\n    }\n  }\n};\n\n\n// node.js module exports\nif (typeof module !== 'undefined') {\n  module.exports = dijkstra;\n}\n"],"names":["dijkstra"],"mappings":";;;;;;AAuBA,QAAIA,YAAW;AAAA,MACb,8BAA8B,SAAS,OAAO,GAAG,GAAG;AAGlD,YAAI,eAAe,CAAE;AAIrB,YAAI,QAAQ,CAAE;AACd,cAAM,CAAC,IAAI;AAMX,YAAI,OAAOA,UAAS,cAAc,KAAM;AACxC,aAAK,KAAK,GAAG,CAAC;AAEd,YAAI,SACA,GAAG,GACH,gBACA,gBACA,WACA,+BACA,gBACA;AACJ,eAAO,CAAC,KAAK,SAAS;AAGpB,oBAAU,KAAK,IAAK;AACpB,cAAI,QAAQ;AACZ,2BAAiB,QAAQ;AAGzB,2BAAiB,MAAM,CAAC,KAAK,CAAE;AAK/B,eAAK,KAAK,gBAAgB;AACxB,gBAAI,eAAe,eAAe,CAAC,GAAG;AAEpC,0BAAY,eAAe,CAAC;AAK5B,8CAAgC,iBAAiB;AAMjD,+BAAiB,MAAM,CAAC;AACxB,4BAAe,OAAO,MAAM,CAAC,MAAM;AACnC,kBAAI,eAAe,iBAAiB,+BAA+B;AACjE,sBAAM,CAAC,IAAI;AACX,qBAAK,KAAK,GAAG,6BAA6B;AAC1C,6BAAa,CAAC,IAAI;AAAA,cAC9B;AAAA,YACA;AAAA,UACA;AAAA,QACA;AAEI,YAAI,OAAO,MAAM,eAAe,OAAO,MAAM,CAAC,MAAM,aAAa;AAC/D,cAAI,MAAM,CAAC,+BAA+B,GAAG,QAAQ,GAAG,GAAG,EAAE,KAAK,EAAE;AACpE,gBAAM,IAAI,MAAM,GAAG;AAAA,QACzB;AAEI,eAAO;AAAA,MACR;AAAA,MAED,6CAA6C,SAAS,cAAc,GAAG;AACrE,YAAI,QAAQ,CAAE;AACd,YAAI,IAAI;AAER,eAAO,GAAG;AACR,gBAAM,KAAK,CAAC;AACE,uBAAa,CAAC;AAC5B,cAAI,aAAa,CAAC;AAAA,QACxB;AACI,cAAM,QAAS;AACf,eAAO;AAAA,MACR;AAAA,MAED,WAAW,SAAS,OAAO,GAAG,GAAG;AAC/B,YAAI,eAAeA,UAAS,6BAA6B,OAAO,GAAG,CAAC;AACpE,eAAOA,UAAS;AAAA,UACd;AAAA,UAAc;AAAA,QAAC;AAAA,MAClB;AAAA;AAAA;AAAA;AAAA,MAKD,eAAe;AAAA,QACb,MAAM,SAAU,MAAM;AACpB,cAAI,IAAIA,UAAS,eACb,IAAI,CAAE,GACN;AACJ,iBAAO,QAAQ,CAAE;AACjB,eAAK,OAAO,GAAG;AACb,gBAAI,EAAE,eAAe,GAAG,GAAG;AACzB,gBAAE,GAAG,IAAI,EAAE,GAAG;AAAA,YACxB;AAAA,UACA;AACM,YAAE,QAAQ,CAAE;AACZ,YAAE,SAAS,KAAK,UAAU,EAAE;AAC5B,iBAAO;AAAA,QACR;AAAA,QAED,gBAAgB,SAAU,GAAG,GAAG;AAC9B,iBAAO,EAAE,OAAO,EAAE;AAAA,QACnB;AAAA;AAAA;AAAA;AAAA;AAAA,QAMD,MAAM,SAAU,OAAO,MAAM;AAC3B,cAAI,OAAO,EAAC,OAAc,KAAU;AACpC,eAAK,MAAM,KAAK,IAAI;AACpB,eAAK,MAAM,KAAK,KAAK,MAAM;AAAA,QAC5B;AAAA;AAAA;AAAA;AAAA,QAKD,KAAK,WAAY;AACf,iBAAO,KAAK,MAAM,MAAO;AAAA,QAC1B;AAAA,QAED,OAAO,WAAY;AACjB,iBAAO,KAAK,MAAM,WAAW;AAAA,QACnC;AAAA,MACA;AAAA,IACC;AAIkC;AACjC,uBAAiBA;AAAA,IACnB;AAAA;;;","x_google_ignoreList":[0]}