@performant-software/geospatial 3.1.28 → 3.1.30-beta.0

package/dist/index.es417.js

@@ -0,0 +1,147 @@
+import { arrayMatrixSize as c, newArrayMatrix as f, pasteArrayMatrix as u, newBlockArrayMatrix as A, transposeArrayMatrix as l } from "./index.es333.js";
+import { Polynomial1 as y } from "./index.es413.js";
+import { BaseIndependentLinearWeightsTransformation as p } from "./index.es407.js";
+import { solveIndependentlyInverse as g } from "./index.es411.js";
+class C extends p {
+  kernelFunction;
+  normFunction;
+  epsilon;
+  coefsArrayMatrices;
+  coefsArrayMatrix;
+  coefsArrayMatricesSize;
+  coefsArrayMatrixSize;
+  weightsArrays;
+  rbfWeightsArrays;
+  affineWeightsArrays;
+  constructor(s, r, e, i, n, t) {
+    super(s, r, n, 3), this.kernelFunction = e, this.normFunction = i, this.epsilon = t, this.coefsArrayMatrices = this.getCoefsArrayMatrices(), this.coefsArrayMatrix = this.coefsArrayMatrices[0], this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((o) => c(o)), this.coefsArrayMatrixSize = c(this.coefsArrayMatrix);
+  }
+  getDestinationPointsArrays() {
+    return [
+      [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((s) => s[0]),
+      [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((s) => s[1])
+    ];
+  }
+  getCoefsArrayMatrix() {
+    const s = f(this.pointCount, this.pointCount, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      for (let o = 0; o < this.pointCount; o++)
+        s[t][o] = this.normFunction(this.sourcePoints[t], this.sourcePoints[o]);
+    if (this.epsilon === void 0) {
+      const t = s.map((o) => o.reduce((a, h) => a + h, 0)).reduce((o, a) => o + a, 0);
+      this.epsilon = t / (Math.pow(this.pointCount, 2) - this.pointCount);
+    }
+    const r = f(this.pointCount, this.pointCount, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      for (let o = 0; o < this.pointCount; o++)
+        r[t][o] = this.kernelFunction(s[t][o], {
+          epsilon: this.epsilon
+        });
+    let e = f(this.pointCount, 3, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      e = u(e, t, 0, [
+        y.getPolynomial1SourcePointCoefsArray(this.sourcePoints[t])
+      ]);
+    const i = f(3, 3, 0);
+    return A([
+      [r, e],
+      [l(e), i]
+    ]);
+  }
+  /**
+   * Get 1x(N+3) coefsArray, populating the (N+3)x(N+3) coefsArrayMatrix
+   *
+   * The coefsArray has a 1xN kernel part and a 1x3 affine part.
+   *
+   * @param sourcePoint
+   */
+  getSourcePointCoefsArray(s) {
+    return [
+      ...this.getRbfKernelSourcePointCoefsArray(s),
+      ...y.getPolynomial1SourcePointCoefsArray(s)
+    ];
+  }
+  getRbfKernelSourcePointCoefsArray(s) {
+    const r = [];
+    for (let e = 0; e < this.pointCount; e++)
+      r.push(this.kernelFunction(this.normFunction(this.sourcePoints[e], s), {
+        epsilon: this.epsilon
+      }));
+    return r;
+  }
+  setWeightsArrays(s, r) {
+    r && (this.epsilon = r), super.setWeightsArrays(s);
+  }
+  /**
+   * Solve the x and y components independently.
+   *
+   * This uses the exact inverse to compute (for each component, using the same coefs for both)
+   * the exact solution for the system of linear equations
+   * which is (in general) invertable to an exact solution.
+   *
+   * This wil result in a weights array for each component with rbf weights and affine weights.
+   */
+  solve() {
+    this.weightsArrays = g(this.coefsArrayMatrix, this.destinationPointsArrays), this.processWeightsArrays();
+  }
+  processWeightsArrays() {
+    if (!this.weightsArrays)
+      throw new Error("Weights not computed");
+    this.rbfWeightsArrays = this.weightsArrays.map((s) => s.slice(0, this.pointCount)), this.affineWeightsArrays = this.weightsArrays.map((s) => s.slice(this.pointCount));
+  }
+  evaluateFunction(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + this.kernelFunction(a, { epsilon: this.epsilon }) * r[t][h], 0), n[t] += e[t][0] + e[t][1] * s[0] + e[t][2] * s[1];
+    return n;
+  }
+  evaluatePartialDerivativeX(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + (a === 0 ? 0 : this.kernelFunction(a, {
+        derivative: 1,
+        epsilon: this.epsilon
+      }) * ((s[0] - this.sourcePoints[h][0]) / a) * r[t][h]), 0), n[t] += e[t][1];
+    return n;
+  }
+  evaluatePartialDerivativeY(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + (a === 0 ? 0 : this.kernelFunction(a, {
+        derivative: 1,
+        epsilon: this.epsilon
+      }) * ((s[1] - this.sourcePoints[h][1]) / a) * r[t][h]), 0), n[t] += e[t][2];
+    return n;
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("ThinPlateSpline transformation weights not computed");
+    const s = this.sourcePoints.length, r = new Float64Array(1 + 2 * s + 6);
+    r[0] = s;
+    for (let i = 0; i < s; i++)
+      r[1 + i] = this.rbfWeightsArrays[0][i];
+    for (let i = 0; i < s; i++)
+      r[1 + s + i] = this.rbfWeightsArrays[1][i];
+    for (let i = 0; i < 3; i++)
+      r[1 + 2 * s + i] = this.affineWeightsArrays[0][i];
+    for (let i = 0; i < 3; i++)
+      r[1 + 2 * s + 3 + i] = this.affineWeightsArrays[1][i];
+    const e = new Float64Array(s * 2);
+    for (let i = 0; i < s; i++)
+      e[i * 2] = this.sourcePoints[i][0], e[i * 2 + 1] = this.sourcePoints[i][1];
+    return {
+      weights: r,
+      sourcePoints: e
+    };
+  }
+}
+export {
+  C as RBF
+};
+//# sourceMappingURL=index.es417.js.map

package/dist/index.es417.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es417.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/RBF.js"],"sourcesContent":["import { arrayMatrixSize, newArrayMatrix, newBlockArrayMatrix, pasteArrayMatrix, transposeArrayMatrix } from '@allmaps/stdlib';\nimport { Polynomial1 } from './Polynomial1.js';\nimport { BaseIndependentLinearWeightsTransformation } from './BaseIndependentLinearWeightsTransformation.js';\nimport { solveIndependentlyInverse } from '../shared/solve-functions.js';\n/**\n * 2D Radial Basis Functions transformation\n *\n * See notebook https://observablehq.com/d/0b57d3b587542794 for code source and explanation\n */\nexport class RBF extends BaseIndependentLinearWeightsTransformation {\n    kernelFunction;\n    normFunction;\n    epsilon;\n    coefsArrayMatrices;\n    coefsArrayMatrix;\n    coefsArrayMatricesSize;\n    coefsArrayMatrixSize;\n    weightsArrays;\n    rbfWeightsArrays;\n    affineWeightsArrays;\n    constructor(sourcePoints, destinationPoints, kernelFunction, normFunction, type, epsilon) {\n        super(sourcePoints, destinationPoints, type, 3);\n        this.kernelFunction = kernelFunction;\n        this.normFunction = normFunction;\n        this.epsilon = epsilon;\n        // Note: getCoefsArrayMatrices can not be moved to the parent class's constructor\n        // since for this class it uses properties (normFunction, kernelFunction, epsilon)\n        // which are only defined after super()\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatrix = this.coefsArrayMatrices[0];\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n        this.coefsArrayMatrixSize = arrayMatrixSize(this.coefsArrayMatrix);\n    }\n    getDestinationPointsArrays() {\n        return [\n            [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((value) => value[0]),\n            [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrix() {\n        // Pre-compute kernelsArrayMatrix: fill normsArrayMatrix\n        // with the point to point distances between all control points\n        const normsArrayMatrix = newArrayMatrix(this.pointCount, this.pointCount, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            for (let j = 0; j < this.pointCount; j++) {\n                normsArrayMatrix[i][j] = this.normFunction(this.sourcePoints[i], this.sourcePoints[j]);\n            }\n        }\n        // If it's not provided, and if it's an input to the kernelFunction,\n        // compute epsilon as the average distance between the control points\n        if (this.epsilon === undefined) {\n            const normsSum = normsArrayMatrix\n                .map((row) => row.reduce((a, c) => a + c, 0))\n                .reduce((a, c) => a + c, 0);\n            this.epsilon = normsSum / (Math.pow(this.pointCount, 2) - this.pointCount);\n        }\n        // Finish the computation of kernelsArrayMatrix by applying the requested kernel function\n        const kernelCoefsArrayMatrix = newArrayMatrix(this.pointCount, this.pointCount, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            for (let j = 0; j < this.pointCount; j++) {\n                kernelCoefsArrayMatrix[i][j] = this.kernelFunction(normsArrayMatrix[i][j], {\n                    epsilon: this.epsilon\n                });\n            }\n        }\n        // Construct Nx3 affineCoefsArrayMatrix\n        // 1 x0 y0\n        // 1 x1 y1\n        // 1 x2 y2\n        // ...\n        let affineCoefsArrayMatrix = newArrayMatrix(this.pointCount, 3, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            affineCoefsArrayMatrix = pasteArrayMatrix(affineCoefsArrayMatrix, i, 0, [\n                Polynomial1.getPolynomial1SourcePointCoefsArray(this.sourcePoints[i])\n            ]);\n        }\n        // Construct 3x3 zerosArrayMatrix\n        const zerosArrayMatrix = newArrayMatrix(3, 3, 0);\n        // Combine kernelsArrayMatrix and affineCoefsArrayMatrix\n        // into new coefsArrayMatrix, to include the affine transformation\n        const coefsArrayMatrix = newBlockArrayMatrix([\n            [kernelCoefsArrayMatrix, affineCoefsArrayMatrix],\n            [transposeArrayMatrix(affineCoefsArrayMatrix), zerosArrayMatrix]\n        ]);\n        return coefsArrayMatrix;\n    }\n    /**\n     * Get 1x(N+3) coefsArray, populating the (N+3)x(N+3) coefsArrayMatrix\n     *\n     * The coefsArray has a 1xN kernel part and a 1x3 affine part.\n     *\n     * @param sourcePoint\n     */\n    getSourcePointCoefsArray(sourcePoint) {\n        return [\n            ...this.getRbfKernelSourcePointCoefsArray(sourcePoint),\n            ...Polynomial1.getPolynomial1SourcePointCoefsArray(sourcePoint)\n        ];\n    }\n    getRbfKernelSourcePointCoefsArray(sourcePoint) {\n        const kernelSourcePointCoefsArray = [];\n        for (let i = 0; i < this.pointCount; i++) {\n            kernelSourcePointCoefsArray.push(this.kernelFunction(this.normFunction(this.sourcePoints[i], sourcePoint), {\n                epsilon: this.epsilon\n            }));\n        }\n        return kernelSourcePointCoefsArray;\n    }\n    setWeightsArrays(weightsArrays, epsilon) {\n        if (epsilon) {\n            this.epsilon = epsilon;\n        }\n        super.setWeightsArrays(weightsArrays);\n    }\n    /**\n     * Solve the x and y components independently.\n     *\n     * This uses the exact inverse to compute (for each component, using the same coefs for both)\n     * the exact solution for the system of linear equations\n     * which is (in general) invertable to an exact solution.\n     *\n     * This wil result in a weights array for each component with rbf weights and affine weights.\n     */\n    solve() {\n        this.weightsArrays = solveIndependentlyInverse(this.coefsArrayMatrix, this.destinationPointsArrays);\n        this.processWeightsArrays();\n    }\n    processWeightsArrays() {\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        this.rbfWeightsArrays = this.weightsArrays.map((array) => array.slice(0, this.pointCount));\n        this.affineWeightsArrays = this.weightsArrays.map((array) => array.slice(this.pointCount));\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPoint[i] = newDistances.reduce((sum, dist, index) => sum +\n                this.kernelFunction(dist, { epsilon: this.epsilon }) *\n                    rbfWeights[i][index], 0);\n            // Add the affine part\n            newDestinationPoint[i] +=\n                affineWeights[i][0] +\n                    affineWeights[i][1] * newSourcePoint[0] +\n                    affineWeights[i][2] * newSourcePoint[1];\n        }\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPointPartDerX[i] = newDistances.reduce((sum, dist, index) => sum +\n                (dist === 0\n                    ? 0\n                    : this.kernelFunction(dist, {\n                        derivative: 1,\n                        epsilon: this.epsilon\n                    }) *\n                        ((newSourcePoint[0] - this.sourcePoints[index][0]) / dist) *\n                        rbfWeights[i][index]), 0);\n            // Add the affine part\n            newDestinationPointPartDerX[i] += affineWeights[i][1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPointPartDerY[i] = newDistances.reduce((sum, dist, index) => sum +\n                (dist === 0\n                    ? 0\n                    : this.kernelFunction(dist, {\n                        derivative: 1,\n                        epsilon: this.epsilon\n                    }) *\n                        ((newSourcePoint[1] - this.sourcePoints[index][1]) / dist) *\n                        rbfWeights[i][index]), 0);\n            // Add the affine part\n            newDestinationPointPartDerY[i] += affineWeights[i][2];\n        }\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('ThinPlateSpline transformation weights not computed');\n        }\n        const n = this.sourcePoints.length;\n        // Format: [n, rbfWx[n], rbfWy[n], affineWx[3], affineWy[3]]\n        const weights = new Float64Array(1 + 2 * n + 6);\n        weights[0] = n;\n        for (let i = 0; i < n; i++) {\n            weights[1 + i] = this.rbfWeightsArrays[0][i];\n        }\n        for (let i = 0; i < n; i++) {\n            weights[1 + n + i] = this.rbfWeightsArrays[1][i];\n        }\n        for (let i = 0; i < 3; i++) {\n            weights[1 + 2 * n + i] = this.affineWeightsArrays[0][i];\n        }\n        for (let i = 0; i < 3; i++) {\n            weights[1 + 2 * n + 3 + i] = this.affineWeightsArrays[1][i];\n        }\n        // Flatten source points\n        const flatSourcePoints = new Float64Array(n * 2);\n        for (let i = 0; i < n; i++) {\n            flatSourcePoints[i * 2] = this.sourcePoints[i][0];\n            flatSourcePoints[i * 2 + 1] = this.sourcePoints[i][1];\n        }\n        return {\n            weights,\n            sourcePoints: flatSourcePoints\n        };\n    }\n}\n"],"names":["RBF","BaseIndependentLinearWeightsTransformation","sourcePoints","destinationPoints","kernelFunction","normFunction","type","epsilon","coefsArrayMatrix","arrayMatrixSize","value","normsArrayMatrix","newArrayMatrix","i","j","normsSum","row","c","a","kernelCoefsArrayMatrix","affineCoefsArrayMatrix","pasteArrayMatrix","Polynomial1","zerosArrayMatrix","newBlockArrayMatrix","transposeArrayMatrix","sourcePoint","kernelSourcePointCoefsArray","weightsArrays","solveIndependentlyInverse","array","newSourcePoint","rbfWeights","affineWeights","newDistances","newDestinationPoint","sum","dist","index","newDestinationPointPartDerX","newDestinationPointPartDerY","n","weights","flatSourcePoints"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es418.js

@@ -0,0 +1,58 @@
+import { Helmert as o } from "./index.es412.js";
+import { BaseTransformation as h } from "./index.es409.js";
+class g extends h {
+  weightsArrays;
+  constructor(s, r) {
+    super(s, r, "straight", 2);
+  }
+  /** Solve the x and y components jointly.
+   *
+   * This computes the corresponding Helmert transform and get the scale from it.
+   */
+  solve() {
+    const r = new o(this.sourcePoints, this.destinationPoints).getMeasures().scale, e = this.sourcePoints.reduce((t, i) => [t[0] + i[0], t[1] + i[1]]).map((t) => t / this.pointCount), n = this.destinationPoints.reduce((t, i) => [t[0] + i[0], t[1] + i[1]]).map((t) => t / this.pointCount), a = n.map((t, i) => t - e[i] * r);
+    this.weightsArrays = {
+      scale: r,
+      sourcePointsCenter: e,
+      destinationPointsCenter: n,
+      translation: a
+    };
+  }
+  // Evaluate the transformation function at a new point
+  evaluateFunction(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    return [
+      this.weightsArrays.translation[0] + this.weightsArrays.scale * s[0],
+      this.weightsArrays.translation[1] + this.weightsArrays.scale * s[1]
+    ];
+  }
+  // Evaluate the transformation function's partial derivative to x at a new point
+  evaluatePartialDerivativeX(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    return [this.weightsArrays.scale, 0];
+  }
+  // Evaluate the transformation function's partial derivative to y at a new point
+  evaluatePartialDerivativeY(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    return [0, this.weightsArrays.scale];
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    return {
+      weights: new Float64Array([
+        this.weightsArrays.translation[0],
+        this.weightsArrays.translation[1],
+        this.weightsArrays.scale
+      ]),
+      sourcePoints: new Float64Array(0)
+    };
+  }
+}
+export {
+  g as Straight
+};
+//# sourceMappingURL=index.es418.js.map

package/dist/index.es418.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es418.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Straight.js"],"sourcesContent":["import { Helmert } from './Helmert.js';\nimport { BaseTransformation } from './BaseTransformation.js';\nexport class Straight extends BaseTransformation {\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'straight', 2);\n    }\n    /** Solve the x and y components jointly.\n     *\n     * This computes the corresponding Helmert transform and get the scale from it.\n     */\n    solve() {\n        const helmertTransformation = new Helmert(this.sourcePoints, this.destinationPoints);\n        const scale = helmertTransformation.getMeasures().scale;\n        // Compute the centers of the source points and destination points\n        const sourcePointsCenter = this.sourcePoints\n            .reduce((center, point) => [center[0] + point[0], center[1] + point[1]])\n            .map((coordinate) => coordinate / this.pointCount);\n        const destinationPointsCenter = this.destinationPoints\n            .reduce((center, point) => [center[0] + point[0], center[1] + point[1]])\n            .map((coordinate) => coordinate / this.pointCount);\n        // Compute the translation vector from the (scaled) center of the source points to the center of the destination points\n        const translation = destinationPointsCenter.map((coord, i) => coord - sourcePointsCenter[i] * scale);\n        this.weightsArrays = {\n            scale,\n            sourcePointsCenter,\n            destinationPointsCenter,\n            translation\n        };\n    }\n    // Evaluate the transformation function at a new point\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPoint = [\n            this.weightsArrays.translation[0] +\n                this.weightsArrays.scale * newSourcePoint[0],\n            this.weightsArrays.translation[1] +\n                this.weightsArrays.scale * newSourcePoint[1]\n        ];\n        return newDestinationPoint;\n    }\n    // Evaluate the transformation function's partial derivative to x at a new point\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerX = [this.weightsArrays.scale, 0];\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to y at a new point\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerY = [0, this.weightsArrays.scale];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Straight: [tx, ty, scale]\n        return {\n            weights: new Float64Array([\n                this.weightsArrays.translation[0],\n                this.weightsArrays.translation[1],\n                this.weightsArrays.scale\n            ]),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Straight","BaseTransformation","sourcePoints","destinationPoints","scale","Helmert","sourcePointsCenter","center","point","coordinate","destinationPointsCenter","translation","coord","newSourcePoint","_newSourcePoint"],"mappings":";;AAEO,MAAMA,UAAiBC,EAAmB;AAAA,EAC7C;AAAA,EACA,YAAYC,GAAcC,GAAmB;AACzC,UAAMD,GAAcC,GAAmB,YAAY,CAAC;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ;AAEJ,UAAMC,IADwB,IAAIC,EAAQ,KAAK,cAAc,KAAK,iBAAiB,EAC/C,YAAA,EAAc,OAE5CC,IAAqB,KAAK,aAC3B,OAAO,CAACC,GAAQC,MAAU,CAACD,EAAO,CAAC,IAAIC,EAAM,CAAC,GAAGD,EAAO,CAAC,IAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAI,CAACC,MAAeA,IAAa,KAAK,UAAU,GAC/CC,IAA0B,KAAK,kBAChC,OAAO,CAACH,GAAQC,MAAU,CAACD,EAAO,CAAC,IAAIC,EAAM,CAAC,GAAGD,EAAO,CAAC,IAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAI,CAACC,MAAeA,IAAa,KAAK,UAAU,GAE/CE,IAAcD,EAAwB,IAAI,CAACE,GAAO,MAAMA,IAAQN,EAAmB,CAAC,IAAIF,CAAK;AACnG,SAAK,gBAAgB;AAAA,MACjB,OAAAA;AAAA,MACA,oBAAAE;AAAA,MACA,yBAAAI;AAAA,MACA,aAAAC;AAAA,IAAA;AAAA,EAER;AAAA;AAAA,EAEA,iBAAiBE,GAAgB;AAI7B,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAQ1C,WAN4B;AAAA,MACxB,KAAK,cAAc,YAAY,CAAC,IAC5B,KAAK,cAAc,QAAQA,EAAe,CAAC;AAAA,MAC/C,KAAK,cAAc,YAAY,CAAC,IAC5B,KAAK,cAAc,QAAQA,EAAe,CAAC;AAAA,IAAA;AAAA,EAGvD;AAAA;AAAA,EAEA,2BAA2BC,GAAiB;AAIxC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,WADoC,CAAC,KAAK,cAAc,OAAO,CAAC;AAAA,EAEpE;AAAA;AAAA,EAEA,2BAA2BA,GAAiB;AAIxC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,WADoC,CAAC,GAAG,KAAK,cAAc,KAAK;AAAA,EAEpE;AAAA,EACA,sCAAsC;AAIlC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,WAAO;AAAA,MACH,SAAS,IAAI,aAAa;AAAA,QACtB,KAAK,cAAc,YAAY,CAAC;AAAA,QAChC,KAAK,cAAc,YAAY,CAAC;AAAA,QAChC,KAAK,cAAc;AAAA,MAAA,CACtB;AAAA,MACD,cAAc,IAAI,aAAa,CAAC;AAAA,IAAA;AAAA,EAExC;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es419.js

@@ -0,0 +1,85 @@
+import { bboxToRectangle as G } from "./index.es215.js";
+import { conformLineString as C, midPoint as P, conformRing as F, squaredDistance as g, distance as a } from "./index.es274.js";
+const V = {
+  maxDepth: 0,
+  minSourceDistance: 0,
+  minDestinationDistance: 0,
+  minOffsetRatio: 0,
+  minOffsetDistance: 1 / 0,
+  sourceMidPointFunction: P,
+  destinationMidPointFunction: P
+};
+function x(n, i, t) {
+  n = C(n);
+  const o = n.map((c) => ({
+    source: c,
+    destination: i(c)
+  })), e = L(o, !1).map((c) => d(c, i, t, 0)).flat(1);
+  return R(e, !0);
+}
+function j(n, i, t) {
+  n = F(n);
+  const o = n.map((c) => ({
+    source: c,
+    destination: i(c)
+  })), e = L(o, !0).map((c) => d(c, i, t, 0)).flat(1);
+  return R(e, !1);
+}
+function d(n, i, t, o) {
+  const s = T(n, i, t, o);
+  return s ? [
+    d([n[0], s], i, t, o + 1),
+    d([s, n[1]], i, t, o + 1)
+  ].flat(1) : [n];
+}
+function T(n, i, t, o) {
+  if (o >= t.maxDepth || t.maxDepth <= 0 || a(n[0].source, n[1].source) < t.minSourceDistance || a(n[0].destination, n[1].destination) < t.minDestinationDistance)
+    return;
+  const { sourceMidPoint: s, destinationMidPointFromRefinementFunction: e, destinationMidPointsDistance: c, destinationLineDistance: u } = v(n, i, t);
+  return q({
+    destinationMidPointsDistance: c,
+    destinationLineDistance: u
+  }, t) ? {
+    source: s,
+    destination: e
+  } : void 0;
+}
+function v(n, i, t) {
+  const o = t.sourceMidPointFunction(n[0].source, n[1].source), s = t.destinationMidPointFunction(n[0].destination, n[1].destination), e = i(o), c = a(s, e), u = a(n[0].destination, n[1].destination);
+  return {
+    sourceMidPoint: o,
+    destinationMidPointFromRefinementFunction: e,
+    destinationMidPointsDistance: c,
+    destinationLineDistance: u
+  };
+}
+function q({ destinationMidPointsDistance: n, destinationLineDistance: i }, t) {
+  return n / i > t.minOffsetRatio || n > t.minOffsetDistance;
+}
+function k(n, i, t) {
+  const o = G(n), s = o[2], e = o[3], c = o[1], u = o[0], f = t.sourceMidPointFunction(s, c), m = t.sourceMidPointFunction(e, u), h = t.sourceMidPointFunction(s, e), D = t.sourceMidPointFunction(c, u), M = [[f, m], [h, D]].map((r) => x(r, i, t).map((l) => l.source));
+  if (M.every((r) => r.length == 2))
+    return;
+  const S = M.map((r) => r.slice(0, -1).map((l, p) => g(l, r[p + 1])));
+  return Math.sqrt(Math.min(...S.flat()));
+}
+function L(n, i = !1) {
+  const t = n.length - (i ? 0 : 1), o = [];
+  for (let s = 0; s < t; s++)
+    o.push([n[s], n[(s + 1) % n.length]]);
+  return o;
+}
+function R(n, i = !1) {
+  const t = n.map((o) => o[0]);
+  return i && t.push(n[n.length - 1][1]), t;
+}
+export {
+  V as defaultRefinementOptions,
+  R as gcpLinesToGcps,
+  L as gcpsToGcpLines,
+  k as getSourceRefinementResolution,
+  T as newMidGcpIfShouldSplitGcpLine,
+  x as refineLineString,
+  j as refineRing
+};
+//# sourceMappingURL=index.es419.js.map

package/dist/index.es419.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es419.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/refinement-functions.js"],"sourcesContent":["import { midPoint, distance, squaredDistance, conformLineString, conformRing, bboxToRectangle } from '@allmaps/stdlib';\n// About Refinement Functions:\n//\n// Refinement function are used both in forward and backward transformation\n// and are the generalised approach to refine lineStrings, rings etc.\n// when they are transformed using a (forward or backward) 'refinement function'.\n//\n// See the way refinement methods are called:\n// with a different refinementFunction and refinementOptions for the forward and backward case.\n//\n// The concepts of 'source' and 'destination' for refinement methods\n// might therefore differ from the from the transform methods that called them.\n// For forward transform methods, 'source' and 'destination' in the refinement context\n// are the same as in their original transform context.\n// For backward transform methods, they are inversed.\n// Hence, in the refinement contect we always act source > destination.\nexport const defaultRefinementOptions = {\n    maxDepth: 0,\n    minSourceDistance: 0,\n    minDestinationDistance: 0,\n    minOffsetRatio: 0,\n    minOffsetDistance: Infinity,\n    sourceMidPointFunction: midPoint,\n    destinationMidPointFunction: midPoint\n};\n// Refine Geometries\nexport function refineLineString(lineString, refinementFunction, refinementOptions) {\n    lineString = conformLineString(lineString);\n    const gcps = lineString.map((point) => ({\n        source: point,\n        destination: refinementFunction(point)\n    }));\n    const gcpLines = gcpsToGcpLines(gcps, false);\n    const refinedGcpLines = gcpLines\n        .map((gcpLine) => splitGcpLineRecursively(gcpLine, refinementFunction, refinementOptions, 0))\n        .flat(1);\n    return gcpLinesToGcps(refinedGcpLines, true);\n}\nexport function refineRing(ring, refinementFunction, refinementOptions) {\n    ring = conformRing(ring);\n    const gcps = ring.map((point) => ({\n        source: point,\n        destination: refinementFunction(point)\n    }));\n    const gcpLines = gcpsToGcpLines(gcps, true);\n    const refinedGcpLines = gcpLines\n        .map((line) => splitGcpLineRecursively(line, refinementFunction, refinementOptions, 0))\n        .flat(1);\n    return gcpLinesToGcps(refinedGcpLines, false);\n}\nfunction splitGcpLineRecursively(gcpLine, refinementFunction, refinementOptions, depth) {\n    const newMidGcp = newMidGcpIfShouldSplitGcpLine(gcpLine, refinementFunction, refinementOptions, depth);\n    if (newMidGcp) {\n        return [\n            splitGcpLineRecursively([gcpLine[0], newMidGcp], refinementFunction, refinementOptions, depth + 1),\n            splitGcpLineRecursively([newMidGcp, gcpLine[1]], refinementFunction, refinementOptions, depth + 1)\n        ].flat(1);\n    }\n    else {\n        return [gcpLine];\n    }\n}\n// Should split line\n// This function checks if a GcpLine should be splits\n// and returns the new midGcp if so, or undefined otherwise\nexport function newMidGcpIfShouldSplitGcpLine(gcpLine, refinementFunction, refinementOptions, depth) {\n    if (depth >= refinementOptions.maxDepth ||\n        refinementOptions.maxDepth <= 0 ||\n        distance(gcpLine[0].source, gcpLine[1].source) <\n            refinementOptions.minSourceDistance ||\n        distance(gcpLine[0].destination, gcpLine[1].destination) <\n            refinementOptions.minDestinationDistance) {\n        return undefined;\n    }\n    const { sourceMidPoint, destinationMidPointFromRefinementFunction, destinationMidPointsDistance, destinationLineDistance } = splitGcpLinePointInfo(gcpLine, refinementFunction, refinementOptions);\n    const shouldSplit = shouldSplitGcpLine({\n        destinationMidPointsDistance,\n        destinationLineDistance\n    }, refinementOptions);\n    return shouldSplit\n        ? {\n            source: sourceMidPoint,\n            destination: destinationMidPointFromRefinementFunction\n        }\n        : undefined;\n}\nfunction splitGcpLinePointInfo(gcpLine, refinementFunction, refinementOptions) {\n    const sourceMidPoint = refinementOptions.sourceMidPointFunction(gcpLine[0].source, gcpLine[1].source);\n    const destinationMidPoint = refinementOptions.destinationMidPointFunction(gcpLine[0].destination, gcpLine[1].destination);\n    const destinationMidPointFromRefinementFunction = refinementFunction(sourceMidPoint);\n    const destinationMidPointsDistance = distance(destinationMidPoint, destinationMidPointFromRefinementFunction);\n    const destinationLineDistance = distance(gcpLine[0].destination, gcpLine[1].destination);\n    return {\n        sourceMidPoint,\n        destinationMidPointFromRefinementFunction,\n        destinationMidPointsDistance,\n        destinationLineDistance\n    };\n}\nfunction shouldSplitGcpLine({ destinationMidPointsDistance, destinationLineDistance }, refinementOptions) {\n    return (destinationMidPointsDistance / destinationLineDistance >\n        refinementOptions.minOffsetRatio ||\n        destinationMidPointsDistance > refinementOptions.minOffsetDistance);\n}\n// Get source refinement resolution\nexport function getSourceRefinementResolution(sourceBbox, refinementFunction, refinementOptions) {\n    const sourceRectangle = bboxToRectangle(sourceBbox);\n    const sourceTRPoint = sourceRectangle[2];\n    const sourceTLPoint = sourceRectangle[3];\n    const sourceBRPoint = sourceRectangle[1];\n    const sourceBLPoint = sourceRectangle[0];\n    const sourceCRPoint = refinementOptions.sourceMidPointFunction(sourceTRPoint, sourceBRPoint);\n    const sourceCLPoint = refinementOptions.sourceMidPointFunction(sourceTLPoint, sourceBLPoint);\n    const sourceTCPoint = refinementOptions.sourceMidPointFunction(sourceTRPoint, sourceTLPoint);\n    const sourceBCPoint = refinementOptions.sourceMidPointFunction(sourceBRPoint, sourceBLPoint);\n    // Get horizontal and vertical lines from points\n    // Note: Could also add sourceHTLine, sourceHBLine, sourceVLLine, sourceVRLine\n    // to get a more accurate resolution (at the expense of more refinement computations),\n    // but testing showed this was not needed\n    const sourceHCLine = [sourceCRPoint, sourceCLPoint];\n    const sourceVCLine = [sourceTCPoint, sourceBCPoint];\n    const sourceMultiLine = [sourceHCLine, sourceVCLine];\n    // Refine lines\n    const sourceRefinedMultiLineString = sourceMultiLine.map((sourceLine) => refineLineString(sourceLine, refinementFunction, refinementOptions).map((generalGcp) => generalGcp.source));\n    if (sourceRefinedMultiLineString.every((sourceRefinedLineString) => sourceRefinedLineString.length == 2)) {\n        return undefined;\n    }\n    // Compute minimal line length of refinement\n    // Note: Tried to acchieve this by working with unflattened refined line and computing depth\n    // but that proved difficult for TypeScript\n    const sourceRefinedMultiLineStringSquaredLengths = sourceRefinedMultiLineString.map((sourceRefinedLineString) => sourceRefinedLineString\n        .slice(0, -1)\n        .map((sourcePoint, index) => squaredDistance(sourcePoint, sourceRefinedLineString[index + 1])));\n    const sourceRefinedMultiLineStringMinLength = Math.sqrt(Math.min(...sourceRefinedMultiLineStringSquaredLengths.flat()));\n    return sourceRefinedMultiLineStringMinLength;\n}\n// Convert\nexport function gcpsToGcpLines(gcps, close = false) {\n    const lineCount = gcps.length - (close ? 0 : 1);\n    const lines = [];\n    for (let index = 0; index < lineCount; index++) {\n        lines.push([gcps[index], gcps[(index + 1) % gcps.length]]);\n    }\n    return lines;\n}\nexport function gcpLinesToGcps(lines, close = false) {\n    const gcps = lines.map((line) => line[0]);\n    if (close) {\n        gcps.push(lines[lines.length - 1][1]);\n    }\n    return gcps;\n}\n"],"names":["defaultRefinementOptions","midPoint","refineLineString","lineString","refinementFunction","refinementOptions","conformLineString","gcps","point","refinedGcpLines","gcpsToGcpLines","gcpLine","splitGcpLineRecursively","gcpLinesToGcps","refineRing","ring","conformRing","line","depth","newMidGcp","newMidGcpIfShouldSplitGcpLine","distance","sourceMidPoint","destinationMidPointFromRefinementFunction","destinationMidPointsDistance","destinationLineDistance","splitGcpLinePointInfo","shouldSplitGcpLine","destinationMidPoint","getSourceRefinementResolution","sourceBbox","sourceRectangle","bboxToRectangle","sourceTRPoint","sourceTLPoint","sourceBRPoint","sourceBLPoint","sourceCRPoint","sourceCLPoint","sourceTCPoint","sourceBCPoint","sourceRefinedMultiLineString","sourceLine","generalGcp","sourceRefinedLineString","sourceRefinedMultiLineStringSquaredLengths","sourcePoint","index","squaredDistance","close","lineCount","lines"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es42.js

@@ -1,6 +1,6 @@
-import r from "./index.es218.js";
+import r from "./index.es235.js";
 import { isIE11 as t } from "./index.es39.js";
-import { ie11fingerprint as o, mapMethods as i } from "./index.es224.js";
+import { ie11fingerprint as o, mapMethods as i } from "./index.es241.js";
 const a = t ? o(i) : r("Map");
 export {
   a as default

package/dist/index.es420.js

@@ -0,0 +1,9 @@
+import o, { m as e } from "./index.es517.js";
+const t = e.SingularValueDecomposition, i = o.Matrix ? o.Matrix : e.Matrix, s = e.inverse, a = e.pseudoInverse;
+export {
+  t as SingularValueDecomposition,
+  i as default,
+  s as inverse,
+  a as pseudoInverse
+};
+//# sourceMappingURL=index.es420.js.map

package/dist/index.es420.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es420.js","sources":["../../../node_modules/ml-matrix/matrix.mjs"],"sourcesContent":["import * as matrix from './matrix.js';\n\nexport const AbstractMatrix = matrix.AbstractMatrix;\nexport const CHO = matrix.CHO;\nexport const CholeskyDecomposition = matrix.CholeskyDecomposition;\nexport const DistanceMatrix = matrix.DistanceMatrix;\nexport const EVD = matrix.EVD;\nexport const EigenvalueDecomposition = matrix.EigenvalueDecomposition;\nexport const LU = matrix.LU;\nexport const LuDecomposition = matrix.LuDecomposition;\nexport const Matrix = matrix.Matrix;\nexport const MatrixColumnSelectionView = matrix.MatrixColumnSelectionView;\nexport const MatrixColumnView = matrix.MatrixColumnView;\nexport const MatrixFlipColumnView = matrix.MatrixFlipColumnView;\nexport const MatrixFlipRowView = matrix.MatrixFlipRowView;\nexport const MatrixRowSelectionView = matrix.MatrixRowSelectionView;\nexport const MatrixRowView = matrix.MatrixRowView;\nexport const MatrixSelectionView = matrix.MatrixSelectionView;\nexport const MatrixSubView = matrix.MatrixSubView;\nexport const MatrixTransposeView = matrix.MatrixTransposeView;\nexport const NIPALS = matrix.NIPALS;\nexport const Nipals = matrix.Nipals;\nexport const QR = matrix.QR;\nexport const QrDecomposition = matrix.QrDecomposition;\nexport const SVD = matrix.SVD;\nexport const SingularValueDecomposition = matrix.SingularValueDecomposition;\nexport const SymmetricMatrix = matrix.SymmetricMatrix;\nexport const WrapperMatrix1D = matrix.WrapperMatrix1D;\nexport const WrapperMatrix2D = matrix.WrapperMatrix2D;\nexport const correlation = matrix.correlation;\nexport const covariance = matrix.covariance;\nexport default matrix.default.Matrix ? matrix.default.Matrix : matrix.Matrix;\nexport const determinant = matrix.determinant;\nexport const inverse = matrix.inverse;\nexport const linearDependencies = matrix.linearDependencies;\nexport const pseudoInverse = matrix.pseudoInverse;\nexport const solve = matrix.solve;\nexport const wrap = matrix.wrap;\n"],"names":["SingularValueDecomposition","matrix.SingularValueDecomposition","Matrix","matrix.default","matrix.Matrix","inverse","matrix.inverse","pseudoInverse","matrix.pseudoInverse"],"mappings":";AAyBY,MAACA,IAA6BC,EAAAA,4BAM1CC,IAAeC,EAAe,SAASA,EAAe,SAASC,EAAAA,QAElDC,IAAUC,EAAAA,SAEVC,IAAgBC,EAAAA;","x_google_ignoreList":[0]}

package/dist/index.es421.js

@@ -0,0 +1,261 @@
+import { orient2d as j } from "./index.es271.js";
+const Y = Math.pow(2, -52), q = new Uint32Array(512);
+class C {
+  /**
+   * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).
+   * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.
+   *
+   * @template P
+   * @param {P[]} points
+   * @param {(p: P) => number} [getX]
+   * @param {(p: P) => number} [getY]
+   */
+  // @ts-expect-error TS2322
+  static from(t, i = Q, h = V) {
+    const r = t.length, l = new Float64Array(r * 2);
+    for (let n = 0; n < r; n++) {
+      const o = t[n];
+      l[2 * n] = i(o), l[2 * n + 1] = h(o);
+    }
+    return new C(l);
+  }
+  /**
+   * Constructs a delaunay triangulation object given an array of point coordinates of the form:
+   * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.
+   *
+   * @param {T} coords
+   */
+  constructor(t) {
+    const i = t.length >> 1;
+    if (i > 0 && typeof t[0] != "number") throw new Error("Expected coords to contain numbers.");
+    this.coords = t;
+    const h = Math.max(2 * i - 5, 0);
+    this._triangles = new Uint32Array(h * 3), this._halfedges = new Int32Array(h * 3), this._hashSize = Math.ceil(Math.sqrt(i)), this._hullPrev = new Uint32Array(i), this._hullNext = new Uint32Array(i), this._hullTri = new Uint32Array(i), this._hullHash = new Int32Array(this._hashSize), this._ids = new Uint32Array(i), this._dists = new Float64Array(i), this.trianglesLen = 0, this._cx = 0, this._cy = 0, this._hullStart = 0, this.hull = this._triangles, this.triangles = this._triangles, this.halfedges = this._halfedges, this.update();
+  }
+  /**
+   * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.
+   * Useful for iterative relaxation algorithms such as Lloyd's.
+   */
+  update() {
+    const { coords: t, _hullPrev: i, _hullNext: h, _hullTri: r, _hullHash: l } = this, n = t.length >> 1;
+    let o = 1 / 0, f = 1 / 0, g = -1 / 0, m = -1 / 0;
+    for (let e = 0; e < n; e++) {
+      const u = t[2 * e], a = t[2 * e + 1];
+      u < o && (o = u), a < f && (f = a), u > g && (g = u), a > m && (m = a), this._ids[e] = e;
+    }
+    const d = (o + g) / 2, b = (f + m) / 2;
+    let c = 0, y = 0, w = 0;
+    for (let e = 0, u = 1 / 0; e < n; e++) {
+      const a = X(d, b, t[2 * e], t[2 * e + 1]);
+      a < u && (c = e, u = a);
+    }
+    const T = t[2 * c], M = t[2 * c + 1];
+    for (let e = 0, u = 1 / 0; e < n; e++) {
+      if (e === c) continue;
+      const a = X(T, M, t[2 * e], t[2 * e + 1]);
+      a < u && a > 0 && (y = e, u = a);
+    }
+    let U = t[2 * y], k = t[2 * y + 1], G = 1 / 0;
+    for (let e = 0; e < n; e++) {
+      if (e === c || e === y) continue;
+      const u = B(T, M, U, k, t[2 * e], t[2 * e + 1]);
+      u < G && (w = e, G = u);
+    }
+    let D = t[2 * w], E = t[2 * w + 1];
+    if (G === 1 / 0) {
+      for (let a = 0; a < n; a++)
+        this._dists[a] = t[2 * a] - t[0] || t[2 * a + 1] - t[1];
+      L(this._ids, this._dists, 0, n - 1);
+      const e = new Uint32Array(n);
+      let u = 0;
+      for (let a = 0, x = -1 / 0; a < n; a++) {
+        const A = this._ids[a], S = this._dists[A];
+        S > x && (e[u++] = A, x = S);
+      }
+      this.hull = e.subarray(0, u), this.triangles = new Uint32Array(0), this.halfedges = new Int32Array(0);
+      return;
+    }
+    if (j(T, M, U, k, D, E) < 0) {
+      const e = y, u = U, a = k;
+      y = w, U = D, k = E, w = e, D = u, E = a;
+    }
+    const N = J(T, M, U, k, D, E);
+    this._cx = N.x, this._cy = N.y;
+    for (let e = 0; e < n; e++)
+      this._dists[e] = X(t[2 * e], t[2 * e + 1], N.x, N.y);
+    L(this._ids, this._dists, 0, n - 1), this._hullStart = c;
+    let P = 3;
+    h[c] = i[w] = y, h[y] = i[c] = w, h[w] = i[y] = c, r[c] = 0, r[y] = 1, r[w] = 2, l.fill(-1), l[this._hashKey(T, M)] = c, l[this._hashKey(U, k)] = y, l[this._hashKey(D, E)] = w, this.trianglesLen = 0, this._addTriangle(c, y, w, -1, -1, -1);
+    for (let e = 0, u = 0, a = 0; e < this._ids.length; e++) {
+      const x = this._ids[e], A = t[2 * x], S = t[2 * x + 1];
+      if (e > 0 && Math.abs(A - u) <= Y && Math.abs(S - a) <= Y || (u = A, a = S, x === c || x === y || x === w)) continue;
+      let z = 0;
+      for (let H = 0, F = this._hashKey(A, S); H < this._hashSize && (z = l[(F + H) % this._hashSize], !(z !== -1 && z !== h[z])); H++)
+        ;
+      z = i[z];
+      let _ = z, p;
+      for (; p = h[_], j(A, S, t[2 * _], t[2 * _ + 1], t[2 * p], t[2 * p + 1]) >= 0; )
+        if (_ = p, _ === z) {
+          _ = -1;
+          break;
+        }
+      if (_ === -1) continue;
+      let K = this._addTriangle(_, x, h[_], -1, -1, r[_]);
+      r[x] = this._legalize(K + 2), r[_] = K, P++;
+      let I = h[_];
+      for (; p = h[I], j(A, S, t[2 * I], t[2 * I + 1], t[2 * p], t[2 * p + 1]) < 0; )
+        K = this._addTriangle(I, x, p, r[x], -1, r[I]), r[x] = this._legalize(K + 2), h[I] = I, P--, I = p;
+      if (_ === z)
+        for (; p = i[_], j(A, S, t[2 * p], t[2 * p + 1], t[2 * _], t[2 * _ + 1]) < 0; )
+          K = this._addTriangle(p, x, _, -1, r[_], r[p]), this._legalize(K + 2), r[p] = K, h[_] = _, P--, _ = p;
+      this._hullStart = i[x] = _, h[_] = i[I] = x, h[x] = I, l[this._hashKey(A, S)] = x, l[this._hashKey(t[2 * _], t[2 * _ + 1])] = _;
+    }
+    this.hull = new Uint32Array(P);
+    for (let e = 0, u = this._hullStart; e < P; e++)
+      this.hull[e] = u, u = h[u];
+    this.triangles = this._triangles.subarray(0, this.trianglesLen), this.halfedges = this._halfedges.subarray(0, this.trianglesLen);
+  }
+  /**
+   * Calculate an angle-based key for the edge hash used for advancing convex hull.
+   *
+   * @param {number} x
+   * @param {number} y
+   * @private
+   */
+  _hashKey(t, i) {
+    return Math.floor(O(t - this._cx, i - this._cy) * this._hashSize) % this._hashSize;
+  }
+  /**
+   * Flip an edge in a pair of triangles if it doesn't satisfy the Delaunay condition.
+   *
+   * @param {number} a
+   * @private
+   */
+  _legalize(t) {
+    const { _triangles: i, _halfedges: h, coords: r } = this;
+    let l = 0, n = 0;
+    for (; ; ) {
+      const o = h[t], f = t - t % 3;
+      if (n = f + (t + 2) % 3, o === -1) {
+        if (l === 0) break;
+        t = q[--l];
+        continue;
+      }
+      const g = o - o % 3, m = f + (t + 1) % 3, d = g + (o + 2) % 3, b = i[n], c = i[t], y = i[m], w = i[d];
+      if (R(
+        r[2 * b],
+        r[2 * b + 1],
+        r[2 * c],
+        r[2 * c + 1],
+        r[2 * y],
+        r[2 * y + 1],
+        r[2 * w],
+        r[2 * w + 1]
+      )) {
+        i[t] = w, i[o] = b;
+        const M = h[d];
+        if (M === -1) {
+          let k = this._hullStart;
+          do {
+            if (this._hullTri[k] === d) {
+              this._hullTri[k] = t;
+              break;
+            }
+            k = this._hullPrev[k];
+          } while (k !== this._hullStart);
+        }
+        this._link(t, M), this._link(o, h[n]), this._link(n, d);
+        const U = g + (o + 1) % 3;
+        l < q.length && (q[l++] = U);
+      } else {
+        if (l === 0) break;
+        t = q[--l];
+      }
+    }
+    return n;
+  }
+  /**
+   * Link two half-edges to each other.
+   * @param {number} a
+   * @param {number} b
+   * @private
+   */
+  _link(t, i) {
+    this._halfedges[t] = i, i !== -1 && (this._halfedges[i] = t);
+  }
+  /**
+   * Add a new triangle given vertex indices and adjacent half-edge ids.
+   *
+   * @param {number} i0
+   * @param {number} i1
+   * @param {number} i2
+   * @param {number} a
+   * @param {number} b
+   * @param {number} c
+   * @private
+   */
+  _addTriangle(t, i, h, r, l, n) {
+    const o = this.trianglesLen;
+    return this._triangles[o] = t, this._triangles[o + 1] = i, this._triangles[o + 2] = h, this._link(o, r), this._link(o + 1, l), this._link(o + 2, n), this.trianglesLen += 3, o;
+  }
+}
+function O(s, t) {
+  const i = s / (Math.abs(s) + Math.abs(t));
+  return (t > 0 ? 3 - i : 1 + i) / 4;
+}
+function X(s, t, i, h) {
+  const r = s - i, l = t - h;
+  return r * r + l * l;
+}
+function R(s, t, i, h, r, l, n, o) {
+  const f = s - n, g = t - o, m = i - n, d = h - o, b = r - n, c = l - o, y = f * f + g * g, w = m * m + d * d, T = b * b + c * c;
+  return f * (d * T - w * c) - g * (m * T - w * b) + y * (m * c - d * b) < 0;
+}
+function B(s, t, i, h, r, l) {
+  const n = i - s, o = h - t, f = r - s, g = l - t, m = n * n + o * o, d = f * f + g * g, b = 0.5 / (n * g - o * f), c = (g * m - o * d) * b, y = (n * d - f * m) * b;
+  return c * c + y * y;
+}
+function J(s, t, i, h, r, l) {
+  const n = i - s, o = h - t, f = r - s, g = l - t, m = n * n + o * o, d = f * f + g * g, b = 0.5 / (n * g - o * f), c = s + (g * m - o * d) * b, y = t + (n * d - f * m) * b;
+  return { x: c, y };
+}
+function L(s, t, i, h) {
+  if (h - i <= 20)
+    for (let r = i + 1; r <= h; r++) {
+      const l = s[r], n = t[l];
+      let o = r - 1;
+      for (; o >= i && t[s[o]] > n; ) s[o + 1] = s[o--];
+      s[o + 1] = l;
+    }
+  else {
+    const r = i + h >> 1;
+    let l = i + 1, n = h;
+    v(s, r, l), t[s[i]] > t[s[h]] && v(s, i, h), t[s[l]] > t[s[h]] && v(s, l, h), t[s[i]] > t[s[l]] && v(s, i, l);
+    const o = s[l], f = t[o];
+    for (; ; ) {
+      do
+        l++;
+      while (t[s[l]] < f);
+      do
+        n--;
+      while (t[s[n]] > f);
+      if (n < l) break;
+      v(s, l, n);
+    }
+    s[i + 1] = s[n], s[n] = o, h - l + 1 >= n - i ? (L(s, t, l, h), L(s, t, i, n - 1)) : (L(s, t, i, n - 1), L(s, t, l, h));
+  }
+}
+function v(s, t, i) {
+  const h = s[t];
+  s[t] = s[i], s[i] = h;
+}
+function Q(s) {
+  return s[0];
+}
+function V(s) {
+  return s[1];
+}
+export {
+  C as default
+};
+//# sourceMappingURL=index.es421.js.map