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

package/dist/index.cjs316.js

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */const M=Symbol("Comlink.proxy"),A=Symbol("Comlink.endpoint"),O=Symbol("Comlink.releaseProxy"),E=Symbol("Comlink.finalizer"),h=Symbol("Comlink.thrown"),R=e=>typeof e=="object"&&e!==null||typeof e=="function",_={canHandle:e=>R(e)&&e[M],serialize(e){const{port1:t,port2:r}=new MessageChannel;return S(e,t),[r,[r]]},deserialize(e){return e.start(),z(e)}},j={canHandle:e=>R(e)&&h in e,serialize({value:e}){let t;return e instanceof Error?t={isError:!0,value:{message:e.message,name:e.name,stack:e.stack}}:t={isError:!1,value:e},[t,[]]},deserialize(e){throw e.isError?Object.assign(new Error(e.value.message),e.value):e.value}},k=new Map([["proxy",_],["throw",j]]);function I(e,t){for(const r of e)if(t===r||r==="*"||r instanceof RegExp&&r.test(t))return!0;return!1}function S(e,t=globalThis,r=["*"]){t.addEventListener("message",function g(n){if(!n||!n.data)return;if(!I(r,n.origin)){console.warn(`Invalid origin '${n.origin}' for comlink proxy`);return}const{id:s,type:f,path:c}=Object.assign({path:[]},n.data),l=(n.data.argumentList||[]).map(y);let a;try{const o=c.slice(0,-1).reduce((i,d)=>i[d],e),u=c.reduce((i,d)=>i[d],e);switch(f){case"GET":a=u;break;case"SET":o[c.slice(-1)[0]]=y(n.data.value),a=!0;break;case"APPLY":a=u.apply(o,l);break;case"CONSTRUCT":{const i=new u(...l);a=V(i)}break;case"ENDPOINT":{const{port1:i,port2:d}=new MessageChannel;S(e,d),a=L(i,[i])}break;case"RELEASE":a=void 0;break;default:return}}catch(o){a={value:o,[h]:0}}Promise.resolve(a).catch(o=>({value:o,[h]:0})).then(o=>{const[u,i]=x(o);t.postMessage(Object.assign(Object.assign({},u),{id:s}),i),f==="RELEASE"&&(t.removeEventListener("message",g),C(t),E in e&&typeof e[E]=="function"&&e[E]())}).catch(o=>{const[u,i]=x({value:new TypeError("Unserializable return value"),[h]:0});t.postMessage(Object.assign(Object.assign({},u),{id:s}),i)})}),t.start&&t.start()}function W(e){return e.constructor.name==="MessagePort"}function C(e){W(e)&&e.close()}function z(e,t){const r=new Map;return e.addEventListener("message",function(n){const{data:s}=n;if(!s||!s.id)return;const f=r.get(s.id);if(f)try{f(s)}finally{r.delete(s.id)}}),P(e,r,[],t)}function w(e){if(e)throw new Error("Proxy has been released and is not useable")}function N(e){return m(e,new Map,{type:"RELEASE"}).then(()=>{C(e)})}const b=new WeakMap,p="FinalizationRegistry"in globalThis&&new FinalizationRegistry(e=>{const t=(b.get(e)||0)-1;b.set(e,t),t===0&&N(e)});function D(e,t){const r=(b.get(t)||0)+1;b.set(t,r),p&&p.register(e,t,e)}function F(e){p&&p.unregister(e)}function P(e,t,r=[],g=function(){}){let n=!1;const s=new Proxy(g,{get(f,c){if(w(n),c===O)return()=>{F(s),N(e),t.clear(),n=!0};if(c==="then"){if(r.length===0)return{then:()=>s};const l=m(e,t,{type:"GET",path:r.map(a=>a.toString())}).then(y);return l.then.bind(l)}return P(e,t,[...r,c])},set(f,c,l){w(n);const[a,o]=x(l);return m(e,t,{type:"SET",path:[...r,c].map(u=>u.toString()),value:a},o).then(y)},apply(f,c,l){w(n);const a=r[r.length-1];if(a===A)return m(e,t,{type:"ENDPOINT"}).then(y);if(a==="bind")return P(e,t,r.slice(0,-1));const[o,u]=T(l);return m(e,t,{type:"APPLY",path:r.map(i=>i.toString()),argumentList:o},u).then(y)},construct(f,c){w(n);const[l,a]=T(c);return m(e,t,{type:"CONSTRUCT",path:r.map(o=>o.toString()),argumentList:l},a).then(y)}});return D(s,e),s}function U(e){return Array.prototype.concat.apply([],e)}function T(e){const t=e.map(x);return[t.map(r=>r[0]),U(t.map(r=>r[1]))]}const H=new WeakMap;function L(e,t){return H.set(e,t),e}function V(e){return Object.assign(e,{[M]:!0})}function x(e){for(const[t,r]of k)if(r.canHandle(e)){const[g,n]=r.serialize(e);return[{type:"HANDLER",name:t,value:g},n]}return[{type:"RAW",value:e},H.get(e)||[]]}function y(e){switch(e.type){case"HANDLER":return k.get(e.name).deserialize(e.value);case"RAW":return e.value}}function m(e,t,r,g){return new Promise(n=>{const s=G();t.set(s,n),e.start&&e.start(),e.postMessage(Object.assign({id:s},r),g)})}function G(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}exports.createEndpoint=A;exports.expose=S;exports.finalizer=E;exports.proxy=V;exports.proxyMarker=M;exports.releaseProxy=O;exports.transfer=L;exports.transferHandlers=k;exports.wrap=z;
+//# sourceMappingURL=index.cjs316.js.map

package/dist/index.cjs316.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs316.js","sources":["../../../node_modules/comlink/dist/esm/comlink.mjs"],"sourcesContent":["/**\n * @license\n * Copyright 2019 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\nconst proxyMarker = Symbol(\"Comlink.proxy\");\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\nconst finalizer = Symbol(\"Comlink.finalizer\");\nconst throwMarker = Symbol(\"Comlink.thrown\");\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\n/**\n * Internal transfer handle to handle objects marked to proxy.\n */\nconst proxyTransferHandler = {\n    canHandle: (val) => isObject(val) && val[proxyMarker],\n    serialize(obj) {\n        const { port1, port2 } = new MessageChannel();\n        expose(obj, port1);\n        return [port2, [port2]];\n    },\n    deserialize(port) {\n        port.start();\n        return wrap(port);\n    },\n};\n/**\n * Internal transfer handler to handle thrown exceptions.\n */\nconst throwTransferHandler = {\n    canHandle: (value) => isObject(value) && throwMarker in value,\n    serialize({ value }) {\n        let serialized;\n        if (value instanceof Error) {\n            serialized = {\n                isError: true,\n                value: {\n                    message: value.message,\n                    name: value.name,\n                    stack: value.stack,\n                },\n            };\n        }\n        else {\n            serialized = { isError: false, value };\n        }\n        return [serialized, []];\n    },\n    deserialize(serialized) {\n        if (serialized.isError) {\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\n        }\n        throw serialized.value;\n    },\n};\n/**\n * Allows customizing the serialization of certain values.\n */\nconst transferHandlers = new Map([\n    [\"proxy\", proxyTransferHandler],\n    [\"throw\", throwTransferHandler],\n]);\nfunction isAllowedOrigin(allowedOrigins, origin) {\n    for (const allowedOrigin of allowedOrigins) {\n        if (origin === allowedOrigin || allowedOrigin === \"*\") {\n            return true;\n        }\n        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction expose(obj, ep = globalThis, allowedOrigins = [\"*\"]) {\n    ep.addEventListener(\"message\", function callback(ev) {\n        if (!ev || !ev.data) {\n            return;\n        }\n        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {\n            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);\n            return;\n        }\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\n        let returnValue;\n        try {\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\n            switch (type) {\n                case \"GET\" /* MessageType.GET */:\n                    {\n                        returnValue = rawValue;\n                    }\n                    break;\n                case \"SET\" /* MessageType.SET */:\n                    {\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\n                        returnValue = true;\n                    }\n                    break;\n                case \"APPLY\" /* MessageType.APPLY */:\n                    {\n                        returnValue = rawValue.apply(parent, argumentList);\n                    }\n                    break;\n                case \"CONSTRUCT\" /* MessageType.CONSTRUCT */:\n                    {\n                        const value = new rawValue(...argumentList);\n                        returnValue = proxy(value);\n                    }\n                    break;\n                case \"ENDPOINT\" /* MessageType.ENDPOINT */:\n                    {\n                        const { port1, port2 } = new MessageChannel();\n                        expose(obj, port2);\n                        returnValue = transfer(port1, [port1]);\n                    }\n                    break;\n                case \"RELEASE\" /* MessageType.RELEASE */:\n                    {\n                        returnValue = undefined;\n                    }\n                    break;\n                default:\n                    return;\n            }\n        }\n        catch (value) {\n            returnValue = { value, [throwMarker]: 0 };\n        }\n        Promise.resolve(returnValue)\n            .catch((value) => {\n            return { value, [throwMarker]: 0 };\n        })\n            .then((returnValue) => {\n            const [wireValue, transferables] = toWireValue(returnValue);\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n            if (type === \"RELEASE\" /* MessageType.RELEASE */) {\n                // detach and deactive after sending release response above.\n                ep.removeEventListener(\"message\", callback);\n                closeEndPoint(ep);\n                if (finalizer in obj && typeof obj[finalizer] === \"function\") {\n                    obj[finalizer]();\n                }\n            }\n        })\n            .catch((error) => {\n            // Send Serialization Error To Caller\n            const [wireValue, transferables] = toWireValue({\n                value: new TypeError(\"Unserializable return value\"),\n                [throwMarker]: 0,\n            });\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n        });\n    });\n    if (ep.start) {\n        ep.start();\n    }\n}\nfunction isMessagePort(endpoint) {\n    return endpoint.constructor.name === \"MessagePort\";\n}\nfunction closeEndPoint(endpoint) {\n    if (isMessagePort(endpoint))\n        endpoint.close();\n}\nfunction wrap(ep, target) {\n    const pendingListeners = new Map();\n    ep.addEventListener(\"message\", function handleMessage(ev) {\n        const { data } = ev;\n        if (!data || !data.id) {\n            return;\n        }\n        const resolver = pendingListeners.get(data.id);\n        if (!resolver) {\n            return;\n        }\n        try {\n            resolver(data);\n        }\n        finally {\n            pendingListeners.delete(data.id);\n        }\n    });\n    return createProxy(ep, pendingListeners, [], target);\n}\nfunction throwIfProxyReleased(isReleased) {\n    if (isReleased) {\n        throw new Error(\"Proxy has been released and is not useable\");\n    }\n}\nfunction releaseEndpoint(ep) {\n    return requestResponseMessage(ep, new Map(), {\n        type: \"RELEASE\" /* MessageType.RELEASE */,\n    }).then(() => {\n        closeEndPoint(ep);\n    });\n}\nconst proxyCounter = new WeakMap();\nconst proxyFinalizers = \"FinalizationRegistry\" in globalThis &&\n    new FinalizationRegistry((ep) => {\n        const newCount = (proxyCounter.get(ep) || 0) - 1;\n        proxyCounter.set(ep, newCount);\n        if (newCount === 0) {\n            releaseEndpoint(ep);\n        }\n    });\nfunction registerProxy(proxy, ep) {\n    const newCount = (proxyCounter.get(ep) || 0) + 1;\n    proxyCounter.set(ep, newCount);\n    if (proxyFinalizers) {\n        proxyFinalizers.register(proxy, ep, proxy);\n    }\n}\nfunction unregisterProxy(proxy) {\n    if (proxyFinalizers) {\n        proxyFinalizers.unregister(proxy);\n    }\n}\nfunction createProxy(ep, pendingListeners, path = [], target = function () { }) {\n    let isProxyReleased = false;\n    const proxy = new Proxy(target, {\n        get(_target, prop) {\n            throwIfProxyReleased(isProxyReleased);\n            if (prop === releaseProxy) {\n                return () => {\n                    unregisterProxy(proxy);\n                    releaseEndpoint(ep);\n                    pendingListeners.clear();\n                    isProxyReleased = true;\n                };\n            }\n            if (prop === \"then\") {\n                if (path.length === 0) {\n                    return { then: () => proxy };\n                }\n                const r = requestResponseMessage(ep, pendingListeners, {\n                    type: \"GET\" /* MessageType.GET */,\n                    path: path.map((p) => p.toString()),\n                }).then(fromWireValue);\n                return r.then.bind(r);\n            }\n            return createProxy(ep, pendingListeners, [...path, prop]);\n        },\n        set(_target, prop, rawValue) {\n            throwIfProxyReleased(isProxyReleased);\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\n            const [value, transferables] = toWireValue(rawValue);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"SET\" /* MessageType.SET */,\n                path: [...path, prop].map((p) => p.toString()),\n                value,\n            }, transferables).then(fromWireValue);\n        },\n        apply(_target, _thisArg, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const last = path[path.length - 1];\n            if (last === createEndpoint) {\n                return requestResponseMessage(ep, pendingListeners, {\n                    type: \"ENDPOINT\" /* MessageType.ENDPOINT */,\n                }).then(fromWireValue);\n            }\n            // We just pretend that `bind()` didn’t happen.\n            if (last === \"bind\") {\n                return createProxy(ep, pendingListeners, path.slice(0, -1));\n            }\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"APPLY\" /* MessageType.APPLY */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n        construct(_target, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"CONSTRUCT\" /* MessageType.CONSTRUCT */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n    });\n    registerProxy(proxy, ep);\n    return proxy;\n}\nfunction myFlat(arr) {\n    return Array.prototype.concat.apply([], arr);\n}\nfunction processArguments(argumentList) {\n    const processed = argumentList.map(toWireValue);\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\n}\nconst transferCache = new WeakMap();\nfunction transfer(obj, transfers) {\n    transferCache.set(obj, transfers);\n    return obj;\n}\nfunction proxy(obj) {\n    return Object.assign(obj, { [proxyMarker]: true });\n}\nfunction windowEndpoint(w, context = globalThis, targetOrigin = \"*\") {\n    return {\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\n        addEventListener: context.addEventListener.bind(context),\n        removeEventListener: context.removeEventListener.bind(context),\n    };\n}\nfunction toWireValue(value) {\n    for (const [name, handler] of transferHandlers) {\n        if (handler.canHandle(value)) {\n            const [serializedValue, transferables] = handler.serialize(value);\n            return [\n                {\n                    type: \"HANDLER\" /* WireValueType.HANDLER */,\n                    name,\n                    value: serializedValue,\n                },\n                transferables,\n            ];\n        }\n    }\n    return [\n        {\n            type: \"RAW\" /* WireValueType.RAW */,\n            value,\n        },\n        transferCache.get(value) || [],\n    ];\n}\nfunction fromWireValue(value) {\n    switch (value.type) {\n        case \"HANDLER\" /* WireValueType.HANDLER */:\n            return transferHandlers.get(value.name).deserialize(value.value);\n        case \"RAW\" /* WireValueType.RAW */:\n            return value.value;\n    }\n}\nfunction requestResponseMessage(ep, pendingListeners, msg, transfers) {\n    return new Promise((resolve) => {\n        const id = generateUUID();\n        pendingListeners.set(id, resolve);\n        if (ep.start) {\n            ep.start();\n        }\n        ep.postMessage(Object.assign({ id }, msg), transfers);\n    });\n}\nfunction generateUUID() {\n    return new Array(4)\n        .fill(0)\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\n        .join(\"-\");\n}\n\nexport { createEndpoint, expose, finalizer, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n"],"names":["proxyMarker","createEndpoint","releaseProxy","finalizer","throwMarker","isObject","val","proxyTransferHandler","obj","port1","port2","expose","port","wrap","throwTransferHandler","value","serialized","transferHandlers","isAllowedOrigin","allowedOrigins","origin","allowedOrigin","ep","callback","ev","id","type","path","argumentList","fromWireValue","returnValue","parent","prop","rawValue","proxy","transfer","wireValue","transferables","toWireValue","closeEndPoint","error","isMessagePort","endpoint","target","pendingListeners","data","resolver","createProxy","throwIfProxyReleased","isReleased","releaseEndpoint","requestResponseMessage","proxyCounter","proxyFinalizers","newCount","registerProxy","unregisterProxy","isProxyReleased","_target","r","p","_thisArg","rawArgumentList","last","processArguments","myFlat","arr","processed","v","transferCache","transfers","name","handler","serializedValue","msg","resolve","generateUUID"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs317.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=["log2sigma","twoOmega","airyKavr","signDetJ","thetaa"];function f(t,n,o,c=1){if(t.length===0)return new Map;if(!n||!o)return new Map(t.map(s=>[s,0]));const{E:u,F:g,a:h,b:m}=M(n,o);return new Map(t.map(s=>{if(r.indexOf(s)===-1)throw new Error("Distortion "+s+" not supported");switch(r.indexOf(s)){case 0:return[s,w(h,m,c)];case 1:return[s,q(h,m)];case 2:return[s,O(h,m,c)];case 3:return[s,p(n,o)];case 4:return[s,y(n,h,m,u,g)];default:return[s,0]}}))}function M(t,n){const o=t[0]**2+t[1]**2,c=t[0]*n[0]+t[1]*n[1],u=n[0]**2+n[1]**2,g=Math.sqrt(.5*(o+u+Math.sqrt((o-u)**2+4*c**2))),h=Math.sqrt(.5*(o+u-Math.sqrt((o-u)**2+4*c**2)));return{E:o,F:c,G:u,a:g,b:h}}function w(t,n,o=1){return(Math.log(t*n)-2*Math.log(o))/Math.log(2)}function q(t,n){return 2*Math.asin((t-n)/(t+n))}function O(t,n,o=1){return .5*(Math.log(t/o)**2+Math.log(n/o)**2)}function p(t,n){return Math.sign(t[0]*n[1]-t[1]*n[0])}function y(t,n,o,c,u){const g=Math.atan(t[1]/t[0]),h=Math.sign(-u)*Math.asin(Math.sqrt((1-n**2/c)/(1-(n/o)**2)));return g-h}exports.computeDistortionsFromPartialDerivatives=f;exports.supportedDistortionMeasures=r;
+//# sourceMappingURL=index.cjs317.js.map

package/dist/index.cjs317.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs317.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/distortion.js"],"sourcesContent":["export const supportedDistortionMeasures = [\n    'log2sigma',\n    'twoOmega',\n    'airyKavr',\n    'signDetJ',\n    'thetaa'\n];\n/**\n * Compute the distortion value of selected distortion measures from the partial derivatives at a specific point\n *\n * @param distortionMeasures - The requested distortion measures\n * @param partialDerivativeX - The partial derivative to 'x' of the transformation, evaluated at a set point\n * @param partialDerivativeY - The partial derivative to 'y' of the transformation, evaluated at a set point\n * @param referenceScale - The reference area scaling (sigma) to take into account for certain distortion measures (like 'log2sigma'), e.g. computed via a helmert transform\n * @returns A map of distortion measures and distortion values at the point\n */\nexport function computeDistortionsFromPartialDerivatives(distortionMeasures, partialDerivativeX, partialDerivativeY, referenceScale = 1) {\n    if (distortionMeasures.length === 0) {\n        return new Map();\n    }\n    if (!partialDerivativeX || !partialDerivativeY) {\n        return new Map(distortionMeasures.map((distortionMeasure) => [distortionMeasure, 0]));\n    }\n    const { E, F, a, b } = computeDistortionIntermediates(partialDerivativeX, partialDerivativeY);\n    return new Map(distortionMeasures.map((distortionMeasure) => {\n        if (supportedDistortionMeasures.indexOf(distortionMeasure) === -1) {\n            throw new Error('Distortion ' + distortionMeasure + ' not supported');\n        }\n        switch (supportedDistortionMeasures.indexOf(distortionMeasure)) {\n            case 0:\n                return [distortionMeasure, log2sigma(a, b, referenceScale)];\n            case 1:\n                return [distortionMeasure, twoOmega(a, b)];\n            case 2:\n                return [distortionMeasure, airyKavr(a, b, referenceScale)];\n            case 3:\n                return [\n                    distortionMeasure,\n                    signDetJ(partialDerivativeX, partialDerivativeY)\n                ];\n            case 4:\n                return [distortionMeasure, thetaa(partialDerivativeX, a, b, E, F)];\n            default:\n                return [distortionMeasure, 0];\n        }\n    }));\n}\nfunction computeDistortionIntermediates(partialDerivativeX, partialDerivativeY) {\n    const E = partialDerivativeX[0] ** 2 + partialDerivativeX[1] ** 2;\n    const F = partialDerivativeX[0] * partialDerivativeY[0] +\n        partialDerivativeX[1] * partialDerivativeY[1];\n    const G = partialDerivativeY[0] ** 2 + partialDerivativeY[1] ** 2;\n    const a = Math.sqrt(0.5 * (E + G + Math.sqrt((E - G) ** 2 + 4 * F ** 2)));\n    const b = Math.sqrt(0.5 * (E + G - Math.sqrt((E - G) ** 2 + 4 * F ** 2)));\n    return { E, F, G, a, b };\n}\nfunction log2sigma(a, b, referenceScale = 1) {\n    return (Math.log(a * b) - 2 * Math.log(referenceScale)) / Math.log(2);\n}\nfunction twoOmega(a, b) {\n    return 2 * Math.asin((a - b) / (a + b));\n}\nfunction airyKavr(a, b, referenceScale = 1) {\n    return (0.5 *\n        (Math.log(a / referenceScale) ** 2 + Math.log(b / referenceScale) ** 2));\n}\nfunction signDetJ(partialDerivativeX, partialDerivativeY) {\n    return Math.sign(partialDerivativeX[0] * partialDerivativeY[1] -\n        partialDerivativeX[1] * partialDerivativeY[0]);\n}\nfunction thetaa(partialDerivativeX, a, b, E, F) {\n    const thetaxp = Math.atan(partialDerivativeX[1] / partialDerivativeX[0]);\n    const alphap = Math.sign(-F) * Math.asin(Math.sqrt((1 - a ** 2 / E) / (1 - (a / b) ** 2)));\n    return thetaxp - alphap;\n}\n"],"names":["supportedDistortionMeasures","computeDistortionsFromPartialDerivatives","distortionMeasures","partialDerivativeX","partialDerivativeY","referenceScale","distortionMeasure","E","F","a","b","computeDistortionIntermediates","log2sigma","twoOmega","airyKavr","signDetJ","thetaa","G","thetaxp","alphap"],"mappings":"gFAAO,MAAMA,EAA8B,CACvC,YACA,WACA,WACA,WACA,QACJ,EAUO,SAASC,EAAyCC,EAAoBC,EAAoBC,EAAoBC,EAAiB,EAAG,CACrI,GAAIH,EAAmB,SAAW,EAC9B,WAAW,IAEf,GAAI,CAACC,GAAsB,CAACC,EACxB,OAAO,IAAI,IAAIF,EAAmB,IAAKI,GAAsB,CAACA,EAAmB,CAAC,CAAC,CAAC,EAExF,KAAM,CAAE,EAAAC,EAAG,EAAAC,EAAG,EAAAC,EAAG,EAAAC,GAAMC,EAA+BR,EAAoBC,CAAkB,EAC5F,OAAO,IAAI,IAAIF,EAAmB,IAAKI,GAAsB,CACzD,GAAIN,EAA4B,QAAQM,CAAiB,IAAM,GAC3D,MAAM,IAAI,MAAM,cAAgBA,EAAoB,gBAAgB,EAExE,OAAQN,EAA4B,QAAQM,CAAiB,EAAA,CACzD,IAAK,GACD,MAAO,CAACA,EAAmBM,EAAUH,EAAGC,EAAGL,CAAc,CAAC,EAC9D,IAAK,GACD,MAAO,CAACC,EAAmBO,EAASJ,EAAGC,CAAC,CAAC,EAC7C,IAAK,GACD,MAAO,CAACJ,EAAmBQ,EAASL,EAAGC,EAAGL,CAAc,CAAC,EAC7D,IAAK,GACD,MAAO,CACHC,EACAS,EAASZ,EAAoBC,CAAkB,CAAA,EAEvD,IAAK,GACD,MAAO,CAACE,EAAmBU,EAAOb,EAAoBM,EAAGC,EAAGH,EAAGC,CAAC,CAAC,EACrE,QACI,MAAO,CAACF,EAAmB,CAAC,CAAA,CAExC,CAAC,CAAC,CACN,CACA,SAASK,EAA+BR,EAAoBC,EAAoB,CAC5E,MAAMG,EAAIJ,EAAmB,CAAC,GAAK,EAAIA,EAAmB,CAAC,GAAK,EAC1DK,EAAIL,EAAmB,CAAC,EAAIC,EAAmB,CAAC,EAClDD,EAAmB,CAAC,EAAIC,EAAmB,CAAC,EAC1Ca,EAAIb,EAAmB,CAAC,GAAK,EAAIA,EAAmB,CAAC,GAAK,EAC1DK,EAAI,KAAK,KAAK,IAAOF,EAAIU,EAAI,KAAK,MAAMV,EAAIU,IAAM,EAAI,EAAIT,GAAK,CAAC,EAAE,EAClEE,EAAI,KAAK,KAAK,IAAOH,EAAIU,EAAI,KAAK,MAAMV,EAAIU,IAAM,EAAI,EAAIT,GAAK,CAAC,EAAE,EACxE,MAAO,CAAE,EAAAD,EAAG,EAAAC,EAAG,EAAAS,EAAG,EAAAR,EAAG,EAAAC,CAAA,CACzB,CACA,SAASE,EAAUH,EAAGC,EAAGL,EAAiB,EAAG,CACzC,OAAQ,KAAK,IAAII,EAAIC,CAAC,EAAI,EAAI,KAAK,IAAIL,CAAc,GAAK,KAAK,IAAI,CAAC,CACxE,CACA,SAASQ,EAASJ,EAAGC,EAAG,CACpB,MAAO,GAAI,KAAK,MAAMD,EAAIC,IAAMD,EAAIC,EAAE,CAC1C,CACA,SAASI,EAASL,EAAGC,EAAGL,EAAiB,EAAG,CACxC,MAAQ,KACH,KAAK,IAAII,EAAIJ,CAAc,GAAK,EAAI,KAAK,IAAIK,EAAIL,CAAc,GAAK,EAC7E,CACA,SAASU,EAASZ,EAAoBC,EAAoB,CACtD,OAAO,KAAK,KAAKD,EAAmB,CAAC,EAAIC,EAAmB,CAAC,EACzDD,EAAmB,CAAC,EAAIC,EAAmB,CAAC,CAAC,CACrD,CACA,SAASY,EAAOb,EAAoBM,EAAGC,EAAGH,EAAGC,EAAG,CAC5C,MAAMU,EAAU,KAAK,KAAKf,EAAmB,CAAC,EAAIA,EAAmB,CAAC,CAAC,EACjEgB,EAAS,KAAK,KAAK,CAACX,CAAC,EAAI,KAAK,KAAK,KAAK,MAAM,EAAIC,GAAK,EAAIF,IAAM,GAAKE,EAAIC,IAAM,EAAE,CAAC,EACzF,OAAOQ,EAAUC,CACrB","x_google_ignoreList":[0]}

package/dist/index.cjs318.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const T=require("./index.cjs223.js"),l=require("./index.cjs217.js"),m=require("./index.cjs319.js"),G=require("./index.cjs224.js"),e=require("./index.cjs225.js");class u extends m.GcpTransformer{internalProjection;projection;internalProjectionToProjection;projectionToInternalProjection;lonLatToProjection;projectionToLonLat;constructor(o,n="polynomial",t){const r=l.mergeOptionsUnlessUndefined(e.defaultProjectedGcpTransformerOptions,t),i=T(r.internalProjection.definition,r.projection.definition),s=i.forward,a=i.inverse,p=T(e.lonLatProjection.definition,r.projection.definition),j=p.forward,P=p.inverse,f={...t,postToGeo:s,preToResource:a};o=o.filter(c=>c.geo&&c.resource).map(c=>({resource:c.resource,geo:j(c.geo)})),super(o,n,f),this.internalProjection=r.internalProjection,this.projection=r.projection,this.internalProjectionToProjection=s,this.projectionToInternalProjection=a,this.lonLatToProjection=j,this.projectionToLonLat=P}get gcps(){return super.gcps}get lonlatGcps(){return this.projectedGcps.map(({resource:o,geo:n})=>({resource:o,geo:this.projectionToLonLat(n)}))}get interalProjectedGcps(){return this.projectedGcps.map(({resource:o,geo:n})=>({resource:o,geo:this.projectionToInternalProjection(n)}))}get projectedGcps(){return this.gcps}transformToProjectedGeo(o,n,t){const r=e.projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection,n);return super.transformToGeo(o,r,t)}transformToGeo(o,n,t){return this.transformToProjectedGeo(o,l.mergePartialOptions(n,{projection:e.lonLatProjection}),t)}transformToResource(o,n,t){const r=e.projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection,n);return super.transformToResource(o,r,t)}isNonWarping(){return e.isEqualProjection(this.projection,this.internalProjection)===!0&&G.nonWarpingTransformationTypes.includes(this.type)}getToProjectedGeoTransformationResolution(o,n){const t=e.projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection,n);return super.getToGeoTransformationResolution(o,t)}getToGeoTransformationResolution(o,n){return this.getToProjectedGeoTransformationResolution(o,l.mergePartialOptions(n,{projection:e.lonLatProjection}))}getToResourceTransformationResolution(o,n){const t=e.projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection,n);return super.getToResourceTransformationResolution(o,t)}static fromGeoreferencedMap(o,n){const t={transformationType:o.transformation?.type,internalProjection:o.resourceCrs};return n=l.mergeOptions(t,n),new u(o.gcps,n.transformationType,n)}static setProjection(o,n){if(e.isEqualProjection(n,o.projection))return o;const t=T(o.internalProjection.definition,n.definition),r=t.forward,i=t.inverse,s=T(e.lonLatProjection.definition,n.definition),a=s.forward,p=s.inverse,j={postToGeo:r,preToResource:i};return o.setTransformerOptions(j),o.projection=n,o.internalProjectionToProjection=r,o.projectionToInternalProjection=i,o.lonLatToProjection=a,o.projectionToLonLat=p,o}}exports.ProjectedGcpTransformer=u;
+//# sourceMappingURL=index.cjs318.js.map

package/dist/index.cjs318.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs318.js","sources":["../../../node_modules/@allmaps/project/dist/projected-transformers/ProjectedGcpTransformer.js"],"sourcesContent":["import proj4 from 'proj4';\nimport { mergeOptions, mergeOptionsUnlessUndefined, mergePartialOptions } from '@allmaps/stdlib';\nimport { GcpTransformer, nonWarpingTransformationTypes } from '@allmaps/transform';\nimport { defaultProjectedGcpTransformerOptions, isEqualProjection, lonLatProjection, projectedGcpTransformOptionsToGcpTransformOptions } from '../shared/project-functions.js';\n/**\n * Class for Projected Ground Control Point Transformers.\n *\n * A Projected GCP Transformer can transform input geometries between 'resource' and 'projected geo' spaces.\n *\n * It does this using a transformation (of a certain type) built from\n * a set of Ground Control Points (with coordinates in\n * resource and geo space), a transformation type,\n * and an internal projection and projection.\n *\n * GCPs are expected in lon-lat 'EPSG:4326' (and are projected to the internal projection).\n * The default projection for the internal projection and projection is WebMercator 'EPSG:3857'.\n *\n * A postToGeo function is built from the internal projection to the projection (by default an identity projection).\n * A preToResource function is built from the projection to the internal projection (by default an identity projection).\n *\n * Like the GCP Transformer class it extends,\n * it has a method to transform 'toGeo' (from resource to projected geo space)\n * and 'toResource' (from projected geo to resource space),\n *\n * Like the GCP Transformer class it extends,\n * the `differentHandedness` setting is `true` by default,\n * since we expect the resource coordinates to identify pixels on an image,\n * with origin in the top left and the y-axis pointing down.\n *\n * @param internalProjection - the internal projection to which the GCPs (supplied in lon-lat 'EPSG:4326') are projected before building the transformation functions.\n * @param projection - the projection of the 'projected geo' space, in which the 'toProjectedGeo()' methods results its results.\n * @param internalProjectionToProjection - the postToGeo used to go from the internal projection to the projection.\n * @param projectionToInternalProjection - the preToResource function used to go from the projection to the internal projection.\n */\nexport class ProjectedGcpTransformer extends GcpTransformer {\n    internalProjection;\n    projection;\n    internalProjectionToProjection;\n    projectionToInternalProjection;\n    lonLatToProjection;\n    projectionToLonLat;\n    /**\n     * Create a ProjectedGcpTransformer\n     *\n     * @param gcps - An array of Ground Control Points (GCPs) in lon-lat 'EPSG:4326'\n     * @param type - The transformation type\n     * @param partialProjectedGcpTransformerOptions - Projected GCP Transformer options\n     */ constructor(gcps, type = 'polynomial', partialProjectedGcpTransformerOptions) {\n        const projectedGcpTransformerOptions = mergeOptionsUnlessUndefined(defaultProjectedGcpTransformerOptions, partialProjectedGcpTransformerOptions);\n        const internalProjectionToProjectionConverter = proj4(projectedGcpTransformerOptions.internalProjection.definition, projectedGcpTransformerOptions.projection.definition);\n        const postToGeo = internalProjectionToProjectionConverter.forward;\n        const preToResource = internalProjectionToProjectionConverter.inverse;\n        const lonLatToProjectionConverter = proj4(lonLatProjection.definition, projectedGcpTransformerOptions.projection.definition);\n        const lonLatToProjection = lonLatToProjectionConverter.forward;\n        const projectionToLonlat = lonLatToProjectionConverter.inverse;\n        const partialGcpTransformerOptions = {\n            ...partialProjectedGcpTransformerOptions,\n            postToGeo,\n            preToResource\n        };\n        gcps = gcps\n            // Allow incomplete GCPs, but filter them out\n            .filter((gcp) => gcp.geo && gcp.resource)\n            .map((gcp) => ({\n            resource: gcp.resource,\n            geo: lonLatToProjection(gcp.geo)\n        }));\n        super(gcps, type, partialGcpTransformerOptions);\n        this.internalProjection = projectedGcpTransformerOptions.internalProjection;\n        this.projection = projectedGcpTransformerOptions.projection;\n        this.internalProjectionToProjection = postToGeo;\n        this.projectionToInternalProjection = preToResource;\n        this.lonLatToProjection = lonLatToProjection;\n        this.projectionToLonLat = projectionToLonlat;\n    }\n    /**\n     * Get GCPs as they were inputed to the GCP Transformer.\n     *\n     * For a Projected GCP Transformer, these are the GCPs in projected coordinates.\n     */\n    get gcps() {\n        return super.gcps;\n    }\n    /**\n     * Get GCPs in interal projected coordinates.\n     */\n    get lonlatGcps() {\n        return this.projectedGcps.map(({ resource, geo }) => ({\n            resource,\n            geo: this.projectionToLonLat(geo)\n        }));\n    }\n    /**\n     * Get GCPs in interal projected coordinates.\n     */\n    get interalProjectedGcps() {\n        return this.projectedGcps.map(({ resource, geo }) => ({\n            resource,\n            geo: this.projectionToInternalProjection(geo)\n        }));\n    }\n    /**\n     * Get GCPs in projected coordinates.\n     */\n    get projectedGcps() {\n        return this.gcps;\n    }\n    /**\n     * Transform a geometry from resource space to projected geo space\n     *\n     * @param resourceGeometry - Geometry to transform\n     * @param partialProjectedGcpTransformOptions - Projected GCP Transform options\n     * @param gcpToP - Return type function\n     * @returns Input geometry transformed to projected geo space\n     */\n    transformToProjectedGeo(resourceGeometry, partialProjectedGcpTransformOptions, gcpToP) {\n        const partialGcpTransformOptions = projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection, partialProjectedGcpTransformOptions);\n        return super.transformToGeo(resourceGeometry, partialGcpTransformOptions, gcpToP);\n    }\n    /**\n     * Transform a geometry from resource space to geo space\n     *\n     * @param resourceGeometry - Geometry to transform\n     * @param partialProjectedGcpTransformOptions - Projected GCP Transform options\n     * @param gcpToP - Return type function\n     * @returns Input geometry transformed to projected geo space\n     */\n    transformToGeo(resourceGeometry, partialProjectedGcpTransformOptions, gcpToP) {\n        return this.transformToProjectedGeo(resourceGeometry, mergePartialOptions(partialProjectedGcpTransformOptions, {\n            projection: lonLatProjection\n        }), gcpToP);\n    }\n    /**\n     * Transform a geometry from projected geo space to resource space\n     *\n     * @param projectedGeoGeometry - Geometry to transform\n     * @param partialProjectedGcpTransformOptions - Projected GCP Transform options\n     * @param gcpToP - Return type function\n     * @returns Input geometry transformed to resource space\n     */\n    transformToResource(projectedGeoGeometry, partialProjectedGcpTransformOptions, gcpToP) {\n        const partialGcpTransformOptions = projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection, partialProjectedGcpTransformOptions);\n        return super.transformToResource(projectedGeoGeometry, partialGcpTransformOptions, gcpToP);\n    }\n    isNonWarping() {\n        return (isEqualProjection(this.projection, this.internalProjection) === true &&\n            nonWarpingTransformationTypes.includes(this.type));\n    }\n    /**\n     * Get the resolution of the toProjectedGeo transformation in resource space, within a given bbox.\n     *\n     * This informs you in how fine the warping is, in resource space.\n     * It can be useful e.g. to create a triangulation in resource space\n     * that is fine enough for this warping or set the minSourceDistance options.\n     *\n     * It is obtained by transforming toProjectedGeo two linestring,\n     * namely the horizontal and vertical midlines of the given bbox.\n     * The toProjectedGeo transformation will refine these lines:\n     * it will break them in small enough pieces to obtain a near continuous result.\n     *\n     * Resolution returned in the length of the shortest piece, measured in resource coordinates,\n     * or undefined if no refinements were needed.\n     *\n     * @param resourceBbox - BBox in resource space where the resolution is requested, or undefined to get this from the GCPs\n     * @param partialGcpTransformOptions - GCP Transform options to consider during the transformation\n     * @returns Resolution of the toProjectedGeo transformation in resource space\n     */\n    getToProjectedGeoTransformationResolution(resourceBbox, partialProjectedGcpTransformOptions) {\n        const partialGcpTransformOptions = projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection, partialProjectedGcpTransformOptions);\n        return super.getToGeoTransformationResolution(resourceBbox, partialGcpTransformOptions);\n    }\n    /**\n     * Get the resolution of the toGeo transformation in resource space, within a given bbox.\n     *\n     * This informs you in how fine the warping is, in resource space.\n     * It can be useful e.g. to create a triangulation in resource space\n     * that is fine enough for this warping or set the minSourceDistance options.\n     *\n     * It is obtained by transforming toGeo two linestring,\n     * namely the horizontal and vertical midlines of the given bbox.\n     * The toGeo transformation will refine these lines:\n     * it will break them in small enough pieces to obtain a near continuous result.\n     *\n     * Resolution returned in the length of the shortest piece, measured in resource coordinates,\n     * or undefined if no refinements were needed.\n     *\n     * @param resourceBbox - BBox in resource space where the resolution is requested, or undefined to get this from the GCPs\n     * @param partialGcpTransformOptions - GCP Transform options to consider during the transformation\n     * @returns Resolution of the toGeo transformation in resource space\n     */\n    getToGeoTransformationResolution(resourceBbox, partialProjectedGcpTransformOptions) {\n        return this.getToProjectedGeoTransformationResolution(resourceBbox, mergePartialOptions(partialProjectedGcpTransformOptions, {\n            projection: lonLatProjection\n        }));\n    }\n    /**\n     * Get the resolution of the toResource transformation in projected geo space, within a given bbox.\n     *\n     * This informs you in how fine the warping is, in projected geo space.\n     * It can be useful e.g. to create a triangulation in projected geo space\n     * that is fine enough for this warping or set the minDestionationDistance options.\n     *\n     * It is obtained by transforming toResource two linestring,\n     * namely the horizontal and vertical midlines of the given bbox.\n     * The toResource transformation will refine these lines:\n     * it will break them in small enough pieces to obtain a near continuous result.\n     *\n     * Resolution returned in the length of the shortest piece, measured in internal projected geo coordinates,\n     * or undefined if no refinements were needed.\n     *\n     * @param projectedGeoBbox - BBox in projected geo space where the resolution is requested, or undefined to get this from the GCPs\n     * @param partialGcpTransformOptions - GCP Transform options to consider during the transformation\n     * @returns Resolution of the toResource transformation in internal projected geo space\n     */\n    getToResourceTransformationResolution(projectedGeoBbox, partialProjectedGcpTransformOptions) {\n        const partialGcpTransformOptions = projectedGcpTransformOptionsToGcpTransformOptions(this.internalProjection, partialProjectedGcpTransformOptions);\n        return super.getToResourceTransformationResolution(projectedGeoBbox, partialGcpTransformOptions);\n    }\n    /**\n     * Create a Projected GCP Transformer from a Georeferenced Map\n     *\n     * @param georeferencedMap - A Georeferenced Map\n     * @param options - Options, including Projected GCP Transformer Options, and a transformation type to overrule the type defined in the Georeferenced Map\n     * @returns A Projected GCP Transformer\n     */\n    static fromGeoreferencedMap(georeferencedMap, options) {\n        const georeferencedMapInput = {\n            transformationType: georeferencedMap.transformation?.type,\n            internalProjection: georeferencedMap.resourceCrs\n        };\n        options = mergeOptions(georeferencedMapInput, options);\n        return new ProjectedGcpTransformer(georeferencedMap.gcps, options.transformationType, options);\n    }\n    /**\n     * Set the projection.\n     *\n     * To transform 'toGeo' or 'toResource' to or from a different projection\n     * than set on a transformer's construction (but using the same internal projection)\n     * it's possible to specify the requested projection in the transform options.\n     *\n     * This way we circumvent a possibly expensive recomputation\n     * of the toGeo and/or toResource transformations.\n     *\n     * To do this more systematically, it's possible to set\n     * a projected gcp transformer's projection using this method.\n     *\n     * Combine this with a deep clone of the transformer instance\n     * to keep the original transformer as well.\n     *\n     * @returns this\n     */\n    static setProjection(projectedTransformer, projection) {\n        if (isEqualProjection(projection, projectedTransformer.projection)) {\n            return projectedTransformer;\n        }\n        const internalProjectionToProjectionConverter = proj4(projectedTransformer.internalProjection.definition, projection.definition);\n        const postToGeo = internalProjectionToProjectionConverter.forward;\n        const preToResource = internalProjectionToProjectionConverter.inverse;\n        const lonLatToProjectionConverter = proj4(lonLatProjection.definition, projection.definition);\n        const lonLatToProjection = lonLatToProjectionConverter.forward;\n        const projectionToLonLat = lonLatToProjectionConverter.inverse;\n        const partialGcpTransformerOptions = {\n            postToGeo,\n            preToResource\n        };\n        // Note: no need to change the GCPs!\n        // They have already been converted to the internal projection\n        // in the GCP Transformer constructor\n        projectedTransformer.setTransformerOptions(partialGcpTransformerOptions);\n        projectedTransformer.projection = projection;\n        projectedTransformer.internalProjectionToProjection = postToGeo;\n        projectedTransformer.projectionToInternalProjection = preToResource;\n        projectedTransformer.lonLatToProjection = lonLatToProjection;\n        projectedTransformer.projectionToLonLat = projectionToLonLat;\n        return projectedTransformer;\n    }\n}\n"],"names":["ProjectedGcpTransformer","GcpTransformer","gcps","type","partialProjectedGcpTransformerOptions","projectedGcpTransformerOptions","mergeOptionsUnlessUndefined","defaultProjectedGcpTransformerOptions","internalProjectionToProjectionConverter","proj4","postToGeo","preToResource","lonLatToProjectionConverter","lonLatProjection","lonLatToProjection","projectionToLonlat","partialGcpTransformerOptions","gcp","resource","geo","resourceGeometry","partialProjectedGcpTransformOptions","gcpToP","partialGcpTransformOptions","projectedGcpTransformOptionsToGcpTransformOptions","mergePartialOptions","projectedGeoGeometry","isEqualProjection","nonWarpingTransformationTypes","resourceBbox","projectedGeoBbox","georeferencedMap","options","georeferencedMapInput","mergeOptions","projectedTransformer","projection","projectionToLonLat"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs319.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./index.cjs330.js"),T=require("./index.cjs275.js"),G=require("./index.cjs217.js"),m=require("./index.cjs334.js"),g=require("./index.cjs360.js"),a=require("./index.cjs224.js"),c=require("./index.cjs361.js");class p extends g.BaseGcpTransformer{constructor(o,r="polynomial",e){const n=o.filter(t=>t.geo&&t.resource).map(c.gcpToGeneralGcp);e=G.mergePartialOptions({differentHandedness:!0},e),super(n,r,a.gcpTransformerOptionsToGeneralGcpTransformerOptions(e))}get gcps(){return this.generalGcpsInternal.map(c.generalGcpToGcp)}getTransformerOptions(){return this.transformerOptions}setTransformerOptions(o){this.transformerOptions=G.mergeOptions(this.transformerOptions,a.gcpTransformerOptionsToGeneralGcpTransformerOptions(o))}getToGeoTransformation(){return super.getForwardTransformationInternal()}getToResourceTransformation(){return super.getBackwardTransformationInternal()}transformToGeo(o,r,e=c.gcpToPointForToGeo){const n=s=>e(c.generalGcpToGcp(s)),t=a.gcpTransformOptionsToGeneralGcpTransformOptions(r);return super.transformForwardInternal(o,t,n)}transformToResource(o,r,e=c.gcpToPointForToResource){const n=s=>e(c.generalGcpToGcp(s)),t=a.gcpTransformOptionsToGeneralGcpTransformOptions(r);return super.transformBackwardInternal(o,t,n)}getToGeoTransformationResolution(o,r){const e=a.gcpTransformOptionsToGeneralGcpTransformOptions(r);return super.getForwardTransformationResolutionInternal(o,e)}getToResourceTransformationResolution(o,r){const e=a.gcpTransformOptionsToGeneralGcpTransformOptions(r);return super.getBackwardTransformationResolutionInternal(o,e)}static transformSvgToGeojson(o,r,e){const n=o.transformToGeo(m.svgGeometryToGeometry(r),e);return T.geometryToGeojsonGeometry(n)}static transformSvgStringToGeojsonFeatureCollection(o,r,e){const n=[];for(const t of m.stringToSvgGeometriesGenerator(r)){const s=this.transformSvgToGeojson(o,t,e);n.push(s)}return i.geojsonGeometriesToGeojsonFeatureCollection(n)}static transformGeojsonToSvg(o,r,e){const n=o.transformToResource(i.geojsonGeometryToGeometry(r),e);return T.geometryToSvgGeometry(n)}static transformGeojsonFeatureCollectionToSvgString(o,r,e){const n=[];for(const t of i.geojsonFeatureCollectionToGeojsonGeometries(r)){const s=this.transformGeojsonToSvg(o,t,e);n.push(s)}return m.svgGeometriesToSvgString(n)}static fromGeoreferencedMap(o,r){return new p(o.gcps,r?.transformationType||o.transformation?.type,r)}}exports.GcpTransformer=p;
+//# sourceMappingURL=index.cjs319.js.map

package/dist/index.cjs319.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs319.js","sources":["../../../node_modules/@allmaps/transform/dist/transformers/GcpTransformer.js"],"sourcesContent":["import { geojsonGeometryToGeometry, geojsonGeometriesToGeojsonFeatureCollection, geojsonFeatureCollectionToGeojsonGeometries, geometryToGeojsonGeometry, geometryToSvgGeometry, stringToSvgGeometriesGenerator, svgGeometriesToSvgString, svgGeometryToGeometry, mergePartialOptions, mergeOptions } from '@allmaps/stdlib';\nimport { BaseGcpTransformer } from './BaseGcpTransformer.js';\nimport { gcpTransformerOptionsToGeneralGcpTransformerOptions, gcpTransformOptionsToGeneralGcpTransformOptions } from '../shared/transform-functions.js';\nimport { gcpToGeneralGcp, gcpToPointForToGeo, gcpToPointForToResource, generalGcpToGcp } from '../shared/conversion-functions.js';\n/**\n * Class for Ground Control Point Transformers.\n *\n * A GCP Transformer can transform input geometries between 'resource' and 'geo' spaces.\n *\n * It does this using a transformation (of a certain type) built from\n * a set of Ground Control Points (with coordinates in\n * resource and geo space) and a transformation type.\n *\n * It has a method to transform 'toGeo' (from resource to geo space)\n * and 'toResource' (from geo to resource space),\n *\n * This class differs from the GeneralGcpTransformer class in that\n * it specifically handles the typical Allmaps case where:\n * - We read in Ground Control Points using the Gcp type, with `resource` and `geo` fields.\n * - We use the terms 'toGeo' for the 'forward' transformation and 'toResource' for the 'backward' transformation.\n * - The `differentHandedness` setting is `true` by default, since we expect the resource coordinates to identify pixels on an image, with origin in the top left and the y-axis pointing down.\n * */\nexport class GcpTransformer extends BaseGcpTransformer {\n    /**\n     * Create a GcpTransformer\n     *\n     * @param gcps - An array of Ground Control Points (GCPs)\n     * @param type - The transformation type\n     * @param partialGcpTransformerOptions - GCP Transformer options\n     */ constructor(gcps, type = 'polynomial', partialGcpTransformerOptions) {\n        const generalGcps = gcps\n            // Allow incomplete GCPs, but filter them out\n            .filter((gcp) => gcp.geo && gcp.resource)\n            .map(gcpToGeneralGcp);\n        partialGcpTransformerOptions = mergePartialOptions({ differentHandedness: true }, partialGcpTransformerOptions);\n        super(generalGcps, type, gcpTransformerOptionsToGeneralGcpTransformerOptions(partialGcpTransformerOptions));\n    }\n    /**\n     * Get GCPs as they were inputed to the GCP Transformer.\n     */\n    get gcps() {\n        return this.generalGcpsInternal.map(generalGcpToGcp);\n    }\n    /**\n     * Get the transformer options.\n     */\n    getTransformerOptions() {\n        return this.transformerOptions;\n    }\n    /**\n     * Set the transformer options.\n     *\n     * Use with caution, especially for options that have effects in the constructor.\n     */\n    setTransformerOptions(partialGcpTransformerOptions) {\n        this.transformerOptions = mergeOptions(this.transformerOptions, gcpTransformerOptionsToGeneralGcpTransformerOptions(partialGcpTransformerOptions));\n    }\n    /**\n     * Get the forward transformation. Create if it doesn't exist yet.\n     */\n    getToGeoTransformation() {\n        return super.getForwardTransformationInternal();\n    }\n    /**\n     * Get the backward transformation. Create if it doesn't exist yet.\n     */\n    getToResourceTransformation() {\n        return super.getBackwardTransformationInternal();\n    }\n    /**\n     * Transform a geometry from resource space to geo space\n     *\n     * @param resourceGeometry - Geometry to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @param gcpToP - Return type function\n     * @returns Input geometry transformed to geo space\n     */\n    transformToGeo(resourceGeometry, partialGcpTransformOptions, gcpToP = gcpToPointForToGeo) {\n        const generalGcpToP = (generalGcp) => gcpToP(generalGcpToGcp(generalGcp));\n        const partialGeneralGcpTransformOptions = gcpTransformOptionsToGeneralGcpTransformOptions(partialGcpTransformOptions);\n        return super.transformForwardInternal(resourceGeometry, partialGeneralGcpTransformOptions, generalGcpToP);\n    }\n    /**\n     * Transform a geometry from geo space to resource space\n     *\n     * @param geoGeometry - Geometry to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @param gcpToP - Return type function\n     * @returns Input geometry transformed to resource space\n     */\n    transformToResource(geoGeometry, partialGcpTransformOptions, gcpToP = gcpToPointForToResource) {\n        const generalGcpToP = (generalGcp) => gcpToP(generalGcpToGcp(generalGcp));\n        const partialGeneralGcpTransformOptions = gcpTransformOptionsToGeneralGcpTransformOptions(partialGcpTransformOptions);\n        return super.transformBackwardInternal(geoGeometry, partialGeneralGcpTransformOptions, generalGcpToP);\n    }\n    /**\n     * Get the resolution of the toGeo transformation in resource space, within a given bbox.\n     *\n     * This informs you in how fine the warping is, in resource space.\n     * It can be useful e.g. to create a triangulation in resource space\n     * that is fine enough for this warping or set the minSourceDistance options.\n     *\n     * It is obtained by transforming toGeo two linestring,\n     * namely the horizontal and vertical midlines of the given bbox.\n     * The toGeo transformation will refine these lines:\n     * it will break them in small enough pieces to obtain a near continuous result.\n     *\n     * Resolution returned in the length of the shortest piece, measured in resource coordinates,\n     * or undefined if no refinements were needed.\n     *\n     * @param resourceBbox - BBox in resource space where the resolution is requested, or undefined to get this from the GCPs\n     * @param partialGcpTransformOptions - GCP Transform options to consider during the transformation\n     * @returns Resolution of the toGeo transformation in resource space\n     */\n    getToGeoTransformationResolution(resourceBbox, partialGcpTransformOptions) {\n        const partialGeneralGcpTransformOptions = gcpTransformOptionsToGeneralGcpTransformOptions(partialGcpTransformOptions);\n        return super.getForwardTransformationResolutionInternal(resourceBbox, partialGeneralGcpTransformOptions);\n    }\n    /**\n     * Get the resolution of the toResource transformation in geo space, within a given bbox.\n     *\n     * This informs you in how fine the warping is, in geo space.\n     * It can be useful e.g. to create a triangulation in geo space\n     * that is fine enough for this warping or set the minDestionationDistance options.\n     *\n     * It is obtained by transforming toResource two linestring,\n     * namely the horizontal and vertical midlines of the given bbox.\n     * The toResource transformation will refine these lines:\n     * it will break them in small enough pieces to obtain a near continuous result.\n     *\n     * Resolution returned in the length of the shortest piece, measured in geo coordinates,\n     * or undefined if no refinements were needed.\n     *\n     * @param geoBbox - BBox in geo space where the resolution is requested, or undefined to get this from the GCPs\n     * @param partialGcpTransformOptions - GCP Transform options to consider during the transformation\n     * @returns Resolution of the toResource transformation in geo space\n     */\n    getToResourceTransformationResolution(geoBbox, partialGcpTransformOptions) {\n        const generalGcpTransformOptions = gcpTransformOptionsToGeneralGcpTransformOptions(partialGcpTransformOptions);\n        return super.getBackwardTransformationResolutionInternal(geoBbox, generalGcpTransformOptions);\n    }\n    /**\n     * Transform an SVG geometry from resource space to geo space as a GeoJSON Geometry\n     *\n     * This is a shortcut method, available as static method in order not to overpopulate intellisense suggestions\n     * Note: Multi-geometries are not supported\n     *\n     * @param transformer - A GCP Transformer defining the transformation\n     * @param svgGeometry - SVG geometry to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @returns Input SVG geometry transformed to geo space, as a GeoJSON Geometry\n     */\n    static transformSvgToGeojson(transformer, svgGeometry, partialGcpTransformOptions) {\n        // This middle step is needed to make typescript happy\n        const transformedGeometry = transformer.transformToGeo(svgGeometryToGeometry(svgGeometry), partialGcpTransformOptions);\n        return geometryToGeojsonGeometry(transformedGeometry);\n    }\n    /**\n     * Transform an SVG string from resource space to geo space to a GeoJSON FeatureCollection\n     *\n     * This is a shortcut method, available as static method in order not to overpopulate intellisense suggestions\n     * Note: Multi-geometries are not supported\n     *\n     * @param transformer - A GCP Transformer defining the transformation\n     * @param svg - An SVG string to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @returns Input SVG string transformed to geo space, as a GeoJSON FeatureCollection\n     */\n    static transformSvgStringToGeojsonFeatureCollection(transformer, svg, partialGcpTransformOptions) {\n        const geojsonGeometries = [];\n        for (const svgGeometry of stringToSvgGeometriesGenerator(svg)) {\n            const geojsonGeometry = this.transformSvgToGeojson(transformer, svgGeometry, partialGcpTransformOptions);\n            geojsonGeometries.push(geojsonGeometry);\n        }\n        return geojsonGeometriesToGeojsonFeatureCollection(geojsonGeometries);\n    }\n    /**\n     * Transform a GeoJSON Geometry from geo space to resource space to a SVG geometry\n     *\n     * This is a shortcut method, available as static method in order not to overpopulate intellisense suggestions\n     * Note: Multi-geometries are not supported\n     *\n     * @param transformer - A GCP Transformer defining the transformation\n     * @param geojsonGeometry - GeoJSON Geometry to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @returns Input GeoJSON Geometry transform to resource space, as SVG geometry\n     */\n    static transformGeojsonToSvg(transformer, geojsonGeometry, partialGcpTransformOptions) {\n        // This middle step is needed to make typescript happy\n        const transformedGeometry = transformer.transformToResource(geojsonGeometryToGeometry(geojsonGeometry), partialGcpTransformOptions);\n        return geometryToSvgGeometry(transformedGeometry);\n    }\n    /**\n     * Transform a GeoJSON FeatureCollection from geo space to resource space to a SVG string\n     *\n     * This is a shortcut method, available as static method in order not to overpopulate intellisense suggestions\n     * Note: Multi-geometries are not supported\n     *\n     * @param transformer - A GCP Transformer defining the transformation\n     * @param geojson - GeoJSON FeatureCollection to transform\n     * @param partialGcpTransformOptions - GCP Transform options\n     * @returns Input GeoJSON FeaturesCollection transformed to resource space, as SVG string\n     */\n    static transformGeojsonFeatureCollectionToSvgString(transformer, geojson, partialGcpTransformOptions) {\n        const svgGeometries = [];\n        for (const geojsonGeometry of geojsonFeatureCollectionToGeojsonGeometries(geojson)) {\n            const svgGeometry = this.transformGeojsonToSvg(transformer, geojsonGeometry, partialGcpTransformOptions);\n            svgGeometries.push(svgGeometry);\n        }\n        return svgGeometriesToSvgString(svgGeometries);\n    }\n    /**\n     * Create a Projected GCP Transformer from a Georeferenced Map\n     *\n     * @param georeferencedMap - A Georeferenced Map\n     * @param options - Options, including GCP Transformer Options, and a transformation type to overrule the type defined in the Georeferenced Map\n     * @returns A Projected GCP Transformer\n     */\n    static fromGeoreferencedMap(georeferencedMap, options) {\n        return new GcpTransformer(georeferencedMap.gcps, options?.transformationType || georeferencedMap.transformation?.type, options);\n    }\n}\n"],"names":["GcpTransformer","BaseGcpTransformer","gcps","type","partialGcpTransformerOptions","generalGcps","gcp","gcpToGeneralGcp","mergePartialOptions","gcpTransformerOptionsToGeneralGcpTransformerOptions","generalGcpToGcp","mergeOptions","resourceGeometry","partialGcpTransformOptions","gcpToP","gcpToPointForToGeo","generalGcpToP","generalGcp","partialGeneralGcpTransformOptions","gcpTransformOptionsToGeneralGcpTransformOptions","geoGeometry","gcpToPointForToResource","resourceBbox","geoBbox","generalGcpTransformOptions","transformer","svgGeometry","transformedGeometry","svgGeometryToGeometry","geometryToGeojsonGeometry","svg","geojsonGeometries","stringToSvgGeometriesGenerator","geojsonGeometry","geojsonGeometriesToGeojsonFeatureCollection","geojsonGeometryToGeometry","geometryToSvgGeometry","geojson","svgGeometries","geojsonFeatureCollectionToGeojsonGeometries","svgGeometriesToSvgString","georeferencedMap","options"],"mappings":"+SAsBO,MAAMA,UAAuBC,EAAAA,kBAAmB,CAO/C,YAAYC,EAAMC,EAAO,aAAcC,EAA8B,CACrE,MAAMC,EAAcH,EAEf,OAAQI,GAAQA,EAAI,KAAOA,EAAI,QAAQ,EACvC,IAAIC,EAAAA,eAAe,EACxBH,EAA+BI,EAAAA,oBAAoB,CAAE,oBAAqB,EAAA,EAAQJ,CAA4B,EAC9G,MAAMC,EAAaF,EAAMM,EAAAA,oDAAoDL,CAA4B,CAAC,CAC9G,CAIA,IAAI,MAAO,CACP,OAAO,KAAK,oBAAoB,IAAIM,iBAAe,CACvD,CAIA,uBAAwB,CACpB,OAAO,KAAK,kBAChB,CAMA,sBAAsBN,EAA8B,CAChD,KAAK,mBAAqBO,eAAa,KAAK,mBAAoBF,EAAAA,oDAAoDL,CAA4B,CAAC,CACrJ,CAIA,wBAAyB,CACrB,OAAO,MAAM,iCAAA,CACjB,CAIA,6BAA8B,CAC1B,OAAO,MAAM,kCAAA,CACjB,CASA,eAAeQ,EAAkBC,EAA4BC,EAASC,EAAAA,mBAAoB,CACtF,MAAMC,EAAiBC,GAAeH,EAAOJ,EAAAA,gBAAgBO,CAAU,CAAC,EAClEC,EAAoCC,EAAAA,gDAAgDN,CAA0B,EACpH,OAAO,MAAM,yBAAyBD,EAAkBM,EAAmCF,CAAa,CAC5G,CASA,oBAAoBI,EAAaP,EAA4BC,EAASO,EAAAA,wBAAyB,CAC3F,MAAML,EAAiBC,GAAeH,EAAOJ,EAAAA,gBAAgBO,CAAU,CAAC,EAClEC,EAAoCC,EAAAA,gDAAgDN,CAA0B,EACpH,OAAO,MAAM,0BAA0BO,EAAaF,EAAmCF,CAAa,CACxG,CAoBA,iCAAiCM,EAAcT,EAA4B,CACvE,MAAMK,EAAoCC,EAAAA,gDAAgDN,CAA0B,EACpH,OAAO,MAAM,2CAA2CS,EAAcJ,CAAiC,CAC3G,CAoBA,sCAAsCK,EAASV,EAA4B,CACvE,MAAMW,EAA6BL,EAAAA,gDAAgDN,CAA0B,EAC7G,OAAO,MAAM,4CAA4CU,EAASC,CAA0B,CAChG,CAYA,OAAO,sBAAsBC,EAAaC,EAAab,EAA4B,CAE/E,MAAMc,EAAsBF,EAAY,eAAeG,EAAAA,sBAAsBF,CAAW,EAAGb,CAA0B,EACrH,OAAOgB,EAAAA,0BAA0BF,CAAmB,CACxD,CAYA,OAAO,6CAA6CF,EAAaK,EAAKjB,EAA4B,CAC9F,MAAMkB,EAAoB,CAAA,EAC1B,UAAWL,KAAeM,iCAA+BF,CAAG,EAAG,CAC3D,MAAMG,EAAkB,KAAK,sBAAsBR,EAAaC,EAAab,CAA0B,EACvGkB,EAAkB,KAAKE,CAAe,CAC1C,CACA,OAAOC,EAAAA,4CAA4CH,CAAiB,CACxE,CAYA,OAAO,sBAAsBN,EAAaQ,EAAiBpB,EAA4B,CAEnF,MAAMc,EAAsBF,EAAY,oBAAoBU,EAAAA,0BAA0BF,CAAe,EAAGpB,CAA0B,EAClI,OAAOuB,EAAAA,sBAAsBT,CAAmB,CACpD,CAYA,OAAO,6CAA6CF,EAAaY,EAASxB,EAA4B,CAClG,MAAMyB,EAAgB,CAAA,EACtB,UAAWL,KAAmBM,8CAA4CF,CAAO,EAAG,CAChF,MAAMX,EAAc,KAAK,sBAAsBD,EAAaQ,EAAiBpB,CAA0B,EACvGyB,EAAc,KAAKZ,CAAW,CAClC,CACA,OAAOc,EAAAA,yBAAyBF,CAAa,CACjD,CAQA,OAAO,qBAAqBG,EAAkBC,EAAS,CACnD,OAAO,IAAI1C,EAAeyC,EAAiB,KAAMC,GAAS,oBAAsBD,EAAiB,gBAAgB,KAAMC,CAAO,CAClI,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs320.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function n(r,t,o){let e;if(typeof o=="function"?e=await o(r,t):e=await fetch(r,t),!e.ok){const s=await e.json();throw s&&s.error?new Error(s.error):e.statusText?new Error(e.statusText):e.status===404?new Error(`Not found: ${r} (404)`):e.status===500?new Error("Internal server error (500)"):new Error(`Failed to fetch: ${r} (${e.status})`)}return e}async function a(r,t,o){return await(await n(r,t,o)).json()}async function f(r,t,o){return await a(`${r}/info.json`,t,o)}exports.fetchImageInfo=f;exports.fetchJson=a;exports.fetchUrl=n;
+//# sourceMappingURL=index.cjs320.js.map

package/dist/index.cjs320.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs320.js","sources":["../../../node_modules/@allmaps/stdlib/dist/fetch.js"],"sourcesContent":["export async function fetchUrl(input, init, fetchFn) {\n    let response;\n    if (typeof fetchFn === 'function') {\n        response = await fetchFn(input, init);\n    }\n    else {\n        response = await fetch(input, init);\n    }\n    if (!response.ok) {\n        const json = await response.json();\n        if (json && json.error) {\n            throw new Error(json.error);\n        }\n        else if (response.statusText) {\n            throw new Error(response.statusText);\n        }\n        else if (response.status === 404) {\n            throw new Error(`Not found: ${input} (404)`);\n        }\n        else if (response.status === 500) {\n            throw new Error('Internal server error (500)');\n        }\n        else {\n            throw new Error(`Failed to fetch: ${input} (${response.status})`);\n        }\n    }\n    return response;\n}\nexport async function fetchJson(input, init, fetchFn) {\n    const response = await fetchUrl(input, init, fetchFn);\n    return await response.json();\n}\nexport async function fetchImageInfo(imageUri, init, fetchFn) {\n    return await fetchJson(`${imageUri}/info.json`, init, fetchFn);\n}\nexport async function fetchImageBitmap(input, init, fetchFn) {\n    const response = await fetchUrl(input, init, fetchFn);\n    const blob = await response.blob();\n    return await createImageBitmap(blob);\n}\n"],"names":["fetchUrl","input","init","fetchFn","response","json","fetchJson","fetchImageInfo","imageUri"],"mappings":"gFAAA,eAAsBA,EAASC,EAAOC,EAAMC,EAAS,CACjD,IAAIC,EAOJ,GANI,OAAOD,GAAY,WACnBC,EAAW,MAAMD,EAAQF,EAAOC,CAAI,EAGpCE,EAAW,MAAM,MAAMH,EAAOC,CAAI,EAElC,CAACE,EAAS,GAAI,CACd,MAAMC,EAAO,MAAMD,EAAS,KAAA,EAC5B,MAAIC,GAAQA,EAAK,MACP,IAAI,MAAMA,EAAK,KAAK,EAErBD,EAAS,WACR,IAAI,MAAMA,EAAS,UAAU,EAE9BA,EAAS,SAAW,IACnB,IAAI,MAAM,cAAcH,CAAK,QAAQ,EAEtCG,EAAS,SAAW,IACnB,IAAI,MAAM,6BAA6B,EAGvC,IAAI,MAAM,oBAAoBH,CAAK,KAAKG,EAAS,MAAM,GAAG,CAExE,CACA,OAAOA,CACX,CACA,eAAsBE,EAAUL,EAAOC,EAAMC,EAAS,CAElD,OAAO,MADU,MAAMH,EAASC,EAAOC,EAAMC,CAAO,GAC9B,KAAA,CAC1B,CACA,eAAsBI,EAAeC,EAAUN,EAAMC,EAAS,CAC1D,OAAO,MAAMG,EAAU,GAAGE,CAAQ,aAAcN,EAAMC,CAAO,CACjE","x_google_ignoreList":[0]}

package/dist/index.cjs321.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function f(t,g,r,e=()=>!0,o=()=>!0){if(t.has(g)&&e(t.get(g)))return t.get(g);{const u=r();return o(u)&&t.set(g,u),u}}function l(t,g,r,e,o=()=>!0,u=()=>!0){if(t.get(g)?.has(r)&&o(t.get(g)?.get(r)))return t.get(g)?.get(r);{const n=e();return u(n)&&(t.get(g)||t.set(g,new Map),t.get(g)?.set(r,n)),n}}function m(t,g,r,e,o,u,n,s=()=>!0,p=()=>!0){if(t.get(g)?.get(r)?.get(e)?.get(o)?.has(u)&&s(t.get(g)?.get(r)?.get(e)?.get(o)?.get(u)))return t.get(g)?.get(r)?.get(e)?.get(o)?.get(u);{const i=n();return p(i)&&(t.get(g)||t.set(g,new Map),t.get(g)?.get(r)||t.get(g)?.set(r,new Map),t.get(g)?.get(r)?.get(e)||t.get(g)?.get(r)?.set(e,new Map),t.get(g)?.get(r)?.get(e)?.get(o)||t.get(g)?.get(r)?.get(e)?.set(o,new Map),t.get(g)?.get(r)?.get(e)?.get(o)?.set(u,i)),i}}exports.getPropertyFromCacheOrComputation=f;exports.getPropertyFromDoubleCacheOrComputation=l;exports.getPropertyFromQuintupleCacheOrComputation=m;
+//# sourceMappingURL=index.cjs321.js.map

package/dist/index.cjs321.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs321.js","sources":["../../../node_modules/@allmaps/stdlib/dist/cache.js"],"sourcesContent":["export function getPropertyFromCacheOrComputation(cache, key, computation, checkUse = () => true, checkStore = () => true) {\n    if (cache.has(key) && checkUse(cache.get(key))) {\n        return cache.get(key);\n    }\n    else {\n        const result = computation();\n        if (checkStore(result)) {\n            cache.set(key, result);\n        }\n        return result;\n    }\n}\nexport function getPropertyFromDoubleCacheOrComputation(cache, key0, key1, computation, checkUse = () => true, checkStore = () => true) {\n    if (cache.get(key0)?.has(key1) && checkUse(cache.get(key0)?.get(key1))) {\n        return cache.get(key0)?.get(key1);\n    }\n    else {\n        const result = computation();\n        if (checkStore(result)) {\n            if (!cache.get(key0)) {\n                cache.set(key0, new Map());\n            }\n            cache.get(key0)?.set(key1, result);\n        }\n        return result;\n    }\n}\nexport function getPropertyFromTripleCacheOrComputation(cache, key0, key1, key2, computation, checkUse = () => true, checkStore = () => true) {\n    if (cache.get(key0)?.get(key1)?.has(key2) &&\n        checkUse(cache.get(key0)?.get(key1)?.get(key2))) {\n        return cache.get(key0)?.get(key1)?.get(key2);\n    }\n    else {\n        const result = computation();\n        if (checkStore(result)) {\n            if (!cache.get(key0)) {\n                cache.set(key0, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)) {\n                cache.get(key0)?.set(key1, new Map());\n            }\n            cache.get(key0)?.get(key1)?.set(key2, result);\n        }\n        return result;\n    }\n}\nexport function getPropertyFromQuadrupleCacheOrComputation(cache, key0, key1, key2, key3, computation, checkUse = () => true, checkStore = () => true) {\n    if (cache.get(key0)?.get(key1)?.get(key2)?.has(key3) &&\n        checkUse(cache.get(key0)?.get(key1)?.get(key2)?.get(key3))) {\n        return cache.get(key0)?.get(key1)?.get(key2)?.get(key3);\n    }\n    else {\n        const result = computation();\n        if (checkStore(result)) {\n            if (!cache.get(key0)) {\n                cache.set(key0, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)) {\n                cache.get(key0)?.set(key1, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)?.get(key2)) {\n                cache.get(key0)?.get(key1)?.set(key2, new Map());\n            }\n            cache.get(key0)?.get(key1)?.get(key2)?.set(key3, result);\n        }\n        return result;\n    }\n}\nexport function getPropertyFromQuintupleCacheOrComputation(cache, key0, key1, key2, key3, key4, computation, checkUse = () => true, checkStore = () => true) {\n    if (cache.get(key0)?.get(key1)?.get(key2)?.get(key3)?.has(key4) &&\n        checkUse(cache.get(key0)?.get(key1)?.get(key2)?.get(key3)?.get(key4))) {\n        return cache.get(key0)?.get(key1)?.get(key2)?.get(key3)?.get(key4);\n    }\n    else {\n        const result = computation();\n        if (checkStore(result)) {\n            if (!cache.get(key0)) {\n                cache.set(key0, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)) {\n                cache.get(key0)?.set(key1, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)?.get(key2)) {\n                cache.get(key0)?.get(key1)?.set(key2, new Map());\n            }\n            if (!cache.get(key0)?.get(key1)?.get(key2)?.get(key3)) {\n                cache.get(key0)?.get(key1)?.get(key2)?.set(key3, new Map());\n            }\n            cache.get(key0)?.get(key1)?.get(key2)?.get(key3)?.set(key4, result);\n        }\n        return result;\n    }\n}\n"],"names":["getPropertyFromCacheOrComputation","cache","key","computation","checkUse","checkStore","result","getPropertyFromDoubleCacheOrComputation","key0","key1","getPropertyFromQuintupleCacheOrComputation","key2","key3","key4"],"mappings":"gFAAO,SAASA,EAAkCC,EAAOC,EAAKC,EAAaC,EAAW,IAAM,GAAMC,EAAa,IAAM,GAAM,CACvH,GAAIJ,EAAM,IAAIC,CAAG,GAAKE,EAASH,EAAM,IAAIC,CAAG,CAAC,EACzC,OAAOD,EAAM,IAAIC,CAAG,EAEnB,CACD,MAAMI,EAASH,EAAA,EACf,OAAIE,EAAWC,CAAM,GACjBL,EAAM,IAAIC,EAAKI,CAAM,EAElBA,CACX,CACJ,CACO,SAASC,EAAwCN,EAAOO,EAAMC,EAAMN,EAAaC,EAAW,IAAM,GAAMC,EAAa,IAAM,GAAM,CACpI,GAAIJ,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAKL,EAASH,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,CAAC,EACjE,OAAOR,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,EAE/B,CACD,MAAMH,EAASH,EAAA,EACf,OAAIE,EAAWC,CAAM,IACZL,EAAM,IAAIO,CAAI,GACfP,EAAM,IAAIO,EAAM,IAAI,GAAK,EAE7BP,EAAM,IAAIO,CAAI,GAAG,IAAIC,EAAMH,CAAM,GAE9BA,CACX,CACJ,CA0CO,SAASI,EAA2CT,EAAOO,EAAMC,EAAME,EAAMC,EAAMC,EAAMV,EAAaC,EAAW,IAAM,GAAMC,EAAa,IAAM,GAAM,CACzJ,GAAIJ,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIC,CAAI,GAC1DT,EAASH,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIC,CAAI,CAAC,EACpE,OAAOZ,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIC,CAAI,EAEhE,CACD,MAAMP,EAASH,EAAA,EACf,OAAIE,EAAWC,CAAM,IACZL,EAAM,IAAIO,CAAI,GACfP,EAAM,IAAIO,EAAM,IAAI,GAAK,EAExBP,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAC1BR,EAAM,IAAIO,CAAI,GAAG,IAAIC,EAAM,IAAI,GAAK,EAEnCR,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GACrCV,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,EAAM,IAAI,GAAK,EAE9CV,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,CAAI,GAChDX,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,EAAM,IAAI,GAAK,EAE9DX,EAAM,IAAIO,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIE,CAAI,GAAG,IAAIC,CAAI,GAAG,IAAIC,EAAMP,CAAM,GAE/DA,CACX,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs322.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const F=require("./index.cjs229.js"),l=require("./index.cjs230.js"),d=require("./index.cjs231.js"),w=require("./index.cjs423.js"),S=require("./index.cjs424.js"),m=require("./index.cjs425.js"),j=require("./index.cjs426.js"),z="image";function q(p,e){if(e?.preferredFormats){const n=new Set(p),i=e.preferredFormats.find(o=>n.has(o.toLowerCase()));if(i)return i.toLowerCase()}return"jpg"}class A{embedded=!0;uri;type=z;maxWidth;maxHeight;maxArea;supportsAnyRegionAndSize;supportedFormats;preferredFormats;width;height;majorVersion;constructor(e,n){const{parsedCanvas:i}=n||{};let o,r;if(i&&"service"in e){const s=e;let t,a;if(Array.isArray(s.service)?s.service.forEach(h=>{try{const g=m.getMajorIiifVersionFromImageService(h);(!a||g>a)&&(a=g,t=h)}catch{}}):t=s.service,!t)throw new Error("Unsupported IIIF Image Service");if("@id"in t)this.uri=t["@id"];else if("id"in t)this.uri=t.id;else throw new Error("Unsupported IIIF Image Service");if("type"in t&&t.type==="ImageService3")this.majorVersion=3;else if("type"in t&&t.type==="ImageService2"||"@type"in t&&t["@type"]==="ImageService2"||"@context"in t&&t["@context"]===d.Image2ContextString)this.majorVersion=2;else if("@context"in t&&(t["@context"]===l.Image1ContextString||t["@context"]===l.Image1ContextStringIncorrect))this.majorVersion=1;else if("profile"in t){let h;if(Array.isArray(t.profile)&&t.profile.length>0)h=t.profile[0];else if(typeof t.profile=="string")h=t.profile;else throw new Error("Unsupported IIIF Image Service");h.match(l.image1ProfileUriRegex)?this.majorVersion=1:h.match(d.image2ProfileUriRegex)?this.majorVersion=2:this.majorVersion=3}else throw new Error("Unsupported IIIF Image Service");if("profile"in t){const h=m.getProfileProperties(t);this.supportsAnyRegionAndSize=h.supportsAnyRegionAndSize,this.maxWidth=h.maxWidth,this.maxHeight=h.maxHeight,this.maxArea=h.maxArea,this.supportedFormats=m.getSupportedFormats(t)}else this.supportsAnyRegionAndSize=!1,this.supportedFormats=["jpg"];t.width&&(o=t.width),t.height&&(r=t.height)}else{if("@id"in e)this.uri=e["@id"];else if("id"in e)this.uri=e.id;else throw new Error("Unsupported IIIF Image");if("type"in e&&e.type==="ImageService3")this.majorVersion=3;else if("@type"in e&&e["@type"]==="iiif:Image"||"@context"in e&&e["@context"]===d.Image2ContextString)this.majorVersion=2;else if("@context"in e&&e["@context"]===l.Image1ContextString)this.majorVersion=1;else throw new Error("Unsupported IIIF Image");if("profile"in e){const s=m.getProfileProperties(e);this.supportsAnyRegionAndSize=s.supportsAnyRegionAndSize,this.maxWidth=s.maxWidth,this.maxHeight=s.maxHeight,this.maxArea=s.maxArea,this.supportedFormats=m.getSupportedFormats(e)}else this.supportsAnyRegionAndSize=!1,this.supportedFormats=["jpg"];"preferredFormats"in e&&(this.preferredFormats=e.preferredFormats)}if(!o)if(i)o=i.width;else if(e.width!==void 0)o=e.width;else throw new Error("Width not present on either Canvas or Image Resource");if(!r)if(i)r=i.height;else if(e.height!==void 0)r=e.height;else throw new Error("Height not present on either Canvas or Image Resource");this.width=o,this.height=r}getImageUrl(e,n){const{region:i,size:o}=e;let r,s,t,a,h;i?(h=`${i.x},${i.y},${i.width},${i.height}`,t=i.height,a=i.width):(h="full",t=this.height,a=this.width);let g;if(o){r=Math.round(o.width),s=Math.round(o.height);const R=String(r);let u=String(s);const x=a/t,I=s*x/x;this.majorVersion<=2&&s===Math.round(I)&&(u=""),g=`${R},${u}`}else r=this.width,s=this.height,g=this.majorVersion===2?"full":"max";const c=r*s;if(this.maxWidth!==void 0&&r>this.maxWidth)throw new Error(`Width of requested image is too large: ${r} > ${this.maxWidth}`);if(this.maxHeight!==void 0&&s>this.maxHeight)throw new Error(`Height of requested image is too large: ${s} > ${this.maxHeight}`);if(this.maxArea!==void 0&&c>this.maxArea)throw new Error(`Area of requested image is too large: ${c} > ${this.maxArea}`);const y=this.majorVersion===1?"native":"default",v=q(this.supportedFormats,n);return`${this.uri}/${h}/${g}/0/${y}.${v}`}getImageRequest(e,n="cover"){return S.getImageRequest({width:this.width,height:this.height},e,n,{supportsAnyRegionAndSize:this.supportsAnyRegionAndSize,maxWidth:this.maxWidth,maxHeight:this.maxHeight,maxArea:this.maxArea})}}class f extends A{source;tileZoomLevels;sizes;embedded=!1;constructor(e,n){super(e),this.source=n?.source;const i=m.getProfileProperties(e);let o;"tiles"in e&&(o=e.tiles),this.tileZoomLevels=w.getTileZoomLevels({width:this.width,height:this.height},o,i.supportsAnyRegionAndSize),"sizes"in e&&(this.sizes=e.sizes)}static parse(e,n){const{majorVersion:i,keepSource:o}=n||{};let r;return i===1?r=l.Image1Schema.parse(e):i===2?r=d.Image2Schema.parse(e):i===3?r=j.Image3Schema.parse(e):r=F.ImageSchema.parse(e),new f(r,o?{source:e}:{})}getTileImageRequest(e,n,i){return w.getTileImageRequest({width:this.width,height:this.height},e,n,i)}getImageRequest(e,n="cover"){return S.getImageRequest({width:this.width,height:this.height},e,n,{supportsAnyRegionAndSize:this.supportsAnyRegionAndSize,sizes:this.sizes,tileZoomLevels:this.tileZoomLevels,maxWidth:this.maxWidth,maxHeight:this.maxHeight,maxArea:this.maxArea})}}exports.EmbeddedImage=A;exports.Image=f;
+//# sourceMappingURL=index.cjs322.js.map

package/dist/index.cjs322.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs322.js","sources":["../../../node_modules/@allmaps/iiif-parser/dist/classes/image.js"],"sourcesContent":["import { Image1Schema, Image2Schema, Image3Schema, ImageSchema } from '../schemas/iiif.js';\nimport { Image1ContextString, Image1ContextStringIncorrect, image1ProfileUriRegex } from '../schemas/image.1.js';\nimport { Image2ContextString, image2ProfileUriRegex } from '../schemas/image.2.js';\nimport { getTileZoomLevels, getTileImageRequest } from '../lib/tiles.js';\nimport { getImageRequest } from '../lib/image-requests.js';\nimport { getProfileProperties, getMajorIiifVersionFromImageService, getSupportedFormats } from '../lib/profile.js';\nconst ImageTypeString = 'image';\nfunction getImageUrlFormat(supportedFormats, options) {\n    if (options?.preferredFormats) {\n        const supportedFormatSet = new Set(supportedFormats);\n        const preferredFormat = options.preferredFormats.find((format) => supportedFormatSet.has(format.toLowerCase()));\n        if (preferredFormat) {\n            return preferredFormat.toLowerCase();\n        }\n    }\n    return 'jpg';\n}\n/**\n * Parsed IIIF Image, embedded in a Canvas\n *\n * @property embedded - Whether the Image is embedded in a Canvas\n * @property type - Resource type, equals 'image'\n * @property uri - URI of Image\n * @property majorVersion - IIIF API version of Image\n * @property supportsAnyRegionAndSize - Whether the associated Image Service supports any region and size\n * @property supportedFormats - Array of supported image formats of the associated Image Service\n * @property maxWidth - Maximum width of the associated Image Service\n * @property maxHeight - Maximum height of the associated Image Service\n * @property maxArea - Maximum area of the associated Image Service\n * @property width - Width of Image\n * @property height - Height of Image\n */\nexport class EmbeddedImage {\n    embedded = true;\n    uri;\n    type = ImageTypeString;\n    maxWidth;\n    maxHeight;\n    maxArea;\n    supportsAnyRegionAndSize;\n    supportedFormats;\n    preferredFormats;\n    width;\n    height;\n    majorVersion;\n    constructor(parsedImage, options) {\n        const { parsedCanvas } = options || {};\n        let width;\n        let height;\n        if (parsedCanvas && 'service' in parsedImage) {\n            const parsedEmbeddedImage = parsedImage;\n            let imageService;\n            let majorVersion;\n            if (Array.isArray(parsedEmbeddedImage.service)) {\n                parsedEmbeddedImage.service.forEach((currentImageService) => {\n                    try {\n                        const currentMajorVersion = getMajorIiifVersionFromImageService(currentImageService);\n                        if (!majorVersion || currentMajorVersion > majorVersion) {\n                            majorVersion = currentMajorVersion;\n                            imageService = currentImageService;\n                        }\n                    }\n                    catch {\n                        // Ignore this error, throw error later if no valid image service is found\n                    }\n                });\n            }\n            else {\n                imageService = parsedEmbeddedImage.service;\n            }\n            if (!imageService) {\n                throw new Error('Unsupported IIIF Image Service');\n            }\n            if ('@id' in imageService) {\n                this.uri = imageService['@id'];\n            }\n            else if ('id' in imageService) {\n                this.uri = imageService.id;\n            }\n            else {\n                throw new Error('Unsupported IIIF Image Service');\n            }\n            if ('type' in imageService && imageService.type === 'ImageService3') {\n                this.majorVersion = 3;\n            }\n            else if (('type' in imageService && imageService.type === 'ImageService2') ||\n                ('@type' in imageService &&\n                    imageService['@type'] === 'ImageService2') ||\n                ('@context' in imageService &&\n                    imageService['@context'] === Image2ContextString)) {\n                this.majorVersion = 2;\n            }\n            else if ('@context' in imageService &&\n                (imageService['@context'] === Image1ContextString ||\n                    imageService['@context'] === Image1ContextStringIncorrect)) {\n                this.majorVersion = 1;\n            }\n            else if ('profile' in imageService) {\n                let profile;\n                if (Array.isArray(imageService.profile) &&\n                    imageService.profile.length > 0) {\n                    profile = imageService.profile[0];\n                }\n                else if (typeof imageService.profile === 'string') {\n                    profile = imageService.profile;\n                }\n                else {\n                    throw new Error('Unsupported IIIF Image Service');\n                }\n                if (profile.match(image1ProfileUriRegex)) {\n                    this.majorVersion = 1;\n                }\n                else if (profile.match(image2ProfileUriRegex)) {\n                    this.majorVersion = 2;\n                }\n                else {\n                    this.majorVersion = 3;\n                }\n            }\n            else {\n                throw new Error('Unsupported IIIF Image Service');\n            }\n            if ('profile' in imageService) {\n                const profileProperties = getProfileProperties(imageService);\n                this.supportsAnyRegionAndSize =\n                    profileProperties.supportsAnyRegionAndSize;\n                this.maxWidth = profileProperties.maxWidth;\n                this.maxHeight = profileProperties.maxHeight;\n                this.maxArea = profileProperties.maxArea;\n                this.supportedFormats = getSupportedFormats(imageService);\n            }\n            else {\n                this.supportsAnyRegionAndSize = false;\n                this.supportedFormats = ['jpg'];\n            }\n            if (imageService.width) {\n                width = imageService.width;\n            }\n            if (imageService.height) {\n                height = imageService.height;\n            }\n        }\n        else {\n            if ('@id' in parsedImage) {\n                this.uri = parsedImage['@id'];\n            }\n            else if ('id' in parsedImage) {\n                this.uri = parsedImage.id;\n            }\n            else {\n                throw new Error('Unsupported IIIF Image');\n            }\n            if ('type' in parsedImage && parsedImage.type === 'ImageService3') {\n                this.majorVersion = 3;\n            }\n            else if (('@type' in parsedImage && parsedImage['@type'] === 'iiif:Image') ||\n                ('@context' in parsedImage &&\n                    parsedImage['@context'] === Image2ContextString)) {\n                this.majorVersion = 2;\n            }\n            else if ('@context' in parsedImage &&\n                parsedImage['@context'] === Image1ContextString) {\n                this.majorVersion = 1;\n            }\n            else {\n                throw new Error('Unsupported IIIF Image');\n            }\n            if ('profile' in parsedImage) {\n                const profileProperties = getProfileProperties(parsedImage);\n                this.supportsAnyRegionAndSize =\n                    profileProperties.supportsAnyRegionAndSize;\n                this.maxWidth = profileProperties.maxWidth;\n                this.maxHeight = profileProperties.maxHeight;\n                this.maxArea = profileProperties.maxArea;\n                this.supportedFormats = getSupportedFormats(parsedImage);\n            }\n            else {\n                this.supportsAnyRegionAndSize = false;\n                this.supportedFormats = ['jpg'];\n            }\n            if ('preferredFormats' in parsedImage) {\n                this.preferredFormats = parsedImage.preferredFormats;\n            }\n        }\n        if (!width) {\n            if (parsedCanvas) {\n                width = parsedCanvas.width;\n            }\n            else if (parsedImage.width !== undefined) {\n                width = parsedImage.width;\n            }\n            else {\n                throw new Error('Width not present on either Canvas or Image Resource');\n            }\n        }\n        if (!height) {\n            if (parsedCanvas) {\n                height = parsedCanvas.height;\n            }\n            else if (parsedImage.height !== undefined) {\n                height = parsedImage.height;\n            }\n            else {\n                throw new Error('Height not present on either Canvas or Image Resource');\n            }\n        }\n        this.width = width;\n        this.height = height;\n    }\n    /**\n     * Generates a IIIF Image API URL for the requested region and size\n     * @param imageRequest - Image request object containing the desired region and size of the requested image\n     * @param options - Options for generating the requested image URL\n     * @returns Image API URL that can be used to fetch the requested image\n     */\n    getImageUrl(imageRequest, options) {\n        const { region, size } = imageRequest;\n        let width;\n        let height;\n        let regionHeight;\n        let regionWidth;\n        let urlRegion;\n        if (region) {\n            urlRegion = `${region.x},${region.y},${region.width},${region.height}`;\n            regionHeight = region.height;\n            regionWidth = region.width;\n        }\n        else {\n            urlRegion = 'full';\n            regionHeight = this.height;\n            regionWidth = this.width;\n        }\n        let urlSize;\n        if (size) {\n            width = Math.round(size.width);\n            height = Math.round(size.height);\n            const widthStr = String(width);\n            let heightStr = String(height);\n            const aspectRatio = regionWidth / regionHeight;\n            const aspectRatioWidth = height * aspectRatio;\n            const aspectRatioHeight = aspectRatioWidth / aspectRatio;\n            if (this.majorVersion <= 2) {\n                // In IIIF Image API 2.1 and below, use\n                // \"the w, syntax for images that should be scaled maintaining the aspect ratio\"\n                // In version 3, use \"w,h if the size requested does not require upscaling\"\n                // See:\n                // - https://iiif.io/api/image/2.1/#canonical-uri-syntax\n                // - https://iiif.io/api/image/3.0/#48-canonical-uri-syntax\n                // And see also:\n                // - https://www.jack-reed.com/2016/10/14/rounding-strategies-used-in-iiif.html\n                if (height === Math.round(aspectRatioHeight)) {\n                    heightStr = '';\n                }\n            }\n            urlSize = `${widthStr},${heightStr}`;\n        }\n        else {\n            width = this.width;\n            height = this.height;\n            urlSize = this.majorVersion === 2 ? 'full' : 'max';\n        }\n        const area = width * height;\n        if (this.maxWidth !== undefined) {\n            if (width > this.maxWidth) {\n                throw new Error(`Width of requested image is too large: ${width} > ${this.maxWidth}`);\n            }\n        }\n        if (this.maxHeight !== undefined) {\n            if (height > this.maxHeight) {\n                throw new Error(`Height of requested image is too large: ${height} > ${this.maxHeight}`);\n            }\n        }\n        if (this.maxArea !== undefined) {\n            if (area > this.maxArea) {\n                throw new Error(`Area of requested image is too large: ${area} > ${this.maxArea}`);\n            }\n        }\n        const quality = this.majorVersion === 1 ? 'native' : 'default';\n        const format = getImageUrlFormat(this.supportedFormats, options);\n        return `${this.uri}/${urlRegion}/${urlSize}/0/${quality}.${format}`;\n    }\n    getImageRequest(size, mode = 'cover') {\n        return getImageRequest({ width: this.width, height: this.height }, size, mode, {\n            supportsAnyRegionAndSize: this.supportsAnyRegionAndSize,\n            maxWidth: this.maxWidth,\n            maxHeight: this.maxHeight,\n            maxArea: this.maxArea\n        });\n    }\n}\n/**\n * Parsed IIIF Image\n * @property tileZoomLevels - Array of parsed tile zoom levels\n * @property sizes - Array of parsed sizes\n */\nexport class Image extends EmbeddedImage {\n    source;\n    tileZoomLevels;\n    sizes;\n    embedded = false;\n    constructor(parsedImage, options) {\n        super(parsedImage);\n        this.source = options?.source;\n        const profileProperties = getProfileProperties(parsedImage);\n        let tilesets;\n        if ('tiles' in parsedImage) {\n            tilesets = parsedImage.tiles;\n        }\n        this.tileZoomLevels = getTileZoomLevels({ width: this.width, height: this.height }, tilesets, profileProperties.supportsAnyRegionAndSize);\n        if ('sizes' in parsedImage) {\n            this.sizes = parsedImage.sizes;\n        }\n    }\n    /**\n     * Parses a IIIF image and returns a [Image](#image) containing the parsed version\n     * @param iiifImage - Source data of IIIF Image\n     * @param majorVersion - IIIF API version of Image. If not provided, it will be determined automatically\n     * @returns Parsed IIIF Image\n     * @static\n     */\n    static parse(iiifImage, parseOptions) {\n        const { majorVersion, keepSource } = parseOptions || {};\n        let parsedImage;\n        if (majorVersion === 1) {\n            parsedImage = Image1Schema.parse(iiifImage);\n        }\n        else if (majorVersion === 2) {\n            parsedImage = Image2Schema.parse(iiifImage);\n        }\n        else if (majorVersion === 3) {\n            parsedImage = Image3Schema.parse(iiifImage);\n        }\n        else {\n            parsedImage = ImageSchema.parse(iiifImage);\n        }\n        return new Image(parsedImage, keepSource ? { source: iiifImage } : {});\n    }\n    // TODO: rename this to getImageRequest\n    /**\n     * Returns a Image request object for a tile with the requested zoom level, column, and row\n     * @param zoomLevel - Desired zoom level of the requested tile\n     * @param column - Column of the requested tile\n     * @param row - Row of the requested tile\n     * @returns Image request object that can be used to fetch the requested tile\n     */\n    getTileImageRequest(zoomLevel, column, row) {\n        return getTileImageRequest({ width: this.width, height: this.height }, zoomLevel, column, row);\n    }\n    /**\n     * Returns a Image request object for the requested region and size\n     * @param size - Size of the requested thumbnail\n     * @param mode - Desired fit mode of the requested thumbnail\n     * @returns Image request object that can be used to fetch the requested thumbnail\n     */\n    getImageRequest(size, mode = 'cover') {\n        return getImageRequest({ width: this.width, height: this.height }, size, mode, {\n            supportsAnyRegionAndSize: this.supportsAnyRegionAndSize,\n            sizes: this.sizes,\n            tileZoomLevels: this.tileZoomLevels,\n            maxWidth: this.maxWidth,\n            maxHeight: this.maxHeight,\n            maxArea: this.maxArea\n        });\n    }\n}\n"],"names":["ImageTypeString","getImageUrlFormat","supportedFormats","options","supportedFormatSet","preferredFormat","format","EmbeddedImage","parsedImage","parsedCanvas","width","height","parsedEmbeddedImage","imageService","majorVersion","currentImageService","currentMajorVersion","getMajorIiifVersionFromImageService","Image2ContextString","Image1ContextString","Image1ContextStringIncorrect","profile","image1ProfileUriRegex","image2ProfileUriRegex","profileProperties","getProfileProperties","getSupportedFormats","imageRequest","region","size","regionHeight","regionWidth","urlRegion","urlSize","widthStr","heightStr","aspectRatio","aspectRatioHeight","area","quality","mode","getImageRequest","Image","tilesets","getTileZoomLevels","iiifImage","parseOptions","keepSource","Image1Schema","Image2Schema","Image3Schema","ImageSchema","zoomLevel","column","row","getTileImageRequest"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs323.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index.cjs427.js");var n=1,t=4;function o(e){return r(e,n|t)}module.exports=o;
+//# sourceMappingURL=index.cjs323.js.map

package/dist/index.cjs323.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs323.js","sources":["../../../node_modules/lodash-es/cloneDeep.js"],"sourcesContent":["import baseClone from './_baseClone.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nexport default cloneDeep;\n"],"names":["CLONE_DEEP_FLAG","CLONE_SYMBOLS_FLAG","cloneDeep","value","baseClone"],"mappings":"kDAGA,IAAIA,EAAkB,EAClBC,EAAqB,EAoBzB,SAASC,EAAUC,EAAO,CACxB,OAAOC,EAAUD,EAAOH,EAAkBC,CAAkB,CAC9D","x_google_ignoreList":[0]}

package/dist/index.cjs324.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const G=require("./index.cjs358.js"),N=require("./index.cjs218.js"),w=require("./index.cjs215.js"),c=require("./index.cjs275.js"),O=require("./index.cjs217.js"),t=require("./index.cjs359.js"),U=1e-4,K={steinerPoints:[],steinerPolygons:[],minimumTriangleAngle:U,computeInsideSteinerPolygons:!1};function j(i,p,_){const l=O.mergeOptions(K,_);i=c.conformPolygon(i);const R=w.polygonIsBboxRectangle(i);let P=l.steinerPolygons.map(e=>c.conformPolygon(e));const b=t.buildKDBushPointIndex(l.steinerPoints);i=t.splitPolygonLines(i,l.steinerPoints,b),P=P.map(e=>t.splitPolygonLines(e,l.steinerPoints,b));const y=t.preprocessPolygonForInsideCheck(i),B=l.steinerPoints.filter(e=>t.coordsInPolygonForInsidenessCheck(e[0],e[1],y));let u=[],m=[],d=[],f=[],h=[],q=[];p?(u=t.interpolatePolygon(i,p),d=P.map(e=>t.interpolatePolygon(e,p)),h=t.bboxToGridPoints(w.computeBbox(i),p),q=h.filter(e=>t.coordsInPolygonForInsidenessCheck(e[0],e[1],y))):(u=i,d=P),m=u.flat(),f=d.flat(2);const E=[...m,...q,...f,...B],r=[],S=new Map;for(const e of E){const n=`${e[0]},${e[1]}`;S.has(n)||(S.set(n,r.length),r.push(e))}const k=([e,n])=>{const s=S.get(`${e},${n}`);if(s===void 0)throw new Error(`Point not found in uniquePoints: [${e}, ${n}]`);return s},x=u.map(e=>e.map(k)),C=new Set(x.flat()),F=d.map(e=>e.map(n=>n.map(k))),A=[...x,...F.flat()].flatMap(e=>e.map((n,s)=>[n,e[(s+1)%e.length]])),L=new G(r.flat()),o=new N(L);o.delaunify(!0),o.constrainAll(A);let I=[],a=[];const M=[];for(let e=0;e<o.del.triangles.length;e+=3)I.push([o.del.triangles[e],o.del.triangles[e+1],o.del.triangles[e+2]]),a.push([r[o.del.triangles[e]],r[o.del.triangles[e+1]],r[o.del.triangles[e+2]]]),M.push(C.has(o.del.triangles[e])||C.has(o.del.triangles[e+1])||C.has(o.del.triangles[e+2]));let g=a.map(e=>c.midPoint(...e));const T=a.map((e,n)=>M[n]?(R?!0:t.coordsInPolygonForInsidenessCheck(g[n][0],g[n][1],y))&&c.triangleAngles(e).every(s=>s>=l.minimumTriangleAngle):!0);I=I.filter((e,n)=>T[n]),a=a.filter((e,n)=>T[n]),g=g.filter((e,n)=>T[n]);let $=[];const v=P.map(e=>c.closePolygon(e));if(l.computeInsideSteinerPolygons){const e=v.map(n=>t.preprocessPolygonForInsideCheck(n));$=a.map((n,s)=>t.coordsInPolygonsForInsidenessCheck(g[s][0],g[s][1],e)===!0)}return{interpolatedPolygon:u,interpolatedPolygonPoints:m,gridPoints:h,gridPointsInPolygon:q,interpolatedSteinerPolygons:d,interpolatedSteinerPolygonsPoints:f,uniquePoints:r,triangles:a,uniquePointIndexTriangles:I,uniquePointIndexInterpolatedPolygon:x,uniquePointIndexEdges:A,uniquePointIndexInterpolatedSteinerPolygons:F,insideSteinerPolygonsTriangles:$}}exports.interpolatePolygon=t.interpolatePolygon;exports.interpolateRing=t.interpolateRing;exports.triangulateToUnique=j;
+//# sourceMappingURL=index.cjs324.js.map

package/dist/index.cjs324.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs324.js","sources":["../../../node_modules/@allmaps/triangulate/dist/triangulate.js"],"sourcesContent":["import Delaunator from 'delaunator';\nimport Constrainautor from '@kninnug/constrainautor';\nimport { closePolygon, computeBbox, conformPolygon, mergeOptions, midPoint, polygonIsBboxRectangle, triangleAngles } from '@allmaps/stdlib';\nimport { bboxToGridPoints, interpolateRing, interpolatePolygon, coordsInPolygonForInsidenessCheck, preprocessPolygonForInsideCheck, coordsInPolygonsForInsidenessCheck, buildKDBushPointIndex, splitPolygonLines } from './shared.js';\nconst MINIMUM_TRIANGLE_ANGLE = 0.0001;\nconst defaultTriangulationOptions = {\n    steinerPoints: [],\n    steinerPolygons: [],\n    minimumTriangleAngle: MINIMUM_TRIANGLE_ANGLE,\n    computeInsideSteinerPolygons: false\n};\nexport { interpolateRing, interpolatePolygon };\n/**\n * Triangulate a polygon to triangles smaller then a distance\n *\n * Grid points are placed inside the polygon to obtain small, well conditioned triangles.\n *\n * @param polygon - Polygon\n * @param distance - Distance that conditions the triangles\n * @param triangulationOptions - Triangulation Options.\n * @returns Array of triangles partitioning the polygon\n */\nexport function triangulate(polygon, distance, triangulationOptions) {\n    {\n        const { triangles } = triangulateToUnique(polygon, distance, triangulationOptions);\n        return triangles;\n    }\n}\n/**\n * Triangulate a polygon to triangles smaller then a distance, and return them via unique points.\n *\n * Grid points are placed inside the polygon to obtain small, well conditioned triangles.\n *\n * This function returns the triangulation as an array of unique points, and triangles of indices refering to those unique points.\n *\n * @param polygon - Polygon\n * @param distance - Distance that conditions the triangles\n * @param partialOptions - Triangulation Options.\n * @returns Triangulation Object with uniquePointIndexTriangles and uniquePoints\n */\nexport function triangulateToUnique(polygon, distance, partialOptions) {\n    const options = mergeOptions(defaultTriangulationOptions, partialOptions);\n    // Conform polygon and Steiner polygons (this also checks if there are at least 3 points)\n    polygon = conformPolygon(polygon);\n    const polygonIsRectangle = polygonIsBboxRectangle(polygon);\n    let steinerPolygons = options.steinerPolygons.map((steinerPolygon) => conformPolygon(steinerPolygon));\n    // Split polygon and Steiner polygons using Steiner points\n    const steinerPointIndex = buildKDBushPointIndex(options.steinerPoints);\n    polygon = splitPolygonLines(polygon, options.steinerPoints, steinerPointIndex);\n    steinerPolygons = steinerPolygons.map((steinerPolygon) => splitPolygonLines(steinerPolygon, options.steinerPoints, steinerPointIndex));\n    // Preprocess polygon\n    const polygonForInsidenessCheck = preprocessPolygonForInsideCheck(polygon);\n    // Gather Steinerpoints\n    const steinerPointsInPolygon = options.steinerPoints.filter((point) => coordsInPolygonForInsidenessCheck(point[0], point[1], polygonForInsidenessCheck));\n    // Interpolate polygons and create grid based on distance\n    let interpolatedPolygon = [];\n    let interpolatedPolygonPoints = [];\n    let interpolatedSteinerPolygons = [];\n    let interpolatedSteinerPolygonsPoints = [];\n    let gridPoints = [];\n    let gridPointsInPolygon = [];\n    if (distance) {\n        // Interpolate polygon\n        interpolatedPolygon = interpolatePolygon(polygon, distance);\n        // Interpolate Steiner Polygons\n        interpolatedSteinerPolygons = steinerPolygons.map((steinerPolygon) => interpolatePolygon(steinerPolygon, distance));\n        // Add grid points inside the polygon\n        gridPoints = bboxToGridPoints(computeBbox(polygon), distance);\n        gridPointsInPolygon = gridPoints.filter((point) => coordsInPolygonForInsidenessCheck(point[0], point[1], polygonForInsidenessCheck));\n    }\n    else {\n        interpolatedPolygon = polygon;\n        interpolatedSteinerPolygons = steinerPolygons;\n    }\n    interpolatedPolygonPoints = interpolatedPolygon.flat();\n    interpolatedSteinerPolygonsPoints = interpolatedSteinerPolygons.flat(2);\n    // Gather all points and deduplicate to keep only unique points\n    // with map from points to their index in uniquePoints, and index getter\n    const allPoints = [\n        ...interpolatedPolygonPoints,\n        ...gridPointsInPolygon,\n        ...interpolatedSteinerPolygonsPoints,\n        ...steinerPointsInPolygon\n    ];\n    const uniquePoints = [];\n    const uniquePointIndexByPointString = new Map();\n    for (const point of allPoints) {\n        const key = `${point[0]},${point[1]}`;\n        if (!uniquePointIndexByPointString.has(key)) {\n            uniquePointIndexByPointString.set(key, uniquePoints.length);\n            uniquePoints.push(point);\n        }\n    }\n    const getPointIndex = ([x, y]) => {\n        const index = uniquePointIndexByPointString.get(`${x},${y}`);\n        if (index === undefined)\n            throw new Error(`Point not found in uniquePoints: [${x}, ${y}]`);\n        return index;\n    };\n    // Lookup point indices for the edges of the interpolated polygon\n    const uniquePointIndexInterpolatedPolygon = interpolatedPolygon.map((ring) => ring.map(getPointIndex));\n    const uniquePointIndexSetInterpolatedPolygon = new Set(uniquePointIndexInterpolatedPolygon.flat());\n    // Lookup point indices for the edges of the interpolated steiner polygons\n    const uniquePointIndexInterpolatedSteinerPolygons = interpolatedSteinerPolygons.map((polygon) => polygon.map((ring) => ring.map(getPointIndex)));\n    // Gather all constrained edges\n    // TODO: consider to make unique, but this could be very expensive and low chance of non-uniquess\n    const uniquePointIndexEdges = [\n        ...uniquePointIndexInterpolatedPolygon,\n        ...uniquePointIndexInterpolatedSteinerPolygons.flat()\n    ].flatMap((ring) => ring.map((uniquePointIndex, i) => [\n        uniquePointIndex,\n        ring[(i + 1) % ring.length]\n    ]));\n    // Initialize Delaunay triangulation\n    const delautator = new Delaunator(uniquePoints.flat());\n    // Constrain triangulation\n    // Note: instead of\n    // const constrainautor = new Constrainautor(delautator, uniquePointIndexEdges)\n    // which gives an error \"Constraining edge intersects point\" for small distances, e.g. maxDepth 7 on https://gist.githubusercontent.com/sammeltassen/fa3dbfaf4dfa800e00824478c4bd1928/raw/f182beac911e38b0a1d1eb420fbd54b4e6d2f2eb/nl-railway-map.json\n    // we perform a delaunify check first as proposed by\n    // https://github.com/kninnug/Constrainautor/issues/11#issuecomment-2571296247\n    // Keep an eye on proposed solutions, sinche the delaunify check is expensive\n    const constrainautor = new Constrainautor(delautator);\n    constrainautor.delaunify(true);\n    constrainautor.constrainAll(uniquePointIndexEdges);\n    let uniquePointIndexTriangles = [];\n    let triangles = [];\n    const triangleIsAlongInterpolatedPolygon = [];\n    for (let i = 0; i < constrainautor.del.triangles.length; i += 3) {\n        uniquePointIndexTriangles.push([\n            constrainautor.del.triangles[i],\n            constrainautor.del.triangles[i + 1],\n            constrainautor.del.triangles[i + 2]\n        ]);\n        triangles.push([\n            uniquePoints[constrainautor.del.triangles[i]],\n            uniquePoints[constrainautor.del.triangles[i + 1]],\n            uniquePoints[constrainautor.del.triangles[i + 2]]\n        ]);\n        // Only classify triangles if they are along the border\n        triangleIsAlongInterpolatedPolygon.push(uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i]) ||\n            uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i + 1]) ||\n            uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i + 2]));\n    }\n    // Triangle midPoints\n    let triangleMidPoints = triangles.map((triangle) => midPoint(...triangle));\n    // Only keep triangles inside polygon\n    const triangleShouldKeep = triangles.map((triangle, index) => {\n        // Only keep if inside (and can't be outside if polygon is bbox)\n        // This check for every triangle is expensive!\n        if (triangleIsAlongInterpolatedPolygon[index]) {\n            return ((polygonIsRectangle\n                ? true\n                : coordsInPolygonForInsidenessCheck(triangleMidPoints[index][0], triangleMidPoints[index][1], polygonForInsidenessCheck)) &&\n                triangleAngles(triangle).every((angle) => angle >= options.minimumTriangleAngle));\n        }\n        else {\n            return true;\n        }\n    });\n    uniquePointIndexTriangles = uniquePointIndexTriangles.filter((_triangle, index) => triangleShouldKeep[index]);\n    triangles = triangles.filter((_triangle, index) => triangleShouldKeep[index]);\n    triangleMidPoints = triangleMidPoints.filter((_triangle, index) => triangleShouldKeep[index]);\n    // If requested, compute if triangles are inside steiner polygons\n    // This check for every triangle is expensive!\n    let insideSteinerPolygonsTriangles = [];\n    const steinerClosedPolygons = steinerPolygons.map((steinerPolygon) => closePolygon(steinerPolygon));\n    if (options.computeInsideSteinerPolygons) {\n        const steinerClosedPolygonsForInsidenessCheck = steinerClosedPolygons.map((steinerPolygon) => preprocessPolygonForInsideCheck(steinerPolygon));\n        insideSteinerPolygonsTriangles = triangles.map((_triangle, index) => coordsInPolygonsForInsidenessCheck(triangleMidPoints[index][0], triangleMidPoints[index][1], steinerClosedPolygonsForInsidenessCheck) === true);\n    }\n    return {\n        interpolatedPolygon,\n        interpolatedPolygonPoints,\n        gridPoints,\n        gridPointsInPolygon,\n        interpolatedSteinerPolygons,\n        interpolatedSteinerPolygonsPoints,\n        uniquePoints,\n        triangles,\n        uniquePointIndexTriangles,\n        uniquePointIndexInterpolatedPolygon,\n        uniquePointIndexEdges,\n        uniquePointIndexInterpolatedSteinerPolygons,\n        insideSteinerPolygonsTriangles\n    };\n}\n"],"names":["MINIMUM_TRIANGLE_ANGLE","defaultTriangulationOptions","triangulateToUnique","polygon","distance","partialOptions","options","mergeOptions","conformPolygon","polygonIsRectangle","polygonIsBboxRectangle","steinerPolygons","steinerPolygon","steinerPointIndex","buildKDBushPointIndex","splitPolygonLines","polygonForInsidenessCheck","preprocessPolygonForInsideCheck","steinerPointsInPolygon","point","coordsInPolygonForInsidenessCheck","interpolatedPolygon","interpolatedPolygonPoints","interpolatedSteinerPolygons","interpolatedSteinerPolygonsPoints","gridPoints","gridPointsInPolygon","interpolatePolygon","bboxToGridPoints","computeBbox","allPoints","uniquePoints","uniquePointIndexByPointString","key","getPointIndex","x","y","index","uniquePointIndexInterpolatedPolygon","ring","uniquePointIndexSetInterpolatedPolygon","uniquePointIndexInterpolatedSteinerPolygons","uniquePointIndexEdges","uniquePointIndex","i","delautator","Delaunator","constrainautor","Constrainautor","uniquePointIndexTriangles","triangles","triangleIsAlongInterpolatedPolygon","triangleMidPoints","triangle","midPoint","triangleShouldKeep","triangleAngles","angle","_triangle","insideSteinerPolygonsTriangles","steinerClosedPolygons","closePolygon","steinerClosedPolygonsForInsidenessCheck","coordsInPolygonsForInsidenessCheck"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs325.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./index.cjs215.js"),y=require("./index.cjs275.js"),l=require("./index.cjs270.js"),c=require("./index.cjs353.js");var b=!0,u=class{rbush=new c;polygonsById=new Map;bboxesById=new Map;itemsById=new Map;addItem(e,t){this.removeItem(e);const s=a.computeBbox(t),r={minX:s[0],minY:s[1],maxX:s[2],maxY:s[3],id:e};this.polygonsById.set(e,t),this.bboxesById.set(e,s),this.itemsById.set(e,r),this.rbush.insert(r)}removeItem(e){const t=this.itemsById.get(e);t&&(this.rbush.remove(t),this.polygonsById.delete(e),this.bboxesById.delete(e),this.itemsById.delete(e))}clear(){this.polygonsById.clear(),this.bboxesById.clear(),this.itemsById.clear(),this.rbush.clear()}#e(e,t,s,r){return this.rbush.search({minX:e,minY:t,maxX:s,maxY:r})}getBbox(e){return this.bboxesById.get(e)}getPolygon(e){return this.polygonsById.get(e)}searchFromBbox(e){const[t,s,r,i]=e;return this.#e(t,s,r,i).map(n=>n.id)}searchFromPoint(e,t=b){const[s,r,i,n]=[e[0],e[1],e[0],e[1]],m=this.#e(s,r,i,n);return t?m.filter(o=>{const h=this.polygonsById.get(o.id);return h?l(e,y.closePolygon(h)):!1}).map(o=>o.id):m.map(o=>o.id)}};exports.RTree=u;
+//# sourceMappingURL=index.cjs325.js.map

package/dist/index.cjs325.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs325.js","sources":["../../../node_modules/@allmaps/render/dist/maps/RTree.js"],"sourcesContent":["import { closePolygon, computeBbox } from \"@allmaps/stdlib\";\nimport inside from \"point-in-polygon-hao\";\nimport RBush from \"rbush\";\n//#region src/maps/RTree.ts\nvar DEFAULT_FILTER_INSIDE_POLYGON = true;\n/**\n* 2D spatial index for polygons\n*/\nvar RTree = class {\n\trbush = new RBush();\n\tpolygonsById = /* @__PURE__ */ new Map();\n\tbboxesById = /* @__PURE__ */ new Map();\n\titemsById = /* @__PURE__ */ new Map();\n\taddItem(id, polygon) {\n\t\tthis.removeItem(id);\n\t\tconst bbox = computeBbox(polygon);\n\t\tconst item = {\n\t\t\tminX: bbox[0],\n\t\t\tminY: bbox[1],\n\t\t\tmaxX: bbox[2],\n\t\t\tmaxY: bbox[3],\n\t\t\tid\n\t\t};\n\t\tthis.polygonsById.set(id, polygon);\n\t\tthis.bboxesById.set(id, bbox);\n\t\tthis.itemsById.set(id, item);\n\t\tthis.rbush.insert(item);\n\t}\n\tremoveItem(id) {\n\t\tconst item = this.itemsById.get(id);\n\t\tif (item) {\n\t\t\tthis.rbush.remove(item);\n\t\t\tthis.polygonsById.delete(id);\n\t\t\tthis.bboxesById.delete(id);\n\t\t\tthis.itemsById.delete(id);\n\t\t}\n\t}\n\tclear() {\n\t\tthis.polygonsById.clear();\n\t\tthis.bboxesById.clear();\n\t\tthis.itemsById.clear();\n\t\tthis.rbush.clear();\n\t}\n\t#search(minX, minY, maxX, maxY) {\n\t\treturn this.rbush.search({\n\t\t\tminX,\n\t\t\tminY,\n\t\t\tmaxX,\n\t\t\tmaxY\n\t\t});\n\t}\n\tgetBbox(id) {\n\t\treturn this.bboxesById.get(id);\n\t}\n\tgetPolygon(id) {\n\t\treturn this.polygonsById.get(id);\n\t}\n\tsearchFromBbox(bbox) {\n\t\tconst [minX, minY, maxX, maxY] = bbox;\n\t\treturn this.#search(minX, minY, maxX, maxY).map((item) => item.id);\n\t}\n\tsearchFromPoint(point, filterInsidePolygon = DEFAULT_FILTER_INSIDE_POLYGON) {\n\t\tconst [minX, minY, maxX, maxY] = [\n\t\t\tpoint[0],\n\t\t\tpoint[1],\n\t\t\tpoint[0],\n\t\t\tpoint[1]\n\t\t];\n\t\tconst rtreeResults = this.#search(minX, minY, maxX, maxY);\n\t\tif (filterInsidePolygon) return rtreeResults.filter((item) => {\n\t\t\tconst polygon = this.polygonsById.get(item.id);\n\t\t\tif (polygon) return inside(point, closePolygon(polygon));\n\t\t\telse return false;\n\t\t}).map((item) => item.id);\n\t\telse return rtreeResults.map((item) => item.id);\n\t}\n};\n//#endregion\nexport { RTree };\n\n//# sourceMappingURL=RTree.js.map"],"names":["DEFAULT_FILTER_INSIDE_POLYGON","RTree","RBush","id","polygon","bbox","computeBbox","item","#search","minX","minY","maxX","maxY","point","filterInsidePolygon","rtreeResults","inside","closePolygon"],"mappings":"kNAIA,IAAIA,EAAgC,GAIhCC,EAAQ,KAAM,CACjB,MAAQ,IAAIC,EACZ,iBAAmC,IACnC,eAAiC,IACjC,cAAgC,IAChC,QAAQC,EAAIC,EAAS,CACpB,KAAK,WAAWD,CAAE,EAClB,MAAME,EAAOC,EAAAA,YAAYF,CAAO,EAC1BG,EAAO,CACZ,KAAMF,EAAK,CAAC,EACZ,KAAMA,EAAK,CAAC,EACZ,KAAMA,EAAK,CAAC,EACZ,KAAMA,EAAK,CAAC,EACZ,GAAAF,CAAA,EAED,KAAK,aAAa,IAAIA,EAAIC,CAAO,EACjC,KAAK,WAAW,IAAID,EAAIE,CAAI,EAC5B,KAAK,UAAU,IAAIF,EAAII,CAAI,EAC3B,KAAK,MAAM,OAAOA,CAAI,CACvB,CACA,WAAWJ,EAAI,CACd,MAAMI,EAAO,KAAK,UAAU,IAAIJ,CAAE,EAC9BI,IACH,KAAK,MAAM,OAAOA,CAAI,EACtB,KAAK,aAAa,OAAOJ,CAAE,EAC3B,KAAK,WAAW,OAAOA,CAAE,EACzB,KAAK,UAAU,OAAOA,CAAE,EAE1B,CACA,OAAQ,CACP,KAAK,aAAa,MAAA,EAClB,KAAK,WAAW,MAAA,EAChB,KAAK,UAAU,MAAA,EACf,KAAK,MAAM,MAAA,CACZ,CACAK,GAAQC,EAAMC,EAAMC,EAAMC,EAAM,CAC/B,OAAO,KAAK,MAAM,OAAO,CACxB,KAAAH,EACA,KAAAC,EACA,KAAAC,EACA,KAAAC,CAAA,CACA,CACF,CACA,QAAQT,EAAI,CACX,OAAO,KAAK,WAAW,IAAIA,CAAE,CAC9B,CACA,WAAWA,EAAI,CACd,OAAO,KAAK,aAAa,IAAIA,CAAE,CAChC,CACA,eAAeE,EAAM,CACpB,KAAM,CAACI,EAAMC,EAAMC,EAAMC,CAAI,EAAIP,EACjC,OAAO,KAAKG,GAAQC,EAAMC,EAAMC,EAAMC,CAAI,EAAE,IAAKL,GAASA,EAAK,EAAE,CAClE,CACA,gBAAgBM,EAAOC,EAAsBd,EAA+B,CAC3E,KAAM,CAACS,EAAMC,EAAMC,EAAMC,CAAI,EAAI,CAChCC,EAAM,CAAC,EACPA,EAAM,CAAC,EACPA,EAAM,CAAC,EACPA,EAAM,CAAC,CAAA,EAEFE,EAAe,KAAKP,GAAQC,EAAMC,EAAMC,EAAMC,CAAI,EACxD,OAAIE,EAA4BC,EAAa,OAAQR,GAAS,CAC7D,MAAMH,EAAU,KAAK,aAAa,IAAIG,EAAK,EAAE,EAC7C,OAAIH,EAAgBY,EAAOH,EAAOI,EAAAA,aAAab,CAAO,CAAC,EAC3C,EACb,CAAC,EAAE,IAAKG,GAASA,EAAK,EAAE,EACZQ,EAAa,IAAKR,GAASA,EAAK,EAAE,CAC/C,CACD","x_google_ignoreList":[0]}

package/dist/index.cjs326.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index.cjs354.js"),u=require("./index.cjs355.js"),n=16;function a(e){return s.sha1Hex(e)}function r(e,t=n){return a(String(e)).slice(0,t)}function h(e,t=n){return r(u.serialize(e),t)}exports.generateChecksum=h;exports.generateId=r;
+//# sourceMappingURL=index.cjs326.js.map

package/dist/index.cjs326.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs326.js","sources":["../../../node_modules/@allmaps/id/dist/sync.js"],"sourcesContent":["import { sha1Hex } from './sha1.js';\nimport { serialize } from './checksum.js';\nconst DEFAULT_LENGTH = 16;\n/**\n * Computes SHA-1 hash of input string.\n *\n * @param Input string.\n * @returns SHA-1 hash of `str`.\n */\nfunction generateHash(str) {\n    return sha1Hex(str);\n}\n/**\n * Generates an ID from a string using the SHA-1 algorithm. Given the same input, the ID will always be the same.\n *\n * @param str - Input string\n * @param length - Length of returned hash. The maximum length of the hash is 40 characters. The default length is 16.\n * @returns First `length` characters of the SHA-1 hash of `str`.\n */\nexport function generateId(str, length = DEFAULT_LENGTH) {\n    const hash = generateHash(String(str));\n    return hash.slice(0, length);\n}\n/**\n * Generates a random ID.\n *\n * @param length - Length of returned hash. The maximum length of the hash is 40 characters.\n * @returns First `length` characters of the SHA-1 hash of a random UUID.\n */\nexport function generateRandomId(length = DEFAULT_LENGTH) {\n    const uuid = crypto.randomUUID();\n    const id = generateId(uuid, length);\n    return id;\n}\n/**\n * Generates a checksum of a JSON object.\n *\n * @param obj - JSON object.\n * @param length - Length of returned hash. The maximum length of the hash is 40 characters.\n * @returns First `length` characters of the SHA-1 hash of sorted and serialized version of `obj`.\n */\nexport function generateChecksum(obj, length = DEFAULT_LENGTH) {\n    const checksum = generateId(serialize(obj), length);\n    return checksum;\n}\n"],"names":["DEFAULT_LENGTH","generateHash","str","sha1Hex","generateId","length","generateChecksum","obj","serialize"],"mappings":"oJAEMA,EAAiB,GAOvB,SAASC,EAAaC,EAAK,CACvB,OAAOC,EAAAA,QAAQD,CAAG,CACtB,CAQO,SAASE,EAAWF,EAAKG,EAASL,EAAgB,CAErD,OADaC,EAAa,OAAOC,CAAG,CAAC,EACzB,MAAM,EAAGG,CAAM,CAC/B,CAmBO,SAASC,EAAiBC,EAAKF,EAASL,EAAgB,CAE3D,OADiBI,EAAWI,EAAAA,UAAUD,CAAG,EAAGF,CAAM,CAEtD","x_google_ignoreList":[0]}

package/dist/index.cjs327.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./index.cjs226.js");const n=require("./index.cjs459.js"),i=require("./index.cjs460.js"),l=require("./index.cjs461.js"),d=require("./index.cjs462.js");function f(e){return{id:g(e),...C(e),type:h(e),partOf:m(e),provider:A(e)}}function g(e){if(i.isAnnotation1(e)){const r=e.target.source;return"id"in r?r.id:r["@id"]}else return e.target.service[0]["@id"]}function h(e){return"service"in e.target?e.target.service[0].type:e.target.source.type}function m(e){if(i.isAnnotation1(e))return e.target.source.partOf}function A(e){if(i.isAnnotation1(e))return e.target.source.provider}function w(e){return"pixelCoords"in e?e.pixelCoords:e.resourceCoords}function y(e){return e.body.features.map(r=>({resource:w(r.properties),geo:r.geometry.coordinates}))}function v(e){if(i.isAnnotation1(e))return{created:e.created,modified:e.modified}}function C(e){if(i.isAnnotation1(e))return{width:e.target.source.width,height:e.target.source.height};const s=e.target.selector.value,p=/width="(?<width>\d+)"/.exec(s),o=/height="(?<height>\d+)"/.exec(s),t=p?.groups?.width,c=o?.groups?.height;if(!t||!c)throw new Error("Could not parse image dimensions");return{width:parseInt(t),height:parseInt(c)}}function P(e){const s=e.target.selector.value,o=/points="(?<points>.+)"/.exec(s)?.groups;if(o&&o.points){const t=o.points.trim().split(/\s+/);if(t[0]===t[t.length-1]&&t.splice(-1),t.length>=3)return t.map(c=>{const u=c.split(",");if(u.length===2)return[parseFloat(u[0]),parseFloat(u[1])];throw new Error("Could not parse resource mask")});throw new Error("Could not parse resource mask")}else throw new Error("Could not parse resource mask")}function a(e){let r;"resourceCrs"in e.body&&(r=e.body.resourceCrs);let s;return"_allmaps"in e.body&&(s=e.body._allmaps),{"@context":"https://schemas.allmaps.org/map/2/context.json",type:"GeoreferencedMap",id:e.id,...v(e),resource:f(e),gcps:y(e),resourceMask:P(e),transformation:e.body.transformation,resourceCrs:r,_allmaps:s}}function b(e){if(n.isAnnotationPageBeforeParse(e)){let r;return"items"in e&&Array.isArray(e.items)&&n.isAnnotation0BeforeParse(e.items[0])?r=l.AnnotationPageSchema.parse(e):r=d.AnnotationPageSchema.parse(e),r.items.map(s=>a(s))}else{let r;return n.isAnnotation0BeforeParse(e)?r=l.AnnotationSchema.parse(e):r=d.AnnotationSchema.parse(e),[a(r)]}}exports.parseAnnotation=b;
+//# sourceMappingURL=index.cjs327.js.map

package/dist/index.cjs327.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs327.js","sources":["../../../node_modules/@allmaps/annotation/dist/parser.js"],"sourcesContent":["import { Annotation0Schema, Annotation1Schema, AnnotationPage0Schema, AnnotationPage1Schema } from './schemas/annotation.js';\nimport { isAnnotationPageBeforeParse, isAnnotation0BeforeParse } from './before-parse.js';\nimport { isAnnotation1 } from './guards.js';\nfunction parseResource(annotation) {\n    return {\n        id: parseImageId(annotation),\n        ...parseImageDimensions(annotation),\n        type: parseResourceType(annotation),\n        partOf: parsePartOf(annotation),\n        provider: parseProvider(annotation)\n    };\n}\nfunction parseImageId(annotation) {\n    if (isAnnotation1(annotation)) {\n        const source = annotation.target.source;\n        if ('id' in source) {\n            return source.id;\n        }\n        else {\n            return source['@id'];\n        }\n    }\n    else {\n        return annotation.target.service[0]['@id'];\n    }\n}\nfunction parseResourceType(annotation) {\n    if ('service' in annotation.target) {\n        return annotation.target.service[0].type;\n    }\n    else {\n        return annotation.target.source.type;\n    }\n}\nfunction parsePartOf(annotation) {\n    if (isAnnotation1(annotation)) {\n        return annotation.target.source.partOf;\n    }\n}\nfunction parseProvider(annotation) {\n    if (isAnnotation1(annotation)) {\n        return annotation.target.source.provider;\n    }\n}\nfunction parseResourceCoords(properties) {\n    if ('pixelCoords' in properties) {\n        return properties.pixelCoords;\n    }\n    else {\n        return properties.resourceCoords;\n    }\n}\nfunction parseGcps(annotation) {\n    return annotation.body.features.map((gcpFeature) => ({\n        resource: parseResourceCoords(gcpFeature.properties),\n        geo: gcpFeature.geometry.coordinates\n    }));\n}\nfunction parseDates(annotation) {\n    if (isAnnotation1(annotation)) {\n        return {\n            created: annotation.created,\n            modified: annotation.modified\n        };\n    }\n}\nfunction parseImageDimensions(annotation) {\n    if (isAnnotation1(annotation)) {\n        return {\n            width: annotation.target.source.width,\n            height: annotation.target.source.height\n        };\n    }\n    const selector = annotation.target.selector;\n    const svg = selector.value;\n    const widthResult = /width=\"(?<width>\\d+)\"/.exec(svg);\n    const heightResult = /height=\"(?<height>\\d+)\"/.exec(svg);\n    const width = widthResult?.groups?.width;\n    const height = heightResult?.groups?.height;\n    if (!width || !height) {\n        throw new Error('Could not parse image dimensions');\n    }\n    return {\n        width: parseInt(width),\n        height: parseInt(height)\n    };\n}\nfunction parseResourceMask(annotation) {\n    const selector = annotation.target.selector;\n    const svg = selector.value;\n    const result = /points=\"(?<points>.+)\"/.exec(svg);\n    const groups = result?.groups;\n    if (groups && groups.points) {\n        const pointStrings = groups.points.trim().split(/\\s+/);\n        // Resource masks are not round-trip: they don't repeat the first point at the end of the list of points.\n        // According to their spec, SVG polygons are not supposed to be round-trip either.\n        // Here we deal with inputs that are round-trip by removing the last point\n        if (pointStrings[0] === pointStrings[pointStrings.length - 1]) {\n            pointStrings.splice(-1);\n        }\n        if (pointStrings.length >= 3) {\n            return pointStrings.map((point) => {\n                const numberStrings = point.split(',');\n                if (numberStrings.length === 2) {\n                    return [parseFloat(numberStrings[0]), parseFloat(numberStrings[1])];\n                }\n                else {\n                    throw new Error('Could not parse resource mask');\n                }\n            });\n        }\n        else {\n            throw new Error('Could not parse resource mask');\n        }\n    }\n    else {\n        throw new Error('Could not parse resource mask');\n    }\n}\nfunction getGeoreferencedMap(annotation) {\n    let resourceCrs;\n    if ('resourceCrs' in annotation.body) {\n        resourceCrs = annotation.body.resourceCrs;\n    }\n    let _allmaps;\n    if ('_allmaps' in annotation.body) {\n        _allmaps = annotation.body._allmaps;\n    }\n    return {\n        '@context': 'https://schemas.allmaps.org/map/2/context.json',\n        type: 'GeoreferencedMap',\n        id: annotation.id,\n        ...parseDates(annotation),\n        resource: parseResource(annotation),\n        gcps: parseGcps(annotation),\n        resourceMask: parseResourceMask(annotation),\n        transformation: annotation.body.transformation,\n        resourceCrs,\n        _allmaps\n    };\n}\n/**\n * Parses a Georeference Annotation or an Annotation Page containing multiple Georeference Annotations\n * and returns an array of Georeferenced Maps.\n * @param {Annotation | AnnotationPage} annotation - Georeference Annotation or Annotation Page containing multiple Georeference Annotations\n * @returns {Map[]} Array of maps\n * @example\n * ```js\n * import fs from 'fs'\n * import { parseAnnotation } from '@allmaps/annotation'\n *\n * const annotation = JSON.parse(fs.readFileSync('./examples/annotation.example.json'))\n * const maps = parseAnnotation(annotation)\n * ```\n */\nexport function parseAnnotation(annotation) {\n    if (isAnnotationPageBeforeParse(annotation)) {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedAnnotationPage;\n        if ('items' in annotation &&\n            Array.isArray(annotation.items) &&\n            isAnnotation0BeforeParse(annotation.items[0])) {\n            parsedAnnotationPage = AnnotationPage0Schema.parse(annotation);\n        }\n        else {\n            parsedAnnotationPage = AnnotationPage1Schema.parse(annotation);\n        }\n        return parsedAnnotationPage.items.map((parsedAnnotation) => getGeoreferencedMap(parsedAnnotation));\n    }\n    else {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedAnnotation;\n        if (isAnnotation0BeforeParse(annotation)) {\n            parsedAnnotation = Annotation0Schema.parse(annotation);\n        }\n        else {\n            parsedAnnotation = Annotation1Schema.parse(annotation);\n        }\n        return [getGeoreferencedMap(parsedAnnotation)];\n    }\n}\n"],"names":["parseResource","annotation","parseImageId","parseImageDimensions","parseResourceType","parsePartOf","parseProvider","isAnnotation1","source","parseResourceCoords","properties","parseGcps","gcpFeature","parseDates","svg","widthResult","heightResult","width","height","parseResourceMask","groups","pointStrings","point","numberStrings","getGeoreferencedMap","resourceCrs","_allmaps","parseAnnotation","isAnnotationPageBeforeParse","parsedAnnotationPage","isAnnotation0BeforeParse","AnnotationPage0Schema","AnnotationPage1Schema","parsedAnnotation","Annotation0Schema","Annotation1Schema"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs328.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./index.cjs226.js");require("./index.cjs227.js");const c=require("./index.cjs466.js"),o=require("./index.cjs459.js"),n=require("./index.cjs464.js"),f=require("./index.cjs465.js");function a(e){if(o.isGeoreferencedMapsBeforeParse(e)){let r;return o.isGeoreferencedMap2BeforeParse(e[0])?r=n.GeoreferencedMapsSchema.parse(e):r=f.GeoreferencedMapsSchema.parse(e),c.toGeoreferencedMaps2(r)}else{let r;return o.isGeoreferencedMap2BeforeParse(e)?r=n.GeoreferencedMapSchema.parse(e):r=f.GeoreferencedMapSchema.parse(e),c.toGeoreferencedMap2(r)}}exports.validateGeoreferencedMap=a;
+//# sourceMappingURL=index.cjs328.js.map

package/dist/index.cjs328.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs328.js","sources":["../../../node_modules/@allmaps/annotation/dist/validator.js"],"sourcesContent":["import { Annotation0Schema, Annotation1Schema, AnnotationPage0Schema, AnnotationPage1Schema } from './schemas/annotation.js';\nimport { GeoreferencedMap1Schema, GeoreferencedMaps1Schema, GeoreferencedMap2Schema, GeoreferencedMaps2Schema } from './schemas/georeferenced-map.js';\nimport { toAnnotation1, toAnnotationPage1, toGeoreferencedMap2, toGeoreferencedMaps2 } from './convert.js';\nimport { isAnnotationPageBeforeParse, isAnnotation0BeforeParse, isGeoreferencedMapsBeforeParse, isGeoreferencedMap2BeforeParse } from './before-parse.js';\nexport function validateAnnotation(annotation) {\n    if (isAnnotationPageBeforeParse(annotation)) {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedAnnotationPage;\n        if ('items' in annotation &&\n            Array.isArray(annotation.items) &&\n            isAnnotation0BeforeParse(annotation.items[0])) {\n            parsedAnnotationPage = AnnotationPage0Schema.parse(annotation);\n        }\n        else {\n            parsedAnnotationPage = AnnotationPage1Schema.parse(annotation);\n        }\n        return toAnnotationPage1(parsedAnnotationPage);\n    }\n    else {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedAnnotation;\n        if (isAnnotation0BeforeParse(annotation)) {\n            parsedAnnotation = Annotation0Schema.parse(annotation);\n        }\n        else {\n            parsedAnnotation = Annotation1Schema.parse(annotation);\n        }\n        return toAnnotation1(parsedAnnotation);\n    }\n}\nexport function validateGeoreferencedMap(mapOrMaps) {\n    if (isGeoreferencedMapsBeforeParse(mapOrMaps)) {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedGeoreferencedMaps;\n        if (isGeoreferencedMap2BeforeParse(mapOrMaps[0])) {\n            parsedGeoreferencedMaps = GeoreferencedMaps2Schema.parse(mapOrMaps);\n        }\n        else {\n            parsedGeoreferencedMaps = GeoreferencedMaps1Schema.parse(mapOrMaps);\n        }\n        return toGeoreferencedMaps2(parsedGeoreferencedMaps);\n    }\n    else {\n        // Seperate .parse for different versions for better Zod errors\n        let parsedGeoreferencedMap;\n        if (isGeoreferencedMap2BeforeParse(mapOrMaps)) {\n            parsedGeoreferencedMap = GeoreferencedMap2Schema.parse(mapOrMaps);\n        }\n        else {\n            parsedGeoreferencedMap = GeoreferencedMap1Schema.parse(mapOrMaps);\n        }\n        return toGeoreferencedMap2(parsedGeoreferencedMap);\n    }\n}\n"],"names":["validateGeoreferencedMap","mapOrMaps","isGeoreferencedMapsBeforeParse","parsedGeoreferencedMaps","isGeoreferencedMap2BeforeParse","GeoreferencedMaps2Schema","GeoreferencedMaps1Schema","toGeoreferencedMaps2","parsedGeoreferencedMap","GeoreferencedMap2Schema","GeoreferencedMap1Schema","toGeoreferencedMap2"],"mappings":"4QA8BO,SAASA,EAAyBC,EAAW,CAChD,GAAIC,EAAAA,+BAA+BD,CAAS,EAAG,CAE3C,IAAIE,EACJ,OAAIC,iCAA+BH,EAAU,CAAC,CAAC,EAC3CE,EAA0BE,EAAAA,wBAAyB,MAAMJ,CAAS,EAGlEE,EAA0BG,EAAAA,wBAAyB,MAAML,CAAS,EAE/DM,EAAAA,qBAAqBJ,CAAuB,CACvD,KACK,CAED,IAAIK,EACJ,OAAIJ,EAAAA,+BAA+BH,CAAS,EACxCO,EAAyBC,EAAAA,uBAAwB,MAAMR,CAAS,EAGhEO,EAAyBE,EAAAA,uBAAwB,MAAMT,CAAS,EAE7DU,EAAAA,oBAAoBH,CAAsB,CACrD,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs329.js

@@ -0,0 +1,2 @@
+"use strict";function i(e,n={}){const{sorted:l}=n;l||(e=e.slice().sort(h));const s=e.length,r=new Array(s*2);let t=0;for(let c=0;c<s;c++){const o=e[c];for(;t>=2&&u(r[t-2],r[t-1],o)<=0;)t--;r[t++]=o}const f=t+1;for(let c=s-2;c>=0;c--){const o=e[c];for(;t>=f&&u(r[t-2],r[t-1],o)<=0;)t--;r[t++]=o}return r.slice(0,t-1)}function u(e,n,l){return(n[1]-e[1])*(l[0]-e[0])-(n[0]-e[0])*(l[1]-e[1])}function h(e,n){return e[0]===n[0]?e[1]-n[1]:e[0]-n[0]}module.exports=i;
+//# sourceMappingURL=index.cjs329.js.map

package/dist/index.cjs329.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs329.js","sources":["../../../node_modules/monotone-chain-convex-hull/lib-esm/index.js"],"sourcesContent":["/**\n * Computes the convex hull of a binary image using Andrew's Monotone Chain Algorithm\n * http://www.algorithmist.com/index.php/Monotone_Chain_Convex_Hull\n *\n * @param points - An array of points.\n * @param options - MCCH Algorithm options.\n * @return Coordinates of the convex hull in clockwise order\n */\nexport default function monotoneChainConvexHull(points, options = {}) {\n    const { sorted } = options;\n    if (!sorted) {\n        points = points.slice().sort(byXThenY);\n    }\n    const n = points.length;\n    const result = new Array(n * 2);\n    let k = 0;\n    for (let i = 0; i < n; i++) {\n        const point = points[i];\n        while (k >= 2 && cw(result[k - 2], result[k - 1], point) <= 0) {\n            k--;\n        }\n        result[k++] = point;\n    }\n    const t = k + 1;\n    for (let i = n - 2; i >= 0; i--) {\n        const point = points[i];\n        while (k >= t && cw(result[k - 2], result[k - 1], point) <= 0) {\n            k--;\n        }\n        result[k++] = point;\n    }\n    return result.slice(0, k - 1);\n}\nfunction cw(p1, p2, p3) {\n    return (p2[1] - p1[1]) * (p3[0] - p1[0]) - (p2[0] - p1[0]) * (p3[1] - p1[1]);\n}\nfunction byXThenY(point1, point2) {\n    if (point1[0] === point2[0]) {\n        return point1[1] - point2[1];\n    }\n    return point1[0] - point2[0];\n}\n//# sourceMappingURL=index.js.map"],"names":["monotoneChainConvexHull","points","options","sorted","byXThenY","n","result","k","i","point","cw","t","p1","p2","p3","point1","point2"],"mappings":"aAQA,SAAwBA,EAAwBC,EAAQC,EAAU,GAAI,CAClE,KAAM,CAAE,OAAAC,GAAWD,EACdC,IACDF,EAASA,EAAO,QAAQ,KAAKG,CAAQ,GAEzC,MAAMC,EAAIJ,EAAO,OACXK,EAAS,IAAI,MAAMD,EAAI,CAAC,EAC9B,IAAIE,EAAI,EACR,QAASC,EAAI,EAAGA,EAAIH,EAAGG,IAAK,CACxB,MAAMC,EAAQR,EAAOO,CAAC,EACtB,KAAOD,GAAK,GAAKG,EAAGJ,EAAOC,EAAI,CAAC,EAAGD,EAAOC,EAAI,CAAC,EAAGE,CAAK,GAAK,GACxDF,IAEJD,EAAOC,GAAG,EAAIE,CAClB,CACA,MAAME,EAAIJ,EAAI,EACd,QAASC,EAAIH,EAAI,EAAGG,GAAK,EAAGA,IAAK,CAC7B,MAAMC,EAAQR,EAAOO,CAAC,EACtB,KAAOD,GAAKI,GAAKD,EAAGJ,EAAOC,EAAI,CAAC,EAAGD,EAAOC,EAAI,CAAC,EAAGE,CAAK,GAAK,GACxDF,IAEJD,EAAOC,GAAG,EAAIE,CAClB,CACA,OAAOH,EAAO,MAAM,EAAGC,EAAI,CAAC,CAChC,CACA,SAASG,EAAGE,EAAIC,EAAIC,EAAI,CACpB,OAAQD,EAAG,CAAC,EAAID,EAAG,CAAC,IAAME,EAAG,CAAC,EAAIF,EAAG,CAAC,IAAMC,EAAG,CAAC,EAAID,EAAG,CAAC,IAAME,EAAG,CAAC,EAAIF,EAAG,CAAC,EAC9E,CACA,SAASR,EAASW,EAAQC,EAAQ,CAC9B,OAAID,EAAO,CAAC,IAAMC,EAAO,CAAC,EACfD,EAAO,CAAC,EAAIC,EAAO,CAAC,EAExBD,EAAO,CAAC,EAAIC,EAAO,CAAC,CAC/B","x_google_ignoreList":[0]}

package/dist/index.cjs330.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index.cjs275.js");function l(o){return Array.isArray(o)&&o.length>=2&&o.every(e=>typeof e=="number")}function y(o){return Array.isArray(o)&&o.every(l)}function u(o){return Array.isArray(o)&&o.every(l)}function a(o){return Array.isArray(o)&&o.every(u)}function c(o){return Array.isArray(o)&&o.every(l)}function g(o){return Array.isArray(o)&&o.every(y)}function f(o){return Array.isArray(o)&&o.every(a)}function j(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="Point"&&"coordinates"in o&&l(o.coordinates)}function P(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="LineString"&&"coordinates"in o&&y(o.coordinates)}function d(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="Polygon"&&"coordinates"in o&&Array.isArray(o.coordinates)&&a(o.coordinates)}function G(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="MultiPoint"&&"coordinates"in o&&c(o.coordinates)}function M(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="MultiLineString"&&"coordinates"in o&&g(o.coordinates)}function m(o){return typeof o=="object"&&o!==null&&"type"in o&&o.type==="MultiPolygon"&&"coordinates"in o&&Array.isArray(o.coordinates)&&f(o.coordinates)}function w(o){const e=typeof o=="object"&&o!==null,n=e&&"type"in o&&typeof o.type=="string"&&(o.type==="Point"||o.type==="LineString"||o.type==="Polygon"||o.type==="MultiPoint"||o.type==="MultiLineString"||o.type==="MultiPolygon"),r=e&&"coordinates"in o&&Array.isArray(o.coordinates);return n&&r}function i(o){return o.slice(0,2)}function T(o){return i(o.coordinates)}function S(o){return s.conformLineString(o.coordinates.map(i))}function L(o,e=!1){const t=s.conformPolygon(o.coordinates.map(n=>n.map(i)));return e?t.map(n=>[...n,n[0]]):t}function A(o){return o.coordinates.map(i)}function p(o){return s.conformMultiLineString(o.coordinates.map(e=>e.map(i)))}function C(o,e=!1){const t=s.conformMultiPolygon(o.coordinates.map(n=>n.map(r=>r.map(i))));return e?t.map(n=>n.map(r=>[...r,r[0]])):t}function F(o){if(j(o))return T(o);if(P(o))return S(o);if(d(o))return L(o);if(G(o))return A(o);if(M(o))return p(o);if(m(o))return C(o);throw new Error("Geometry type not supported")}function O(o){return s.geometryToPoints(F(o))}function v(o,e){return{type:"Feature",properties:{},geometry:o}}function R(o,e){return{type:"FeatureCollection",features:o.map((t,n)=>v(t))}}function h(o){return o.geometry}function q(o){return o.features.map(h)}exports.geojsonFeatureCollectionToGeojsonGeometries=q;exports.geojsonFeatureToGeojsonGeometry=h;exports.geojsonGeometriesToGeojsonFeatureCollection=R;exports.geojsonGeometryToGeojsonFeature=v;exports.geojsonGeometryToGeometry=F;exports.geojsonGeometryToPoints=O;exports.geojsonLineStringToLineString=S;exports.geojsonMultiLineStringToMultiLineString=p;exports.geojsonMultiPointToMultiPoint=A;exports.geojsonMultiPolygonToMultiPolygon=C;exports.geojsonPointToPoint=T;exports.geojsonPolygonToPolygon=L;exports.isGeojsonGeometry=w;exports.isGeojsonLineString=P;exports.isGeojsonLineStringCoordinates=y;exports.isGeojsonMultiLineString=M;exports.isGeojsonMultiLineStringCoordinates=g;exports.isGeojsonMultiPoint=G;exports.isGeojsonMultiPointCoordinates=c;exports.isGeojsonMultiPolygon=m;exports.isGeojsonMultiPolygonCoordinates=f;exports.isGeojsonPoint=j;exports.isGeojsonPolygon=d;exports.isGeojsonPolygonCoordinates=a;exports.isGeojsonRingCoordinates=u;
+//# sourceMappingURL=index.cjs330.js.map

package/dist/index.cjs330.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs330.js","sources":["../../../node_modules/@allmaps/stdlib/dist/geojson.js"],"sourcesContent":["import { conformLineString, conformRing, conformPolygon, conformMultiLineString, conformMultiPolygon, geometryToSvgGeometry, geometryToPoints } from './geometry.js';\n// Assert\nfunction isGeojsonPointCoordinates(input) {\n    return (Array.isArray(input) &&\n        input.length >= 2 &&\n        input.every((item) => typeof item === 'number'));\n}\nexport function isGeojsonLineStringCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonPointCoordinates);\n}\nexport function isGeojsonRingCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonPointCoordinates);\n}\nexport function isGeojsonPolygonCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonRingCoordinates);\n}\nexport function isGeojsonMultiPointCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonPointCoordinates);\n}\nexport function isGeojsonMultiLineStringCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonLineStringCoordinates);\n}\nexport function isGeojsonMultiPolygonCoordinates(input) {\n    return Array.isArray(input) && input.every(isGeojsonPolygonCoordinates);\n}\nexport function isGeojsonPoint(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'Point' &&\n        'coordinates' in input &&\n        isGeojsonPointCoordinates(input.coordinates));\n}\nexport function isGeojsonLineString(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'LineString' &&\n        'coordinates' in input &&\n        isGeojsonLineStringCoordinates(input.coordinates));\n}\nexport function isGeojsonPolygon(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'Polygon' &&\n        'coordinates' in input &&\n        Array.isArray(input.coordinates) &&\n        isGeojsonPolygonCoordinates(input.coordinates));\n}\nexport function isGeojsonMultiPoint(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'MultiPoint' &&\n        'coordinates' in input &&\n        isGeojsonMultiPointCoordinates(input.coordinates));\n}\nexport function isGeojsonMultiLineString(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'MultiLineString' &&\n        'coordinates' in input &&\n        isGeojsonMultiLineStringCoordinates(input.coordinates));\n}\nexport function isGeojsonMultiPolygon(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        'type' in input &&\n        input.type === 'MultiPolygon' &&\n        'coordinates' in input &&\n        Array.isArray(input.coordinates) &&\n        isGeojsonMultiPolygonCoordinates(input.coordinates));\n}\nexport function isGeojsonGeometry(obj) {\n    const isObject = typeof obj === 'object' && obj !== null;\n    const hasStringType = isObject && 'type' in obj && typeof obj.type === 'string';\n    const isValidType = hasStringType &&\n        (obj.type === 'Point' ||\n            obj.type === 'LineString' ||\n            obj.type === 'Polygon' ||\n            obj.type === 'MultiPoint' ||\n            obj.type === 'MultiLineString' ||\n            obj.type === 'MultiPolygon');\n    const hasCoordinatesArray = isObject && 'coordinates' in obj && Array.isArray(obj.coordinates);\n    return isValidType && hasCoordinatesArray;\n}\nexport function isGeojsonMultiGeometry(obj) {\n    const isObject = typeof obj === 'object' && obj !== null;\n    const hasStringType = isObject && 'type' in obj && typeof obj.type === 'string';\n    const isValidType = hasStringType &&\n        (obj.type === 'MultiPoint' ||\n            obj.type === 'MultiLineString' ||\n            obj.type === 'MultiPolygon');\n    const hasCoordinatesArray = isObject && 'coordinates' in obj && Array.isArray(obj.coordinates);\n    return isValidType && hasCoordinatesArray;\n}\n// Convert to Geometry\n// Note: GeoJSON points can have more then two coordiantes\nfunction geojsonPointCoordinatesToPoint(geojsonPointCoordinates) {\n    return geojsonPointCoordinates.slice(0, 2);\n}\nexport function geojsonPointToPoint(geojsonPoint) {\n    return geojsonPointCoordinatesToPoint(geojsonPoint.coordinates);\n}\nexport function geojsonLineStringToLineString(geojsonLineString) {\n    return conformLineString(geojsonLineString.coordinates.map(geojsonPointCoordinatesToPoint));\n}\nexport function geojsonPolygonToRing(geojsonPolygon, close = false) {\n    const outerRing = conformRing(geojsonPolygon.coordinates[0].map(geojsonPointCoordinatesToPoint));\n    return close ? [...outerRing, outerRing[0]] : outerRing;\n}\nexport function geojsonPolygonToPolygon(geojsonPolygon, close = false) {\n    const polygon = conformPolygon(geojsonPolygon.coordinates.map((ring) => ring.map(geojsonPointCoordinatesToPoint)));\n    return close ? polygon.map((ring) => [...ring, ring[0]]) : polygon;\n}\nexport function geojsonMultiPointToMultiPoint(geojsonMultiPoint) {\n    return geojsonMultiPoint.coordinates.map(geojsonPointCoordinatesToPoint);\n}\nexport function geojsonMultiLineStringToMultiLineString(geojsonMultiLineString) {\n    return conformMultiLineString(geojsonMultiLineString.coordinates.map((l) => l.map(geojsonPointCoordinatesToPoint)));\n}\nexport function geojsonMultiPolygonToMultiPolygon(geojsonMultiPolygon, close = false) {\n    const multipolygon = conformMultiPolygon(geojsonMultiPolygon.coordinates.map((p) => p.map((l) => l.map(geojsonPointCoordinatesToPoint))));\n    return close\n        ? multipolygon.map((polygon) => polygon.map((ring) => [...ring, ring[0]]))\n        : multipolygon;\n}\n/**\n * Converts a GeoJSON Geometry to a Geometry\n * @param geojsonGeometry - GeoJSON Geometry\n * @returns Geometry\n */\nexport function geojsonGeometryToGeometry(geojsonGeometry) {\n    if (isGeojsonPoint(geojsonGeometry)) {\n        return geojsonPointToPoint(geojsonGeometry);\n    }\n    else if (isGeojsonLineString(geojsonGeometry)) {\n        return geojsonLineStringToLineString(geojsonGeometry);\n    }\n    else if (isGeojsonPolygon(geojsonGeometry)) {\n        return geojsonPolygonToPolygon(geojsonGeometry);\n    }\n    else if (isGeojsonMultiPoint(geojsonGeometry)) {\n        return geojsonMultiPointToMultiPoint(geojsonGeometry);\n    }\n    else if (isGeojsonMultiLineString(geojsonGeometry)) {\n        return geojsonMultiLineStringToMultiLineString(geojsonGeometry);\n    }\n    else if (isGeojsonMultiPolygon(geojsonGeometry)) {\n        return geojsonMultiPolygonToMultiPolygon(geojsonGeometry);\n    }\n    else {\n        throw new Error('Geometry type not supported');\n    }\n}\n// Convert to SVG\nexport function geojsonGeometryToSvgGeometry(geojsonGeometry) {\n    return geometryToSvgGeometry(geojsonGeometryToGeometry(geojsonGeometry));\n}\n// Convert to points\nexport function geojsonGeometryToPoints(geoJsonGeometry) {\n    return geometryToPoints(geojsonGeometryToGeometry(geoJsonGeometry));\n}\n// Wrap Geometry in Feature\nexport function geojsonGeometryToGeojsonFeature(geojsonGeometry, properties) {\n    return {\n        type: 'Feature',\n        properties: properties ? properties : {},\n        geometry: geojsonGeometry\n    };\n}\nexport function geojsonFeaturesToGeojsonFeatureCollection(geojsonFeatures) {\n    if (!Array.isArray(geojsonFeatures)) {\n        geojsonFeatures = [geojsonFeatures];\n    }\n    return {\n        type: 'FeatureCollection',\n        features: geojsonFeatures\n    };\n}\nexport function geojsonGeometriesToGeojsonFeatureCollection(geojsonGeometries, properties) {\n    return {\n        type: 'FeatureCollection',\n        features: geojsonGeometries.map((geometry, i) => properties\n            ? geojsonGeometryToGeojsonFeature(geometry, properties[i])\n            : geojsonGeometryToGeojsonFeature(geometry))\n    };\n}\nexport function geojsonFeatureToGeojsonGeometry(geojsonFeature) {\n    return geojsonFeature.geometry;\n}\nexport function geojsonFeatureCollectionToGeojsonGeometries(geojsonFeatureCollection) {\n    return geojsonFeatureCollection.features.map(geojsonFeatureToGeojsonGeometry);\n}\n// Expand\nexport function expandGeojsonMultiPointToGeojsonPoints(geojsonMultiPoint) {\n    return geojsonMultiPoint.coordinates.map((point) => {\n        return {\n            type: 'Point',\n            coordinates: point\n        };\n    });\n}\nexport function expandGeojsonMultiLineStringToGeojsonLineStrings(geojsonMultiLineString) {\n    return geojsonMultiLineString.coordinates.map((lineString) => {\n        return {\n            type: 'LineString',\n            coordinates: lineString\n        };\n    });\n}\nexport function expandGeojsonMultiPolygonToGeojsonPolygons(geojsonMultiPolygon) {\n    return geojsonMultiPolygon.coordinates.map((polygon) => {\n        return {\n            type: 'Polygon',\n            coordinates: polygon\n        };\n    });\n}\nexport function expandGeojsonMultiGeometryToGeojsonGeometries(geojsonMultiGeometry) {\n    if (isGeojsonMultiPoint(geojsonMultiGeometry)) {\n        return expandGeojsonMultiPointToGeojsonPoints(geojsonMultiGeometry);\n    }\n    else if (isGeojsonMultiLineString(geojsonMultiGeometry)) {\n        return expandGeojsonMultiLineStringToGeojsonLineStrings(geojsonMultiGeometry);\n    }\n    else if (isGeojsonMultiPolygon(geojsonMultiGeometry)) {\n        return expandGeojsonMultiPolygonToGeojsonPolygons(geojsonMultiGeometry);\n    }\n    else {\n        throw new Error('Geometry type not supported');\n    }\n}\n// Contract\nexport function contractGeojsonPointsToGeojsonMultiPoint(geojsonPoints) {\n    return {\n        type: 'MultiPoint',\n        coordinates: geojsonPoints.map((geojsonPoint) => geojsonPoint.coordinates)\n    };\n}\nexport function contractGeojsonLineStringsToGeojsonMultiLineString(geojsonLineStrings) {\n    return {\n        type: 'MultiLineString',\n        coordinates: geojsonLineStrings.map((geojsonLineString) => geojsonLineString.coordinates)\n    };\n}\nexport function contractGeojsonPolygonsToGeojsonMultiPolygon(geojsonPolygons) {\n    return {\n        type: 'MultiPolygon',\n        coordinates: geojsonPolygons.map((geojsonPolygon) => geojsonPolygon.coordinates)\n    };\n}\nexport function contractGeojsonGeometriesToGeojsonMultiGeometry(geojsonGeometries) {\n    if (geojsonGeometries.every(isGeojsonPoint)) {\n        return contractGeojsonPointsToGeojsonMultiPoint(geojsonGeometries);\n    }\n    else if (geojsonGeometries.every(isGeojsonLineString)) {\n        return contractGeojsonLineStringsToGeojsonMultiLineString(geojsonGeometries);\n    }\n    else if (geojsonGeometries.every(isGeojsonPolygon)) {\n        return contractGeojsonPolygonsToGeojsonMultiPolygon(geojsonGeometries);\n    }\n    else {\n        throw new Error('Geometry type not supported');\n    }\n}\nexport function mergeGeojsonFeaturesCollections(geojsonFeatureCollections) {\n    return {\n        type: 'FeatureCollection',\n        features: geojsonFeatureCollections\n            .map((geojsonFeatureCollection) => geojsonFeatureCollection.features)\n            .flat(1)\n    };\n}\n"],"names":["isGeojsonPointCoordinates","input","item","isGeojsonLineStringCoordinates","isGeojsonRingCoordinates","isGeojsonPolygonCoordinates","isGeojsonMultiPointCoordinates","isGeojsonMultiLineStringCoordinates","isGeojsonMultiPolygonCoordinates","isGeojsonPoint","isGeojsonLineString","isGeojsonPolygon","isGeojsonMultiPoint","isGeojsonMultiLineString","isGeojsonMultiPolygon","isGeojsonGeometry","obj","isObject","isValidType","hasCoordinatesArray","geojsonPointCoordinatesToPoint","geojsonPointCoordinates","geojsonPointToPoint","geojsonPoint","geojsonLineStringToLineString","geojsonLineString","conformLineString","geojsonPolygonToPolygon","geojsonPolygon","close","polygon","conformPolygon","ring","geojsonMultiPointToMultiPoint","geojsonMultiPoint","geojsonMultiLineStringToMultiLineString","geojsonMultiLineString","conformMultiLineString","l","geojsonMultiPolygonToMultiPolygon","geojsonMultiPolygon","multipolygon","conformMultiPolygon","p","geojsonGeometryToGeometry","geojsonGeometry","geojsonGeometryToPoints","geoJsonGeometry","geometryToPoints","geojsonGeometryToGeojsonFeature","properties","geojsonGeometriesToGeojsonFeatureCollection","geojsonGeometries","geometry","i","geojsonFeatureToGeojsonGeometry","geojsonFeature","geojsonFeatureCollectionToGeojsonGeometries","geojsonFeatureCollection"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs331.js

@@ -0,0 +1,2 @@
+"use strict";const r="a-f\\d",p=`#?[${r}]{3}[${r}]?`,$=`#?[${r}]{6}([${r}]{2})?`,f=new RegExp(`[^#${r}]`,"gi"),g=new RegExp(`^${p}$|^${$}$`,"i");function u(t,e={}){if(typeof t!="string"||f.test(t)||!g.test(t))throw new TypeError("Expected a valid hex string");t=t.replace(/^#/,"");let a=1;t.length===8&&(a=Number.parseInt(t.slice(6,8),16)/255,t=t.slice(0,6)),t.length===4&&(a=Number.parseInt(t.slice(3,4).repeat(2),16)/255,t=t.slice(0,3)),t.length===3&&(t=t[0]+t[0]+t[1]+t[1]+t[2]+t[2]);const s=Number.parseInt(t,16),c=s>>16,i=s>>8&255,o=s&255,n=typeof e.alpha=="number"?e.alpha:a;if(e.format==="array")return[c,i,o,n];if(e.format==="css"){const l=n===1?"":` / ${Number((n*100).toFixed(2))}%`;return`rgb(${c} ${i} ${o}${l})`}return{red:c,green:i,blue:o,alpha:n}}module.exports=u;
+//# sourceMappingURL=index.cjs331.js.map

package/dist/index.cjs331.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs331.js","sources":["../../../node_modules/hex-rgb/index.js"],"sourcesContent":["const hexCharacters = 'a-f\\\\d';\nconst match3or4Hex = `#?[${hexCharacters}]{3}[${hexCharacters}]?`;\nconst match6or8Hex = `#?[${hexCharacters}]{6}([${hexCharacters}]{2})?`;\nconst nonHexChars = new RegExp(`[^#${hexCharacters}]`, 'gi');\nconst validHexSize = new RegExp(`^${match3or4Hex}$|^${match6or8Hex}$`, 'i');\n\nexport default function hexRgb(hex, options = {}) {\n\tif (typeof hex !== 'string' || nonHexChars.test(hex) || !validHexSize.test(hex)) {\n\t\tthrow new TypeError('Expected a valid hex string');\n\t}\n\n\thex = hex.replace(/^#/, '');\n\tlet alphaFromHex = 1;\n\n\tif (hex.length === 8) {\n\t\talphaFromHex = Number.parseInt(hex.slice(6, 8), 16) / 255;\n\t\thex = hex.slice(0, 6);\n\t}\n\n\tif (hex.length === 4) {\n\t\talphaFromHex = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255;\n\t\thex = hex.slice(0, 3);\n\t}\n\n\tif (hex.length === 3) {\n\t\thex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];\n\t}\n\n\tconst number = Number.parseInt(hex, 16);\n\tconst red = number >> 16;\n\tconst green = (number >> 8) & 255;\n\tconst blue = number & 255;\n\tconst alpha = typeof options.alpha === 'number' ? options.alpha : alphaFromHex;\n\n\tif (options.format === 'array') {\n\t\treturn [red, green, blue, alpha];\n\t}\n\n\tif (options.format === 'css') {\n\t\tconst alphaString = alpha === 1 ? '' : ` / ${Number((alpha * 100).toFixed(2))}%`;\n\t\treturn `rgb(${red} ${green} ${blue}${alphaString})`;\n\t}\n\n\treturn {red, green, blue, alpha};\n}\n"],"names":["hexCharacters","match3or4Hex","match6or8Hex","nonHexChars","validHexSize","hexRgb","hex","options","alphaFromHex","number","red","green","blue","alpha","alphaString"],"mappings":"aAAA,MAAMA,EAAgB,SAChBC,EAAe,MAAMD,CAAa,QAAQA,CAAa,KACvDE,EAAe,MAAMF,CAAa,SAASA,CAAa,SACxDG,EAAc,IAAI,OAAO,MAAMH,CAAa,IAAK,IAAI,EACrDI,EAAe,IAAI,OAAO,IAAIH,CAAY,MAAMC,CAAY,IAAK,GAAG,EAE1E,SAAwBG,EAAOC,EAAKC,EAAU,GAAI,CACjD,GAAI,OAAOD,GAAQ,UAAYH,EAAY,KAAKG,CAAG,GAAK,CAACF,EAAa,KAAKE,CAAG,EAC7E,MAAM,IAAI,UAAU,6BAA6B,EAGlDA,EAAMA,EAAI,QAAQ,KAAM,EAAE,EAC1B,IAAIE,EAAe,EAEfF,EAAI,SAAW,IAClBE,EAAe,OAAO,SAASF,EAAI,MAAM,EAAG,CAAC,EAAG,EAAE,EAAI,IACtDA,EAAMA,EAAI,MAAM,EAAG,CAAC,GAGjBA,EAAI,SAAW,IAClBE,EAAe,OAAO,SAASF,EAAI,MAAM,EAAG,CAAC,EAAE,OAAO,CAAC,EAAG,EAAE,EAAI,IAChEA,EAAMA,EAAI,MAAM,EAAG,CAAC,GAGjBA,EAAI,SAAW,IAClBA,EAAMA,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAIA,EAAI,CAAC,GAGzD,MAAMG,EAAS,OAAO,SAASH,EAAK,EAAE,EAChCI,EAAMD,GAAU,GAChBE,EAASF,GAAU,EAAK,IACxBG,EAAOH,EAAS,IAChBI,EAAQ,OAAON,EAAQ,OAAU,SAAWA,EAAQ,MAAQC,EAElE,GAAID,EAAQ,SAAW,QACtB,MAAO,CAACG,EAAKC,EAAOC,EAAMC,CAAK,EAGhC,GAAIN,EAAQ,SAAW,MAAO,CAC7B,MAAMO,EAAcD,IAAU,EAAI,GAAK,MAAM,QAAQA,EAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,IAC7E,MAAO,OAAOH,CAAG,IAAIC,CAAK,IAAIC,CAAI,GAAGE,CAAW,GACjD,CAEA,MAAO,CAAC,IAAAJ,EAAK,MAAAC,EAAO,KAAAC,EAAM,MAAAC,CAAA,CAC3B","x_google_ignoreList":[0]}

package/dist/index.cjs332.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./index.cjs443.js");function t(s,e){return r(s,e)}module.exports=t;
+//# sourceMappingURL=index.cjs332.js.map

package/dist/index.cjs332.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs332.js","sources":["../../../node_modules/lodash-es/isEqual.js"],"sourcesContent":["import baseIsEqual from './_baseIsEqual.js';\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.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 * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nexport default isEqual;\n"],"names":["isEqual","value","other","baseIsEqual"],"mappings":"kDA8BA,SAASA,EAAQC,EAAOC,EAAO,CAC7B,OAAOC,EAAYF,EAAOC,CAAK,CACjC","x_google_ignoreList":[0]}

package/dist/index.cjs333.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("./index.cjs216.js");function m(r,n,a=0){if(r<=0||n<=0)throw new Error("Empty ArrayMatrix not supported");const e=new Array(r);for(let s=0;s<r;s++){const i=new Array(n);for(let o=0;o<n;o++)i[o]=a;e[s]=i}return e}function y(r){return[r.length,r[0].length]}function h(r){const n=r.length,a=new Array(n);for(let e=0;e<n;e++)a[e]=r[e].slice();return a}function p(r,n,a,e){const s=y(e),i=h(r);for(let o=0;o<s[0];o++)for(let c=0;c<s[1];c++)i[n+o][a+c]=e[o][c];return i}function M(r){const n=r.length,a=r[0].length,e=new Array(a);for(let s=0;s<a;s++){const i=new Array(n);for(let o=0;o<n;o++)i[o]=r[o][s];e[s]=i}return e}function g(r,n=0){const a=y(r),e=r.map(t=>t.map(l=>y(l))),s=e.map(t=>t.map(l=>l[0])),i=M(s),o=i[0];if(!i.every(t=>f.isEqualArray(t,i[0])))throw new Error("The blocks, by block column, must have the same sequence of rows.");const c=[];let u=0;o.forEach(t=>{c.push(u),u=u+t});const x=u,w=e.map(t=>t.map(l=>l[1])),v=w[0];if(!w.every(t=>f.isEqualArray(t,v)))throw new Error("The blocks, by block row, must have the same sequence of columns.");u=0,w[0].forEach(t=>{u=u+t});let A=m(x,u,n);for(let t=0;t<a[0];t++)for(let l=0;l<a[1];l++)A=p(A,c[t],c[l],r[t][l]);return A}exports.arrayMatrixSize=y;exports.newArrayMatrix=m;exports.newBlockArrayMatrix=g;exports.pasteArrayMatrix=p;exports.shallowCopyArrayMatrix=h;exports.transposeArrayMatrix=M;
+//# sourceMappingURL=index.cjs333.js.map