@mapsindoors/map-template 1.95.0 → 1.95.2

package/dist/route-travel-mode.enum-BvqP1fpw.js

@@ -0,0 +1,9 @@
+var RouteTravelMode;
+(function (RouteTravelMode) {
+    RouteTravelMode["Walking"] = "walking";
+    RouteTravelMode["Bicycling"] = "bicycling";
+    RouteTravelMode["Transit"] = "transit";
+    RouteTravelMode["Driving"] = "driving";
+})(RouteTravelMode || (RouteTravelMode = {}));
+
+export { RouteTravelMode as R };

package/dist/sort-order.enum-jsLAbYWg.js

@@ -0,0 +1,566 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-B85MJLTf.js';
+
+var fuzzysort$2 = {exports: {}};
+
+var fuzzysort$1 = fuzzysort$2.exports;
+
+var hasRequiredFuzzysort;
+
+function requireFuzzysort () {
+	if (hasRequiredFuzzysort) return fuzzysort$2.exports;
+	hasRequiredFuzzysort = 1;
+	(function (module) {
+((root, UMD) => {
+		  if(module.exports) module.exports = UMD();
+		  else root['fuzzysort'] = UMD();
+		})(fuzzysort$1, _ => {
+
+		  var single = (search, target) => {                                                                                                                                                                                                                        if(search=='farzher')return {target:"farzher was here (^-^*)/",score:0,_indexes:[0]}
+		    if(!search || !target) return NULL
+
+		    var preparedSearch = getPreparedSearch(search);
+		    if(!isObj(target)) target = getPrepared(target);
+
+		    var searchBitflags = preparedSearch.bitflags;
+		    if((searchBitflags & target._bitflags) !== searchBitflags) return NULL
+
+		    return algorithm(preparedSearch, target)
+		  };
+
+
+		  var go = (search, targets, options) => {                                                                                                                                                                                                                  if(search=='farzher')return [{target:"farzher was here (^-^*)/",score:0,_indexes:[0],obj:targets?targets[0]:NULL}]
+		    if(!search) return options&&options.all ? all(search, targets, options) : noResults
+
+		    var preparedSearch = getPreparedSearch(search);
+		    var searchBitflags = preparedSearch.bitflags;
+
+		    var threshold = options&&options.threshold || INT_MIN;
+		    var limit     = options&&options['limit']  || INT_MAX; // for some reason only limit breaks when minified
+
+		    var resultsLen = 0; var limitedCount = 0;
+		    var targetsLen = targets.length;
+
+		    // This code is copy/pasted 3 times for performance reasons [options.keys, options.key, no keys]
+
+		    // options.key
+		    if(options && options.key) {
+		      var key = options.key;
+		      for(var i = 0; i < targetsLen; ++i) { var obj = targets[i];
+		        var target = getValue(obj, key);
+		        if(!target) continue
+		        if(!isObj(target)) target = getPrepared(target);
+
+		        if((searchBitflags & target._bitflags) !== searchBitflags) continue
+		        var result = algorithm(preparedSearch, target);
+		        if(result === NULL) continue
+		        if(result.score < threshold) continue
+
+		        // have to clone result so duplicate targets from different obj can each reference the correct obj
+		        result = {target:result.target, _targetLower:'', _targetLowerCodes:NULL, _nextBeginningIndexes:NULL, _bitflags:0, score:result.score, _indexes:result._indexes, obj:obj}; // hidden
+
+		        if(resultsLen < limit) { q.add(result); ++resultsLen; }
+		        else {
+		          ++limitedCount;
+		          if(result.score > q.peek().score) q.replaceTop(result);
+		        }
+		      }
+
+		    // options.keys
+		    } else if(options && options.keys) {
+		      var scoreFn = options['scoreFn'] || defaultScoreFn;
+		      var keys = options.keys;
+		      var keysLen = keys.length;
+		      for(var i = 0; i < targetsLen; ++i) { var obj = targets[i];
+		        var objResults = new Array(keysLen);
+		        for (var keyI = 0; keyI < keysLen; ++keyI) {
+		          var key = keys[keyI];
+		          var target = getValue(obj, key);
+		          if(!target) { objResults[keyI] = NULL; continue }
+		          if(!isObj(target)) target = getPrepared(target);
+
+		          if((searchBitflags & target._bitflags) !== searchBitflags) objResults[keyI] = NULL;
+		          else objResults[keyI] = algorithm(preparedSearch, target);
+		        }
+		        objResults.obj = obj; // before scoreFn so scoreFn can use it
+		        var score = scoreFn(objResults);
+		        if(score === NULL) continue
+		        if(score < threshold) continue
+		        objResults.score = score;
+		        if(resultsLen < limit) { q.add(objResults); ++resultsLen; }
+		        else {
+		          ++limitedCount;
+		          if(score > q.peek().score) q.replaceTop(objResults);
+		        }
+		      }
+
+		    // no keys
+		    } else {
+		      for(var i = 0; i < targetsLen; ++i) { var target = targets[i];
+		        if(!target) continue
+		        if(!isObj(target)) target = getPrepared(target);
+
+		        if((searchBitflags & target._bitflags) !== searchBitflags) continue
+		        var result = algorithm(preparedSearch, target);
+		        if(result === NULL) continue
+		        if(result.score < threshold) continue
+		        if(resultsLen < limit) { q.add(result); ++resultsLen; }
+		        else {
+		          ++limitedCount;
+		          if(result.score > q.peek().score) q.replaceTop(result);
+		        }
+		      }
+		    }
+
+		    if(resultsLen === 0) return noResults
+		    var results = new Array(resultsLen);
+		    for(var i = resultsLen - 1; i >= 0; --i) results[i] = q.poll();
+		    results.total = resultsLen + limitedCount;
+		    return results
+		  };
+
+
+		  var highlight = (result, hOpen, hClose) => {
+		    if(typeof hOpen === 'function') return highlightCallback(result, hOpen)
+		    if(result === NULL) return NULL
+		    if(hOpen === undefined) hOpen = '<b>';
+		    if(hClose === undefined) hClose = '</b>';
+		    var highlighted = '';
+		    var matchesIndex = 0;
+		    var opened = false;
+		    var target = result.target;
+		    var targetLen = target.length;
+		    var indexes = result._indexes;
+		    indexes = indexes.slice(0, indexes.len).sort((a,b)=>a-b);
+		    for(var i = 0; i < targetLen; ++i) { var char = target[i];
+		      if(indexes[matchesIndex] === i) {
+		        ++matchesIndex;
+		        if(!opened) { opened = true;
+		          highlighted += hOpen;
+		        }
+
+		        if(matchesIndex === indexes.length) {
+		          highlighted += char + hClose + target.substr(i+1);
+		          break
+		        }
+		      } else {
+		        if(opened) { opened = false;
+		          highlighted += hClose;
+		        }
+		      }
+		      highlighted += char;
+		    }
+
+		    return highlighted
+		  };
+		  var highlightCallback = (result, cb) => {
+		    if(result === NULL) return NULL
+		    var target = result.target;
+		    var targetLen = target.length;
+		    var indexes = result._indexes;
+		    indexes = indexes.slice(0, indexes.len).sort((a,b)=>a-b);
+		    var highlighted = '';
+		    var matchI = 0;
+		    var indexesI = 0;
+		    var opened = false;
+		    var result = [];
+		    for(var i = 0; i < targetLen; ++i) { var char = target[i];
+		      if(indexes[indexesI] === i) {
+		        ++indexesI;
+		        if(!opened) { opened = true;
+		          result.push(highlighted); highlighted = '';
+		        }
+
+		        if(indexesI === indexes.length) {
+		          highlighted += char;
+		          result.push(cb(highlighted, matchI++)); highlighted = '';
+		          result.push(target.substr(i+1));
+		          break
+		        }
+		      } else {
+		        if(opened) { opened = false;
+		          result.push(cb(highlighted, matchI++)); highlighted = '';
+		        }
+		      }
+		      highlighted += char;
+		    }
+		    return result
+		  };
+
+
+		  var indexes = result => result._indexes.slice(0, result._indexes.len).sort((a,b)=>a-b);
+
+
+		  var prepare = (target) => {
+		    if(typeof target !== 'string') target = '';
+		    var info = prepareLowerInfo(target);
+		    return {'target':target, _targetLower:info._lower, _targetLowerCodes:info.lowerCodes, _nextBeginningIndexes:NULL, _bitflags:info.bitflags, 'score':NULL, _indexes:[0], 'obj':NULL} // hidden
+		  };
+
+
+		  // Below this point is only internal code
+		  // Below this point is only internal code
+		  // Below this point is only internal code
+		  // Below this point is only internal code
+
+
+		  var prepareSearch = (search) => {
+		    if(typeof search !== 'string') search = '';
+		    search = search.trim();
+		    var info = prepareLowerInfo(search);
+
+		    var spaceSearches = [];
+		    if(info.containsSpace) {
+		      var searches = search.split(/\s+/);
+		      searches = [...new Set(searches)]; // distinct
+		      for(var i=0; i<searches.length; i++) {
+		        if(searches[i] === '') continue
+		        var _info = prepareLowerInfo(searches[i]);
+		        spaceSearches.push({lowerCodes:_info.lowerCodes, _lower:searches[i].toLowerCase(), containsSpace:false});
+		      }
+		    }
+
+		    return {lowerCodes: info.lowerCodes, bitflags: info.bitflags, containsSpace: info.containsSpace, _lower: info._lower, spaceSearches: spaceSearches}
+		  };
+
+
+
+		  var getPrepared = (target) => {
+		    if(target.length > 999) return prepare(target) // don't cache huge targets
+		    var targetPrepared = preparedCache.get(target);
+		    if(targetPrepared !== undefined) return targetPrepared
+		    targetPrepared = prepare(target);
+		    preparedCache.set(target, targetPrepared);
+		    return targetPrepared
+		  };
+		  var getPreparedSearch = (search) => {
+		    if(search.length > 999) return prepareSearch(search) // don't cache huge searches
+		    var searchPrepared = preparedSearchCache.get(search);
+		    if(searchPrepared !== undefined) return searchPrepared
+		    searchPrepared = prepareSearch(search);
+		    preparedSearchCache.set(search, searchPrepared);
+		    return searchPrepared
+		  };
+
+
+		  var all = (search, targets, options) => {
+		    var results = []; results.total = targets.length;
+
+		    var limit = options && options.limit || INT_MAX;
+
+		    if(options && options.key) {
+		      for(var i=0;i<targets.length;i++) { var obj = targets[i];
+		        var target = getValue(obj, options.key);
+		        if(!target) continue
+		        if(!isObj(target)) target = getPrepared(target);
+		        target.score = INT_MIN;
+		        target._indexes.len = 0;
+		        var result = target;
+		        result = {target:result.target, _targetLower:'', _targetLowerCodes:NULL, _nextBeginningIndexes:NULL, _bitflags:0, score:target.score, _indexes:NULL, obj:obj}; // hidden
+		        results.push(result); if(results.length >= limit) return results
+		      }
+		    } else if(options && options.keys) {
+		      for(var i=0;i<targets.length;i++) { var obj = targets[i];
+		        var objResults = new Array(options.keys.length);
+		        for (var keyI = options.keys.length - 1; keyI >= 0; --keyI) {
+		          var target = getValue(obj, options.keys[keyI]);
+		          if(!target) { objResults[keyI] = NULL; continue }
+		          if(!isObj(target)) target = getPrepared(target);
+		          target.score = INT_MIN;
+		          target._indexes.len = 0;
+		          objResults[keyI] = target;
+		        }
+		        objResults.obj = obj;
+		        objResults.score = INT_MIN;
+		        results.push(objResults); if(results.length >= limit) return results
+		      }
+		    } else {
+		      for(var i=0;i<targets.length;i++) { var target = targets[i];
+		        if(!target) continue
+		        if(!isObj(target)) target = getPrepared(target);
+		        target.score = INT_MIN;
+		        target._indexes.len = 0;
+		        results.push(target); if(results.length >= limit) return results
+		      }
+		    }
+
+		    return results
+		  };
+
+
+		  var algorithm = (preparedSearch, prepared, allowSpaces=false) => {
+		    if(allowSpaces===false && preparedSearch.containsSpace) return algorithmSpaces(preparedSearch, prepared)
+
+		    var searchLower = preparedSearch._lower;
+		    var searchLowerCodes = preparedSearch.lowerCodes;
+		    var searchLowerCode = searchLowerCodes[0];
+		    var targetLowerCodes = prepared._targetLowerCodes;
+		    var searchLen = searchLowerCodes.length;
+		    var targetLen = targetLowerCodes.length;
+		    var searchI = 0; // where we at
+		    var targetI = 0; // where you at
+		    var matchesSimpleLen = 0;
+
+		    // very basic fuzzy match; to remove non-matching targets ASAP!
+		    // walk through target. find sequential matches.
+		    // if all chars aren't found then exit
+		    for(;;) {
+		      var isMatch = searchLowerCode === targetLowerCodes[targetI];
+		      if(isMatch) {
+		        matchesSimple[matchesSimpleLen++] = targetI;
+		        ++searchI; if(searchI === searchLen) break
+		        searchLowerCode = searchLowerCodes[searchI];
+		      }
+		      ++targetI; if(targetI >= targetLen) return NULL // Failed to find searchI
+		    }
+
+		    var searchI = 0;
+		    var successStrict = false;
+		    var matchesStrictLen = 0;
+
+		    var nextBeginningIndexes = prepared._nextBeginningIndexes;
+		    if(nextBeginningIndexes === NULL) nextBeginningIndexes = prepared._nextBeginningIndexes = prepareNextBeginningIndexes(prepared.target);
+		    targetI = matchesSimple[0]===0 ? 0 : nextBeginningIndexes[matchesSimple[0]-1];
+
+		    // Our target string successfully matched all characters in sequence!
+		    // Let's try a more advanced and strict test to improve the score
+		    // only count it as a match if it's consecutive or a beginning character!
+		    var backtrackCount = 0;
+		    if(targetI !== targetLen) for(;;) {
+		      if(targetI >= targetLen) {
+		        // We failed to find a good spot for this search char, go back to the previous search char and force it forward
+		        if(searchI <= 0) break // We failed to push chars forward for a better match
+
+		        ++backtrackCount; if(backtrackCount > 200) break // exponential backtracking is taking too long, just give up and return a bad match
+
+		        --searchI;
+		        var lastMatch = matchesStrict[--matchesStrictLen];
+		        targetI = nextBeginningIndexes[lastMatch];
+
+		      } else {
+		        var isMatch = searchLowerCodes[searchI] === targetLowerCodes[targetI];
+		        if(isMatch) {
+		          matchesStrict[matchesStrictLen++] = targetI;
+		          ++searchI; if(searchI === searchLen) { successStrict = true; break }
+		          ++targetI;
+		        } else {
+		          targetI = nextBeginningIndexes[targetI];
+		        }
+		      }
+		    }
+
+		    // check if it's a substring match
+		    var substringIndex = prepared._targetLower.indexOf(searchLower, matchesSimple[0]); // perf: this is slow
+		    var isSubstring = ~substringIndex;
+		    if(isSubstring && !successStrict) { // rewrite the indexes from basic to the substring
+		      for(var i=0; i<matchesSimpleLen; ++i) matchesSimple[i] = substringIndex+i;
+		    }
+		    var isSubstringBeginning = false;
+		    if(isSubstring) {
+		      isSubstringBeginning = prepared._nextBeginningIndexes[substringIndex-1] === substringIndex;
+		    }
+
+		    { // tally up the score & keep track of matches for highlighting later
+		      if(successStrict) { var matchesBest = matchesStrict; var matchesBestLen = matchesStrictLen; }
+		      else { var matchesBest = matchesSimple; var matchesBestLen = matchesSimpleLen; }
+
+		      var score = 0;
+
+		      var extraMatchGroupCount = 0;
+		      for(var i = 1; i < searchLen; ++i) {
+		        if(matchesBest[i] - matchesBest[i-1] !== 1) {score -= matchesBest[i]; ++extraMatchGroupCount;}
+		      }
+		      var unmatchedDistance = matchesBest[searchLen-1] - matchesBest[0] - (searchLen-1);
+
+		      score -= (12+unmatchedDistance) * extraMatchGroupCount; // penality for more groups
+
+		      if(matchesBest[0] !== 0) score -= matchesBest[0]*matchesBest[0]*.2; // penality for not starting near the beginning
+
+		      if(!successStrict) {
+		        score *= 1000;
+		      } else {
+		        // successStrict on a target with too many beginning indexes loses points for being a bad target
+		        var uniqueBeginningIndexes = 1;
+		        for(var i = nextBeginningIndexes[0]; i < targetLen; i=nextBeginningIndexes[i]) ++uniqueBeginningIndexes;
+
+		        if(uniqueBeginningIndexes > 24) score *= (uniqueBeginningIndexes-24)*10; // quite arbitrary numbers here ...
+		      }
+
+		      if(isSubstring)          score /= 1+searchLen*searchLen*1; // bonus for being a full substring
+		      if(isSubstringBeginning) score /= 1+searchLen*searchLen*1; // bonus for substring starting on a beginningIndex
+
+		      score -= targetLen - searchLen; // penality for longer targets
+		      prepared.score = score;
+
+		      for(var i = 0; i < matchesBestLen; ++i) prepared._indexes[i] = matchesBest[i];
+		      prepared._indexes.len = matchesBestLen;
+
+		      return prepared
+		    }
+		  };
+		  var algorithmSpaces = (preparedSearch, target) => {
+		    var seen_indexes = new Set();
+		    var score = 0;
+		    var result = NULL;
+
+		    var first_seen_index_last_search = 0;
+		    var searches = preparedSearch.spaceSearches;
+		    for(var i=0; i<searches.length; ++i) {
+		      var search = searches[i];
+
+		      result = algorithm(search, target);
+		      if(result === NULL) return NULL
+
+		      score += result.score;
+
+		      // dock points based on order otherwise "c man" returns Manifest.cpp instead of CheatManager.h
+		      if(result._indexes[0] < first_seen_index_last_search) {
+		        score -= first_seen_index_last_search - result._indexes[0];
+		      }
+		      first_seen_index_last_search = result._indexes[0];
+
+		      for(var j=0; j<result._indexes.len; ++j) seen_indexes.add(result._indexes[j]);
+		    }
+
+		    // allows a search with spaces that's an exact substring to score well
+		    var allowSpacesResult = algorithm(preparedSearch, target, /*allowSpaces=*/true);
+		    if(allowSpacesResult !== NULL && allowSpacesResult.score > score) {
+		      return allowSpacesResult
+		    }
+
+		    result.score = score;
+
+		    var i = 0;
+		    for (let index of seen_indexes) result._indexes[i++] = index;
+		    result._indexes.len = i;
+
+		    return result
+		  };
+
+
+		  var prepareLowerInfo = (str) => {
+		    var strLen = str.length;
+		    var lower = str.toLowerCase();
+		    var lowerCodes = []; // new Array(strLen)    sparse array is too slow
+		    var bitflags = 0;
+		    var containsSpace = false; // space isn't stored in bitflags because of how searching with a space works
+
+		    for(var i = 0; i < strLen; ++i) {
+		      var lowerCode = lowerCodes[i] = lower.charCodeAt(i);
+
+		      if(lowerCode === 32) {
+		        containsSpace = true;
+		        continue // it's important that we don't set any bitflags for space
+		      }
+
+		      var bit = lowerCode>=97&&lowerCode<=122 ? lowerCode-97 // alphabet
+		              : lowerCode>=48&&lowerCode<=57  ? 26           // numbers
+		                                                             // 3 bits available
+		              : lowerCode<=127                ? 30           // other ascii
+		              :                                 31;           // other utf8
+		      bitflags |= 1<<bit;
+		    }
+
+		    return {lowerCodes:lowerCodes, bitflags:bitflags, containsSpace:containsSpace, _lower:lower}
+		  };
+		  var prepareBeginningIndexes = (target) => {
+		    var targetLen = target.length;
+		    var beginningIndexes = []; var beginningIndexesLen = 0;
+		    var wasUpper = false;
+		    var wasAlphanum = false;
+		    for(var i = 0; i < targetLen; ++i) {
+		      var targetCode = target.charCodeAt(i);
+		      var isUpper = targetCode>=65&&targetCode<=90;
+		      var isAlphanum = isUpper || targetCode>=97&&targetCode<=122 || targetCode>=48&&targetCode<=57;
+		      var isBeginning = isUpper && !wasUpper || !wasAlphanum || !isAlphanum;
+		      wasUpper = isUpper;
+		      wasAlphanum = isAlphanum;
+		      if(isBeginning) beginningIndexes[beginningIndexesLen++] = i;
+		    }
+		    return beginningIndexes
+		  };
+		  var prepareNextBeginningIndexes = (target) => {
+		    var targetLen = target.length;
+		    var beginningIndexes = prepareBeginningIndexes(target);
+		    var nextBeginningIndexes = []; // new Array(targetLen)     sparse array is too slow
+		    var lastIsBeginning = beginningIndexes[0];
+		    var lastIsBeginningI = 0;
+		    for(var i = 0; i < targetLen; ++i) {
+		      if(lastIsBeginning > i) {
+		        nextBeginningIndexes[i] = lastIsBeginning;
+		      } else {
+		        lastIsBeginning = beginningIndexes[++lastIsBeginningI];
+		        nextBeginningIndexes[i] = lastIsBeginning===undefined ? targetLen : lastIsBeginning;
+		      }
+		    }
+		    return nextBeginningIndexes
+		  };
+
+
+		  var cleanup = () => { preparedCache.clear(); preparedSearchCache.clear(); matchesSimple = []; matchesStrict = []; };
+
+		  var preparedCache       = new Map();
+		  var preparedSearchCache = new Map();
+		  var matchesSimple = []; var matchesStrict = [];
+
+
+		  // for use with keys. just returns the maximum score
+		  var defaultScoreFn = (a) => {
+		    var max = INT_MIN;
+		    var len = a.length;
+		    for (var i = 0; i < len; ++i) {
+		      var result = a[i]; if(result === NULL) continue
+		      var score = result.score;
+		      if(score > max) max = score;
+		    }
+		    if(max === INT_MIN) return NULL
+		    return max
+		  };
+
+		  // prop = 'key'              2.5ms optimized for this case, seems to be about as fast as direct obj[prop]
+		  // prop = 'key1.key2'        10ms
+		  // prop = ['key1', 'key2']   27ms
+		  var getValue = (obj, prop) => {
+		    var tmp = obj[prop]; if(tmp !== undefined) return tmp
+		    var segs = prop;
+		    if(!Array.isArray(prop)) segs = prop.split('.');
+		    var len = segs.length;
+		    var i = -1;
+		    while (obj && (++i < len)) obj = obj[segs[i]];
+		    return obj
+		  };
+
+		  var isObj = (x) => { return typeof x === 'object' }; // faster as a function
+		  // var INT_MAX = 9007199254740991; var INT_MIN = -INT_MAX
+		  var INT_MAX = Infinity; var INT_MIN = -INT_MAX;
+		  var noResults = []; noResults.total = 0;
+		  var NULL = null;
+
+
+		  // Hacked version of https://github.com/lemire/FastPriorityQueue.js
+		  var fastpriorityqueue=r=>{var e=[],o=0,a={},v=r=>{for(var a=0,v=e[a],c=1;c<o;){var s=c+1;a=c,s<o&&e[s].score<e[c].score&&(a=s),e[a-1>>1]=e[a],c=1+(a<<1);}for(var f=a-1>>1;a>0&&v.score<e[f].score;f=(a=f)-1>>1)e[a]=e[f];e[a]=v;};return a.add=(r=>{var a=o;e[o++]=r;for(var v=a-1>>1;a>0&&r.score<e[v].score;v=(a=v)-1>>1)e[a]=e[v];e[a]=r;}),a.poll=(r=>{if(0!==o){var a=e[0];return e[0]=e[--o],v(),a}}),a.peek=(r=>{if(0!==o)return e[0]}),a.replaceTop=(r=>{e[0]=r,v();}),a};
+		  var q = fastpriorityqueue(); // reuse this
+
+
+		  // fuzzysort is written this way for minification. all names are mangeled unless quoted
+		  return {'single':single, 'go':go, 'highlight':highlight, 'prepare':prepare, 'indexes':indexes, 'cleanup':cleanup}
+		}); // UMD
+
+		// TODO: (feature) frecency
+		// TODO: (perf) use different sorting algo depending on the # of results?
+		// TODO: (perf) preparedCache is a memory leak
+		// TODO: (like sublime) backslash === forwardslash
+		// TODO: (perf) prepareSearch seems slow 
+	} (fuzzysort$2));
+	return fuzzysort$2.exports;
+}
+
+var fuzzysortExports = requireFuzzysort();
+var fuzzysort = /*@__PURE__*/getDefaultExportFromCjs(fuzzysortExports);
+
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["Asc"] = "asc";
+    SortOrder["Desc"] = "desc";
+})(SortOrder || (SortOrder = {}));
+
+export { SortOrder as S, fuzzysort as f };

package/dist/{unit-system.enum-eaefb53e.js → unit-system.enum-BwPgAWqL.js}

@@ -1,7 +1,7 @@
 var UnitSystem;
 (function (UnitSystem) {
-  UnitSystem["Imperial"] = "imperial";
-  UnitSystem["Metric"] = "metric";
+    UnitSystem["Imperial"] = "imperial";
+    UnitSystem["Metric"] = "metric";
 })(UnitSystem || (UnitSystem = {}));
 
 export { UnitSystem as U };

package/dist/utils-DNHzysQ6.js

@@ -0,0 +1,61 @@
+function isNumber(str) {
+    return str !== null && str > '' && !isNaN(Number(str));
+}
+function formatNumber(n) {
+    return Number(n).toLocaleString(undefined, { minimumFractionDigits: 0 });
+}
+function isNullOrUndefined(input) {
+    return (input === null || input === undefined);
+}
+/**
+ * Check if current browser is Internet Explorer.
+ *
+ * @export
+ * @returns {boolean}
+ */
+function isInternetExplorer() {
+    return (navigator.userAgent.match(/Trident/g) || navigator.userAgent.match(/MSIE/g)) ? true : false;
+}
+/**
+ * Check if string is a valid URL.
+ * @param {string} urlString
+ * @returns {boolean}
+ */
+function isUrlValid(urlString) {
+    try {
+        new URL(urlString);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * Append query parameters to image URL hosted by MapsIndoors to request with specific size or scale depending on hostname.
+ * @param {string} imageURL - URL for image
+ * @param {number} iconDisplaySize - The width and height that the icon should be displayed in
+ * @returns string
+ */
+function appendMapsIndoorsImageQueryParameters(imageURL, iconDisplaySize) {
+    if (isUrlValid(imageURL) === false) {
+        return;
+    }
+    const url = new URL(imageURL);
+    const hostname = url.hostname;
+    if (hostname === 'image.mapsindoors.com') {
+        // Add query parameters for image size and fitMode.
+        const devicePixelRatio = Math.max(2, window.devicePixelRatio || 1); // Forced minimum of 2 to circumvent poor scaling quality delivered from the image API (see MIBAPI-2566)
+        const imageRequestWidth = iconDisplaySize * devicePixelRatio;
+        const imageRequestHeight = iconDisplaySize * devicePixelRatio;
+        url.searchParams.set('width', imageRequestWidth.toString());
+        url.searchParams.set('height', imageRequestHeight.toString());
+        url.searchParams.set('fitMode', 'cover');
+    }
+    if (['app.mapsindoors.com', 'v2.mapsindoors.com'].includes(hostname)) {
+        // For legacy images, add a scale parameter
+        url.searchParams.set('scale', '2');
+    }
+    return url.toString();
+}
+
+export { isNumber as a, appendMapsIndoorsImageQueryParameters as b, isInternetExplorer as c, formatNumber as f, isNullOrUndefined as i };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapsindoors/map-template",
   "description": "Get a MapsIndoors map up and running in less than 10 mins.",
-  "version": "1.95.0",
+  "version": "1.95.2",
   "private": false,
   "files": [
     "dist/*.js",

package/dist/_commonjsHelpers-ba3f0406.js

@@ -1,21 +0,0 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-export { commonjsGlobal as a, createCommonjsModule as c, getDefaultExportFromCjs as g };