@unocss/preset-mini 0.19.0 → 0.20.4

package/dist/chunks/default3.cjs

@@ -48,43 +48,28 @@ const variantCombinators = [
 
 const variantColorsMediaOrClass = [
   (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
+    if (dark === "class")
+      return variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
+    if (dark === "class")
+      return variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variants$1.variantMatcher("dark")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: dark)"
-        };
-      }
-    }
+    if (dark === "media")
+      return variants$1.variantParentMatcher("dark", "@media (prefers-color-scheme: dark)")(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variants$1.variantMatcher("light")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: light)"
-        };
-      }
-    }
+    if (dark === "media")
+      return variants$1.variantParentMatcher("light", "@media (prefers-color-scheme: light)")(v);
   }
 ];
 
+const variantLanguageDirections = [
+  variants$1.variantMatcher("rtl", (input) => `[dir="rtl"] $$ ${input}`),
+  variants$1.variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
+];
+
 const variantImportant = {
   match(matcher) {
     if (matcher.startsWith("!")) {
@@ -118,21 +103,25 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
+
+const variantMotions = [
+  variants$1.variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
+  variants$1.variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
+];
+
+const variantOrientations = [
+  variants$1.variantParentMatcher("landscape", "@media (orientation: landscape)"),
+  variants$1.variantParentMatcher("portrait", "@media (orientation: portrait)")
+];
+
+const variantPrint = variants$1.variantParentMatcher("print", "@media print");
 
 const variants = [
-  variantSpace,
   variantNegative,
   variantImportant,
+  variantPrint,
+  ...variantOrientations,
+  ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
   pseudo.variantPseudoClasses,
@@ -140,13 +129,17 @@ const variants = [
   pseudo.variantTaggedPseudoClasses,
   pseudo.variantPseudoElements,
   pseudo.partClasses,
-  ...variantColorsMediaOrClass
+  ...variantColorsMediaOrClass,
+  ...variantLanguageDirections
 ];
 
 exports.variantBreakpoints = variantBreakpoints;
 exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
+exports.variantLanguageDirections = variantLanguageDirections;
+exports.variantMotions = variantMotions;
 exports.variantNegative = variantNegative;
-exports.variantSpace = variantSpace;
+exports.variantOrientations = variantOrientations;
+exports.variantPrint = variantPrint;
 exports.variants = variants;

package/dist/chunks/default3.mjs

@@ -1,4 +1,4 @@
-import { v as variantMatcher } from './variants.mjs';
+import { v as variantMatcher, a as variantParentMatcher } from './variants.mjs';
 import { v as variantPseudoClasses, a as variantPseudoClassFunctions, b as variantTaggedPseudoClasses, c as variantPseudoElements, p as partClasses } from './pseudo.mjs';
 
 const regexCache = {};
@@ -46,43 +46,28 @@ const variantCombinators = [
 
 const variantColorsMediaOrClass = [
   (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
+    if (dark === "class")
+      return variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
+    if (dark === "class")
+      return variantMatcher("light", (input) => `.light $$ ${input}`)(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variantMatcher("dark")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: dark)"
-        };
-      }
-    }
+    if (dark === "media")
+      return variantParentMatcher("dark", "@media (prefers-color-scheme: dark)")(v);
   },
   (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variantMatcher("light")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: light)"
-        };
-      }
-    }
+    if (dark === "media")
+      return variantParentMatcher("light", "@media (prefers-color-scheme: light)")(v);
   }
 ];
 
+const variantLanguageDirections = [
+  variantMatcher("rtl", (input) => `[dir="rtl"] $$ ${input}`),
+  variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
+];
+
 const variantImportant = {
   match(matcher) {
     if (matcher.startsWith("!")) {
@@ -116,21 +101,25 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
+
+const variantMotions = [
+  variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
+  variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
+];
+
+const variantOrientations = [
+  variantParentMatcher("landscape", "@media (orientation: landscape)"),
+  variantParentMatcher("portrait", "@media (orientation: portrait)")
+];
+
+const variantPrint = variantParentMatcher("print", "@media print");
 
 const variants = [
-  variantSpace,
   variantNegative,
   variantImportant,
+  variantPrint,
+  ...variantOrientations,
+  ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
   variantPseudoClasses,
@@ -138,7 +127,8 @@ const variants = [
   variantTaggedPseudoClasses,
   variantPseudoElements,
   partClasses,
-  ...variantColorsMediaOrClass
+  ...variantColorsMediaOrClass,
+  ...variantLanguageDirections
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantImportant as d, variantNegative as e, variantSpace as f, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantLanguageDirections as d, variantImportant as e, variantNegative as f, variantMotions as g, variantOrientations as h, variantPrint as i, variants as v };

package/dist/chunks/pseudo.cjs

@@ -8,6 +8,7 @@ const PseudoClasses = Object.fromEntries([
   "link",
   "visited",
   "target",
+  ["open", "[open]"],
   "hover",
   "active",
   "focus-visible",
@@ -24,39 +25,44 @@ const PseudoClasses = Object.fromEntries([
   "indeterminate",
   "valid",
   "invalid",
+  "in-range",
+  "out-of-range",
   "required",
   "optional",
   "root",
   "empty",
-  ["even-of-type", "nth-of-type(even)"],
-  ["even", "nth-child(even)"],
-  ["odd-of-type", "nth-of-type(odd)"],
-  ["odd", "nth-child(odd)"],
+  ["even-of-type", ":nth-of-type(even)"],
+  ["even", ":nth-child(even)"],
+  ["odd-of-type", ":nth-of-type(odd)"],
+  ["odd", ":nth-child(odd)"],
   "first-of-type",
-  ["first", "first-child"],
+  ["first", ":first-child"],
   "last-of-type",
-  ["last", "last-child"],
+  ["last", ":last-child"],
   "only-child",
   "only-of-type"
 ].map(core.toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
-  "selection"
-];
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(core.toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+const PseudoElementsStr = Object.keys(PseudoElements).join("|");
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
+const PseudoElementsRE = new RegExp(`^(${PseudoElementsStr})[:-]`);
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 function shouldAdd(entires) {
@@ -68,13 +74,13 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   return (input) => {
     const match = input.match(re);
     if (match) {
-      let pseudo = PseudoClasses[match[3]] || match[3];
+      let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
       if (match[2])
-        pseudo = `${match[2]}(:${pseudo})`;
+        pseudo = `:${match[2]}(${pseudo})`;
       return {
         matcher: input.slice(match[1].length + tag.length + 2),
         selector: (s, body) => {
-          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}:${pseudo}:`) : `${parent}:${pseudo}${combinator}${s}`;
+          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}${pseudo}:`) : `${parent}${pseudo}${combinator}${s}`;
         }
       };
     }
@@ -83,9 +89,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 const variantPseudoElements = (input) => {
   const match = input.match(PseudoElementsRE);
   if (match) {
+    const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s) => `${s}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };
@@ -93,10 +100,10 @@ const variantPseudoClasses = {
   match: (input) => {
     const match = input.match(PseudoClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[1].length + 1),
-        selector: (s, body) => shouldAdd(body) && `${s}:${pseudo}`
+        selector: (s, body) => shouldAdd(body) && `${s}${pseudo}`
       };
     }
   },
@@ -107,10 +114,10 @@ const variantPseudoClassFunctions = {
     const match = input.match(PseudoClassFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || match[2];
+      const pseudo = PseudoClasses[match[2]] || `:${match[2]}`;
       return {
         matcher: input.slice(match[1].length + match[2].length + 2),
-        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(:${pseudo})`
+        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(${pseudo})`
       };
     }
   },

package/dist/chunks/pseudo.mjs

@@ -6,6 +6,7 @@ const PseudoClasses = Object.fromEntries([
   "link",
   "visited",
   "target",
+  ["open", "[open]"],
   "hover",
   "active",
   "focus-visible",
@@ -22,39 +23,44 @@ const PseudoClasses = Object.fromEntries([
   "indeterminate",
   "valid",
   "invalid",
+  "in-range",
+  "out-of-range",
   "required",
   "optional",
   "root",
   "empty",
-  ["even-of-type", "nth-of-type(even)"],
-  ["even", "nth-child(even)"],
-  ["odd-of-type", "nth-of-type(odd)"],
-  ["odd", "nth-child(odd)"],
+  ["even-of-type", ":nth-of-type(even)"],
+  ["even", ":nth-child(even)"],
+  ["odd-of-type", ":nth-of-type(odd)"],
+  ["odd", ":nth-child(odd)"],
   "first-of-type",
-  ["first", "first-child"],
+  ["first", ":first-child"],
   "last-of-type",
-  ["last", "last-child"],
+  ["last", ":last-child"],
   "only-child",
   "only-of-type"
 ].map(toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
-  "selection"
-];
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+const PseudoElementsStr = Object.keys(PseudoElements).join("|");
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
+const PseudoElementsRE = new RegExp(`^(${PseudoElementsStr})[:-]`);
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 function shouldAdd(entires) {
@@ -66,13 +72,13 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   return (input) => {
     const match = input.match(re);
     if (match) {
-      let pseudo = PseudoClasses[match[3]] || match[3];
+      let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
       if (match[2])
-        pseudo = `${match[2]}(:${pseudo})`;
+        pseudo = `:${match[2]}(${pseudo})`;
       return {
         matcher: input.slice(match[1].length + tag.length + 2),
         selector: (s, body) => {
-          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}:${pseudo}:`) : `${parent}:${pseudo}${combinator}${s}`;
+          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}${pseudo}:`) : `${parent}${pseudo}${combinator}${s}`;
         }
       };
     }
@@ -81,9 +87,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 const variantPseudoElements = (input) => {
   const match = input.match(PseudoElementsRE);
   if (match) {
+    const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s) => `${s}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };
@@ -91,10 +98,10 @@ const variantPseudoClasses = {
   match: (input) => {
     const match = input.match(PseudoClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[1].length + 1),
-        selector: (s, body) => shouldAdd(body) && `${s}:${pseudo}`
+        selector: (s, body) => shouldAdd(body) && `${s}${pseudo}`
       };
     }
   },
@@ -105,10 +112,10 @@ const variantPseudoClassFunctions = {
     const match = input.match(PseudoClassFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || match[2];
+      const pseudo = PseudoClasses[match[2]] || `:${match[2]}`;
       return {
         matcher: input.slice(match[1].length + match[2].length + 2),
-        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(:${pseudo})`
+        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(${pseudo})`
       };
     }
   },

package/dist/chunks/utilities.cjs

@@ -35,6 +35,31 @@ const xyzMap = {
   "z": ["-z"],
   "": ["-x", "-y"]
 };
+const basePositionMap = [
+  "top",
+  "top center",
+  "top left",
+  "top right",
+  "bottom",
+  "bottom center",
+  "bottom left",
+  "bottom right",
+  "left",
+  "left center",
+  "left top",
+  "left bottom",
+  "right",
+  "right center",
+  "right top",
+  "right bottom",
+  "center",
+  "center top",
+  "center bottom",
+  "center left",
+  "center right",
+  "center center"
+];
+const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
 
 const cssBasicProps = [
   "color",
@@ -93,13 +118,17 @@ const cssProps = [
 const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
 const unitOnlyRE = /^(px)$/i;
+function round(n) {
+  return n.toFixed(10).replace(/\.0+$/, "").replace(/(\.\d+?)0+$/, "$1");
+}
 function numberWithUnit(str) {
   const match = str.match(numberWithUnitRE);
   if (!match)
     return;
-  const [, , unit] = match;
-  if (unit)
-    return str;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (unit && !Number.isNaN(num))
+    return `${round(num)}${unit}`;
 }
 function auto(str) {
   if (str === "auto" || str === "a")
@@ -112,11 +141,9 @@ function rem(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num / 4}rem`;
+    return unit ? `${round(num)}${unit}` : `${round(num / 4)}rem`;
 }
 function px(str) {
   if (str.match(unitOnlyRE))
@@ -125,25 +152,23 @@ function px(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num}px`;
+    return unit ? `${round(num)}${unit}` : `${round(num)}px`;
 }
 function number(str) {
   if (!numberRE.test(str))
     return;
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return num;
+    return round(num);
 }
 function percent(str) {
   if (str.endsWith("%"))
     str = str.slice(0, -1);
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return `${num / 100}`;
+    return `${round(num / 100)}`;
 }
 function fraction(str) {
   if (str === "full")
@@ -151,7 +176,7 @@ function fraction(str) {
   const [left, right] = str.split("/");
   const num = parseFloat(left) / parseFloat(right);
   if (!Number.isNaN(num))
-    return `${num * 100}%`;
+    return `${round(num * 100)}%`;
 }
 function bracket(str) {
   if (str && str[0] === "[" && str[str.length - 1] === "]") {
@@ -165,20 +190,19 @@ function cssvar(str) {
     return `var(--${str.slice(1)})`;
 }
 function time(str) {
-  const duration = Number(str.replace(/(s|ms)$/, ""));
-  if (isNaN(duration))
+  const match = str.match(/^(-?[0-9.]+)(s|ms)?$/i);
+  if (!match)
     return;
-  if (/(s|ms)$/.test(str))
-    return str;
-  return `${str}ms`;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
 function global(str) {
   if (["inherit", "initial", "revert", "unset"].includes(str))
     return str;
 }
 function properties(str) {
-  if (str === void 0)
-    return;
   for (const prop of str.split(",")) {
     if (!cssProps.includes(prop))
       return;
@@ -225,8 +249,10 @@ const parseColor = (body, theme) => {
   const bracketOrMain = bracket || main;
   if (bracketOrMain.startsWith("#"))
     color = bracketOrMain.slice(1);
-  if (bracketOrMain.startsWith("hex-"))
+  else if (bracketOrMain.startsWith("hex-"))
     color = bracketOrMain.slice(4);
+  else if (main.startsWith("$"))
+    color = handler.cssvar(main);
   color = color || bracket;
   let no = "DEFAULT";
   if (!color) {
@@ -247,37 +273,46 @@ const parseColor = (body, theme) => {
     else if (no && colorData)
       color = colorData[no];
   }
+  const rgba = core.hex2rgba(color);
+  const alpha = opacity ? opacity[0] === "[" ? handler.bracket.percent(opacity) : parseFloat(opacity) / 100 : rgba?.[3];
+  const hasAlpha = alpha != null && !Number.isNaN(alpha);
+  if (rgba) {
+    if (hasAlpha) {
+      rgba[3] = typeof alpha === "string" && !alpha.includes("%") ? parseFloat(alpha) : alpha;
+    } else {
+      rgba.splice(3);
+    }
+  }
   return {
     opacity,
     name,
     no,
     color,
-    rgba: core.hex2rgba(color)
+    rgba,
+    alpha: hasAlpha ? alpha : void 0
   };
 };
 const colorResolver = (property, varName) => ([, body], { theme }) => {
   const data = parseColor(body, theme);
   if (!data)
     return;
-  const { opacity, color, rgba } = data;
+  const { alpha, opacity, color, rgba } = data;
   if (!color)
     return;
-  const a = opacity ? opacity[0] === "[" ? handler.bracket.percent(opacity) : parseFloat(opacity) / 100 : rgba?.[3];
   if (rgba) {
-    if (a != null && !Number.isNaN(a)) {
-      rgba[3] = typeof a === "string" && !a.includes("%") ? parseFloat(a) : a;
+    if (alpha != null) {
       return {
         [property]: `rgba(${rgba.join(",")})`
       };
     } else {
       return {
-        [`--un-${varName}-opacity`]: 1,
-        [property]: `rgba(${rgba.slice(0, 3).join(",")},var(--un-${varName}-opacity))`
+        [`--un-${varName}-opacity`]: (opacity && handler.cssvar(opacity)) ?? 1,
+        [property]: `rgba(${rgba.join(",")},var(--un-${varName}-opacity))`
       };
     }
   } else {
     return {
-      [property]: color.replace("%alpha", `${a || 1}`)
+      [property]: color.replace("%alpha", `${alpha || 1}`)
     };
   }
 };
@@ -290,5 +325,6 @@ exports.directionSize = directionSize;
 exports.h = h;
 exports.handler = handler;
 exports.parseColor = parseColor;
+exports.positionMap = positionMap;
 exports.valueHandlers = valueHandlers;
 exports.xyzMap = xyzMap;