@performant-software/geospatial 3.1.25-beta.1 → 3.1.25-beta.2

package/dist/index.es218.js

@@ -1,11 +1,383 @@
-import { toString as n } from "./index.es37.js";
-function a(t) {
-  var r = "[object " + t + "]";
-  return function(e) {
-    return n.call(e) === r;
-  };
+import { orient2d as p } from "./index.es471.js";
+import { incircle as S } from "./index.es472.js";
+class C {
+  constructor(t, s) {
+    this.W = t, this.bs = s;
+  }
+  /**
+   * Add a number to the set.
+   *
+   * @param idx The number to add. Must be 0 <= idx < len.
+   * @return this.
+   */
+  add(t) {
+    const s = this.W, n = t / s | 0, e = t % s;
+    return this.bs[n] |= 1 << e, this;
+  }
+  /**
+   * Delete a number from the set.
+   *
+   * @param idx The number to delete. Must be 0 <= idx < len.
+   * @return this.
+   */
+  delete(t) {
+    const s = this.W, n = t / s | 0, e = t % s;
+    return this.bs[n] &= ~(1 << e), this;
+  }
+  /**
+   * Add or delete a number in the set, depending on the second argument.
+   *
+   * @param idx The number to add or delete. Must be 0 <= idx < len.
+   * @param val If true, add the number, otherwise delete.
+   * @return val.
+   */
+  set(t, s) {
+    const n = this.W, e = t / n | 0, r = 1 << t % n;
+    return this.bs[e] ^= (-s ^ this.bs[e]) & r, s;
+  }
+  /**
+   * Whether the number is in the set.
+   *
+   * @param idx The number to test. Must be 0 <= idx < len.
+   * @return True if the number is in the set.
+   */
+  has(t) {
+    const s = this.W, n = t / s | 0, e = t % s;
+    return !!(this.bs[n] & 1 << e);
+  }
+  /**
+   * Iterate over the numbers that are in the set. The callback is invoked
+   * with each number that is set. It is allowed to change the BitSet during
+   * iteration. If it deletes a number that has not been iterated over, that
+   * number will not show up in a later call. If it adds a number during
+   * iteration, that number may or may not show up in a later call.
+   *
+   * @param fn The function to call for each number.
+   * @return this.
+   */
+  forEach(t) {
+    const s = this.W, n = this.bs, e = n.length;
+    for (let i = 0; i < e; i++) {
+      let r = 0;
+      for (; n[i] && r < s; )
+        n[i] & 1 << r && t(i * s + r), r++;
+    }
+    return this;
+  }
+}
+class M extends C {
+  /**
+   * Create a bit set.
+   *
+   * @param len The length of the bit set, limiting the maximum value that
+   *        can be stored in it to len - 1.
+   */
+  constructor(t) {
+    const n = new Uint8Array(Math.ceil(t / 8)).fill(0);
+    super(8, n);
+  }
+}
+function b(h) {
+  return h % 3 === 2 ? h - 2 : h + 1;
+}
+function w(h) {
+  return h % 3 === 0 ? h + 2 : h - 1;
+}
+const v = 2 ** 32 - 1;
+class D {
+  /**
+   * Make a Constrainautor.
+   *
+   * @param del The triangulation output from Delaunator.
+   * @param edges If provided, constrain these edges as by constrainAll.
+   */
+  constructor(t, s) {
+    if (!t || typeof t != "object" || !t.triangles || !t.halfedges || !t.coords)
+      throw new Error("Expected an object with Delaunator output");
+    if (t.triangles.length % 3 || t.halfedges.length !== t.triangles.length || t.coords.length % 2)
+      throw new Error("Delaunator output appears inconsistent");
+    if (t.triangles.length < 3)
+      throw new Error("No edges in triangulation");
+    this.del = t;
+    const n = t.coords.length >> 1, e = t.triangles.length;
+    this.vertMap = new Uint32Array(n).fill(v), this.flips = new M(e), this.consd = new M(e);
+    const i = t.triangles, r = this.vertMap;
+    for (let o = 0; o < e; o++) {
+      const c = i[o];
+      r[c] === v && this.updateVert(o);
+    }
+    s && this.constrainAll(s);
+  }
+  /**
+   * Constrain the triangulation such that there is an edge between p1 and p2.
+   *
+   * @param segP1 The index of one segment end-point in the coords array.
+   * @param segP2 The index of the other segment end-point in the coords array.
+   * @return The id of the edge that points from p1 to p2. If the
+   *         constrained edge lies on the hull and points in the opposite
+   *         direction (p2 to p1), the negative of its id is returned.
+   */
+  constrainOne(t, s) {
+    const { triangles: n, halfedges: e } = this.del, i = this.vertMap, r = this.consd, o = i[t];
+    if (o === v || i[s] === v)
+      throw new Error("Cannot constrain between points that are not triangulated");
+    let c = o;
+    do {
+      const f = n[c], g = b(c);
+      if (f === s)
+        return this.protect(c);
+      const d = w(c), m = n[d];
+      if (m === s)
+        return this.protect(g), g;
+      if (this.intersectSegments(t, s, m, f)) {
+        c = d;
+        break;
+      }
+      c = e[g];
+    } while (c !== -1 && c !== o);
+    let l = c, a = -1;
+    for (; c !== -1; ) {
+      const f = e[c], g = w(c), d = w(f), m = b(f);
+      if (f === -1)
+        throw new Error("Constraining edge exited the hull");
+      if (r.has(c))
+        throw new Error("Edge intersects already constrained edge");
+      if (this.isCollinear(t, s, n[c]) || this.isCollinear(t, s, n[f]))
+        throw new Error("Constraining edge intersects point");
+      if (!this.intersectSegments(n[c], n[f], n[g], n[d])) {
+        if (a === -1 && (a = c), n[d] === s) {
+          if (c === a)
+            throw new Error("Infinite loop: non-convex quadrilateral");
+          c = a, a = -1;
+          continue;
+        }
+        if (this.intersectSegments(t, s, n[d], n[f]))
+          c = d;
+        else if (this.intersectSegments(t, s, n[m], n[d]))
+          c = m;
+        else if (a === c)
+          throw new Error("Infinite loop: no further intersect after non-convex");
+        continue;
+      }
+      if (this.flipDiagonal(c), this.intersectSegments(t, s, n[g], n[d]) && (a === -1 && (a = g), a === g))
+        throw new Error("Infinite loop: flipped diagonal still intersects");
+      n[d] === s ? (l = d, c = a, a = -1) : this.intersectSegments(t, s, n[m], n[d]) && (c = m);
+    }
+    const u = this.flips;
+    this.protect(l);
+    do {
+      var E = 0;
+      u.forEach((f) => {
+        u.delete(f);
+        const g = e[f];
+        g !== -1 && (u.delete(g), this.isDelaunay(f) || (this.flipDiagonal(f), E++));
+      });
+    } while (E > 0);
+    return this.findEdge(t, s);
+  }
+  /**
+   * Fix the Delaunay condition. It is no longer necessary to call this
+   * method after constraining (many) edges, since constrainOne will do it
+   * after each.
+   *
+   * @param deep If true, keep checking & flipping edges until all
+   *        edges are Delaunay, otherwise only check the edges once.
+   * @return The triangulation object.
+   */
+  delaunify(t = !1) {
+    const s = this.del.halfedges, n = this.flips, e = this.consd, i = s.length;
+    do {
+      var r = 0;
+      for (let o = 0; o < i; o++) {
+        if (e.has(o))
+          continue;
+        n.delete(o);
+        const c = s[o];
+        c !== -1 && (n.delete(c), this.isDelaunay(o) || (this.flipDiagonal(o), r++));
+      }
+    } while (t && r > 0);
+    return this;
+  }
+  /**
+   * Call constrainOne on each edge, and delaunify afterwards.
+   *
+   * @param edges The edges to constrain: each element is an array with
+   *        [p1, p2] which are indices into the points array originally
+   *        supplied to Delaunator.
+   * @return The triangulation object.
+   */
+  constrainAll(t) {
+    const s = t.length;
+    for (let n = 0; n < s; n++) {
+      const e = t[n];
+      this.constrainOne(e[0], e[1]);
+    }
+    return this;
+  }
+  /**
+   * Whether an edge is a constrained edge.
+   *
+   * @param edg The edge id.
+   * @return True if the edge is constrained.
+   */
+  isConstrained(t) {
+    return this.consd.has(t);
+  }
+  /**
+   * Find the edge that points from p1 -> p2. If there is only an edge from
+   * p2 -> p1 (i.e. it is on the hull), returns the negative id of it.
+   *
+   * @param p1 The index of the first point into the points array.
+   * @param p2 The index of the second point into the points array.
+   * @return The id of the edge that points from p1 -> p2, or the negative
+   *         id of the edge that goes from p2 -> p1, or Infinity if there is
+   *         no edge between p1 and p2.
+   */
+  findEdge(t, s) {
+    const n = this.vertMap[s], e = this.del.triangles, i = this.del.halfedges;
+    let r = n, o = -1;
+    do {
+      if (e[r] === t)
+        return r;
+      o = b(r), r = i[o];
+    } while (r !== -1 && r !== n);
+    return e[b(o)] === t ? -o : 1 / 0;
+  }
+  /**
+   * Find points that are not triangulated. Trying to constrain an edge
+   * between two points either of which are not triangulated, will result in
+   * an error being thrown from constrainOne.
+   *
+   * @return An array of ids of points that have no incoming edges.
+   */
+  untriangulatedPoints() {
+    const t = [], s = this.vertMap, n = s.length;
+    for (let e = 0; e < n; e++)
+      s[e] === v && t.push(e);
+    return t;
+  }
+  /**
+   * Mark an edge as constrained, i.e. should not be touched by `delaunify`.
+   *
+   * @private
+   * @param edg The edge id.
+   * @return If edg has an adjacent, returns that, otherwise -edg.
+   */
+  protect(t) {
+    const s = this.del.halfedges[t], n = this.flips, e = this.consd;
+    return n.delete(t), e.add(t), s !== -1 ? (n.delete(s), e.add(s), s) : -t;
+  }
+  /**
+   * Mark an edge as flipped, unless it is already marked as constrained.
+   *
+   * @private
+   * @param edg The edge id.
+   * @return True if edg was not constrained.
+   */
+  markFlip(t) {
+    const s = this.del.halfedges, n = this.flips;
+    if (this.consd.has(t))
+      return !1;
+    const i = s[t];
+    return i !== -1 && (n.add(t), n.add(i)), !0;
+  }
+  /**
+   * Flip the edge shared by two triangles.
+   *
+   * @private
+   * @param edg The edge shared by the two triangles, must have an
+   *        adjacent half-edge.
+   * @return The new diagonal.
+   */
+  flipDiagonal(t) {
+    const s = this.del.triangles, n = this.del.halfedges, e = this.flips, i = this.consd, r = n[t], o = w(t), c = b(t), l = w(r), a = b(r), u = n[o], E = n[l];
+    if (i.has(t))
+      throw new Error("Trying to flip a constrained edge");
+    return s[t] = s[l], n[t] = E, e.set(t, e.has(l)) || i.set(t, i.has(l)), E !== -1 && (n[E] = t), n[o] = l, s[r] = s[o], n[r] = u, e.set(r, e.has(o)) || i.set(r, i.has(o)), u !== -1 && (n[u] = r), n[l] = o, this.markFlip(t), this.markFlip(c), this.markFlip(r), this.markFlip(a), e.add(o), i.delete(o), e.add(l), i.delete(l), this.updateVert(t), this.updateVert(c), this.updateVert(r), this.updateVert(a), o;
+  }
+  /**
+   * Whether the two triangles sharing edg conform to the Delaunay condition.
+   * As a shortcut, if the given edge has no adjacent (is on the hull), it is
+   * certainly Delaunay.
+   *
+   * @private
+   * @param edg The edge shared by the triangles to test.
+   * @return True if they are Delaunay.
+   */
+  isDelaunay(t) {
+    const s = this.del.triangles, e = this.del.halfedges[t];
+    if (e === -1)
+      return !0;
+    const i = s[w(t)], r = s[t], o = s[b(t)], c = s[w(e)];
+    return !this.inCircle(i, r, o, c);
+  }
+  /**
+   * Update the vertex -> incoming edge map.
+   *
+   * @private
+   * @param start The id of an *outgoing* edge.
+   * @return The id of the right-most incoming edge.
+   */
+  updateVert(t) {
+    const s = this.del.triangles, n = this.del.halfedges, e = this.vertMap, i = s[t];
+    let r = w(t), o = n[r];
+    for (; o !== -1 && o !== t; )
+      r = w(o), o = n[r];
+    return e[i] = r, r;
+  }
+  /**
+   * Whether the segment between [p1, p2] intersects with [p3, p4]. When the
+   * segments share an end-point (e.g. p1 == p3 etc.), they are not considered
+   * intersecting.
+   *
+   * @private
+   * @param p1 The index of point 1 into this.del.coords.
+   * @param p2 The index of point 2 into this.del.coords.
+   * @param p3 The index of point 3 into this.del.coords.
+   * @param p4 The index of point 4 into this.del.coords.
+   * @return True if the segments intersect.
+   */
+  intersectSegments(t, s, n, e) {
+    const i = this.del.coords;
+    return t === n || t === e || s === n || s === e ? !1 : j(i[t * 2], i[t * 2 + 1], i[s * 2], i[s * 2 + 1], i[n * 2], i[n * 2 + 1], i[e * 2], i[e * 2 + 1]);
+  }
+  /**
+   * Whether point px is in the circumcircle of the triangle formed by p1, p2,
+   * and p3 (which are in counter-clockwise order).
+   *
+   * @param p1 The index of point 1 into this.del.coords.
+   * @param p2 The index of point 2 into this.del.coords.
+   * @param p3 The index of point 3 into this.del.coords.
+   * @param px The index of point x into this.del.coords.
+   * @return True if (px, py) is in the circumcircle.
+   */
+  inCircle(t, s, n, e) {
+    const i = this.del.coords;
+    return S(i[t * 2], i[t * 2 + 1], i[s * 2], i[s * 2 + 1], i[n * 2], i[n * 2 + 1], i[e * 2], i[e * 2 + 1]) < 0;
+  }
+  /**
+   * Whether point p1, p2, and p are collinear.
+   *
+   * @private
+   * @param p1 The index of segment point 1 into this.del.coords.
+   * @param p2 The index of segment point 2 into this.del.coords.
+   * @param p The index of the point p into this.del.coords.
+   * @return True if the points are collinear.
+   */
+  isCollinear(t, s, n) {
+    const e = this.del.coords;
+    return p(e[t * 2], e[t * 2 + 1], e[s * 2], e[s * 2 + 1], e[n * 2], e[n * 2 + 1]) === 0;
+  }
+}
+D.intersectSegments = j;
+function j(h, t, s, n, e, i, r, o) {
+  const c = p(h, t, e, i, r, o), l = p(s, n, e, i, r, o);
+  if (c > 0 && l > 0 || c < 0 && l < 0)
+    return !1;
+  const a = p(e, i, h, t, s, n), u = p(r, o, h, t, s, n);
+  return a > 0 && u > 0 || a < 0 && u < 0 ? !1 : c === 0 && l === 0 && a === 0 && u === 0 ? !(Math.max(e, r) < Math.min(h, s) || Math.max(h, s) < Math.min(e, r) || Math.max(i, o) < Math.min(t, n) || Math.max(t, n) < Math.min(i, o)) : !0;
 }
 export {
-  a as default
+  D as default
 };
 //# sourceMappingURL=index.es218.js.map

package/dist/index.es218.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es218.js","sources":["../node_modules/underscore/modules/_tagTester.js"],"sourcesContent":["import { toString } from './_setup.js';\n\n// Internal function for creating a `toString`-based type tester.\nexport default function tagTester(name) {\n  var tag = '[object ' + name + ']';\n  return function(obj) {\n    return toString.call(obj) === tag;\n  };\n}\n"],"names":["tagTester","name","tag","obj","toString"],"mappings":";AAGA,SAAwBA,EAAUC,GAAM;AACtC,MAAIC,IAAM,aAAaD,IAAO;AAC9B,SAAO,SAASE,GAAK;AACnB,WAAOC,EAAS,KAAKD,CAAG,MAAMD;AAAA,EAChC;AACF;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es218.js","sources":["../../../node_modules/@kninnug/constrainautor/lib/Constrainautor.mjs"],"sourcesContent":["import { incircle, orient2d } from 'robust-predicates';\n\n/**\n * A set of numbers, stored as bits in a typed array. The amount of numbers /\n * the maximum number that can be stored is limited by the length, which is\n * fixed at construction time.\n */\nclass BitSet {\n    constructor(W, bs) {\n        this.W = W;\n        this.bs = bs;\n    }\n    /**\n     * Add a number to the set.\n     *\n     * @param idx The number to add. Must be 0 <= idx < len.\n     * @return this.\n     */\n    add(idx) {\n        const W = this.W;\n        const byte = (idx / W) | 0;\n        const bit = idx % W;\n        this.bs[byte] |= 1 << bit;\n        return this;\n    }\n    /**\n     * Delete a number from the set.\n     *\n     * @param idx The number to delete. Must be 0 <= idx < len.\n     * @return this.\n     */\n    delete(idx) {\n        const W = this.W;\n        const byte = (idx / W) | 0;\n        const bit = idx % W;\n        this.bs[byte] &= ~(1 << bit);\n        return this;\n    }\n    /**\n     * Add or delete a number in the set, depending on the second argument.\n     *\n     * @param idx The number to add or delete. Must be 0 <= idx < len.\n     * @param val If true, add the number, otherwise delete.\n     * @return val.\n     */\n    set(idx, val) {\n        const W = this.W;\n        const byte = (idx / W) | 0;\n        const bit = idx % W;\n        const m = 1 << bit;\n        //this.bs[byte] = set ? this.bs[byte] | m : this.bs[byte] & ~m;\n        this.bs[byte] ^= (-val ^ this.bs[byte]) & m; // -set == set * 255\n        return val;\n    }\n    /**\n     * Whether the number is in the set.\n     *\n     * @param idx The number to test. Must be 0 <= idx < len.\n     * @return True if the number is in the set.\n     */\n    has(idx) {\n        const W = this.W;\n        const byte = (idx / W) | 0;\n        const bit = idx % W;\n        return !!(this.bs[byte] & (1 << bit));\n    }\n    /**\n     * Iterate over the numbers that are in the set. The callback is invoked\n     * with each number that is set. It is allowed to change the BitSet during\n     * iteration. If it deletes a number that has not been iterated over, that\n     * number will not show up in a later call. If it adds a number during\n     * iteration, that number may or may not show up in a later call.\n     *\n     * @param fn The function to call for each number.\n     * @return this.\n     */\n    forEach(fn) {\n        const W = this.W;\n        const bs = this.bs;\n        const len = bs.length;\n        for (let byte = 0; byte < len; byte++) {\n            let bit = 0;\n            // bs[byte] may change during iteration\n            while (bs[byte] && bit < W) {\n                if (bs[byte] & (1 << bit)) {\n                    fn(byte * W + bit);\n                }\n                bit++;\n            }\n        }\n        return this;\n    }\n}\n/**\n * A bit set using 8 bits per cell.\n */\nclass BitSet8 extends BitSet {\n    /**\n     * Create a bit set.\n     *\n     * @param len The length of the bit set, limiting the maximum value that\n     *        can be stored in it to len - 1.\n     */\n    constructor(len) {\n        const W = 8;\n        const bs = new Uint8Array(Math.ceil(len / W)).fill(0);\n        super(W, bs);\n    }\n}\n\nfunction nextEdge(e) { return (e % 3 === 2) ? e - 2 : e + 1; }\nfunction prevEdge(e) { return (e % 3 === 0) ? e + 2 : e - 1; }\nconst U32NIL = 2 ** 32 - 1; // Max value of a Uint32Array: use as a sentinel for not yet defined \n/**\n * Constrain a triangulation from Delaunator, using (parts of) the algorithm\n * in \"A fast algorithm for generating constrained Delaunay triangulations\" by\n * S. W. Sloan.\n */\nclass Constrainautor {\n    /**\n     * Make a Constrainautor.\n     *\n     * @param del The triangulation output from Delaunator.\n     * @param edges If provided, constrain these edges as by constrainAll.\n     */\n    constructor(del, edges) {\n        if (!del || typeof del !== 'object' || !del.triangles || !del.halfedges || !del.coords) {\n            throw new Error(\"Expected an object with Delaunator output\");\n        }\n        if (del.triangles.length % 3 || del.halfedges.length !== del.triangles.length || del.coords.length % 2) {\n            throw new Error(\"Delaunator output appears inconsistent\");\n        }\n        if (del.triangles.length < 3) {\n            throw new Error(\"No edges in triangulation\");\n        }\n        this.del = del;\n        const numPoints = del.coords.length >> 1;\n        const numEdges = del.triangles.length;\n        // Map every vertex id to the right-most edge that points to that vertex.\n        this.vertMap = new Uint32Array(numPoints).fill(U32NIL);\n        // Keep track of edges flipped while constraining\n        this.flips = new BitSet8(numEdges);\n        // Keep track of constrained edges\n        this.consd = new BitSet8(numEdges);\n        const triangles = del.triangles;\n        const vm = this.vertMap;\n        for (let e = 0; e < numEdges; e++) {\n            const v = triangles[e];\n            if (vm[v] === U32NIL) {\n                this.updateVert(e);\n            }\n        }\n        if (edges) {\n            this.constrainAll(edges);\n        }\n    }\n    /**\n     * Constrain the triangulation such that there is an edge between p1 and p2.\n     *\n     * @param segP1 The index of one segment end-point in the coords array.\n     * @param segP2 The index of the other segment end-point in the coords array.\n     * @return The id of the edge that points from p1 to p2. If the\n     *         constrained edge lies on the hull and points in the opposite\n     *         direction (p2 to p1), the negative of its id is returned.\n     */\n    constrainOne(segP1, segP2) {\n        const { triangles, halfedges } = this.del;\n        const vm = this.vertMap;\n        const consd = this.consd;\n        const start = vm[segP1];\n        if (start === U32NIL || vm[segP2] === U32NIL) {\n            throw new Error(`Cannot constrain between points that are not triangulated`);\n        }\n        // Loop over the edges touching segP1\n        let edg = start;\n        do {\n            // edg points toward segP1, so its start-point is opposite it\n            const p4 = triangles[edg];\n            const nxt = nextEdge(edg);\n            // already constrained, but in reverse order\n            if (p4 === segP2) {\n                return this.protect(edg);\n            }\n            // The edge opposite segP1\n            const opp = prevEdge(edg);\n            const p3 = triangles[opp];\n            // already constrained\n            if (p3 === segP2) {\n                this.protect(nxt);\n                return nxt;\n            }\n            // edge opposite segP1 intersects constraint\n            if (this.intersectSegments(segP1, segP2, p3, p4)) {\n                edg = opp;\n                break;\n            }\n            const adj = halfedges[nxt];\n            // The next edge pointing to segP1\n            edg = adj;\n        } while (edg !== -1 && edg !== start);\n        let conEdge = edg;\n        // Walk through the triangulation looking for further intersecting\n        // edges and flip them. If an intersecting edge cannot be flipped,\n        // assign its id to `rescan` and restart from there, until there are\n        // no more intersects.\n        let rescan = -1;\n        while (edg !== -1) {\n            // edg is the intersecting half-edge in the triangle we came from\n            // adj is now the opposite half-edge in the adjacent triangle, which\n            // is away from segP1.\n            const adj = halfedges[edg];\n            // cross diagonal\n            const bot = prevEdge(edg);\n            const top = prevEdge(adj);\n            const rgt = nextEdge(adj);\n            if (adj === -1) {\n                throw new Error(\"Constraining edge exited the hull\");\n            }\n            if (consd.has(edg)) { // || consd.has(adj) // assume consd is consistent\n                throw new Error(\"Edge intersects already constrained edge\");\n            }\n            if (this.isCollinear(segP1, segP2, triangles[edg]) ||\n                this.isCollinear(segP1, segP2, triangles[adj])) {\n                throw new Error(\"Constraining edge intersects point\");\n            }\n            const convex = this.intersectSegments(triangles[edg], triangles[adj], triangles[bot], triangles[top]);\n            // The quadrilateral formed by the two triangles adjoing edg is not\n            // convex, so the edge can't be flipped. Continue looking for the\n            // next intersecting edge and restart at this one later.\n            if (!convex) {\n                if (rescan === -1) {\n                    rescan = edg;\n                }\n                if (triangles[top] === segP2) {\n                    if (edg === rescan) {\n                        throw new Error(\"Infinite loop: non-convex quadrilateral\");\n                    }\n                    edg = rescan;\n                    rescan = -1;\n                    continue;\n                }\n                // Look for the next intersect\n                if (this.intersectSegments(segP1, segP2, triangles[top], triangles[adj])) {\n                    edg = top;\n                }\n                else if (this.intersectSegments(segP1, segP2, triangles[rgt], triangles[top])) {\n                    edg = rgt;\n                }\n                else if (rescan === edg) {\n                    throw new Error(\"Infinite loop: no further intersect after non-convex\");\n                }\n                continue;\n            }\n            this.flipDiagonal(edg);\n            // The new edge might still intersect, which will be fixed in the\n            // next rescan.\n            if (this.intersectSegments(segP1, segP2, triangles[bot], triangles[top])) {\n                if (rescan === -1) {\n                    rescan = bot;\n                }\n                if (rescan === bot) {\n                    throw new Error(\"Infinite loop: flipped diagonal still intersects\");\n                }\n            }\n            // Reached the other segment end-point? Start the rescan.\n            if (triangles[top] === segP2) {\n                conEdge = top;\n                edg = rescan;\n                rescan = -1;\n                // Otherwise, for the next edge that intersects. Because we just\n                // flipped, it's either edg again, or rgt.\n            }\n            else if (this.intersectSegments(segP1, segP2, triangles[rgt], triangles[top])) {\n                edg = rgt;\n            }\n        }\n        const flips = this.flips;\n        this.protect(conEdge);\n        do {\n            // need to use var to scope it outside the loop, but re-initialize\n            // to 0 each iteration\n            var flipped = 0;\n            flips.forEach(edg => {\n                flips.delete(edg);\n                const adj = halfedges[edg];\n                if (adj === -1) {\n                    return;\n                }\n                flips.delete(adj);\n                if (!this.isDelaunay(edg)) {\n                    this.flipDiagonal(edg);\n                    flipped++;\n                }\n            });\n        } while (flipped > 0);\n        return this.findEdge(segP1, segP2);\n    }\n    /**\n     * Fix the Delaunay condition. It is no longer necessary to call this\n     * method after constraining (many) edges, since constrainOne will do it\n     * after each.\n     *\n     * @param deep If true, keep checking & flipping edges until all\n     *        edges are Delaunay, otherwise only check the edges once.\n     * @return The triangulation object.\n     */\n    delaunify(deep = false) {\n        const halfedges = this.del.halfedges;\n        const flips = this.flips;\n        const consd = this.consd;\n        const len = halfedges.length;\n        do {\n            var flipped = 0;\n            for (let edg = 0; edg < len; edg++) {\n                if (consd.has(edg)) {\n                    continue;\n                }\n                flips.delete(edg);\n                const adj = halfedges[edg];\n                if (adj === -1) {\n                    continue;\n                }\n                flips.delete(adj);\n                if (!this.isDelaunay(edg)) {\n                    this.flipDiagonal(edg);\n                    flipped++;\n                }\n            }\n        } while (deep && flipped > 0);\n        return this;\n    }\n    /**\n     * Call constrainOne on each edge, and delaunify afterwards.\n     *\n     * @param edges The edges to constrain: each element is an array with\n     *        [p1, p2] which are indices into the points array originally\n     *        supplied to Delaunator.\n     * @return The triangulation object.\n     */\n    constrainAll(edges) {\n        const len = edges.length;\n        for (let i = 0; i < len; i++) {\n            const e = edges[i];\n            this.constrainOne(e[0], e[1]);\n        }\n        return this;\n    }\n    /**\n     * Whether an edge is a constrained edge.\n     *\n     * @param edg The edge id.\n     * @return True if the edge is constrained.\n     */\n    isConstrained(edg) {\n        return this.consd.has(edg);\n    }\n    /**\n     * Find the edge that points from p1 -> p2. If there is only an edge from\n     * p2 -> p1 (i.e. it is on the hull), returns the negative id of it.\n     *\n     * @param p1 The index of the first point into the points array.\n     * @param p2 The index of the second point into the points array.\n     * @return The id of the edge that points from p1 -> p2, or the negative\n     *         id of the edge that goes from p2 -> p1, or Infinity if there is\n     *         no edge between p1 and p2.\n     */\n    findEdge(p1, p2) {\n        const start1 = this.vertMap[p2];\n        const triangles = this.del.triangles;\n        const halfedges = this.del.halfedges;\n        let edg = start1;\n        let prv = -1;\n        // Walk around p2, iterating over the edges pointing to it\n        do {\n            if (triangles[edg] === p1) {\n                return edg;\n            }\n            prv = nextEdge(edg);\n            edg = halfedges[prv];\n        } while (edg !== -1 && edg !== start1);\n        // Did not find p1 -> p2, the only option is that it is on the hull on\n        // the 'left-hand' side, pointing p2 -> p1 (or there is no edge)\n        if (triangles[nextEdge(prv)] === p1) {\n            return -prv;\n        }\n        return Infinity;\n    }\n    /**\n     * Find points that are not triangulated. Trying to constrain an edge\n     * between two points either of which are not triangulated, will result in\n     * an error being thrown from constrainOne.\n     *\n     * @return An array of ids of points that have no incoming edges.\n     */\n    untriangulatedPoints() {\n        const ret = [];\n        const vm = this.vertMap;\n        const numPoints = vm.length;\n        for (let i = 0; i < numPoints; i++) {\n            if (vm[i] === U32NIL) {\n                ret.push(i);\n            }\n        }\n        return ret;\n    }\n    /**\n     * Mark an edge as constrained, i.e. should not be touched by `delaunify`.\n     *\n     * @private\n     * @param edg The edge id.\n     * @return If edg has an adjacent, returns that, otherwise -edg.\n     */\n    protect(edg) {\n        const adj = this.del.halfedges[edg];\n        const flips = this.flips;\n        const consd = this.consd;\n        flips.delete(edg);\n        consd.add(edg);\n        if (adj !== -1) {\n            flips.delete(adj);\n            consd.add(adj);\n            return adj;\n        }\n        return -edg;\n    }\n    /**\n     * Mark an edge as flipped, unless it is already marked as constrained.\n     *\n     * @private\n     * @param edg The edge id.\n     * @return True if edg was not constrained.\n     */\n    markFlip(edg) {\n        const halfedges = this.del.halfedges;\n        const flips = this.flips;\n        const consd = this.consd;\n        if (consd.has(edg)) {\n            return false;\n        }\n        const adj = halfedges[edg];\n        if (adj !== -1) {\n            flips.add(edg);\n            flips.add(adj);\n        }\n        return true;\n    }\n    /**\n     * Flip the edge shared by two triangles.\n     *\n     * @private\n     * @param edg The edge shared by the two triangles, must have an\n     *        adjacent half-edge.\n     * @return The new diagonal.\n     */\n    flipDiagonal(edg) {\n        // Flip a diagonal\n        //                top                     edg\n        //          o  <----- o            o <------  o \n        //         | ^ \\      ^           |       ^ / ^\n        //      lft|  \\ \\     |        lft|      / /  |\n        //         |   \\ \\adj |           |  bot/ /   |\n        //         | edg\\ \\   |           |    / /top |\n        //         |     \\ \\  |rgt        |   / /     |rgt\n        //         v      \\ v |           v  / v      |\n        //         o ----->  o            o   ------> o \n        //           bot                     adj\n        const triangles = this.del.triangles;\n        const halfedges = this.del.halfedges;\n        const flips = this.flips;\n        const consd = this.consd;\n        const adj = halfedges[edg];\n        const bot = prevEdge(edg);\n        const lft = nextEdge(edg);\n        const top = prevEdge(adj);\n        const rgt = nextEdge(adj);\n        const adjBot = halfedges[bot];\n        const adjTop = halfedges[top];\n        if (consd.has(edg)) { // || consd.has(adj) // assume consd is consistent\n            throw new Error(\"Trying to flip a constrained edge\");\n        }\n        // move *edg to *top\n        triangles[edg] = triangles[top];\n        halfedges[edg] = adjTop;\n        if (!flips.set(edg, flips.has(top))) {\n            consd.set(edg, consd.has(top));\n        }\n        if (adjTop !== -1) {\n            halfedges[adjTop] = edg;\n        }\n        halfedges[bot] = top;\n        // move *adj to *bot\n        triangles[adj] = triangles[bot];\n        halfedges[adj] = adjBot;\n        if (!flips.set(adj, flips.has(bot))) {\n            consd.set(adj, consd.has(bot));\n        }\n        if (adjBot !== -1) {\n            halfedges[adjBot] = adj;\n        }\n        halfedges[top] = bot;\n        this.markFlip(edg);\n        this.markFlip(lft);\n        this.markFlip(adj);\n        this.markFlip(rgt);\n        // mark flips unconditionally\n        flips.add(bot);\n        consd.delete(bot);\n        flips.add(top);\n        consd.delete(top);\n        this.updateVert(edg);\n        this.updateVert(lft);\n        this.updateVert(adj);\n        this.updateVert(rgt);\n        return bot;\n    }\n    /**\n     * Whether the two triangles sharing edg conform to the Delaunay condition.\n     * As a shortcut, if the given edge has no adjacent (is on the hull), it is\n     * certainly Delaunay.\n     *\n     * @private\n     * @param edg The edge shared by the triangles to test.\n     * @return True if they are Delaunay.\n     */\n    isDelaunay(edg) {\n        const triangles = this.del.triangles;\n        const halfedges = this.del.halfedges;\n        const adj = halfedges[edg];\n        if (adj === -1) {\n            return true;\n        }\n        const p1 = triangles[prevEdge(edg)];\n        const p2 = triangles[edg];\n        const p3 = triangles[nextEdge(edg)];\n        const px = triangles[prevEdge(adj)];\n        return !this.inCircle(p1, p2, p3, px);\n    }\n    /**\n     * Update the vertex -> incoming edge map.\n     *\n     * @private\n     * @param start The id of an *outgoing* edge.\n     * @return The id of the right-most incoming edge.\n     */\n    updateVert(start) {\n        const triangles = this.del.triangles;\n        const halfedges = this.del.halfedges;\n        const vm = this.vertMap;\n        const v = triangles[start];\n        // When iterating over incoming edges around a vertex, we do so in\n        // clockwise order ('going left'). If the vertex lies on the hull, two\n        // of the edges will have no opposite, leaving a gap. If the starting\n        // incoming edge is not the right-most, we will miss edges between it\n        // and the gap. So walk counter-clockwise until we find an edge on the\n        // hull, or get back to where we started.\n        let inc = prevEdge(start);\n        let adj = halfedges[inc];\n        while (adj !== -1 && adj !== start) {\n            inc = prevEdge(adj);\n            adj = halfedges[inc];\n        }\n        vm[v] = inc;\n        return inc;\n    }\n    /**\n     * Whether the segment between [p1, p2] intersects with [p3, p4]. When the\n     * segments share an end-point (e.g. p1 == p3 etc.), they are not considered\n     * intersecting.\n     *\n     * @private\n     * @param p1 The index of point 1 into this.del.coords.\n     * @param p2 The index of point 2 into this.del.coords.\n     * @param p3 The index of point 3 into this.del.coords.\n     * @param p4 The index of point 4 into this.del.coords.\n     * @return True if the segments intersect.\n     */\n    intersectSegments(p1, p2, p3, p4) {\n        const pts = this.del.coords;\n        // If the segments share one of the end-points, they cannot intersect\n        // (provided the input is properly segmented, and the triangulation is\n        // correct), but intersectSegments will say that they do. We can catch\n        // it here already.\n        if (p1 === p3 || p1 === p4 || p2 === p3 || p2 === p4) {\n            return false;\n        }\n        return intersectSegments(pts[p1 * 2], pts[p1 * 2 + 1], pts[p2 * 2], pts[p2 * 2 + 1], pts[p3 * 2], pts[p3 * 2 + 1], pts[p4 * 2], pts[p4 * 2 + 1]);\n    }\n    /**\n     * Whether point px is in the circumcircle of the triangle formed by p1, p2,\n     * and p3 (which are in counter-clockwise order).\n     *\n     * @param p1 The index of point 1 into this.del.coords.\n     * @param p2 The index of point 2 into this.del.coords.\n     * @param p3 The index of point 3 into this.del.coords.\n     * @param px The index of point x into this.del.coords.\n     * @return True if (px, py) is in the circumcircle.\n     */\n    inCircle(p1, p2, p3, px) {\n        const pts = this.del.coords;\n        return incircle(pts[p1 * 2], pts[p1 * 2 + 1], pts[p2 * 2], pts[p2 * 2 + 1], pts[p3 * 2], pts[p3 * 2 + 1], pts[px * 2], pts[px * 2 + 1]) < 0.0;\n    }\n    /**\n     * Whether point p1, p2, and p are collinear.\n     *\n     * @private\n     * @param p1 The index of segment point 1 into this.del.coords.\n     * @param p2 The index of segment point 2 into this.del.coords.\n     * @param p The index of the point p into this.del.coords.\n     * @return True if the points are collinear.\n     */\n    isCollinear(p1, p2, p) {\n        const pts = this.del.coords;\n        return orient2d(pts[p1 * 2], pts[p1 * 2 + 1], pts[p2 * 2], pts[p2 * 2 + 1], pts[p * 2], pts[p * 2 + 1]) === 0.0;\n    }\n}\nConstrainautor.intersectSegments = intersectSegments;\n/**\n * Compute if two line segments [p1, p2] and [p3, p4] intersect.\n *\n * @name Constrainautor.intersectSegments\n * @source https://github.com/mikolalysenko/robust-segment-intersect\n * @param p1x The x coordinate of point 1 of the first segment.\n * @param p1y The y coordinate of point 1 of the first segment.\n * @param p2x The x coordinate of point 2 of the first segment.\n * @param p2y The y coordinate of point 2 of the first segment.\n * @param p3x The x coordinate of point 1 of the second segment.\n * @param p3y The y coordinate of point 1 of the second segment.\n * @param p4x The x coordinate of point 2 of the second segment.\n * @param p4y The y coordinate of point 2 of the second segment.\n * @return True if the line segments intersect.\n */\nfunction intersectSegments(p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y) {\n    const x0 = orient2d(p1x, p1y, p3x, p3y, p4x, p4y);\n    const y0 = orient2d(p2x, p2y, p3x, p3y, p4x, p4y);\n    if ((x0 > 0 && y0 > 0) || (x0 < 0 && y0 < 0)) {\n        return false;\n    }\n    const x1 = orient2d(p3x, p3y, p1x, p1y, p2x, p2y);\n    const y1 = orient2d(p4x, p4y, p1x, p1y, p2x, p2y);\n    if ((x1 > 0 && y1 > 0) || (x1 < 0 && y1 < 0)) {\n        return false;\n    }\n    //Check for degenerate collinear case\n    if (x0 === 0 && y0 === 0 && x1 === 0 && y1 === 0) {\n        return !(Math.max(p3x, p4x) < Math.min(p1x, p2x) ||\n            Math.max(p1x, p2x) < Math.min(p3x, p4x) ||\n            Math.max(p3y, p4y) < Math.min(p1y, p2y) ||\n            Math.max(p1y, p2y) < Math.min(p3y, p4y));\n    }\n    return true;\n}\n\nexport { Constrainautor as default };\n"],"names":["BitSet","W","bs","idx","byte","bit","val","m","fn","len","BitSet8","nextEdge","e","prevEdge","U32NIL","Constrainautor","del","edges","numPoints","numEdges","triangles","vm","v","segP1","segP2","halfedges","consd","start","edg","p4","nxt","opp","p3","conEdge","rescan","adj","bot","top","rgt","flips","flipped","deep","i","p1","p2","start1","prv","ret","lft","adjBot","adjTop","px","inc","pts","intersectSegments","incircle","p","orient2d","p1x","p1y","p2x","p2y","p3x","p3y","p4x","p4y","x0","y0","x1","y1"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es219.js

@@ -1,8 +1,20 @@
-import { hasOwnProperty as a } from "./index.es37.js";
-function n(r, t) {
-  return r != null && a.call(r, t);
+import { shades as e } from "./index.es220.js";
+function r(l, u) {
+  return u.reduce((n, a, o) => {
+    const d = (o + 1) * 100, p = `${l}-${d}`;
+    return n[p] = a, n;
+  }, {});
 }
-export {
-  n as default
-};
+({
+  // Add shades
+  ...r("blue", e.blue),
+  ...r("darkblue", e.darkblue),
+  ...r("purple", e.purple),
+  ...r("pink", e.pink),
+  ...r("orange", e.orange),
+  ...r("red", e.red),
+  ...r("green", e.green),
+  ...r("yellow", e.yellow),
+  ...r("gray", e.gray)
+});
 //# sourceMappingURL=index.es219.js.map

package/dist/index.es219.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es219.js","sources":["../node_modules/underscore/modules/_has.js"],"sourcesContent":["import { hasOwnProperty } from './_setup.js';\n\n// Internal function to check whether `key` is an own property name of `obj`.\nexport default function has(obj, key) {\n  return obj != null && hasOwnProperty.call(obj, key);\n}\n"],"names":["has","obj","key","hasOwnProperty"],"mappings":";AAGA,SAAwBA,EAAIC,GAAKC,GAAK;AACpC,SAAOD,KAAO,QAAQE,EAAe,KAAKF,GAAKC,CAAG;AACpD;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es219.js","sources":["../../../node_modules/@allmaps/tailwind/dist/theme-colors.js"],"sourcesContent":["import { blue, darkblue, purple, pink, orange, red, green, yellow, gray, black, white, inherit, current, transparent, shades } from './colors.js';\nfunction flattenShades(color, shades) {\n    return shades.reduce((flattened, hex, index) => {\n        const shade = (index + 1) * 100;\n        const key = `${color}-${shade}`;\n        flattened[key] = hex;\n        return flattened;\n    }, {});\n}\nexport const themeColors = {\n    blue,\n    darkblue,\n    purple,\n    pink,\n    orange,\n    red,\n    green,\n    yellow,\n    gray,\n    black,\n    white,\n    inherit,\n    current,\n    transparent,\n    // Add shades\n    ...flattenShades('blue', shades.blue),\n    ...flattenShades('darkblue', shades.darkblue),\n    ...flattenShades('purple', shades.purple),\n    ...flattenShades('pink', shades.pink),\n    ...flattenShades('orange', shades.orange),\n    ...flattenShades('red', shades.red),\n    ...flattenShades('green', shades.green),\n    ...flattenShades('yellow', shades.yellow),\n    ...flattenShades('gray', shades.gray)\n};\n"],"names":["flattenShades","color","shades","flattened","hex","index","shade","key"],"mappings":";AACA,SAASA,EAAcC,GAAOC,GAAQ;AAClC,SAAOA,EAAO,OAAO,CAACC,GAAWC,GAAKC,MAAU;AAC5C,UAAMC,KAASD,IAAQ,KAAK,KACtBE,IAAM,GAAGN,CAAK,IAAIK,CAAK;AAC7B,WAAAH,EAAUI,CAAG,IAAIH,GACVD;AAAA,EACX,GAAG,CAAA,CAAE;AACT;AAAA,CAC2B;AAAA;AAAA,EAgBvB,GAAGH,EAAc,QAAQE,EAAO,IAAI;AAAA,EACpC,GAAGF,EAAc,YAAYE,EAAO,QAAQ;AAAA,EAC5C,GAAGF,EAAc,UAAUE,EAAO,MAAM;AAAA,EACxC,GAAGF,EAAc,QAAQE,EAAO,IAAI;AAAA,EACpC,GAAGF,EAAc,UAAUE,EAAO,MAAM;AAAA,EACxC,GAAGF,EAAc,OAAOE,EAAO,GAAG;AAAA,EAClC,GAAGF,EAAc,SAASE,EAAO,KAAK;AAAA,EACtC,GAAGF,EAAc,UAAUE,EAAO,MAAM;AAAA,EACxC,GAAGF,EAAc,QAAQE,EAAO,IAAI;AACxC;","x_google_ignoreList":[0]}

package/dist/index.es22.js

@@ -1,5 +1,5 @@
 import { memo as i, useEffect as e } from "react";
-import { applyReactStyle as r } from "./index.es214.js";
+import { applyReactStyle as r } from "./index.es266.js";
 import { useControl as l } from "./index.es30.js";
 function a(o) {
   const t = l(({ mapLib: n }) => new n.NavigationControl(o), {

package/dist/index.es220.js

@@ -1,7 +1,127 @@
-import e from "./index.es249.js";
-import t from "./index.es222.js";
-const f = e(t);
+const b = "#222222", s = "#ffffff", i = 4, e = [
+  "#dff7fa",
+  "#c0eff5",
+  "#a1e7f0",
+  "#82dfeb",
+  "#63d8e6",
+  // Original color
+  "#4facb8",
+  "#3b818a",
+  "#27565c",
+  "#132b2d"
+], f = [
+  "#d7d9ee",
+  "#b0b4de",
+  "#898ecd",
+  "#6269bd",
+  "#3b44ad",
+  // Original color
+  "#2f368a",
+  "#232867",
+  "#171b45",
+  "#0b0d22"
+], d = [
+  "#f3dcf0",
+  "#e7b9e1",
+  "#dc97d2",
+  "#d074c3",
+  "#c552b5",
+  // Original color
+  "#9d4190",
+  "#76316c",
+  "#4e2048",
+  "#271024"
+], o = [
+  "#ffddf1",
+  "#ffbbe3",
+  "#ff99d5",
+  "#ff77c7",
+  "#ff56ba",
+  // Original color
+  "#cc4494",
+  "#99336f",
+  "#66224a",
+  "#321125"
+], c = [
+  "#ffe3d0",
+  "#ffc7a1",
+  "#ffab72",
+  "#ff8f43",
+  "#ff7415",
+  // Original color
+  "#cc5c10",
+  "#99450c",
+  "#662e08",
+  "#321704"
+], n = [
+  "#fededf",
+  "#febebf",
+  "#fe9e9f",
+  "#fe7e7f",
+  "#fe5e60",
+  // Original color
+  "#cb4b4c",
+  "#983839",
+  "#652526",
+  "#321213"
+], a = [
+  "#e0f2e8",
+  "#c1e6d2",
+  "#a2d9bb",
+  "#83cda5",
+  "#64c18f",
+  // Original color
+  "#509a72",
+  "#3c7355",
+  "#284d39",
+  "#13261c"
+], r = [
+  "#fff3d9",
+  "#ffe8b3",
+  "#ffdd8d",
+  "#ffd267",
+  "#ffc742",
+  // Original color
+  "#cc9f34",
+  "#997727",
+  "#664f1a",
+  "#32270d"
+], l = [
+  "#efefef",
+  "#e0e0e0",
+  "#d0d0d0",
+  "#c1c1c1",
+  "#b2b2b2",
+  "#8e8e8e",
+  "#6a6a6a",
+  "#474747",
+  "#232323"
+], t = {
+  blue: e,
+  darkblue: f,
+  purple: d,
+  pink: o,
+  orange: c,
+  red: n,
+  green: a,
+  yellow: r,
+  gray: l
+}, g = e[4], h = f[4];
+d[4];
+const x = o[4];
+c[4];
+const C = n[4], I = a[4], S = r[4];
+l[4];
 export {
-  f as default
+  b as black,
+  g as blue,
+  h as darkblue,
+  I as green,
+  i as originalColorIndex,
+  x as pink,
+  C as red,
+  t as shades,
+  s as white,
+  S as yellow
 };
 //# sourceMappingURL=index.es220.js.map

package/dist/index.es220.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es220.js","sources":["../node_modules/underscore/modules/_isBufferLike.js"],"sourcesContent":["import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getByteLength from './_getByteLength.js';\n\n// Internal helper to determine whether we should spend extensive checks against\n// `ArrayBuffer` et al.\nexport default createSizePropertyCheck(getByteLength);\n"],"names":["isBufferLike","createSizePropertyCheck","getByteLength"],"mappings":";;AAKA,MAAAA,IAAeC,EAAwBC,CAAa;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es220.js","sources":["../../../node_modules/@allmaps/tailwind/dist/colors.js"],"sourcesContent":["// Generated from Luuks color scheme with\n// https://www.colors.tools/tints-and-shades/\nconst black = '#222222';\nconst white = '#ffffff';\nconst inherit = 'inherit';\nconst current = 'currentColor';\nconst transparent = 'transparent';\n// Original color from Luuk's design\nexport const originalColorIndex = 4;\nconst blueShades = [\n    '#dff7fa',\n    '#c0eff5',\n    '#a1e7f0',\n    '#82dfeb',\n    '#63d8e6', // Original color\n    '#4facb8',\n    '#3b818a',\n    '#27565c',\n    '#132b2d'\n];\nconst darkblueShades = [\n    '#d7d9ee',\n    '#b0b4de',\n    '#898ecd',\n    '#6269bd',\n    '#3b44ad', // Original color\n    '#2f368a',\n    '#232867',\n    '#171b45',\n    '#0b0d22'\n];\n// TODO: add dark blue background color\n// '#101655'\nconst purpleShades = [\n    '#f3dcf0',\n    '#e7b9e1',\n    '#dc97d2',\n    '#d074c3',\n    '#c552b5', // Original color\n    '#9d4190',\n    '#76316c',\n    '#4e2048',\n    '#271024'\n];\nconst pinkShades = [\n    '#ffddf1',\n    '#ffbbe3',\n    '#ff99d5',\n    '#ff77c7',\n    '#ff56ba', // Original color\n    '#cc4494',\n    '#99336f',\n    '#66224a',\n    '#321125'\n];\nconst orangeShades = [\n    '#ffe3d0',\n    '#ffc7a1',\n    '#ffab72',\n    '#ff8f43',\n    '#ff7415', // Original color\n    '#cc5c10',\n    '#99450c',\n    '#662e08',\n    '#321704'\n];\nconst redShades = [\n    '#fededf',\n    '#febebf',\n    '#fe9e9f',\n    '#fe7e7f',\n    '#fe5e60', // Original color\n    '#cb4b4c',\n    '#983839',\n    '#652526',\n    '#321213'\n];\nconst greenShades = [\n    '#e0f2e8',\n    '#c1e6d2',\n    '#a2d9bb',\n    '#83cda5',\n    '#64c18f', // Original color\n    '#509a72',\n    '#3c7355',\n    '#284d39',\n    '#13261c'\n];\nconst yellowShades = [\n    '#fff3d9',\n    '#ffe8b3',\n    '#ffdd8d',\n    '#ffd267',\n    '#ffc742', // Original color\n    '#cc9f34',\n    '#997727',\n    '#664f1a',\n    '#32270d'\n];\nconst grayShades = [\n    '#efefef',\n    '#e0e0e0',\n    '#d0d0d0',\n    '#c1c1c1',\n    '#b2b2b2',\n    '#8e8e8e',\n    '#6a6a6a',\n    '#474747',\n    '#232323'\n];\nexport const shades = {\n    blue: blueShades,\n    darkblue: darkblueShades,\n    purple: purpleShades,\n    pink: pinkShades,\n    orange: orangeShades,\n    red: redShades,\n    green: greenShades,\n    yellow: yellowShades,\n    gray: grayShades\n};\nconst blue = blueShades[originalColorIndex];\nconst darkblue = darkblueShades[originalColorIndex];\nconst purple = purpleShades[originalColorIndex];\nconst pink = pinkShades[originalColorIndex];\nconst orange = orangeShades[originalColorIndex];\nconst red = redShades[originalColorIndex];\nconst green = greenShades[originalColorIndex];\nconst yellow = yellowShades[originalColorIndex];\nconst gray = grayShades[originalColorIndex];\nexport { blue, darkblue, purple, pink, orange, red, green, yellow, gray, black, white, inherit, current, transparent };\n"],"names":["black","white","originalColorIndex","blueShades","darkblueShades","purpleShades","pinkShades","orangeShades","redShades","greenShades","yellowShades","grayShades","shades","blue","darkblue","pink","red","green","yellow"],"mappings":"AAEA,MAAMA,IAAQ,WACRC,IAAQ,WAKDC,IAAqB,GAC5BC,IAAa;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAiB;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GAGMC,IAAe;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAa;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAe;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAY;AAAA,EACd;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAc;AAAA,EAChB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAe;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACMC,IAAa;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GACaC,IAAS;AAAA,EAClB,MAAMT;AAAA,EACN,UAAUC;AAAA,EACV,QAAQC;AAAA,EACR,MAAMC;AAAA,EACN,QAAQC;AAAA,EACR,KAAKC;AAAA,EACL,OAAOC;AAAA,EACP,QAAQC;AAAA,EACR,MAAMC;AACV,GACME,IAAOV,EAAW,CAAkB,GACpCW,IAAWV,EAAe,CAAkB;AACnCC,EAAa,CAAkB;AAC9C,MAAMU,IAAOT,EAAW,CAAkB;AAC3BC,EAAa,CAAkB;AAC9C,MAAMS,IAAMR,EAAU,CAAkB,GAClCS,IAAQR,EAAY,CAAkB,GACtCS,IAASR,EAAa,CAAkB;AACjCC,EAAW,CAAkB;","x_google_ignoreList":[0]}