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

package/dist/index.cjs420.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs421.js");class a extends n.BaseTransformation{destinationPointsArrays;constructor(s,t,r,e){super(s,t,r,e),this.destinationPointsArrays=this.getDestinationPointsArrays()}}exports.BaseLinearWeightsTransformation=a;
+//# sourceMappingURL=index.cjs420.js.map

package/dist/index.cjs420.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs420.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseLinearWeightsTransformation.js"],"sourcesContent":["import { BaseTransformation } from './BaseTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights.\n *\n * In general, the system of equations for x and y are dependent on each other, and they are thus solved jointly.\n * For transformations where the system of equations for x and y are independent and can hence be solved separately, a dedicated class exists.\n */\nexport class BaseLinearWeightsTransformation extends BaseTransformation {\n    destinationPointsArrays;\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        super(sourcePoints, destinationPoints, type, pointCountMinimum);\n        this.destinationPointsArrays = this.getDestinationPointsArrays();\n    }\n}\n"],"names":["BaseLinearWeightsTransformation","BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum"],"mappings":"qHAOO,MAAMA,UAAwCC,EAAAA,kBAAmB,CACpE,wBACA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAClE,MAAMH,EAAcC,EAAmBC,EAAMC,CAAiB,EAC9D,KAAK,wBAA0B,KAAK,2BAAA,CACxC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs421.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs275.js");class e{sourcePoints;destinationPoints;destinationTransformedSourcePoints;type;pointCount;pointCountMinimum;errors;destinationRmse;constructor(t,i,s,o){if(this.sourcePoints=t,this.destinationPoints=i,this.pointCount=this.sourcePoints.length,this.type=s,this.pointCountMinimum=o,this.pointCount<this.pointCountMinimum)throw new Error("Not enough control points. A "+this.type+" transformation requires a minimum of "+this.pointCountMinimum+" points, but "+this.pointCount+" are given.")}setWeightsArrays(t){this.weightsArrays=t,this.processWeightsArrays()}processWeightsArrays(){}getDestinationTransformedSourcePoints(){return this.destinationTransformedSourcePoints||(this.destinationTransformedSourcePoints=this.sourcePoints.map(t=>this.evaluateFunction(t))),this.destinationTransformedSourcePoints}getMeasures(){return{}}getErrors(){if(!this.errors){const t=this.getDestinationTransformedSourcePoints();this.errors=this.destinationPoints.map((i,s)=>n.distance(i,t[s]))}return this.errors}getDestinationRmse(){if(!this.destinationRmse){const t=this.getDestinationTransformedSourcePoints();this.destinationTransformedSourcePoints||this.getDestinationTransformedSourcePoints(),this.destinationRmse=n.rms(this.destinationPoints,t)}return this.destinationRmse}}exports.BaseTransformation=e;
+//# sourceMappingURL=index.cjs421.js.map

package/dist/index.cjs421.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs421.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseTransformation.js"],"sourcesContent":["import { distance, rms } from '@allmaps/stdlib';\n/**\n * Base class for transformation.\n */\nexport class BaseTransformation {\n    sourcePoints;\n    destinationPoints;\n    destinationTransformedSourcePoints;\n    type;\n    pointCount;\n    pointCountMinimum;\n    errors;\n    destinationRmse;\n    /**\n     * Create a transformation\n     *\n     * @param sourcePoints - The source points\n     * @param destinationPoints - The destination points\n     * @param type - The transformation type\n     * @param pointCountMinimum - The minimum number of points for the transformation type\n     */\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        this.sourcePoints = sourcePoints;\n        this.destinationPoints = destinationPoints;\n        this.pointCount = this.sourcePoints.length;\n        this.type = type;\n        this.pointCountMinimum = pointCountMinimum;\n        if (this.pointCount < this.pointCountMinimum) {\n            throw new Error('Not enough control points. A ' +\n                this.type +\n                ' transformation requires a minimum of ' +\n                this.pointCountMinimum +\n                ' points, but ' +\n                this.pointCount +\n                ' are given.');\n        }\n    }\n    /**\n     * Set weights.\n     *\n     * The weights might be obtained in other ways then through solving\n     * (e.g. through solving multiple transformation together when staping).\n     * This function can be used to set weights computed elsewhere.\n     */\n    setWeightsArrays(weightsArrays) {\n        this.weightsArrays = weightsArrays;\n        this.processWeightsArrays();\n    }\n    processWeightsArrays() {\n        return;\n    }\n    /**\n     * Get the destination-transformed source points.\n     *\n     * @returns source points, transformed to destination domain\n     */\n    getDestinationTransformedSourcePoints() {\n        if (!this.destinationTransformedSourcePoints) {\n            this.destinationTransformedSourcePoints = this.sourcePoints.map((sourcePoint) => this.evaluateFunction(sourcePoint));\n        }\n        return this.destinationTransformedSourcePoints;\n    }\n    getMeasures() {\n        return {};\n    }\n    getErrors() {\n        if (!this.errors) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            this.errors = this.destinationPoints.map((destinationPoint, index) => distance(destinationPoint, destinationTransformedSourcePoints[index]));\n        }\n        return this.errors;\n    }\n    getDestinationRmse() {\n        if (!this.destinationRmse) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            if (!this.destinationTransformedSourcePoints) {\n                this.getDestinationTransformedSourcePoints();\n            }\n            this.destinationRmse = rms(this.destinationPoints, destinationTransformedSourcePoints);\n        }\n        return this.destinationRmse;\n    }\n}\n"],"names":["BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","weightsArrays","sourcePoint","destinationTransformedSourcePoints","destinationPoint","index","distance","rms"],"mappings":"qHAIO,MAAMA,CAAmB,CAC5B,aACA,kBACA,mCACA,KACA,WACA,kBACA,OACA,gBASA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAMlE,GALA,KAAK,aAAeH,EACpB,KAAK,kBAAoBC,EACzB,KAAK,WAAa,KAAK,aAAa,OACpC,KAAK,KAAOC,EACZ,KAAK,kBAAoBC,EACrB,KAAK,WAAa,KAAK,kBACvB,MAAM,IAAI,MAAM,gCACZ,KAAK,KACL,yCACA,KAAK,kBACL,gBACA,KAAK,WACL,aAAa,CAEzB,CAQA,iBAAiBC,EAAe,CAC5B,KAAK,cAAgBA,EACrB,KAAK,qBAAA,CACT,CACA,sBAAuB,CAEvB,CAMA,uCAAwC,CACpC,OAAK,KAAK,qCACN,KAAK,mCAAqC,KAAK,aAAa,IAAKC,GAAgB,KAAK,iBAAiBA,CAAW,CAAC,GAEhH,KAAK,kCAChB,CACA,aAAc,CACV,MAAO,CAAA,CACX,CACA,WAAY,CACR,GAAI,CAAC,KAAK,OAAQ,CACd,MAAMC,EAAqC,KAAK,sCAAA,EAChD,KAAK,OAAS,KAAK,kBAAkB,IAAI,CAACC,EAAkBC,IAAUC,EAAAA,SAASF,EAAkBD,EAAmCE,CAAK,CAAC,CAAC,CAC/I,CACA,OAAO,KAAK,MAChB,CACA,oBAAqB,CACjB,GAAI,CAAC,KAAK,gBAAiB,CACvB,MAAMF,EAAqC,KAAK,sCAAA,EAC3C,KAAK,oCACN,KAAK,sCAAA,EAET,KAAK,gBAAkBI,EAAAA,IAAI,KAAK,kBAAmBJ,CAAkC,CACzF,CACA,OAAO,KAAK,eAChB,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs422.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./index.cjs315.js"),o=require("./index.cjs419.js"),n=require("./index.cjs423.js");class y extends o.BaseIndependentLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatrix;coefsArrayMatricesSize;coefsArrayMatrixSize;order;weightsArrays;constructor(r,t,s){s=s||1;const e=(s+1)*(s+2)/2;if(super(r,t,"polynomial"+s,e),this.order=s,this.order<1||this.order>3)throw new Error("Only polynomial transformations of order 1, 2 or 3 are supported");this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatrix=this.coefsArrayMatrices[0],this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(a=>i.arrayMatrixSize(a)),this.coefsArrayMatrixSize=i.arrayMatrixSize(this.coefsArrayMatrix)}getDestinationPointsArrays(){return[this.destinationPoints.map(r=>r[0]),this.destinationPoints.map(r=>r[1])]}getCoefsArrayMatrix(){let r=i.newArrayMatrix(this.pointCount,this.pointCountMinimum,0);for(let t=0;t<this.pointCount;t++)r=i.pasteArrayMatrix(r,t,0,[this.getSourcePointCoefsArray(this.sourcePoints[t])]);return r}solve(){this.weightsArrays=n.solveIndependentlyPseudoInverse(this.coefsArrayMatrix,this.destinationPointsArrays)}getTransformationDataAsFloat64Array(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Polynomial transformation weights not computed");return{weights:new Float64Array([...this.weightsArrays[0],...this.weightsArrays[1]]),sourcePoints:new Float64Array(0)}}}exports.BasePolynomialTransformation=y;
+//# sourceMappingURL=index.cjs422.js.map

package/dist/index.cjs422.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs422.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BasePolynomialTransformation.js"],"sourcesContent":["import { arrayMatrixSize, newArrayMatrix, pasteArrayMatrix } from '@allmaps/stdlib';\nimport { BaseIndependentLinearWeightsTransformation } from './BaseIndependentLinearWeightsTransformation.js';\nimport { solveIndependentlyPseudoInverse } from '../shared/solve-functions.js';\nexport class BasePolynomialTransformation extends BaseIndependentLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatrix;\n    coefsArrayMatricesSize;\n    coefsArrayMatrixSize;\n    order;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints, order) {\n        order = order || 1;\n        const pointsCountMinimum = ((order + 1) * (order + 2)) / 2;\n        // If there are less control points than there are coefficients to be determined (for each dimension),\n        // the system can not be solved\n        super(sourcePoints, destinationPoints, ('polynomial' + order), pointsCountMinimum);\n        this.order = order;\n        if (this.order < 1 || this.order > 3) {\n            throw new Error('Only polynomial transformations of order 1, 2 or 3 are supported');\n        }\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.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrix() {\n        let coefsArrayArray = newArrayMatrix(this.pointCount, this.pointCountMinimum, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            coefsArrayArray = pasteArrayMatrix(coefsArrayArray, i, 0, [\n                this.getSourcePointCoefsArray(this.sourcePoints[i])\n            ]);\n        }\n        return coefsArrayArray;\n    }\n    solve() {\n        this.weightsArrays = solveIndependentlyPseudoInverse(this.coefsArrayMatrix, this.destinationPointsArrays);\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Polynomial transformation weights not computed');\n        }\n        // Polynomial: [wx[0], wx[1], ..., wy[0], wy[1], ...]\n        return {\n            weights: new Float64Array([\n                ...this.weightsArrays[0],\n                ...this.weightsArrays[1]\n            ]),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["BasePolynomialTransformation","BaseIndependentLinearWeightsTransformation","sourcePoints","destinationPoints","order","pointsCountMinimum","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayArray","newArrayMatrix","i","pasteArrayMatrix","solveIndependentlyPseudoInverse"],"mappings":"mLAGO,MAAMA,UAAqCC,EAAAA,0CAA2C,CACzF,mBACA,iBACA,uBACA,qBACA,MACA,cACA,YAAYC,EAAcC,EAAmBC,EAAO,CAChDA,EAAQA,GAAS,EACjB,MAAMC,GAAuBD,EAAQ,IAAMA,EAAQ,GAAM,EAKzD,GAFA,MAAMF,EAAcC,EAAoB,aAAeC,EAAQC,CAAkB,EACjF,KAAK,MAAQD,EACT,KAAK,MAAQ,GAAK,KAAK,MAAQ,EAC/B,MAAM,IAAI,MAAM,kEAAkE,EAEtF,KAAK,mBAAqB,KAAK,sBAAA,EAC/B,KAAK,iBAAmB,KAAK,mBAAmB,CAAC,EACjD,KAAK,uBAAyB,KAAK,mBAAmB,IAAKE,GAAqBC,kBAAgBD,CAAgB,CAAC,EACjH,KAAK,qBAAuBC,kBAAgB,KAAK,gBAAgB,CACrE,CACA,4BAA6B,CACzB,MAAO,CACH,KAAK,kBAAkB,IAAKC,GAAUA,EAAM,CAAC,CAAC,EAC9C,KAAK,kBAAkB,IAAKA,GAAUA,EAAM,CAAC,CAAC,CAAA,CAEtD,CACA,qBAAsB,CAClB,IAAIC,EAAkBC,EAAAA,eAAe,KAAK,WAAY,KAAK,kBAAmB,CAAC,EAC/E,QAASC,EAAI,EAAGA,EAAI,KAAK,WAAYA,IACjCF,EAAkBG,EAAAA,iBAAiBH,EAAiBE,EAAG,EAAG,CACtD,KAAK,yBAAyB,KAAK,aAAaA,CAAC,CAAC,CAAA,CACrD,EAEL,OAAOF,CACX,CACA,OAAQ,CACJ,KAAK,cAAgBI,EAAAA,gCAAgC,KAAK,iBAAkB,KAAK,uBAAuB,CAC5G,CACA,qCAAsC,CAIlC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,gDAAgD,EAGpE,MAAO,CACH,QAAS,IAAI,aAAa,CACtB,GAAG,KAAK,cAAc,CAAC,EACvB,GAAG,KAAK,cAAc,CAAC,CAAA,CAC1B,EACD,aAAc,IAAI,aAAa,CAAC,CAAA,CAExC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs423.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs432.js");function c(s,t){const o=new e.default([...s[0],...s[1]]),n=e.default.columnVector([...t[0],...t[1]]);return e.pseudoInverse(o).mmul(n).to1DArray()}function l(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.pseudoInverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function d(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.inverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function v(s,t){const o=[];for(let i=0;i<t;i++)o.push(s[0][i]),o.push(s[1][i]);const n=new e.SingularValueDecomposition(o);return e.default.from1DArray(3,3,n.rightSingularVectors.getColumn(8)).transpose().to2DArray()}exports.solveIndependentlyInverse=d;exports.solveIndependentlyPseudoInverse=l;exports.solveJointlyPseudoInverse=c;exports.solveJointlySvd=v;
+//# sourceMappingURL=index.cjs423.js.map

package/dist/index.cjs423.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs423.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/solve-functions.js"],"sourcesContent":["import Matrix, { inverse, pseudoInverse, SingularValueDecomposition } from 'ml-matrix';\n/**\n * Solve the x and y components jointly using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute a 'best fit' (least squares) approximate solution\n * for the system of linear equations, which is (in general) over-defined and hence lacks an exact solution.\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This will result weightsArray shared by both components: [t_x, t_y, m, n]\n */\nexport function solveJointlyPseudoInverse(coefsArrayMatrices, destinationPointsArrays) {\n    const coefsMatrix = new Matrix([\n        ...coefsArrayMatrices[0],\n        ...coefsArrayMatrices[1]\n    ]);\n    const destinationPointsMatrix = Matrix.columnVector([\n        ...destinationPointsArrays[0],\n        ...destinationPointsArrays[1]\n    ]);\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrix = pseudoInverseCoefsMatrix.mmul(destinationPointsMatrix);\n    const weightsArray = weightsMatrix.to1DArray();\n    return weightsArray;\n}\n/**\n * Solve the x and y components independently using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute (for each component, using the same coefs for both)\n * a 'best fit' (least squares) approximate solution for the system of linear equations\n * which is (in general) over-defined and hence lacks an exact solution.\n *\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This wil result in a weights array for each component:\n * For order = 1: this.weight = [[a0_x, ax_x, ay_x], [a0_y, ax_y, ay_y]]\n * For order = 2: ... (similar, following the same order as in coefsArrayMatrix)\n * For order = 3: ... (similar, following the same order as in coefsArrayMatrix)\n */\nexport function solveIndependentlyPseudoInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrices = [\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components independently using exact inverse.\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 */\nexport function solveIndependentlyInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const inverseCoefsMatrix = inverse(coefsMatrix);\n    const weightsMatrices = [\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components jointly using singular value decomposition.\n *\n * This uses a singular value decomposition to compute the last (i.e. 9th) 'right singular vector',\n * i.e. the one with the smallest singular value, wich holds the weights for the solution.\n * Note that for a set of gcps that exactly follow a projective transformations,\n * the singular value is null and this vector spans the null-space.\n *\n * This wil result in a weights array for each component with rbf weights and affine weights.\n */\nexport function solveJointlySvd(coefsArrayMatrices, pointCount) {\n    // Joint coefs in the same order as in the paper\n    // (Otherwise the weights may differ in sign, even though this should not affect the result)\n    const coefsMatrix = [];\n    for (let i = 0; i < pointCount; i++) {\n        coefsMatrix.push(coefsArrayMatrices[0][i]);\n        coefsMatrix.push(coefsArrayMatrices[1][i]);\n    }\n    const svdCoefsMatrix = new SingularValueDecomposition(coefsMatrix);\n    const weightsMatrix = Matrix.from1DArray(3, 3, svdCoefsMatrix.rightSingularVectors.getColumn(8)).transpose();\n    const weightsArrays = weightsMatrix.to2DArray();\n    return weightsArrays;\n}\n"],"names":["solveJointlyPseudoInverse","coefsArrayMatrices","destinationPointsArrays","coefsMatrix","Matrix","destinationPointsMatrix","pseudoInverse","solveIndependentlyPseudoInverse","coefsArrayMatrix","destinationPointsMatrices","pseudoInverseCoefsMatrix","matrix","solveIndependentlyInverse","inverseCoefsMatrix","inverse","solveJointlySvd","pointCount","svdCoefsMatrix","SingularValueDecomposition"],"mappings":"qHAUO,SAASA,EAA0BC,EAAoBC,EAAyB,CACnF,MAAMC,EAAc,IAAIC,UAAO,CAC3B,GAAGH,EAAmB,CAAC,EACvB,GAAGA,EAAmB,CAAC,CAAA,CAC1B,EACKI,EAA0BD,EAAAA,QAAO,aAAa,CAChD,GAAGF,EAAwB,CAAC,EAC5B,GAAGA,EAAwB,CAAC,CAAA,CAC/B,EAID,OAHiCI,EAAAA,cAAcH,CAAW,EACX,KAAKE,CAAuB,EACxC,UAAA,CAEvC,CAeO,SAASE,EAAgCC,EAAkBN,EAAyB,CACvF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CQ,EAA2BJ,EAAAA,cAAcH,CAAW,EAM1D,MALwB,CACpBO,EAAyB,KAAKD,EAA0B,CAAC,CAAC,EAC1DC,EAAyB,KAAKD,EAA0B,CAAC,CAAC,CAAA,EAExB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAUO,SAASC,EAA0BJ,EAAkBN,EAAyB,CACjF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CW,EAAqBC,EAAAA,QAAQX,CAAW,EAM9C,MALwB,CACpBU,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,EACpDI,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,CAAA,EAElB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAWO,SAASI,EAAgBd,EAAoBe,EAAY,CAG5D,MAAMb,EAAc,CAAA,EACpB,QAAS,EAAI,EAAG,EAAIa,EAAY,IAC5Bb,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EACzCE,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EAE7C,MAAMgB,EAAiB,IAAIC,EAAAA,2BAA2Bf,CAAW,EAGjE,OAFsBC,EAAAA,QAAO,YAAY,EAAG,EAAGa,EAAe,qBAAqB,UAAU,CAAC,CAAC,EAAE,UAAA,EAC7D,UAAA,CAExC","x_google_ignoreList":[0]}

package/dist/index.cjs424.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index.cjs315.js"),a=require("./index.cjs420.js"),o=require("./index.cjs423.js");class h extends a.BaseLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatricesSize;weightsArray;weightsArrays;constructor(t,r){super(t,r,"helmert",2),this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(e=>s.arrayMatrixSize(e))}getDestinationPointsArrays(){return[this.destinationPoints.map(t=>t[0]),this.destinationPoints.map(t=>t[1])]}getCoefsArrayMatrices(){let t=s.newArrayMatrix(this.pointCount,4,0),r=s.newArrayMatrix(this.pointCount,4,0);for(let e=0;e<this.pointCount;e++){const i=this.getSourcePointCoefsArrays(this.sourcePoints[e]);t=s.pasteArrayMatrix(t,e,0,[i[0]]),r=s.pasteArrayMatrix(r,e,0,[i[1]])}return[t,r]}getSourcePointCoefsArrays(t){return[[1,0,t[0],-t[1]],[0,1,t[1],t[0]]]}solve(){this.weightsArray=o.solveJointlyPseudoInverse(this.coefsArrayMatrices,this.destinationPointsArrays),this.weightsArrays=[this.weightsArray,this.weightsArray]}getMeasures(){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");const t={};return t.scale=Math.sqrt(this.weightsArray[2]**2+this.weightsArray[3]**2),t.rotation=Math.atan2(this.weightsArray[3],this.weightsArray[2]),t.translation=[this.weightsArray[0],this.weightsArray[1]],t}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[this.weightsArray[0]+this.weightsArray[2]*t[0]-this.weightsArray[3]*t[1],this.weightsArray[1]+this.weightsArray[2]*t[1]+this.weightsArray[3]*t[0]]}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[this.weightsArray[2],this.weightsArray[3]]}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[-this.weightsArray[3],this.weightsArray[2]]}getTransformationDataAsFloat64Array(){if(this.weightsArray||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return{weights:new Float64Array(this.weightsArray),sourcePoints:new Float64Array(0)}}}exports.Helmert=h;
+//# sourceMappingURL=index.cjs424.js.map

package/dist/index.cjs424.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs424.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Helmert.js"],"sourcesContent":["import { newArrayMatrix, pasteArrayMatrix, arrayMatrixSize } from '@allmaps/stdlib';\nimport { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\nimport { solveJointlyPseudoInverse } from '../shared/solve-functions.js';\n/**\n * 2D Helmert transformation (= similarity transformation)\n *\n * This transformation is a composition of a translation, rotation and scaling. There is no shearing.\n *\n * For this transformations, the system of equations is solved for x and y jointly.\n */\nexport class Helmert extends BaseLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatricesSize;\n    weightsArray;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'helmert', 2);\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n    }\n    getDestinationPointsArrays() {\n        return [\n            this.destinationPoints.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrices() {\n        let coefsArrayMatrix0 = newArrayMatrix(this.pointCount, 4, 0);\n        let coefsArrayMatrix1 = newArrayMatrix(this.pointCount, 4, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            const sourcePointCoefsArrays = this.getSourcePointCoefsArrays(this.sourcePoints[i]);\n            coefsArrayMatrix0 = pasteArrayMatrix(coefsArrayMatrix0, i, 0, [\n                sourcePointCoefsArrays[0]\n            ]);\n            coefsArrayMatrix1 = pasteArrayMatrix(coefsArrayMatrix1, i, 0, [\n                sourcePointCoefsArrays[1]\n            ]);\n        }\n        return [coefsArrayMatrix0, coefsArrayMatrix1];\n    }\n    /**\n     * Get two 1x4 coefsArrays, populating the 2Nx4 coefsArrayMatrices\n     * 1 0 x0 -y0\n     * 1 0 x1 -y1\n     * ...\n     * 0 1 y0 x0\n     * 0 1 y1 x1\n     * ...\n     *\n     * @param sourcePoint\n     */\n    getSourcePointCoefsArrays(sourcePoint) {\n        return [\n            [1, 0, sourcePoint[0], -sourcePoint[1]],\n            [0, 1, sourcePoint[1], sourcePoint[0]]\n        ];\n    }\n    solve() {\n        this.weightsArray = solveJointlyPseudoInverse(this.coefsArrayMatrices, this.destinationPointsArrays);\n        this.weightsArrays = [this.weightsArray, this.weightsArray];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const measures = {};\n        measures.scale = Math.sqrt(this.weightsArray[2] ** 2 + this.weightsArray[3] ** 2);\n        measures.rotation = Math.atan2(this.weightsArray[3], this.weightsArray[2]);\n        measures.translation = [this.weightsArray[0], this.weightsArray[1]];\n        return measures;\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPoint = [\n            this.weightsArray[0] +\n                this.weightsArray[2] * newSourcePoint[0] -\n                this.weightsArray[3] * newSourcePoint[1],\n            this.weightsArray[1] +\n                this.weightsArray[2] * newSourcePoint[1] +\n                this.weightsArray[3] * newSourcePoint[0]\n        ];\n        // Alternatively, using derived helmert measures\n        // this.translation[0] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[0] -\n        //   this.scale * Math.sin(rotation) * newSourcePoint[1],\n        // this.translation[1] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[1] +\n        //   this.scale * Math.sin(rotation) * newSourcePoint[0]\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerX = [\n            this.weightsArray[2],\n            this.weightsArray[3]\n        ];\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerY = [\n            -this.weightsArray[3],\n            this.weightsArray[2]\n        ];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArray) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        // Helmert: [w0, w1, w2, w3]\n        return {\n            weights: new Float64Array(this.weightsArray),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Helmert","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayMatrix0","newArrayMatrix","coefsArrayMatrix1","i","sourcePointCoefsArrays","pasteArrayMatrix","sourcePoint","solveJointlyPseudoInverse","measures","newSourcePoint","_newSourcePoint"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs425.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs422.js");class h extends n.BasePolynomialTransformation{constructor(t,r){super(t,r,1)}getSourcePointCoefsArray(t){return h.getPolynomial1SourcePointCoefsArray(t)}static getPolynomial1SourcePointCoefsArray(t){return[1,t[0],t[1]]}getHomogeneousTransform(){if(this.weightsArrays)return[this.weightsArrays[0][1],this.weightsArrays[1][1],this.weightsArrays[0][2],this.weightsArrays[1][2],this.weightsArrays[0][0],this.weightsArrays[1][0]]}setWeightsArraysFromHomogeneousTransform(t){this.weightsArrays=[[t[4],t[0],t[2]],[t[5],t[1],t[3]]]}getMeasures(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const t={};t.translation=[this.weightsArrays[0][0],this.weightsArrays[1][0]];const r=this.weightsArrays[0][1],s=this.weightsArrays[1][1],e=this.weightsArrays[0][2],a=this.weightsArrays[1][2],o=r*a-s*e;if(r!=0||s!=0){const i=Math.sqrt(r*r+s*s);t.rotation=s>0?Math.acos(r/i):-Math.acos(r/i),t.scales=[i,o/i],t.shears=[Math.atan((r*e+s*a)/(i*i)),0]}else if(e!=0||a!=0){const i=Math.sqrt(e*e+a*a);t.rotation=Math.PI/2-(a>0?Math.acos(-e/i):-Math.acos(e/i)),t.scales=[o/i,i],t.shears=[0,Math.atan((r*e+s*a)/(i*i))]}return t}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][0]+this.weightsArrays[s][1]*t[0]+this.weightsArrays[s][2]*t[1];return r}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][1];return r}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][2];return r}}exports.Polynomial1=h;
+//# sourceMappingURL=index.cjs425.js.map

package/dist/index.cjs425.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs425.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial1.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D First-order Polynomial transformation\n *\n * This transformation is a composition of a translation, rotation, scaling and shearing.\n */\nexport class Polynomial1 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 1);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial1.getPolynomial1SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0\n     * 1 x1 y1\n     * 1 x2 y2\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial1SourcePointCoefsArray(sourcePoint) {\n        return [1, sourcePoint[0], sourcePoint[1]];\n    }\n    getHomogeneousTransform() {\n        if (!this.weightsArrays) {\n            return undefined;\n        }\n        return [\n            this.weightsArrays[0][1],\n            this.weightsArrays[1][1],\n            this.weightsArrays[0][2],\n            this.weightsArrays[1][2],\n            this.weightsArrays[0][0],\n            this.weightsArrays[1][0]\n        ];\n    }\n    setWeightsArraysFromHomogeneousTransform(homogeneousTransform) {\n        this.weightsArrays = [\n            [\n                homogeneousTransform[4],\n                homogeneousTransform[0],\n                homogeneousTransform[2]\n            ],\n            [\n                homogeneousTransform[5],\n                homogeneousTransform[1],\n                homogeneousTransform[3]\n            ]\n        ];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const measures = {};\n        // From: https://stackoverflow.com/questions/12469770/get-skew-or-rotation-value-from-affine-transformation-matrix\n        measures.translation = [this.weightsArrays[0][0], this.weightsArrays[1][0]];\n        const a = this.weightsArrays[0][1];\n        const b = this.weightsArrays[1][1];\n        const c = this.weightsArrays[0][2];\n        const d = this.weightsArrays[1][2];\n        const delta = a * d - b * c;\n        // Apply the QR-like decomposition.\n        if (a != 0 || b != 0) {\n            const r = Math.sqrt(a * a + b * b);\n            measures.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);\n            measures.scales = [r, delta / r];\n            measures.shears = [Math.atan((a * c + b * d) / (r * r)), 0];\n        }\n        else if (c != 0 || d != 0) {\n            const s = Math.sqrt(c * c + d * d);\n            measures.rotation =\n                Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));\n            measures.scales = [delta / s, s];\n            measures.shears = [0, Math.atan((a * c + b * d) / (s * s))];\n        }\n        else {\n            // a = b = c = d = 0\n        }\n        return measures;\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 newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1];\n        }\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 newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] += this.weightsArrays[i][1];\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 newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] += this.weightsArrays[i][2];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial1","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","homogeneousTransform","measures","a","b","c","d","delta","r","s","newSourcePoint","newDestinationPoint","i","_newSourcePoint","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs426.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs422.js");class i extends e.BasePolynomialTransformation{constructor(t,r){super(t,r,2)}getSourcePointCoefsArray(t){return i.getPolynomial2SourcePointCoefsArray(t)}static getPolynomial2SourcePointCoefsArray(t){return[1,t[0],t[1],t[0]**2,t[1]**2,t[0]*t[1]]}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][0]+this.weightsArrays[s][1]*t[0]+this.weightsArrays[s][2]*t[1]+this.weightsArrays[s][3]*t[0]**2+this.weightsArrays[s][4]*t[1]**2+this.weightsArrays[s][5]*t[0]*t[1];return r}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][1]+2*this.weightsArrays[s][3]*t[0]+this.weightsArrays[s][5]*t[1];return r}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][2]+2*this.weightsArrays[s][4]*t[1]+this.weightsArrays[s][5]*t[0];return r}}exports.Polynomial2=i;
+//# sourceMappingURL=index.cjs426.js.map

package/dist/index.cjs426.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs426.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial2.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D Second-order Polynomial transformation\n */\nexport class Polynomial2 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 2);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial2.getPolynomial2SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0 x0^2 y0^2 x0*y0\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial2SourcePointCoefsArray(sourcePoint) {\n        return [\n            1,\n            sourcePoint[0],\n            sourcePoint[1],\n            sourcePoint[0] ** 2,\n            sourcePoint[1] ** 2,\n            sourcePoint[0] * sourcePoint[1]\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        // Apply the helmert coefficients to the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1] +\n                    this.weightsArrays[i][3] * newSourcePoint[0] ** 2 +\n                    this.weightsArrays[i][4] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][5] * newSourcePoint[0] * 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        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] +=\n                this.weightsArrays[i][1] +\n                    2 * this.weightsArrays[i][3] * newSourcePoint[0] +\n                    this.weightsArrays[i][5] * newSourcePoint[1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to x 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        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] +=\n                this.weightsArrays[i][2] +\n                    2 * this.weightsArrays[i][4] * newSourcePoint[1] +\n                    this.weightsArrays[i][5] * newSourcePoint[0];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial2","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","newSourcePoint","newDestinationPoint","i","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"qHAIO,MAAMA,UAAoBC,EAAAA,4BAA6B,CAC1D,YAAYC,EAAcC,EAAmB,CACzC,MAAMD,EAAcC,EAAmB,CAAC,CAC5C,CACA,yBAAyBC,EAAa,CAClC,OAAOJ,EAAY,oCAAoCI,CAAW,CACtE,CAQA,OAAO,oCAAoCA,EAAa,CACpD,MAAO,CACH,EACAA,EAAY,CAAC,EACbA,EAAY,CAAC,EACbA,EAAY,CAAC,GAAK,EAClBA,EAAY,CAAC,GAAK,EAClBA,EAAY,CAAC,EAAIA,EAAY,CAAC,CAAA,CAEtC,CAEA,iBAAiBC,EAAgB,CAI7B,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMC,EAAsB,CAAC,EAAG,CAAC,EACjC,QAASC,EAAI,EAAGA,EAAI,EAAGA,IACnBD,EAAoBC,CAAC,GACjB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,GAAK,EAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,GAAK,EAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAAIA,EAAe,CAAC,EAE3E,OAAOC,CACX,CAEA,2BAA2BD,EAAgB,CAIvC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMG,EAA8B,CAAC,EAAG,CAAC,EACzC,QAASD,EAAI,EAAGA,EAAI,EAAGA,IACnBC,EAA4BD,CAAC,GACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,EAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAEvD,OAAOG,CACX,CAEA,2BAA2BH,EAAgB,CAIvC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMI,EAA8B,CAAC,EAAG,CAAC,EACzC,QAASF,EAAI,EAAGA,EAAI,EAAGA,IACnBE,EAA4BF,CAAC,GACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,EAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAEvD,OAAOI,CACX,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs427.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index.cjs422.js");class i extends h.BasePolynomialTransformation{constructor(s,r){super(s,r,3)}getSourcePointCoefsArray(s){return i.getPolynomial3SourcePointCoefsArray(s)}static getPolynomial3SourcePointCoefsArray(s){return[1,s[0],s[1],s[0]**2,s[1]**2,s[0]*s[1],s[0]**3,s[1]**3,s[0]**2*s[1],s[0]*s[1]**2]}evaluateFunction(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let t=0;t<2;t++)r[t]+=this.weightsArrays[t][0]+this.weightsArrays[t][1]*s[0]+this.weightsArrays[t][2]*s[1]+this.weightsArrays[t][3]*s[0]**2+this.weightsArrays[t][4]*s[1]**2+this.weightsArrays[t][5]*s[0]*s[1]+this.weightsArrays[t][6]*s[0]**3+this.weightsArrays[t][7]*s[1]**3+this.weightsArrays[t][8]*s[0]**2*s[1]+this.weightsArrays[t][9]*s[0]*s[1]**2;return r}evaluatePartialDerivativeX(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let t=0;t<2;t++)r[t]+=this.weightsArrays[t][1]+2*this.weightsArrays[t][3]*s[0]+this.weightsArrays[t][5]*s[1]+3*this.weightsArrays[t][6]*s[0]**2+2*this.weightsArrays[t][8]*s[0]*s[1]+this.weightsArrays[t][9]*s[1]**2;return r}evaluatePartialDerivativeY(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let t=0;t<2;t++)r[t]+=this.weightsArrays[t][2]+2*this.weightsArrays[t][4]*s[1]+this.weightsArrays[t][5]*s[0]+3*this.weightsArrays[t][7]*s[1]**2+this.weightsArrays[t][8]*s[0]**2+2*this.weightsArrays[t][9]*s[0]*s[1];return r}}exports.Polynomial3=i;
+//# sourceMappingURL=index.cjs427.js.map

package/dist/index.cjs427.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs427.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial3.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D Third-order Polynomial transformation\n */\nexport class Polynomial3 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 3);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial3.getPolynomial3SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0 x0^2 y0^2 x0*y0 x0^3 y0^3 x0^2*y0 x0*y0^2\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial3SourcePointCoefsArray(sourcePoint) {\n        return [\n            1,\n            sourcePoint[0],\n            sourcePoint[1],\n            sourcePoint[0] ** 2,\n            sourcePoint[1] ** 2,\n            sourcePoint[0] * sourcePoint[1],\n            sourcePoint[0] ** 3,\n            sourcePoint[1] ** 3,\n            sourcePoint[0] ** 2 * sourcePoint[1],\n            sourcePoint[0] * sourcePoint[1] ** 2\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        // Apply the helmert coefficients to the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1] +\n                    this.weightsArrays[i][3] * newSourcePoint[0] ** 2 +\n                    this.weightsArrays[i][4] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][5] * newSourcePoint[0] * newSourcePoint[1] +\n                    this.weightsArrays[i][6] * newSourcePoint[0] ** 3 +\n                    this.weightsArrays[i][7] * newSourcePoint[1] ** 3 +\n                    this.weightsArrays[i][8] * newSourcePoint[0] ** 2 * newSourcePoint[1] +\n                    this.weightsArrays[i][9] * newSourcePoint[0] * newSourcePoint[1] ** 2;\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        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] +=\n                this.weightsArrays[i][1] +\n                    2 * this.weightsArrays[i][3] * newSourcePoint[0] +\n                    this.weightsArrays[i][5] * newSourcePoint[1] +\n                    3 * this.weightsArrays[i][6] * newSourcePoint[0] ** 2 +\n                    2 * this.weightsArrays[i][8] * newSourcePoint[0] * newSourcePoint[1] +\n                    this.weightsArrays[i][9] * newSourcePoint[1] ** 2;\n        }\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to x 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        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] +=\n                this.weightsArrays[i][2] +\n                    2 * this.weightsArrays[i][4] * newSourcePoint[1] +\n                    this.weightsArrays[i][5] * newSourcePoint[0] +\n                    3 * this.weightsArrays[i][7] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][8] * newSourcePoint[0] ** 2 +\n                    2 * this.weightsArrays[i][9] * newSourcePoint[0] * newSourcePoint[1];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial3","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","newSourcePoint","newDestinationPoint","i","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs428.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs315.js"),h=require("./index.cjs421.js"),y=require("./index.cjs423.js");class A extends h.BaseTransformation{coefsArrayMatrices;weightsArrays;constructor(r,t){super(r,t,"projective",4),this.coefsArrayMatrices=[e.newArrayMatrix(this.pointCount,9,0),e.newArrayMatrix(this.pointCount,9,0)];for(let s=0;s<this.pointCount;s++)this.coefsArrayMatrices[0][s][0]=-r[s][0],this.coefsArrayMatrices[0][s][1]=-r[s][1],this.coefsArrayMatrices[0][s][2]=-1,this.coefsArrayMatrices[0][s][3]=0,this.coefsArrayMatrices[0][s][4]=0,this.coefsArrayMatrices[0][s][5]=0,this.coefsArrayMatrices[0][s][6]=t[s][0]*r[s][0],this.coefsArrayMatrices[0][s][7]=t[s][0]*r[s][1],this.coefsArrayMatrices[0][s][8]=t[s][0],this.coefsArrayMatrices[1][s][0]=0,this.coefsArrayMatrices[1][s][1]=0,this.coefsArrayMatrices[1][s][2]=0,this.coefsArrayMatrices[1][s][3]=-r[s][0],this.coefsArrayMatrices[1][s][4]=-r[s][1],this.coefsArrayMatrices[1][s][5]=-1,this.coefsArrayMatrices[1][s][6]=t[s][1]*r[s][0],this.coefsArrayMatrices[1][s][7]=t[s][1]*r[s][1],this.coefsArrayMatrices[1][s][8]=t[s][1]}solve(){this.weightsArrays=y.solveJointlySvd(this.coefsArrayMatrices,this.pointCount)}evaluateFunction(r){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const t=this.weightsArrays[0][2]*r[0]+this.weightsArrays[1][2]*r[1]+this.weightsArrays[2][2],s=this.weightsArrays[0][0]*r[0]+this.weightsArrays[1][0]*r[1]+this.weightsArrays[2][0],i=this.weightsArrays[0][1]*r[0]+this.weightsArrays[1][1]*r[1]+this.weightsArrays[2][1];return[s/t,i/t]}evaluatePartialDerivativeX(r){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const t=this.weightsArrays[0][2]*r[0]+this.weightsArrays[1][2]*r[1]+this.weightsArrays[2][2],s=this.weightsArrays[0][0]*r[0]+this.weightsArrays[1][0]*r[1]+this.weightsArrays[2][0],i=this.weightsArrays[0][1]*r[0]+this.weightsArrays[1][1]*r[1]+this.weightsArrays[2][1];return[(t*this.weightsArrays[0][0]-this.weightsArrays[0][2]*s)/t**2,(t*this.weightsArrays[0][1]-this.weightsArrays[0][2]*i)/t**2]}evaluatePartialDerivativeY(r){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const t=this.weightsArrays[0][2]*r[0]+this.weightsArrays[1][2]*r[1]+this.weightsArrays[2][2],s=this.weightsArrays[0][0]*r[0]+this.weightsArrays[1][0]*r[1]+this.weightsArrays[2][0],i=this.weightsArrays[0][1]*r[0]+this.weightsArrays[1][1]*r[1]+this.weightsArrays[2][1];return[(t*this.weightsArrays[1][0]-this.weightsArrays[1][2]*s)/t**2,(t*this.weightsArrays[1][1]-this.weightsArrays[1][2]*i)/t**2]}getTransformationDataAsFloat64Array(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Projective transformation weights not computed");const r=[];for(let t=0;t<3;t++)for(let s=0;s<3;s++)r.push(this.weightsArrays[t][s]);return{weights:new Float64Array(r),sourcePoints:new Float64Array(0)}}}exports.Projective=A;
+//# sourceMappingURL=index.cjs428.js.map

package/dist/index.cjs428.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("./index.cjs315.js"),c=require("./index.cjs425.js"),y=require("./index.cjs419.js"),u=require("./index.cjs423.js");class l extends y.BaseIndependentLinearWeightsTransformation{kernelFunction;normFunction;epsilon;coefsArrayMatrices;coefsArrayMatrix;coefsArrayMatricesSize;coefsArrayMatrixSize;weightsArrays;rbfWeightsArrays;affineWeightsArrays;constructor(i,r,e,s,n,t){super(i,r,n,3),this.kernelFunction=e,this.normFunction=s,this.epsilon=t,this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatrix=this.coefsArrayMatrices[0],this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(o=>f.arrayMatrixSize(o)),this.coefsArrayMatrixSize=f.arrayMatrixSize(this.coefsArrayMatrix)}getDestinationPointsArrays(){return[[...this.destinationPoints,[0,0],[0,0],[0,0]].map(i=>i[0]),[...this.destinationPoints,[0,0],[0,0],[0,0]].map(i=>i[1])]}getCoefsArrayMatrix(){const i=f.newArrayMatrix(this.pointCount,this.pointCount,0);for(let t=0;t<this.pointCount;t++)for(let o=0;o<this.pointCount;o++)i[t][o]=this.normFunction(this.sourcePoints[t],this.sourcePoints[o]);if(this.epsilon===void 0){const t=i.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.newArrayMatrix(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(i[t][o],{epsilon:this.epsilon});let e=f.newArrayMatrix(this.pointCount,3,0);for(let t=0;t<this.pointCount;t++)e=f.pasteArrayMatrix(e,t,0,[c.Polynomial1.getPolynomial1SourcePointCoefsArray(this.sourcePoints[t])]);const s=f.newArrayMatrix(3,3,0);return f.newBlockArrayMatrix([[r,e],[f.transposeArrayMatrix(e),s]])}getSourcePointCoefsArray(i){return[...this.getRbfKernelSourcePointCoefsArray(i),...c.Polynomial1.getPolynomial1SourcePointCoefsArray(i)]}getRbfKernelSourcePointCoefsArray(i){const r=[];for(let e=0;e<this.pointCount;e++)r.push(this.kernelFunction(this.normFunction(this.sourcePoints[e],i),{epsilon:this.epsilon}));return r}setWeightsArrays(i,r){r&&(this.epsilon=r),super.setWeightsArrays(i)}solve(){this.weightsArrays=u.solveIndependentlyInverse(this.coefsArrayMatrix,this.destinationPointsArrays),this.processWeightsArrays()}processWeightsArrays(){if(!this.weightsArrays)throw new Error("Weights not computed");this.rbfWeightsArrays=this.weightsArrays.map(i=>i.slice(0,this.pointCount)),this.affineWeightsArrays=this.weightsArrays.map(i=>i.slice(this.pointCount))}evaluateFunction(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+this.kernelFunction(a,{epsilon:this.epsilon})*r[t][h],0),n[t]+=e[t][0]+e[t][1]*i[0]+e[t][2]*i[1];return n}evaluatePartialDerivativeX(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+(a===0?0:this.kernelFunction(a,{derivative:1,epsilon:this.epsilon})*((i[0]-this.sourcePoints[h][0])/a)*r[t][h]),0),n[t]+=e[t][1];return n}evaluatePartialDerivativeY(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+(a===0?0:this.kernelFunction(a,{derivative:1,epsilon:this.epsilon})*((i[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 i=this.sourcePoints.length,r=new Float64Array(1+2*i+6);r[0]=i;for(let s=0;s<i;s++)r[1+s]=this.rbfWeightsArrays[0][s];for(let s=0;s<i;s++)r[1+i+s]=this.rbfWeightsArrays[1][s];for(let s=0;s<3;s++)r[1+2*i+s]=this.affineWeightsArrays[0][s];for(let s=0;s<3;s++)r[1+2*i+3+s]=this.affineWeightsArrays[1][s];const e=new Float64Array(i*2);for(let s=0;s<i;s++)e[s*2]=this.sourcePoints[s][0],e[s*2+1]=this.sourcePoints[s][1];return{weights:r,sourcePoints:e}}}exports.RBF=l;
+//# sourceMappingURL=index.cjs429.js.map

package/dist/index.cjs429.js.map

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

@@ -1,2 +1,2 @@
-"use strict";const r=require("./index.cjs218.js"),t=require("./index.cjs39.js"),e=require("./index.cjs224.js"),i=t.isIE11?e.ie11fingerprint(e.weakMapMethods):r("WeakMap");module.exports=i;
+"use strict";const r=require("./index.cjs225.js"),t=require("./index.cjs39.js"),e=require("./index.cjs231.js"),i=t.isIE11?e.ie11fingerprint(e.weakMapMethods):r("WeakMap");module.exports=i;
 //# sourceMappingURL=index.cjs43.js.map

package/dist/index.cjs430.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./index.cjs424.js"),h=require("./index.cjs421.js");class w extends h.BaseTransformation{weightsArrays;constructor(s,r){super(s,r,"straight",2)}solve(){const r=new o.Helmert(this.sourcePoints,this.destinationPoints).getMeasures().scale,i=this.sourcePoints.reduce((t,e)=>[t[0]+e[0],t[1]+e[1]]).map(t=>t/this.pointCount),n=this.destinationPoints.reduce((t,e)=>[t[0]+e[0],t[1]+e[1]]).map(t=>t/this.pointCount),a=n.map((t,e)=>t-i[e]*r);this.weightsArrays={scale:r,sourcePointsCenter:i,destinationPointsCenter:n,translation:a}}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]]}evaluatePartialDerivativeX(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");return[this.weightsArrays.scale,0]}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)}}}exports.Straight=w;
+//# sourceMappingURL=index.cjs430.js.map

package/dist/index.cjs430.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs430.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","i","newSourcePoint","_newSourcePoint"],"mappings":"oJAEO,MAAMA,UAAiBC,EAAAA,kBAAmB,CAC7C,cACA,YAAYC,EAAcC,EAAmB,CACzC,MAAMD,EAAcC,EAAmB,WAAY,CAAC,CACxD,CAKA,OAAQ,CAEJ,MAAMC,EADwB,IAAIC,EAAAA,QAAQ,KAAK,aAAc,KAAK,iBAAiB,EAC/C,YAAA,EAAc,MAE5CC,EAAqB,KAAK,aAC3B,OAAO,CAACC,EAAQC,IAAU,CAACD,EAAO,CAAC,EAAIC,EAAM,CAAC,EAAGD,EAAO,CAAC,EAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAKC,GAAeA,EAAa,KAAK,UAAU,EAC/CC,EAA0B,KAAK,kBAChC,OAAO,CAACH,EAAQC,IAAU,CAACD,EAAO,CAAC,EAAIC,EAAM,CAAC,EAAGD,EAAO,CAAC,EAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAKC,GAAeA,EAAa,KAAK,UAAU,EAE/CE,EAAcD,EAAwB,IAAI,CAACE,EAAOC,IAAMD,EAAQN,EAAmBO,CAAC,EAAIT,CAAK,EACnG,KAAK,cAAgB,CACjB,MAAAA,EACA,mBAAAE,EACA,wBAAAI,EACA,YAAAC,CAAA,CAER,CAEA,iBAAiBG,EAAgB,CAI7B,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAQ1C,MAN4B,CACxB,KAAK,cAAc,YAAY,CAAC,EAC5B,KAAK,cAAc,MAAQA,EAAe,CAAC,EAC/C,KAAK,cAAc,YAAY,CAAC,EAC5B,KAAK,cAAc,MAAQA,EAAe,CAAC,CAAA,CAGvD,CAEA,2BAA2BC,EAAiB,CAIxC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MADoC,CAAC,KAAK,cAAc,MAAO,CAAC,CAEpE,CAEA,2BAA2BA,EAAiB,CAIxC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MADoC,CAAC,EAAG,KAAK,cAAc,KAAK,CAEpE,CACA,qCAAsC,CAIlC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAO,CACH,QAAS,IAAI,aAAa,CACtB,KAAK,cAAc,YAAY,CAAC,EAChC,KAAK,cAAc,YAAY,CAAC,EAChC,KAAK,cAAc,KAAA,CACtB,EACD,aAAc,IAAI,aAAa,CAAC,CAAA,CAExC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs431.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const G=require("./index.cjs196.js"),u=require("./index.cjs275.js"),C={maxDepth:0,minSourceDistance:0,minDestinationDistance:0,minOffsetRatio:0,minOffsetDistance:1/0,sourceMidPointFunction:u.midPoint,destinationMidPointFunction:u.midPoint};function R(n,o,t){n=u.conformLineString(n);const i=n.map(s=>({source:s,destination:o(s)})),c=f(i,!1).map(s=>d(s,o,t,0)).flat(1);return M(c,!0)}function T(n,o,t){n=u.conformRing(n);const i=n.map(s=>({source:s,destination:o(s)})),c=f(i,!0).map(s=>d(s,o,t,0)).flat(1);return M(c,!1)}function d(n,o,t,i){const e=m(n,o,t,i);return e?[d([n[0],e],o,t,i+1),d([e,n[1]],o,t,i+1)].flat(1):[n]}function m(n,o,t,i){if(i>=t.maxDepth||t.maxDepth<=0||u.distance(n[0].source,n[1].source)<t.minSourceDistance||u.distance(n[0].destination,n[1].destination)<t.minDestinationDistance)return;const{sourceMidPoint:e,destinationMidPointFromRefinementFunction:c,destinationMidPointsDistance:s,destinationLineDistance:r}=F(n,o,t);return b({destinationMidPointsDistance:s,destinationLineDistance:r},t)?{source:e,destination:c}:void 0}function F(n,o,t){const i=t.sourceMidPointFunction(n[0].source,n[1].source),e=t.destinationMidPointFunction(n[0].destination,n[1].destination),c=o(i),s=u.distance(e,c),r=u.distance(n[0].destination,n[1].destination);return{sourceMidPoint:i,destinationMidPointFromRefinementFunction:c,destinationMidPointsDistance:s,destinationLineDistance:r}}function b({destinationMidPointsDistance:n,destinationLineDistance:o},t){return n/o>t.minOffsetRatio||n>t.minOffsetDistance}function v(n,o,t){const i=G.bboxToRectangle(n),e=i[2],c=i[3],s=i[1],r=i[0],P=t.sourceMidPointFunction(e,s),S=t.sourceMidPointFunction(c,r),h=t.sourceMidPointFunction(e,c),p=t.sourceMidPointFunction(s,r),L=[[P,S],[h,p]].map(a=>R(a,o,t).map(l=>l.source));if(L.every(a=>a.length==2))return;const g=L.map(a=>a.slice(0,-1).map((l,D)=>u.squaredDistance(l,a[D+1])));return Math.sqrt(Math.min(...g.flat()))}function f(n,o=!1){const t=n.length-(o?0:1),i=[];for(let e=0;e<t;e++)i.push([n[e],n[(e+1)%n.length]]);return i}function M(n,o=!1){const t=n.map(i=>i[0]);return o&&t.push(n[n.length-1][1]),t}exports.defaultRefinementOptions=C;exports.gcpLinesToGcps=M;exports.gcpsToGcpLines=f;exports.getSourceRefinementResolution=v;exports.newMidGcpIfShouldSplitGcpLine=m;exports.refineLineString=R;exports.refineRing=T;
+//# sourceMappingURL=index.cjs431.js.map

package/dist/index.cjs431.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./index.cjs516.js"),t=e.matrixExports.SingularValueDecomposition,r=e.default.Matrix?e.default.Matrix:e.matrixExports.Matrix,i=e.matrixExports.inverse,o=e.matrixExports.pseudoInverse;exports.SingularValueDecomposition=t;exports.default=r;exports.inverse=i;exports.pseudoInverse=o;
+//# sourceMappingURL=index.cjs432.js.map

package/dist/index.cjs432.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs432.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":"iJAyBaA,EAA6BC,EAAAA,cAAAA,2BAM1CC,EAAeC,EAAAA,QAAe,OAASA,UAAe,OAASC,EAAAA,cAAAA,OAElDC,EAAUC,EAAAA,cAAAA,QAEVC,EAAgBC,EAAAA,cAAAA","x_google_ignoreList":[0]}

package/dist/index.cjs433.js

@@ -0,0 +1,2 @@
+"use strict";const d=require("./index.cjs517.js"),_=require("./index.cjs518.js"),B=require("./index.cjs519.js"),C=require("./index.cjs520.js"),E=require("./index.cjs521.js"),S=require("./index.cjs522.js"),m=require("./index.cjs523.js"),w=require("./index.cjs524.js"),F=require("./index.cjs525.js"),M=require("./index.cjs442.js"),U=require("./index.cjs446.js"),h=require("./index.cjs451.js"),x=require("./index.cjs435.js"),I=require("./index.cjs455.js");var A="[object Arguments]",O="[object Array]",D="[object Boolean]",l="[object Date]",G="[object Error]",q="[object Function]",K="[object GeneratorFunction]",N="[object Map]",R="[object Number]",u="[object Object]",W="[object RegExp]",H="[object Set]",J="[object String]",L="[object Symbol]",P="[object WeakMap]",Q="[object ArrayBuffer]",V="[object DataView]",X="[object Float32Array]",Y="[object Float64Array]",Z="[object Int8Array]",$="[object Int16Array]",z="[object Int32Array]",k="[object Uint8Array]",v="[object Uint8ClampedArray]",rr="[object Uint16Array]",er="[object Uint32Array]",r={};r[A]=r[O]=r[Q]=r[V]=r[D]=r[l]=r[X]=r[Y]=r[Z]=r[$]=r[z]=r[N]=r[R]=r[u]=r[W]=r[H]=r[J]=r[L]=r[k]=r[v]=r[rr]=r[er]=!0;r[G]=r[q]=r[P]=!1;function c(e,g,b,tr,j,n){var t;if(t!==void 0)return t;if(!x(e))return e;var s=M(e);if(s)t=m(e);else{var a=S(e),T=a==q||a==K;if(U(e))return C(e);if(a==u||a==A||T&&!j)t=T?{}:F(e);else{if(!r[a])return j?e:{};t=w(e,a)}}n||(n=new d);var f=n.get(e);if(f)return f;n.set(e,t),I(e)?e.forEach(function(o){t.add(c(o,g,b,o,e,n))}):h(e)&&e.forEach(function(o,i){t.set(i,c(o,g,b,i,e,n))});var p=E,y=s?void 0:p(e);return _(y||e,function(o,i){y&&(i=o,o=e[i]),B(t,i,c(o,g,b,i,e,n))}),t}module.exports=c;
+//# sourceMappingURL=index.cjs433.js.map

package/dist/index.cjs433.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs433.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":"qcA6BA,IAAIA,EAAU,qBACVC,EAAW,iBACXC,EAAU,mBACVC,EAAU,gBACVC,EAAW,iBACXC,EAAU,oBACVC,EAAS,6BACTC,EAAS,eACTC,EAAY,kBACZC,EAAY,kBACZC,EAAY,kBACZC,EAAS,eACTC,EAAY,kBACZC,EAAY,kBACZC,EAAa,mBAEbC,EAAiB,uBACjBC,EAAc,oBACdC,EAAa,wBACbC,EAAa,wBACbC,EAAU,qBACVC,EAAW,sBACXC,EAAW,sBACXC,EAAW,sBACXC,EAAkB,6BAClBC,GAAY,uBACZC,GAAY,uBAGZC,EAAgB,CAAA,EACpBA,EAAc1B,CAAO,EAAI0B,EAAczB,CAAQ,EAC/CyB,EAAcX,CAAc,EAAIW,EAAcV,CAAW,EACzDU,EAAcxB,CAAO,EAAIwB,EAAcvB,CAAO,EAC9CuB,EAAcT,CAAU,EAAIS,EAAcR,CAAU,EACpDQ,EAAcP,CAAO,EAAIO,EAAcN,CAAQ,EAC/CM,EAAcL,CAAQ,EAAIK,EAAcnB,CAAM,EAC9CmB,EAAclB,CAAS,EAAIkB,EAAcjB,CAAS,EAClDiB,EAAchB,CAAS,EAAIgB,EAAcf,CAAM,EAC/Ce,EAAcd,CAAS,EAAIc,EAAcb,CAAS,EAClDa,EAAcJ,CAAQ,EAAII,EAAcH,CAAe,EACvDG,EAAcF,EAAS,EAAIE,EAAcD,EAAS,EAAI,GACtDC,EAActB,CAAQ,EAAIsB,EAAcrB,CAAO,EAC/CqB,EAAcZ,CAAU,EAAI,GAkB5B,SAASa,EAAUC,EAAOC,EAASC,EAAYC,GAAKC,EAAQC,EAAO,CACjE,IAAIC,EAQJ,GAAIA,IAAW,OACb,OAAOA,EAET,GAAI,CAACC,EAASP,CAAK,EACjB,OAAOA,EAET,IAAIQ,EAAQC,EAAQT,CAAK,EACzB,GAAIQ,EACFF,EAASI,EAAeV,CAAK,MAIxB,CACL,IAAIW,EAAMC,EAAOZ,CAAK,EAClBa,EAASF,GAAOlC,GAAWkC,GAAOjC,EAEtC,GAAIoC,EAASd,CAAK,EAChB,OAAOe,EAAYf,CAAa,EAElC,GAAIW,GAAO9B,GAAa8B,GAAOvC,GAAYyC,GAAU,CAACT,EACpDE,EAAoBO,EAAU,GAAKG,EAAgBhB,CAAK,MAMnD,CACL,GAAI,CAACF,EAAca,CAAG,EACpB,OAAOP,EAASJ,EAAQ,CAAA,EAE1BM,EAASW,EAAejB,EAAOW,CAAW,CAC5C,CACF,CAEAN,IAAUA,EAAQ,IAAIa,GACtB,IAAIC,EAAUd,EAAM,IAAIL,CAAK,EAC7B,GAAImB,EACF,OAAOA,EAETd,EAAM,IAAIL,EAAOM,CAAM,EAEnBc,EAAMpB,CAAK,EACbA,EAAM,QAAQ,SAASqB,EAAU,CAC/Bf,EAAO,IAAIP,EAAUsB,EAAUpB,EAASC,EAAYmB,EAAUrB,EAAOK,CAAK,CAAC,CAC7E,CAAC,EACQiB,EAAMtB,CAAK,GACpBA,EAAM,QAAQ,SAASqB,EAAUlB,EAAK,CACpCG,EAAO,IAAIH,EAAKJ,EAAUsB,EAAUpB,EAASC,EAAYC,EAAKH,EAAOK,CAAK,CAAC,CAC7E,CAAC,EAGH,IAAIkB,EACyBC,EAGzBC,EAAQjB,EAAQ,OAAYe,EAASvB,CAAK,EAC9C0B,OAAAA,EAAUD,GAASzB,EAAO,SAASqB,EAAUlB,EAAK,CAC5CsB,IACFtB,EAAMkB,EACNA,EAAWrB,EAAMG,CAAG,GAGtBwB,EAAYrB,EAAQH,EAAKJ,EAAUsB,EAAUpB,EAASC,EAAYC,EAAKH,EAAOK,CAAK,CAAC,CACtF,CAAC,EACMC,CACT","x_google_ignoreList":[0]}

package/dist/index.cjs434.js

@@ -0,0 +1,2 @@
+"use strict";const q=require("./index.cjs435.js"),h=require("./index.cjs436.js"),b=require("./index.cjs437.js");var y="Expected a function",R=Math.max,p=Math.min;function A(x,n,a){var u,c,v,o,i,r,l=0,E=!1,s=!1,d=!0;if(typeof x!="function")throw new TypeError(y);n=b(n)||0,q(a)&&(E=!!a.leading,s="maxWait"in a,v=s?R(b(a.maxWait)||0,n):v,d="trailing"in a?!!a.trailing:d);function g(e){var t=u,f=c;return u=c=void 0,l=e,o=x.apply(f,t),o}function C(e){return l=e,i=setTimeout(m,n),E?g(e):o}function L(e){var t=e-r,f=e-l,W=n-t;return s?p(W,v-f):W}function k(e){var t=e-r,f=e-l;return r===void 0||t>=n||t<0||s&&f>=v}function m(){var e=h();if(k(e))return I(e);i=setTimeout(m,L(e))}function I(e){return i=void 0,d&&u?g(e):(u=c=void 0,o)}function M(){i!==void 0&&clearTimeout(i),l=0,u=r=c=i=void 0}function S(){return i===void 0?o:I(h())}function T(){var e=h(),t=k(e);if(u=arguments,c=this,r=e,t){if(i===void 0)return C(r);if(s)return clearTimeout(i),i=setTimeout(m,n),g(r)}return i===void 0&&(i=setTimeout(m,n)),o}return T.cancel=M,T.flush=S,T}module.exports=A;
+//# sourceMappingURL=index.cjs434.js.map

package/dist/index.cjs434.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs434.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":"gHAKA,IAAIA,EAAkB,sBAGlBC,EAAY,KAAK,IACjBC,EAAY,KAAK,IAwDrB,SAASC,EAASC,EAAMC,EAAMC,EAAS,CACrC,IAAIC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAAiB,EACjBC,EAAU,GACVC,EAAS,GACTC,EAAW,GAEf,GAAI,OAAOZ,GAAQ,WACjB,MAAM,IAAI,UAAUJ,CAAe,EAErCK,EAAOY,EAASZ,CAAI,GAAK,EACrBa,EAASZ,CAAO,IAClBQ,EAAU,CAAC,CAACR,EAAQ,QACpBS,EAAS,YAAaT,EACtBG,EAAUM,EAASd,EAAUgB,EAASX,EAAQ,OAAO,GAAK,EAAGD,CAAI,EAAII,EACrEO,EAAW,aAAcV,EAAU,CAAC,CAACA,EAAQ,SAAWU,GAG1D,SAASG,EAAWC,EAAM,CACxB,IAAIC,EAAOd,EACPe,EAAUd,EAEd,OAAAD,EAAWC,EAAW,OACtBK,EAAiBO,EACjBV,EAASN,EAAK,MAAMkB,EAASD,CAAI,EAC1BX,CACT,CAEA,SAASa,EAAYH,EAAM,CAEzB,OAAAP,EAAiBO,EAEjBT,EAAU,WAAWa,EAAcnB,CAAI,EAEhCS,EAAUK,EAAWC,CAAI,EAAIV,CACtC,CAEA,SAASe,EAAcL,EAAM,CAC3B,IAAIM,EAAoBN,EAAOR,EAC3Be,EAAsBP,EAAOP,EAC7Be,EAAcvB,EAAOqB,EAEzB,OAAOX,EACHb,EAAU0B,EAAanB,EAAUkB,CAAmB,EACpDC,CACN,CAEA,SAASC,EAAaT,EAAM,CAC1B,IAAIM,EAAoBN,EAAOR,EAC3Be,EAAsBP,EAAOP,EAKjC,OAAQD,IAAiB,QAAcc,GAAqBrB,GACzDqB,EAAoB,GAAOX,GAAUY,GAAuBlB,CACjE,CAEA,SAASe,GAAe,CACtB,IAAIJ,EAAOU,EAAA,EACX,GAAID,EAAaT,CAAI,EACnB,OAAOW,EAAaX,CAAI,EAG1BT,EAAU,WAAWa,EAAcC,EAAcL,CAAI,CAAC,CACxD,CAEA,SAASW,EAAaX,EAAM,CAK1B,OAJAT,EAAU,OAINK,GAAYT,EACPY,EAAWC,CAAI,GAExBb,EAAWC,EAAW,OACfE,EACT,CAEA,SAASsB,GAAS,CACZrB,IAAY,QACd,aAAaA,CAAO,EAEtBE,EAAiB,EACjBN,EAAWK,EAAeJ,EAAWG,EAAU,MACjD,CAEA,SAASsB,GAAQ,CACf,OAAOtB,IAAY,OAAYD,EAASqB,EAAaD,GAAK,CAC5D,CAEA,SAASI,GAAY,CACnB,IAAId,EAAOU,EAAA,EACPK,EAAaN,EAAaT,CAAI,EAMlC,GAJAb,EAAW,UACXC,EAAW,KACXI,EAAeQ,EAEXe,EAAY,CACd,GAAIxB,IAAY,OACd,OAAOY,EAAYX,CAAY,EAEjC,GAAIG,EAEF,oBAAaJ,CAAO,EACpBA,EAAU,WAAWa,EAAcnB,CAAI,EAChCc,EAAWP,CAAY,CAElC,CACA,OAAID,IAAY,SACdA,EAAU,WAAWa,EAAcnB,CAAI,GAElCK,CACT,CACA,OAAAwB,EAAU,OAASF,EACnBE,EAAU,MAAQD,EACXC,CACT","x_google_ignoreList":[0]}

package/dist/index.cjs435.js

@@ -0,0 +1,2 @@
+"use strict";function n(t){var e=typeof t;return t!=null&&(e=="object"||e=="function")}module.exports=n;
+//# sourceMappingURL=index.cjs435.js.map

package/dist/index.cjs435.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs435.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,EAAO,CACvB,IAAIC,EAAO,OAAOD,EAClB,OAAOA,GAAS,OAASC,GAAQ,UAAYA,GAAQ,WACvD","x_google_ignoreList":[0]}

package/dist/index.cjs436.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index.cjs447.js");var t=function(){return r.Date.now()};module.exports=t;
+//# sourceMappingURL=index.cjs436.js.map

package/dist/index.cjs436.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs436.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":"kDAkBA,IAAIA,EAAM,UAAW,CACnB,OAAOC,EAAK,KAAK,IAAA,CACnB","x_google_ignoreList":[0]}

package/dist/index.cjs437.js

@@ -0,0 +1,2 @@
+"use strict";const e=require("./index.cjs464.js"),s=require("./index.cjs435.js"),f=require("./index.cjs457.js");var n=NaN,o=/^[-+]0x[0-9a-f]+$/i,c=/^0b[01]+$/i,b=/^0o[0-7]+$/i,y=parseInt;function p(r){if(typeof r=="number")return r;if(f(r))return n;if(s(r)){var t=typeof r.valueOf=="function"?r.valueOf():r;r=s(t)?t+"":t}if(typeof r!="string")return r===0?r:+r;r=e(r);var i=c.test(r);return i||b.test(r)?y(r.slice(2),i?2:8):o.test(r)?n:+r}module.exports=p;
+//# sourceMappingURL=index.cjs437.js.map

package/dist/index.cjs437.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs437.js","sources":["../../../node_modules/lodash-es/toNumber.js"],"sourcesContent":["import baseTrim from './_baseTrim.js';\nimport isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n"],"names":["NAN","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","toNumber","value","isSymbol","isObject","other","baseTrim","isBinary"],"mappings":"gHAKA,IAAIA,EAAM,IAGNC,EAAa,qBAGbC,EAAa,aAGbC,EAAY,cAGZC,EAAe,SAyBnB,SAASC,EAASC,EAAO,CACvB,GAAI,OAAOA,GAAS,SAClB,OAAOA,EAET,GAAIC,EAASD,CAAK,EAChB,OAAON,EAET,GAAIQ,EAASF,CAAK,EAAG,CACnB,IAAIG,EAAQ,OAAOH,EAAM,SAAW,WAAaA,EAAM,UAAYA,EACnEA,EAAQE,EAASC,CAAK,EAAKA,EAAQ,GAAMA,CAC3C,CACA,GAAI,OAAOH,GAAS,SAClB,OAAOA,IAAU,EAAIA,EAAQ,CAACA,EAEhCA,EAAQI,EAASJ,CAAK,EACtB,IAAIK,EAAWT,EAAW,KAAKI,CAAK,EACpC,OAAQK,GAAYR,EAAU,KAAKG,CAAK,EACpCF,EAAaE,EAAM,MAAM,CAAC,EAAGK,EAAW,EAAI,CAAC,EAC5CV,EAAW,KAAKK,CAAK,EAAIN,EAAM,CAACM,CACvC","x_google_ignoreList":[0]}

package/dist/index.cjs438.js

@@ -0,0 +1,2 @@
+"use strict";function t(n,s){return n===s||n!==n&&s!==s}module.exports=t;
+//# sourceMappingURL=index.cjs438.js.map

package/dist/index.cjs438.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs438.js","sources":["../../../node_modules/lodash-es/eq.js"],"sourcesContent":["/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nexport default eq;\n"],"names":["eq","value","other"],"mappings":"aAgCA,SAASA,EAAGC,EAAOC,EAAO,CACxB,OAAOD,IAAUC,GAAUD,IAAUA,GAASC,IAAUA,CAC1D","x_google_ignoreList":[0]}

package/dist/index.cjs439.js

@@ -0,0 +1,2 @@
+"use strict";const e=require("./index.cjs440.js"),s=require("./index.cjs441.js");var t=Object.prototype,n=t.hasOwnProperty,o=t.propertyIsEnumerable,a=e(function(){return arguments}())?e:function(r){return s(r)&&n.call(r,"callee")&&!o.call(r,"callee")};module.exports=a;
+//# sourceMappingURL=index.cjs439.js.map

package/dist/index.cjs439.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs439.js","sources":["../../../node_modules/lodash-es/isArguments.js"],"sourcesContent":["import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\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 `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nexport default isArguments;\n"],"names":["objectProto","hasOwnProperty","propertyIsEnumerable","isArguments","baseIsArguments","value","isObjectLike"],"mappings":"iFAIA,IAAIA,EAAc,OAAO,UAGrBC,EAAiBD,EAAY,eAG7BE,EAAuBF,EAAY,qBAoBnCG,EAAcC,EAAgB,UAAW,CAAE,OAAO,SAAW,GAAG,EAAIA,EAAkB,SAASC,EAAO,CACxG,OAAOC,EAAaD,CAAK,GAAKJ,EAAe,KAAKI,EAAO,QAAQ,GAC/D,CAACH,EAAqB,KAAKG,EAAO,QAAQ,CAC9C","x_google_ignoreList":[0]}

package/dist/index.cjs44.js

@@ -1,2 +1,2 @@
-"use strict";const t=require("./index.cjs218.js"),r=require("./index.cjs39.js"),e=require("./index.cjs224.js"),s=r.isIE11?e.ie11fingerprint(e.setMethods):t("Set");module.exports=s;
+"use strict";const t=require("./index.cjs225.js"),r=require("./index.cjs39.js"),e=require("./index.cjs231.js"),s=r.isIE11?e.ie11fingerprint(e.setMethods):t("Set");module.exports=s;
 //# sourceMappingURL=index.cjs44.js.map

package/dist/index.cjs440.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index.cjs450.js"),s=require("./index.cjs441.js");var t="[object Arguments]";function n(e){return s(e)&&r(e)==t}module.exports=n;
+//# sourceMappingURL=index.cjs440.js.map

package/dist/index.cjs440.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs440.js","sources":["../../../node_modules/lodash-es/_baseIsArguments.js"],"sourcesContent":["import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nexport default baseIsArguments;\n"],"names":["argsTag","baseIsArguments","value","isObjectLike","baseGetTag"],"mappings":"iFAIA,IAAIA,EAAU,qBASd,SAASC,EAAgBC,EAAO,CAC9B,OAAOC,EAAaD,CAAK,GAAKE,EAAWF,CAAK,GAAKF,CACrD","x_google_ignoreList":[0]}

package/dist/index.cjs441.js

@@ -0,0 +1,2 @@
+"use strict";function e(t){return t!=null&&typeof t=="object"}module.exports=e;
+//# sourceMappingURL=index.cjs441.js.map

package/dist/index.cjs441.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs441.js","sources":["../../../node_modules/lodash-es/isObjectLike.js"],"sourcesContent":["/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n"],"names":["isObjectLike","value"],"mappings":"aAwBA,SAASA,EAAaC,EAAO,CAC3B,OAAOA,GAAS,MAAQ,OAAOA,GAAS,QAC1C","x_google_ignoreList":[0]}

package/dist/index.cjs442.js

@@ -0,0 +1,2 @@
+"use strict";var r=Array.isArray;module.exports=r;
+//# sourceMappingURL=index.cjs442.js.map

package/dist/index.cjs442.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs442.js","sources":["../../../node_modules/lodash-es/isArray.js"],"sourcesContent":["/**\n * Checks if `value` is classified as an `Array` object.\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 array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n"],"names":["isArray"],"mappings":"aAuBA,IAAIA,EAAU,MAAM","x_google_ignoreList":[0]}

package/dist/index.cjs443.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index.cjs444.js"),t=require("./index.cjs445.js");function i(n){return n!=null&&t(n.length)&&!r(n)}module.exports=i;
+//# sourceMappingURL=index.cjs443.js.map

package/dist/index.cjs443.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs443.js","sources":["../../../node_modules/lodash-es/isArrayLike.js"],"sourcesContent":["import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nexport default isArrayLike;\n"],"names":["isArrayLike","value","isLength","isFunction"],"mappings":"iFA4BA,SAASA,EAAYC,EAAO,CAC1B,OAAOA,GAAS,MAAQC,EAASD,EAAM,MAAM,GAAK,CAACE,EAAWF,CAAK,CACrE","x_google_ignoreList":[0]}

package/dist/index.cjs444.js

@@ -0,0 +1,2 @@
+"use strict";const e=require("./index.cjs450.js"),c=require("./index.cjs435.js");var r="[object AsyncFunction]",o="[object Function]",a="[object GeneratorFunction]",i="[object Proxy]";function s(n){if(!c(n))return!1;var t=e(n);return t==o||t==a||t==r||t==i}module.exports=s;
+//# sourceMappingURL=index.cjs444.js.map

package/dist/index.cjs444.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs444.js","sources":["../../../node_modules/lodash-es/isFunction.js"],"sourcesContent":["import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\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 a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nexport default isFunction;\n"],"names":["asyncTag","funcTag","genTag","proxyTag","isFunction","value","isObject","tag","baseGetTag"],"mappings":"iFAIA,IAAIA,EAAW,yBACXC,EAAU,oBACVC,EAAS,6BACTC,EAAW,iBAmBf,SAASC,EAAWC,EAAO,CACzB,GAAI,CAACC,EAASD,CAAK,EACjB,MAAO,GAIT,IAAIE,EAAMC,EAAWH,CAAK,EAC1B,OAAOE,GAAON,GAAWM,GAAOL,GAAUK,GAAOP,GAAYO,GAAOJ,CACtE","x_google_ignoreList":[0]}

package/dist/index.cjs445.js

@@ -0,0 +1,2 @@
+"use strict";var r=9007199254740991;function n(t){return typeof t=="number"&&t>-1&&t%1==0&&t<=r}module.exports=n;
+//# sourceMappingURL=index.cjs445.js.map

package/dist/index.cjs445.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs445.js","sources":["../../../node_modules/lodash-es/isLength.js"],"sourcesContent":["/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nexport default isLength;\n"],"names":["MAX_SAFE_INTEGER","isLength","value"],"mappings":"aACA,IAAIA,EAAmB,iBA4BvB,SAASC,EAASC,EAAO,CACvB,OAAO,OAAOA,GAAS,UACrBA,EAAQ,IAAMA,EAAQ,GAAK,GAAKA,GAASF,CAC7C","x_google_ignoreList":[0]}

package/dist/index.cjs446.js

@@ -0,0 +1,2 @@
+"use strict";const t=require("./index.cjs447.js"),f=require("./index.cjs448.js");var o=typeof exports=="object"&&exports&&!exports.nodeType&&exports,e=o&&typeof module=="object"&&module&&!module.nodeType&&module,s=e&&e.exports===o,r=s?t.Buffer:void 0,u=r?r.isBuffer:void 0,v=u||f;module.exports=v;
+//# sourceMappingURL=index.cjs446.js.map