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

package/dist/index.es428.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es428.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Projective.js"],"sourcesContent":["import { newArrayMatrix } from '@allmaps/stdlib';\nimport { BaseTransformation } from './BaseTransformation.js';\nimport { solveJointlySvd } from '../shared/solve-functions.js';\n/**\n * 2D projective (= perspective) transformation\n *\n * For this transformations, the system of equations is solved for x and y jointly.\n *\n * See for more information:\n * Dubrofsky, Elan. \"Homography estimation.\" Diplomová práce. Vancouver: Univerzita Britské Kolumbie 5 (2009).\n * https://citeseerx.ist.psu.edu/doc/10.1.1.186.4411\n * https://www.cs.ubc.ca/sites/default/files/2022-12/Dubrofsky_Elan.pdf\n */\nexport class Projective extends BaseTransformation {\n    coefsArrayMatrices;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'projective', 4);\n        // Construct two Nx9 Matrix projectiveCoefsMatrix\n        // −x0 −y0 −1  0   0   0  x'0x0 x'0y0 x'0\n        // ...\n        // 0   0   0   −x0 −y0 −1 y'0x0 y'0y0 y'0\n        // ...\n        this.coefsArrayMatrices = [\n            newArrayMatrix(this.pointCount, 9, 0),\n            newArrayMatrix(this.pointCount, 9, 0)\n        ];\n        for (let i = 0; i < this.pointCount; i++) {\n            this.coefsArrayMatrices[0][i][0] = -sourcePoints[i][0];\n            this.coefsArrayMatrices[0][i][1] = -sourcePoints[i][1];\n            this.coefsArrayMatrices[0][i][2] = -1;\n            this.coefsArrayMatrices[0][i][3] = 0;\n            this.coefsArrayMatrices[0][i][4] = 0;\n            this.coefsArrayMatrices[0][i][5] = 0;\n            this.coefsArrayMatrices[0][i][6] =\n                destinationPoints[i][0] * sourcePoints[i][0];\n            this.coefsArrayMatrices[0][i][7] =\n                destinationPoints[i][0] * sourcePoints[i][1];\n            this.coefsArrayMatrices[0][i][8] = destinationPoints[i][0];\n            this.coefsArrayMatrices[1][i][0] = 0;\n            this.coefsArrayMatrices[1][i][1] = 0;\n            this.coefsArrayMatrices[1][i][2] = 0;\n            this.coefsArrayMatrices[1][i][3] = -sourcePoints[i][0];\n            this.coefsArrayMatrices[1][i][4] = -sourcePoints[i][1];\n            this.coefsArrayMatrices[1][i][5] = -1;\n            this.coefsArrayMatrices[1][i][6] =\n                destinationPoints[i][1] * sourcePoints[i][0];\n            this.coefsArrayMatrices[1][i][7] =\n                destinationPoints[i][1] * sourcePoints[i][1];\n            this.coefsArrayMatrices[1][i][8] = destinationPoints[i][1];\n        }\n    }\n    solve() {\n        this.weightsArrays = solveJointlySvd(this.coefsArrayMatrices, this.pointCount);\n    }\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 c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPoint = [num1 / c, num2 / c];\n        return newDestinationPoint;\n    }\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 c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPointPartDerX = [\n            (c * this.weightsArrays[0][0] - this.weightsArrays[0][2] * num1) / c ** 2,\n            (c * this.weightsArrays[0][1] - this.weightsArrays[0][2] * num2) / c ** 2\n        ];\n        return newDestinationPointPartDerX;\n    }\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 c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPointPartDerY = [\n            (c * this.weightsArrays[1][0] - this.weightsArrays[1][2] * num1) / c ** 2,\n            (c * this.weightsArrays[1][1] - this.weightsArrays[1][2] * num2) / c ** 2\n        ];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Projective transformation weights not computed');\n        }\n        // Projective: 3x3 matrix flattened column-major\n        const flatWeights = [];\n        for (let col = 0; col < 3; col++) {\n            for (let row = 0; row < 3; row++) {\n                flatWeights.push(this.weightsArrays[col][row]);\n            }\n        }\n        return {\n            weights: new Float64Array(flatWeights),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Projective","BaseTransformation","sourcePoints","destinationPoints","newArrayMatrix","i","solveJointlySvd","newSourcePoint","c","num1","num2","flatWeights","col","row"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es429.js

@@ -0,0 +1,147 @@
+import { arrayMatrixSize as c, newArrayMatrix as f, pasteArrayMatrix as u, newBlockArrayMatrix as A, transposeArrayMatrix as l } from "./index.es315.js";
+import { Polynomial1 as y } from "./index.es425.js";
+import { BaseIndependentLinearWeightsTransformation as p } from "./index.es419.js";
+import { solveIndependentlyInverse as g } from "./index.es423.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.es429.js.map

package/dist/index.es429.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es429.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":";;;;AASO,MAAMA,UAAYC,EAA2C;AAAA,EAChE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAYC,GAAcC,GAAmBC,GAAgBC,GAAcC,GAAMC,GAAS;AACtF,UAAML,GAAcC,GAAmBG,GAAM,CAAC,GAC9C,KAAK,iBAAiBF,GACtB,KAAK,eAAeC,GACpB,KAAK,UAAUE,GAIf,KAAK,qBAAqB,KAAK,sBAAA,GAC/B,KAAK,mBAAmB,KAAK,mBAAmB,CAAC,GACjD,KAAK,yBAAyB,KAAK,mBAAmB,IAAI,CAACC,MAAqBC,EAAgBD,CAAgB,CAAC,GACjH,KAAK,uBAAuBC,EAAgB,KAAK,gBAAgB;AAAA,EACrE;AAAA,EACA,6BAA6B;AACzB,WAAO;AAAA,MACH,CAAC,GAAG,KAAK,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAACC,MAAUA,EAAM,CAAC,CAAC;AAAA,MAC3E,CAAC,GAAG,KAAK,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAACA,MAAUA,EAAM,CAAC,CAAC;AAAA,IAAA;AAAA,EAEnF;AAAA,EACA,sBAAsB;AAGlB,UAAMC,IAAmBC,EAAe,KAAK,YAAY,KAAK,YAAY,CAAC;AAC3E,aAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,eAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,QAAAH,EAAiBE,CAAC,EAAEC,CAAC,IAAI,KAAK,aAAa,KAAK,aAAaD,CAAC,GAAG,KAAK,aAAaC,CAAC,CAAC;AAK7F,QAAI,KAAK,YAAY,QAAW;AAC5B,YAAMC,IAAWJ,EACZ,IAAI,CAACK,MAAQA,EAAI,OAAO,CAAC,GAAGC,MAAM,IAAIA,GAAG,CAAC,CAAC,EAC3C,OAAO,CAACC,GAAGD,MAAMC,IAAID,GAAG,CAAC;AAC9B,WAAK,UAAUF,KAAY,KAAK,IAAI,KAAK,YAAY,CAAC,IAAI,KAAK;AAAA,IACnE;AAEA,UAAMI,IAAyBP,EAAe,KAAK,YAAY,KAAK,YAAY,CAAC;AACjF,aAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,eAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,QAAAK,EAAuBN,CAAC,EAAEC,CAAC,IAAI,KAAK,eAAeH,EAAiBE,CAAC,EAAEC,CAAC,GAAG;AAAA,UACvE,SAAS,KAAK;AAAA,QAAA,CACjB;AAQT,QAAIM,IAAyBR,EAAe,KAAK,YAAY,GAAG,CAAC;AACjE,aAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,MAAAO,IAAyBC,EAAiBD,GAAwBP,GAAG,GAAG;AAAA,QACpES,EAAY,oCAAoC,KAAK,aAAaT,CAAC,CAAC;AAAA,MAAA,CACvE;AAGL,UAAMU,IAAmBX,EAAe,GAAG,GAAG,CAAC;AAO/C,WAJyBY,EAAoB;AAAA,MACzC,CAACL,GAAwBC,CAAsB;AAAA,MAC/C,CAACK,EAAqBL,CAAsB,GAAGG,CAAgB;AAAA,IAAA,CAClE;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,yBAAyBG,GAAa;AAClC,WAAO;AAAA,MACH,GAAG,KAAK,kCAAkCA,CAAW;AAAA,MACrD,GAAGJ,EAAY,oCAAoCI,CAAW;AAAA,IAAA;AAAA,EAEtE;AAAA,EACA,kCAAkCA,GAAa;AAC3C,UAAMC,IAA8B,CAAA;AACpC,aAASd,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,MAAAc,EAA4B,KAAK,KAAK,eAAe,KAAK,aAAa,KAAK,aAAad,CAAC,GAAGa,CAAW,GAAG;AAAA,QACvG,SAAS,KAAK;AAAA,MAAA,CACjB,CAAC;AAEN,WAAOC;AAAA,EACX;AAAA,EACA,iBAAiBC,GAAerB,GAAS;AACrC,IAAIA,MACA,KAAK,UAAUA,IAEnB,MAAM,iBAAiBqB,CAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,QAAQ;AACJ,SAAK,gBAAgBC,EAA0B,KAAK,kBAAkB,KAAK,uBAAuB,GAClG,KAAK,qBAAA;AAAA,EACT;AAAA,EACA,uBAAuB;AACnB,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAE1C,SAAK,mBAAmB,KAAK,cAAc,IAAI,CAACC,MAAUA,EAAM,MAAM,GAAG,KAAK,UAAU,CAAC,GACzF,KAAK,sBAAsB,KAAK,cAAc,IAAI,CAACA,MAAUA,EAAM,MAAM,KAAK,UAAU,CAAC;AAAA,EAC7F;AAAA,EACA,iBAAiBC,GAAgB;AAI7B,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK,oBAAoB,CAAC,KAAK;AAChC,YAAM,IAAI,MAAM,0BAA0B;AAE9C,UAAMC,IAAa,KAAK,kBAClBC,IAAgB,KAAK,qBAErBC,IAAe,KAAK,aAAa,IAAI,CAACR,MAAgB,KAAK,aAAaK,GAAgBL,CAAW,CAAC,GAEpGS,IAAsB,CAAC,GAAG,CAAC;AACjC,aAAStB,IAAI,GAAGA,IAAI,GAAGA;AAEnB,MAAAsB,EAAoBtB,CAAC,IAAIqB,EAAa,OAAO,CAACE,GAAKC,GAAMC,MAAUF,IAC/D,KAAK,eAAeC,GAAM,EAAE,SAAS,KAAK,QAAA,CAAS,IAC/CL,EAAWnB,CAAC,EAAEyB,CAAK,GAAG,CAAC,GAE/BH,EAAoBtB,CAAC,KACjBoB,EAAcpB,CAAC,EAAE,CAAC,IACdoB,EAAcpB,CAAC,EAAE,CAAC,IAAIkB,EAAe,CAAC,IACtCE,EAAcpB,CAAC,EAAE,CAAC,IAAIkB,EAAe,CAAC;AAElD,WAAOI;AAAA,EACX;AAAA,EACA,2BAA2BJ,GAAgB;AAIvC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK,oBAAoB,CAAC,KAAK;AAChC,YAAM,IAAI,MAAM,0BAA0B;AAE9C,UAAMC,IAAa,KAAK,kBAClBC,IAAgB,KAAK,qBAErBC,IAAe,KAAK,aAAa,IAAI,CAACR,MAAgB,KAAK,aAAaK,GAAgBL,CAAW,CAAC,GAEpGa,IAA8B,CAAC,GAAG,CAAC;AACzC,aAAS1B,IAAI,GAAGA,IAAI,GAAGA;AAEnB,MAAA0B,EAA4B1B,CAAC,IAAIqB,EAAa,OAAO,CAACE,GAAKC,GAAMC,MAAUF,KACtEC,MAAS,IACJ,IACA,KAAK,eAAeA,GAAM;AAAA,QACxB,YAAY;AAAA,QACZ,SAAS,KAAK;AAAA,MAAA,CACjB,MACKN,EAAe,CAAC,IAAI,KAAK,aAAaO,CAAK,EAAE,CAAC,KAAKD,KACrDL,EAAWnB,CAAC,EAAEyB,CAAK,IAAI,CAAC,GAEpCC,EAA4B1B,CAAC,KAAKoB,EAAcpB,CAAC,EAAE,CAAC;AAExD,WAAO0B;AAAA,EACX;AAAA,EACA,2BAA2BR,GAAgB;AAIvC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK,oBAAoB,CAAC,KAAK;AAChC,YAAM,IAAI,MAAM,0BAA0B;AAE9C,UAAMC,IAAa,KAAK,kBAClBC,IAAgB,KAAK,qBAErBC,IAAe,KAAK,aAAa,IAAI,CAACR,MAAgB,KAAK,aAAaK,GAAgBL,CAAW,CAAC,GAEpGc,IAA8B,CAAC,GAAG,CAAC;AACzC,aAAS3B,IAAI,GAAGA,IAAI,GAAGA;AAEnB,MAAA2B,EAA4B3B,CAAC,IAAIqB,EAAa,OAAO,CAACE,GAAKC,GAAMC,MAAUF,KACtEC,MAAS,IACJ,IACA,KAAK,eAAeA,GAAM;AAAA,QACxB,YAAY;AAAA,QACZ,SAAS,KAAK;AAAA,MAAA,CACjB,MACKN,EAAe,CAAC,IAAI,KAAK,aAAaO,CAAK,EAAE,CAAC,KAAKD,KACrDL,EAAWnB,CAAC,EAAEyB,CAAK,IAAI,CAAC,GAEpCE,EAA4B3B,CAAC,KAAKoB,EAAcpB,CAAC,EAAE,CAAC;AAExD,WAAO2B;AAAA,EACX;AAAA,EACA,sCAAsC;AAIlC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK,oBAAoB,CAAC,KAAK;AAChC,YAAM,IAAI,MAAM,qDAAqD;AAEzE,UAAMC,IAAI,KAAK,aAAa,QAEtBC,IAAU,IAAI,aAAa,IAAI,IAAID,IAAI,CAAC;AAC9C,IAAAC,EAAQ,CAAC,IAAID;AACb,aAAS,IAAI,GAAG,IAAIA,GAAG;AACnB,MAAAC,EAAQ,IAAI,CAAC,IAAI,KAAK,iBAAiB,CAAC,EAAE,CAAC;AAE/C,aAAS,IAAI,GAAG,IAAID,GAAG;AACnB,MAAAC,EAAQ,IAAID,IAAI,CAAC,IAAI,KAAK,iBAAiB,CAAC,EAAE,CAAC;AAEnD,aAAS,IAAI,GAAG,IAAI,GAAG;AACnB,MAAAC,EAAQ,IAAI,IAAID,IAAI,CAAC,IAAI,KAAK,oBAAoB,CAAC,EAAE,CAAC;AAE1D,aAAS,IAAI,GAAG,IAAI,GAAG;AACnB,MAAAC,EAAQ,IAAI,IAAID,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB,CAAC,EAAE,CAAC;AAG9D,UAAME,IAAmB,IAAI,aAAaF,IAAI,CAAC;AAC/C,aAAS,IAAI,GAAG,IAAIA,GAAG;AACnB,MAAAE,EAAiB,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC,EAAE,CAAC,GAChDA,EAAiB,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC,EAAE,CAAC;AAExD,WAAO;AAAA,MACH,SAAAD;AAAA,MACA,cAAcC;AAAA,IAAA;AAAA,EAEtB;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es43.js

@@ -1,6 +1,6 @@
-import e from "./index.es218.js";
+import e from "./index.es225.js";
 import { isIE11 as r } from "./index.es39.js";
-import { ie11fingerprint as t, weakMapMethods as a } from "./index.es224.js";
+import { ie11fingerprint as t, weakMapMethods as a } from "./index.es231.js";
 const m = r ? t(a) : e("WeakMap");
 export {
   m as default

package/dist/index.es430.js

@@ -0,0 +1,58 @@
+import { Helmert as o } from "./index.es424.js";
+import { BaseTransformation as h } from "./index.es421.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.es430.js.map

package/dist/index.es430.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es430.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.es431.js

@@ -0,0 +1,85 @@
+import { bboxToRectangle as G } from "./index.es196.js";
+import { conformLineString as C, midPoint as P, conformRing as F, squaredDistance as g, distance as a } from "./index.es275.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.es431.js.map

package/dist/index.es431.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es431.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.es432.js

@@ -0,0 +1,9 @@
+import o, { m as e } from "./index.es516.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.es432.js.map

package/dist/index.es432.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es432.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.es433.js

@@ -0,0 +1,56 @@
+import B from "./index.es517.js";
+import C from "./index.es518.js";
+import E from "./index.es519.js";
+import S from "./index.es520.js";
+import w from "./index.es521.js";
+import F from "./index.es522.js";
+import M from "./index.es523.js";
+import U from "./index.es524.js";
+import h from "./index.es525.js";
+import x from "./index.es442.js";
+import I from "./index.es446.js";
+import O from "./index.es451.js";
+import l from "./index.es435.js";
+import D from "./index.es455.js";
+var y = "[object Arguments]", G = "[object Array]", K = "[object Boolean]", N = "[object Date]", R = "[object Error]", A = "[object Function]", W = "[object GeneratorFunction]", q = "[object Map]", H = "[object Number]", s = "[object Object]", J = "[object RegExp]", L = "[object Set]", P = "[object String]", Q = "[object Symbol]", V = "[object WeakMap]", X = "[object ArrayBuffer]", Y = "[object DataView]", Z = "[object Float32Array]", _ = "[object Float64Array]", $ = "[object Int8Array]", u = "[object Int16Array]", z = "[object Int32Array]", k = "[object Uint8Array]", v = "[object Uint8ClampedArray]", rr = "[object Uint16Array]", or = "[object Uint32Array]", r = {};
+r[y] = r[G] = r[X] = r[Y] = r[K] = r[N] = r[Z] = r[_] = r[$] = r[u] = r[z] = r[q] = r[H] = r[s] = r[J] = r[L] = r[P] = r[Q] = r[k] = r[v] = r[rr] = r[or] = !0;
+r[R] = r[A] = r[V] = !1;
+function g(o, f, c, tr, m, a) {
+  var t;
+  if (t !== void 0)
+    return t;
+  if (!l(o))
+    return o;
+  var b = x(o);
+  if (b)
+    t = M(o);
+  else {
+    var n = F(o), j = n == A || n == W;
+    if (I(o))
+      return S(o);
+    if (n == s || n == y || j && !m)
+      t = j ? {} : h(o);
+    else {
+      if (!r[n])
+        return m ? o : {};
+      t = U(o, n);
+    }
+  }
+  a || (a = new B());
+  var T = a.get(o);
+  if (T)
+    return T;
+  a.set(o, t), D(o) ? o.forEach(function(e) {
+    t.add(g(e, f, c, e, o, a));
+  }) : O(o) && o.forEach(function(e, i) {
+    t.set(i, g(e, f, c, i, o, a));
+  });
+  var d = w, p = b ? void 0 : d(o);
+  return C(p || o, function(e, i) {
+    p && (i = e, e = o[i]), E(t, i, g(e, f, c, i, o, a));
+  }), t;
+}
+export {
+  g as default
+};
+//# sourceMappingURL=index.es433.js.map

package/dist/index.es433.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es433.js","sources":["../../../node_modules/lodash-es/_baseClone.js"],"sourcesContent":["import Stack from './_Stack.js';\nimport arrayEach from './_arrayEach.js';\nimport assignValue from './_assignValue.js';\nimport baseAssign from './_baseAssign.js';\nimport baseAssignIn from './_baseAssignIn.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport copyArray from './_copyArray.js';\nimport copySymbols from './_copySymbols.js';\nimport copySymbolsIn from './_copySymbolsIn.js';\nimport getAllKeys from './_getAllKeys.js';\nimport getAllKeysIn from './_getAllKeysIn.js';\nimport getTag from './_getTag.js';\nimport initCloneArray from './_initCloneArray.js';\nimport initCloneByTag from './_initCloneByTag.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isMap from './isMap.js';\nimport isObject from './isObject.js';\nimport isSet from './isSet.js';\nimport keys from './keys.js';\nimport keysIn from './keysIn.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nexport default baseClone;\n"],"names":["argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","cloneableTags","baseClone","value","bitmask","customizer","key","object","stack","result","isObject","isArr","isArray","initCloneArray","tag","getTag","isFunc","isBuffer","cloneBuffer","initCloneObject","initCloneByTag","Stack","stacked","isSet","subValue","isMap","keysFunc","getAllKeys","props","arrayEach","assignValue"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es434.js

@@ -0,0 +1,55 @@
+import S from "./index.es435.js";
+import h from "./index.es436.js";
+import W from "./index.es437.js";
+var y = "Expected a function", R = Math.max, A = Math.min;
+function _(x, n, a) {
+  var u, f, v, o, e, r, l = 0, E = !1, m = !1, s = !0;
+  if (typeof x != "function")
+    throw new TypeError(y);
+  n = W(n) || 0, S(a) && (E = !!a.leading, m = "maxWait" in a, v = m ? R(W(a.maxWait) || 0, n) : v, s = "trailing" in a ? !!a.trailing : s);
+  function g(i) {
+    var t = u, c = f;
+    return u = f = void 0, l = i, o = x.apply(c, t), o;
+  }
+  function b(i) {
+    return l = i, e = setTimeout(d, n), E ? g(i) : o;
+  }
+  function C(i) {
+    var t = i - r, c = i - l, p = n - t;
+    return m ? A(p, v - c) : p;
+  }
+  function k(i) {
+    var t = i - r, c = i - l;
+    return r === void 0 || t >= n || t < 0 || m && c >= v;
+  }
+  function d() {
+    var i = h();
+    if (k(i))
+      return I(i);
+    e = setTimeout(d, C(i));
+  }
+  function I(i) {
+    return e = void 0, s && u ? g(i) : (u = f = void 0, o);
+  }
+  function L() {
+    e !== void 0 && clearTimeout(e), l = 0, u = r = f = e = void 0;
+  }
+  function M() {
+    return e === void 0 ? o : I(h());
+  }
+  function T() {
+    var i = h(), t = k(i);
+    if (u = arguments, f = this, r = i, t) {
+      if (e === void 0)
+        return b(r);
+      if (m)
+        return clearTimeout(e), e = setTimeout(d, n), g(r);
+    }
+    return e === void 0 && (e = setTimeout(d, n)), o;
+  }
+  return T.cancel = L, T.flush = M, T;
+}
+export {
+  _ as default
+};
+//# sourceMappingURL=index.es434.js.map

package/dist/index.es434.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es434.js","sources":["../../../node_modules/lodash-es/debounce.js"],"sourcesContent":["import isObject from './isObject.js';\nimport now from './now.js';\nimport toNumber from './toNumber.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nexport default debounce;\n"],"names":["FUNC_ERROR_TEXT","nativeMax","nativeMin","debounce","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","toNumber","isObject","invokeFunc","time","args","thisArg","leadingEdge","timerExpired","remainingWait","timeSinceLastCall","timeSinceLastInvoke","timeWaiting","shouldInvoke","now","trailingEdge","cancel","flush","debounced","isInvoking"],"mappings":";;;AAKA,IAAIA,IAAkB,uBAGlBC,IAAY,KAAK,KACjBC,IAAY,KAAK;AAwDrB,SAASC,EAASC,GAAMC,GAAMC,GAAS;AACrC,MAAIC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,IAAiB,GACjBC,IAAU,IACVC,IAAS,IACTC,IAAW;AAEf,MAAI,OAAOZ,KAAQ;AACjB,UAAM,IAAI,UAAUJ,CAAe;AAErC,EAAAK,IAAOY,EAASZ,CAAI,KAAK,GACrBa,EAASZ,CAAO,MAClBQ,IAAU,CAAC,CAACR,EAAQ,SACpBS,IAAS,aAAaT,GACtBG,IAAUM,IAASd,EAAUgB,EAASX,EAAQ,OAAO,KAAK,GAAGD,CAAI,IAAII,GACrEO,IAAW,cAAcV,IAAU,CAAC,CAACA,EAAQ,WAAWU;AAG1D,WAASG,EAAWC,GAAM;AACxB,QAAIC,IAAOd,GACPe,IAAUd;AAEd,WAAAD,IAAWC,IAAW,QACtBK,IAAiBO,GACjBV,IAASN,EAAK,MAAMkB,GAASD,CAAI,GAC1BX;AAAA,EACT;AAEA,WAASa,EAAYH,GAAM;AAEzB,WAAAP,IAAiBO,GAEjBT,IAAU,WAAWa,GAAcnB,CAAI,GAEhCS,IAAUK,EAAWC,CAAI,IAAIV;AAAA,EACtC;AAEA,WAASe,EAAcL,GAAM;AAC3B,QAAIM,IAAoBN,IAAOR,GAC3Be,IAAsBP,IAAOP,GAC7Be,IAAcvB,IAAOqB;AAEzB,WAAOX,IACHb,EAAU0B,GAAanB,IAAUkB,CAAmB,IACpDC;AAAA,EACN;AAEA,WAASC,EAAaT,GAAM;AAC1B,QAAIM,IAAoBN,IAAOR,GAC3Be,IAAsBP,IAAOP;AAKjC,WAAQD,MAAiB,UAAcc,KAAqBrB,KACzDqB,IAAoB,KAAOX,KAAUY,KAAuBlB;AAAA,EACjE;AAEA,WAASe,IAAe;AACtB,QAAIJ,IAAOU,EAAA;AACX,QAAID,EAAaT,CAAI;AACnB,aAAOW,EAAaX,CAAI;AAG1B,IAAAT,IAAU,WAAWa,GAAcC,EAAcL,CAAI,CAAC;AAAA,EACxD;AAEA,WAASW,EAAaX,GAAM;AAK1B,WAJAT,IAAU,QAINK,KAAYT,IACPY,EAAWC,CAAI,KAExBb,IAAWC,IAAW,QACfE;AAAA,EACT;AAEA,WAASsB,IAAS;AAChB,IAAIrB,MAAY,UACd,aAAaA,CAAO,GAEtBE,IAAiB,GACjBN,IAAWK,IAAeJ,IAAWG,IAAU;AAAA,EACjD;AAEA,WAASsB,IAAQ;AACf,WAAOtB,MAAY,SAAYD,IAASqB,EAAaD,GAAK;AAAA,EAC5D;AAEA,WAASI,IAAY;AACnB,QAAId,IAAOU,EAAA,GACPK,IAAaN,EAAaT,CAAI;AAMlC,QAJAb,IAAW,WACXC,IAAW,MACXI,IAAeQ,GAEXe,GAAY;AACd,UAAIxB,MAAY;AACd,eAAOY,EAAYX,CAAY;AAEjC,UAAIG;AAEF,4BAAaJ,CAAO,GACpBA,IAAU,WAAWa,GAAcnB,CAAI,GAChCc,EAAWP,CAAY;AAAA,IAElC;AACA,WAAID,MAAY,WACdA,IAAU,WAAWa,GAAcnB,CAAI,IAElCK;AAAA,EACT;AACA,SAAAwB,EAAU,SAASF,GACnBE,EAAU,QAAQD,GACXC;AACT;","x_google_ignoreList":[0]}

package/dist/index.es435.js

@@ -0,0 +1,8 @@
+function n(t) {
+  var e = typeof t;
+  return t != null && (e == "object" || e == "function");
+}
+export {
+  n as default
+};
+//# sourceMappingURL=index.es435.js.map

package/dist/index.es435.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es435.js","sources":["../../../node_modules/lodash-es/isObject.js"],"sourcesContent":["/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n"],"names":["isObject","value","type"],"mappings":"AAyBA,SAASA,EAASC,GAAO;AACvB,MAAIC,IAAO,OAAOD;AAClB,SAAOA,KAAS,SAASC,KAAQ,YAAYA,KAAQ;AACvD;","x_google_ignoreList":[0]}

package/dist/index.es436.js

@@ -0,0 +1,8 @@
+import o from "./index.es447.js";
+var t = function() {
+  return o.Date.now();
+};
+export {
+  t as default
+};
+//# sourceMappingURL=index.es436.js.map

package/dist/index.es436.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es436.js","sources":["../../../node_modules/lodash-es/now.js"],"sourcesContent":["import root from './_root.js';\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nexport default now;\n"],"names":["now","root"],"mappings":";AAkBA,IAAIA,IAAM,WAAW;AACnB,SAAOC,EAAK,KAAK,IAAA;AACnB;","x_google_ignoreList":[0]}