mirage2d 1.1.2 → 1.1.4

package/dist/js/_geojson-equality@0.1.6@geojson-equality/_geojson-equality@0.1.6@geojson-equality.09ffa121.js

@@ -1,133 +0,0 @@
-import { _ as _deepEqual_1_1_1_deepEqual } from "../_deep-equal@1.1.1@deep-equal/_deep-equal@1.1.1@deep-equal.98576c17.js";
-var deepEqual = _deepEqual_1_1_1_deepEqual;
-var Equality = function(opt) {
-  this.precision = opt && opt.precision ? opt.precision : 17;
-  this.direction = opt && opt.direction ? opt.direction : false;
-  this.pseudoNode = opt && opt.pseudoNode ? opt.pseudoNode : false;
-  this.objectComparator = opt && opt.objectComparator ? opt.objectComparator : objectComparator;
-};
-Equality.prototype.compare = function(g1, g2) {
-  if (g1.type !== g2.type || !sameLength(g1, g2))
-    return false;
-  switch (g1.type) {
-    case "Point":
-      return this.compareCoord(g1.coordinates, g2.coordinates);
-    case "LineString":
-      return this.compareLine(g1.coordinates, g2.coordinates, 0, false);
-    case "Polygon":
-      return this.comparePolygon(g1, g2);
-    case "Feature":
-      return this.compareFeature(g1, g2);
-    default:
-      if (g1.type.indexOf("Multi") === 0) {
-        var context = this;
-        var g1s = explode(g1);
-        var g2s = explode(g2);
-        return g1s.every(function(g1part) {
-          return this.some(function(g2part) {
-            return context.compare(g1part, g2part);
-          });
-        }, g2s);
-      }
-  }
-  return false;
-};
-function explode(g) {
-  return g.coordinates.map(function(part) {
-    return {
-      type: g.type.replace("Multi", ""),
-      coordinates: part
-    };
-  });
-}
-function sameLength(g1, g2) {
-  return g1.hasOwnProperty("coordinates") ? g1.coordinates.length === g2.coordinates.length : g1.length === g2.length;
-}
-Equality.prototype.compareCoord = function(c1, c2) {
-  if (c1.length !== c2.length) {
-    return false;
-  }
-  for (var i = 0; i < c1.length; i++) {
-    if (c1[i].toFixed(this.precision) !== c2[i].toFixed(this.precision)) {
-      return false;
-    }
-  }
-  return true;
-};
-Equality.prototype.compareLine = function(path1, path2, ind, isPoly) {
-  if (!sameLength(path1, path2))
-    return false;
-  var p1 = this.pseudoNode ? path1 : this.removePseudo(path1);
-  var p2 = this.pseudoNode ? path2 : this.removePseudo(path2);
-  if (isPoly && !this.compareCoord(p1[0], p2[0])) {
-    p2 = this.fixStartIndex(p2, p1);
-    if (!p2)
-      return;
-  }
-  var sameDirection = this.compareCoord(p1[ind], p2[ind]);
-  if (this.direction || sameDirection) {
-    return this.comparePath(p1, p2);
-  } else {
-    if (this.compareCoord(p1[ind], p2[p2.length - (1 + ind)])) {
-      return this.comparePath(p1.slice().reverse(), p2);
-    }
-    return false;
-  }
-};
-Equality.prototype.fixStartIndex = function(sourcePath, targetPath) {
-  var correctPath, ind = -1;
-  for (var i = 0; i < sourcePath.length; i++) {
-    if (this.compareCoord(sourcePath[i], targetPath[0])) {
-      ind = i;
-      break;
-    }
-  }
-  if (ind >= 0) {
-    correctPath = [].concat(
-      sourcePath.slice(ind, sourcePath.length),
-      sourcePath.slice(1, ind + 1)
-    );
-  }
-  return correctPath;
-};
-Equality.prototype.comparePath = function(p1, p2) {
-  var cont = this;
-  return p1.every(function(c, i) {
-    return cont.compareCoord(c, this[i]);
-  }, p2);
-};
-Equality.prototype.comparePolygon = function(g1, g2) {
-  if (this.compareLine(g1.coordinates[0], g2.coordinates[0], 1, true)) {
-    var holes1 = g1.coordinates.slice(1, g1.coordinates.length);
-    var holes2 = g2.coordinates.slice(1, g2.coordinates.length);
-    var cont = this;
-    return holes1.every(function(h1) {
-      return this.some(function(h2) {
-        return cont.compareLine(h1, h2, 1, true);
-      });
-    }, holes2);
-  } else {
-    return false;
-  }
-};
-Equality.prototype.compareFeature = function(g1, g2) {
-  if (g1.id !== g2.id || !this.objectComparator(g1.properties, g2.properties) || !this.compareBBox(g1, g2)) {
-    return false;
-  }
-  return this.compare(g1.geometry, g2.geometry);
-};
-Equality.prototype.compareBBox = function(g1, g2) {
-  if (!g1.bbox && !g2.bbox || g1.bbox && g2.bbox && this.compareCoord(g1.bbox, g2.bbox)) {
-    return true;
-  }
-  return false;
-};
-Equality.prototype.removePseudo = function(path) {
-  return path;
-};
-function objectComparator(obj1, obj2) {
-  return deepEqual(obj1, obj2, { strict: true });
-}
-var _geojsonEquality_0_1_6_geojsonEquality = Equality;
-var GeojsonEquality = _geojsonEquality_0_1_6_geojsonEquality;
-export { GeojsonEquality as G };

package/dist/js/_geojson-path-finder@1.5.3@geojson-path-finder/_geojson-path-finder@1.5.3@geojson-path-finder.7a10eb99.js

@@ -1,348 +0,0 @@
-import { r as require$$0 } from "../_tinyqueue@2.0.3@tinyqueue/_tinyqueue@2.0.3@tinyqueue.78918532.js";
-import { r as require$$0$1 } from "../_@turf_explode@6.5.0@@turf/_@turf_explode@6.5.0@@turf.5c768db5.js";
-import { r as require$$2 } from "../_@turf_distance@6.5.0@@turf/_@turf_distance@6.5.0@@turf.0c7b8aea.js";
-import { s as require$$3 } from "../_@turf_helpers@6.5.0@@turf/_@turf_helpers@6.5.0@@turf.f1480aa1.js";
-var Queue = require$$0;
-var dijkstra = function(graph, start, end) {
-  var costs = {};
-  costs[start] = 0;
-  var initialState = [0, [start], start];
-  var queue = new Queue([initialState], function(a, b) {
-    return a[0] - b[0];
-  });
-  while (queue.length) {
-    var state = queue.pop();
-    var cost = state[0];
-    var node = state[2];
-    if (node === end) {
-      return state.slice(0, 2);
-    }
-    var neighbours = graph[node];
-    Object.keys(neighbours).forEach(function(n) {
-      var newCost = cost + neighbours[n];
-      if (!(n in costs) || newCost < costs[n]) {
-        costs[n] = newCost;
-        var newState = [newCost, state[1].concat([n]), n];
-        queue.push(newState);
-      }
-    });
-  }
-  return null;
-};
-var roundCoord$2 = function roundCoord(c, precision) {
-  return [
-    Math.round(c[0] / precision) * precision,
-    Math.round(c[1] / precision) * precision
-  ];
-};
-var explode = require$$0$1, roundCoord$1 = roundCoord$2;
-var topology_1 = topology$1;
-function geoJsonReduce(geojson, fn, seed) {
-  if (geojson.type === "FeatureCollection") {
-    return geojson.features.reduce(function reduceFeatures(a, f) {
-      return geoJsonReduce(f, fn, a);
-    }, seed);
-  } else {
-    return fn(seed, geojson);
-  }
-}
-function geoJsonFilterFeatures(geojson, fn) {
-  var features = [];
-  if (geojson.type === "FeatureCollection") {
-    features = features.concat(geojson.features.filter(fn));
-  }
-  return {
-    type: "FeatureCollection",
-    features
-  };
-}
-function isLineString(f) {
-  return f.geometry.type === "LineString";
-}
-function topology$1(geojson, options) {
-  options = options || {};
-  var keyFn = options.keyFn || function defaultKeyFn(c) {
-    return c.join(",");
-  }, precision = options.precision || 1e-5;
-  var lineStrings = geoJsonFilterFeatures(geojson, isLineString);
-  var explodedLineStrings = explode(lineStrings);
-  var vertices = explodedLineStrings.features.reduce(function buildTopologyVertices(cs, f, i, fs) {
-    var rc = roundCoord$1(f.geometry.coordinates, precision);
-    cs[keyFn(rc)] = f.geometry.coordinates;
-    if (i % 1e3 === 0 && options.progress) {
-      options.progress("topo:vertices", i, fs.length);
-    }
-    return cs;
-  }, {}), edges = geoJsonReduce(lineStrings, function buildTopologyEdges(es, f, i, fs) {
-    f.geometry.coordinates.forEach(function buildLineStringEdges(c, i2, cs) {
-      if (i2 > 0) {
-        var k1 = keyFn(roundCoord$1(cs[i2 - 1], precision)), k2 = keyFn(roundCoord$1(c, precision));
-        es.push([k1, k2, f.properties]);
-      }
-    });
-    if (i % 1e3 === 0 && options.progress) {
-      options.progress("topo:edges", i, fs.length);
-    }
-    return es;
-  }, []);
-  return {
-    vertices,
-    edges
-  };
-}
-var compactor$2 = {
-  compactNode,
-  compactGraph
-};
-function findNextEnd(prev, v, vertices, ends, vertexCoords, edgeData, trackIncoming, options) {
-  var weight = vertices[prev][v], reverseWeight = vertices[v][prev], coordinates = [], path = [], reducedEdge = options.edgeDataSeed;
-  if (options.edgeDataReduceFn) {
-    reducedEdge = options.edgeDataReduceFn(reducedEdge, edgeData[v][prev]);
-  }
-  while (!ends[v]) {
-    var edges = vertices[v];
-    if (!edges) {
-      break;
-    }
-    var next = Object.keys(edges).filter(function notPrevious(k) {
-      return k !== prev;
-    })[0];
-    weight += edges[next];
-    if (trackIncoming) {
-      reverseWeight += vertices[next][v];
-      if (path.indexOf(v) >= 0) {
-        ends[v] = vertices[v];
-        break;
-      }
-      path.push(v);
-    }
-    if (options.edgeDataReduceFn) {
-      reducedEdge = options.edgeDataReduceFn(reducedEdge, edgeData[v][next]);
-    }
-    coordinates.push(vertexCoords[v]);
-    prev = v;
-    v = next;
-  }
-  return {
-    vertex: v,
-    weight,
-    reverseWeight,
-    coordinates,
-    reducedEdge
-  };
-}
-function compactNode(k, vertices, ends, vertexCoords, edgeData, trackIncoming, options) {
-  options = options || {};
-  var neighbors = vertices[k];
-  return Object.keys(neighbors).reduce(function compactEdge(result, j) {
-    var neighbor = findNextEnd(k, j, vertices, ends, vertexCoords, edgeData, trackIncoming, options);
-    var weight = neighbor.weight;
-    var reverseWeight = neighbor.reverseWeight;
-    if (neighbor.vertex !== k) {
-      if (!result.edges[neighbor.vertex] || result.edges[neighbor.vertex] > weight) {
-        result.edges[neighbor.vertex] = weight;
-        result.coordinates[neighbor.vertex] = [vertexCoords[k]].concat(neighbor.coordinates);
-        result.reducedEdges[neighbor.vertex] = neighbor.reducedEdge;
-      }
-      if (trackIncoming && !isNaN(reverseWeight) && (!result.incomingEdges[neighbor.vertex] || result.incomingEdges[neighbor.vertex] > reverseWeight)) {
-        result.incomingEdges[neighbor.vertex] = reverseWeight;
-        var coordinates = [vertexCoords[k]].concat(neighbor.coordinates);
-        coordinates.reverse();
-        result.incomingCoordinates[neighbor.vertex] = coordinates;
-      }
-    }
-    return result;
-  }, { edges: {}, incomingEdges: {}, coordinates: {}, incomingCoordinates: {}, reducedEdges: {} });
-}
-function compactGraph(vertices, vertexCoords, edgeData, options) {
-  options = options || {};
-  var progress = options.progress;
-  var ends = Object.keys(vertices).reduce(function findEnds(es, k, i, vs) {
-    var vertex = vertices[k];
-    var edges = Object.keys(vertex);
-    var numberEdges = edges.length;
-    var remove;
-    if (options.compact !== void 0 && !options.compact) {
-      remove = false;
-    } else if (numberEdges === 1) {
-      var other = vertices[edges[0]];
-      remove = !other[k];
-    } else if (numberEdges === 2) {
-      remove = edges.filter(function(n) {
-        return vertices[n][k];
-      }).length === numberEdges;
-    } else {
-      remove = false;
-    }
-    if (!remove) {
-      es[k] = vertex;
-    }
-    if (i % 1e3 === 0 && progress) {
-      progress("compact:ends", i, vs.length);
-    }
-    return es;
-  }, {});
-  return Object.keys(ends).reduce(function compactEnd(result, k, i, es) {
-    var compacted = compactNode(k, vertices, ends, vertexCoords, edgeData, false, options);
-    result.graph[k] = compacted.edges;
-    result.coordinates[k] = compacted.coordinates;
-    if (options.edgeDataReduceFn) {
-      result.reducedEdges[k] = compacted.reducedEdges;
-    }
-    if (i % 1e3 === 0 && progress) {
-      progress("compact:nodes", i, es.length);
-    }
-    return result;
-  }, { graph: {}, coordinates: {}, reducedEdges: {} });
-}
-var topology = topology_1, compactor$1 = compactor$2, distance = require$$2.default, { point } = require$$3;
-var preprocessor = function preprocess(graph, options) {
-  options = options || {};
-  var weightFn = options.weightFn || function defaultWeightFn(a, b) {
-    return distance(point(a), point(b));
-  }, topo;
-  if (graph.type === "FeatureCollection") {
-    topo = topology(graph, options);
-  } else if (graph.edges) {
-    topo = graph;
-  }
-  var graph = topo.edges.reduce(function buildGraph(g, edge, i, es) {
-    var a = edge[0], b = edge[1], props = edge[2], w = weightFn(topo.vertices[a], topo.vertices[b], props), makeEdgeList = function makeEdgeList2(node) {
-      if (!g.vertices[node]) {
-        g.vertices[node] = {};
-        if (options.edgeDataReduceFn) {
-          g.edgeData[node] = {};
-        }
-      }
-    }, concatEdge = function concatEdge2(startNode, endNode, weight) {
-      var v = g.vertices[startNode];
-      v[endNode] = weight;
-      if (options.edgeDataReduceFn) {
-        g.edgeData[startNode][endNode] = options.edgeDataReduceFn(options.edgeDataSeed, props);
-      }
-    };
-    if (w) {
-      makeEdgeList(a);
-      makeEdgeList(b);
-      if (w instanceof Object) {
-        if (w.forward) {
-          concatEdge(a, b, w.forward);
-        }
-        if (w.backward) {
-          concatEdge(b, a, w.backward);
-        }
-      } else {
-        concatEdge(a, b, w);
-        concatEdge(b, a, w);
-      }
-    }
-    if (i % 1e3 === 0 && options.progress) {
-      options.progress("edgeweights", i, es.length);
-    }
-    return g;
-  }, { edgeData: {}, vertices: {} });
-  var compact = compactor$1.compactGraph(graph.vertices, topo.vertices, graph.edgeData, options);
-  return {
-    vertices: graph.vertices,
-    edgeData: graph.edgeData,
-    sourceVertices: topo.vertices,
-    compactedVertices: compact.graph,
-    compactedCoordinates: compact.coordinates,
-    compactedEdges: options.edgeDataReduceFn ? compact.reducedEdges : null
-  };
-};
-var findPath = dijkstra, preprocess2 = preprocessor, compactor = compactor$2, roundCoord2 = roundCoord$2;
-var _geojsonPathFinder_1_5_3_geojsonPathFinder = PathFinder;
-function PathFinder(graph, options) {
-  options = options || {};
-  if (!graph.compactedVertices) {
-    graph = preprocess2(graph, options);
-  }
-  this._graph = graph;
-  this._keyFn = options.keyFn || function(c) {
-    return c.join(",");
-  };
-  this._precision = options.precision || 1e-5;
-  this._options = options;
-  if (Object.keys(this._graph.compactedVertices).filter(function(k) {
-    return k !== "edgeData";
-  }).length === 0) {
-    throw new Error("Compacted graph contains no forks (topology has no intersections).");
-  }
-}
-PathFinder.prototype = {
-  findPath: function(a, b) {
-    var start = this._keyFn(roundCoord2(a.geometry.coordinates, this._precision)), finish = this._keyFn(roundCoord2(b.geometry.coordinates, this._precision));
-    if (!this._graph.vertices[start] || !this._graph.vertices[finish]) {
-      return null;
-    }
-    this._createPhantom(start);
-    this._createPhantom(finish);
-    var path = findPath(this._graph.compactedVertices, start, finish);
-    if (path) {
-      var weight = path[0];
-      path = path[1];
-      return {
-        path: path.reduce(function buildPath(cs, v, i, vs) {
-          if (i > 0) {
-            cs = cs.concat(this._graph.compactedCoordinates[vs[i - 1]][v]);
-          }
-          return cs;
-        }.bind(this), []).concat([this._graph.sourceVertices[finish]]),
-        weight,
-        edgeDatas: this._graph.compactedEdges ? path.reduce(function buildEdgeData(eds, v, i, vs) {
-          if (i > 0) {
-            eds.push({
-              reducedEdge: this._graph.compactedEdges[vs[i - 1]][v]
-            });
-          }
-          return eds;
-        }.bind(this), []) : void 0
-      };
-    } else {
-      return null;
-    }
-  },
-  serialize: function() {
-    return this._graph;
-  },
-  _createPhantom: function(n) {
-    if (this._graph.compactedVertices[n])
-      return null;
-    var phantom = compactor.compactNode(n, this._graph.vertices, this._graph.compactedVertices, this._graph.sourceVertices, this._graph.edgeData, true, this._options);
-    this._graph.compactedVertices[n] = phantom.edges;
-    this._graph.compactedCoordinates[n] = phantom.coordinates;
-    if (this._graph.compactedEdges) {
-      this._graph.compactedEdges[n] = phantom.reducedEdges;
-    }
-    Object.keys(phantom.incomingEdges).forEach(function(neighbor) {
-      this._graph.compactedVertices[neighbor][n] = phantom.incomingEdges[neighbor];
-      this._graph.compactedCoordinates[neighbor][n] = [this._graph.sourceVertices[neighbor]].concat(phantom.incomingCoordinates[neighbor].slice(0, -1));
-      if (this._graph.compactedEdges) {
-        this._graph.compactedEdges[neighbor][n] = phantom.reducedEdges[neighbor];
-      }
-    }.bind(this));
-    return n;
-  },
-  _removePhantom: function(n) {
-    if (!n)
-      return;
-    Object.keys(this._graph.compactedVertices[n]).forEach(function(neighbor) {
-      delete this._graph.compactedVertices[neighbor][n];
-    }.bind(this));
-    Object.keys(this._graph.compactedCoordinates[n]).forEach(function(neighbor) {
-      delete this._graph.compactedCoordinates[neighbor][n];
-    }.bind(this));
-    if (this._graph.compactedEdges) {
-      Object.keys(this._graph.compactedEdges[n]).forEach(function(neighbor) {
-        delete this._graph.compactedEdges[neighbor][n];
-      }.bind(this));
-    }
-    delete this._graph.compactedVertices[n];
-    delete this._graph.compactedCoordinates[n];
-    if (this._graph.compactedEdges) {
-      delete this._graph.compactedEdges[n];
-    }
-  }
-};
-export { _geojsonPathFinder_1_5_3_geojsonPathFinder as _ };

package/dist/js/_geojson-rbush@3.2.0@geojson-rbush/_geojson-rbush@3.2.0@geojson-rbush.2adaeedb.js

@@ -1,93 +0,0 @@
-import { r as require$$0 } from "../_rbush@3.0.1@rbush/_rbush@3.0.1@rbush.57d33d95.js";
-import { s as require$$3$1 } from "../_@turf_helpers@6.5.0@@turf/_@turf_helpers@6.5.0@@turf.f1480aa1.js";
-import { r as require$$2 } from "../_@turf_meta@6.5.0@@turf/_@turf_meta@6.5.0@@turf.1b9d5da5.js";
-import { r as require$$3 } from "../_@turf_bbox@6.5.0@@turf/_@turf_bbox@6.5.0@@turf.4c59feee.js";
-var _geojsonRbush_3_2_0_geojsonRbush = { exports: {} };
-var rbush = require$$0;
-var helpers = require$$3$1;
-var meta = require$$2;
-var turfBBox = require$$3.default;
-var featureEach = meta.featureEach;
-meta.coordEach;
-helpers.polygon;
-var featureCollection = helpers.featureCollection;
-function geojsonRbush(maxEntries) {
-  var tree = new rbush(maxEntries);
-  tree.insert = function(feature) {
-    if (feature.type !== "Feature")
-      throw new Error("invalid feature");
-    feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
-    return rbush.prototype.insert.call(this, feature);
-  };
-  tree.load = function(features) {
-    var load = [];
-    if (Array.isArray(features)) {
-      features.forEach(function(feature) {
-        if (feature.type !== "Feature")
-          throw new Error("invalid features");
-        feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
-        load.push(feature);
-      });
-    } else {
-      featureEach(features, function(feature) {
-        if (feature.type !== "Feature")
-          throw new Error("invalid features");
-        feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
-        load.push(feature);
-      });
-    }
-    return rbush.prototype.load.call(this, load);
-  };
-  tree.remove = function(feature, equals) {
-    if (feature.type !== "Feature")
-      throw new Error("invalid feature");
-    feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
-    return rbush.prototype.remove.call(this, feature, equals);
-  };
-  tree.clear = function() {
-    return rbush.prototype.clear.call(this);
-  };
-  tree.search = function(geojson) {
-    var features = rbush.prototype.search.call(this, this.toBBox(geojson));
-    return featureCollection(features);
-  };
-  tree.collides = function(geojson) {
-    return rbush.prototype.collides.call(this, this.toBBox(geojson));
-  };
-  tree.all = function() {
-    var features = rbush.prototype.all.call(this);
-    return featureCollection(features);
-  };
-  tree.toJSON = function() {
-    return rbush.prototype.toJSON.call(this);
-  };
-  tree.fromJSON = function(json) {
-    return rbush.prototype.fromJSON.call(this, json);
-  };
-  tree.toBBox = function(geojson) {
-    var bbox;
-    if (geojson.bbox)
-      bbox = geojson.bbox;
-    else if (Array.isArray(geojson) && geojson.length === 4)
-      bbox = geojson;
-    else if (Array.isArray(geojson) && geojson.length === 6)
-      bbox = [geojson[0], geojson[1], geojson[3], geojson[4]];
-    else if (geojson.type === "Feature")
-      bbox = turfBBox(geojson);
-    else if (geojson.type === "FeatureCollection")
-      bbox = turfBBox(geojson);
-    else
-      throw new Error("invalid geojson");
-    return {
-      minX: bbox[0],
-      minY: bbox[1],
-      maxX: bbox[2],
-      maxY: bbox[3]
-    };
-  };
-  return tree;
-}
-_geojsonRbush_3_2_0_geojsonRbush.exports = geojsonRbush;
-_geojsonRbush_3_2_0_geojsonRbush.exports.default = geojsonRbush;
-var rbush$1 = _geojsonRbush_3_2_0_geojsonRbush.exports;
-export { rbush$1 as r };