@unocss/preset-mini 0.58.8 → 0.59.0-beta.1

package/dist/rules.d.cts

@@ -1,129 +0,0 @@
-import { Rule, CSSEntries, StaticRule } from '@unocss/core';
-import { T as Theme } from './shared/preset-mini.P5Rzuhf5.cjs';
-
-declare const verticalAligns: Rule[];
-declare const textAligns: Rule[];
-
-declare const outline: Rule<Theme>[];
-declare const appearance: Rule[];
-declare const willChange: Rule[];
-
-declare const borderStyles: string[];
-declare const borders: Rule[];
-declare function handlerBorderStyle([, a, s]: string[]): CSSEntries | undefined;
-
-/**
- * @example op10 op-30 opacity-100
- */
-declare const opacity: Rule[];
-declare const bgColors: Rule[];
-declare const colorScheme: Rule[];
-
-declare const containerParent: Rule[];
-
-declare const textDecorations: Rule<Theme>[];
-
-declare const rules: Rule<Theme>[];
-
-declare const flex: Rule<Theme>[];
-
-declare const gaps: Rule[];
-
-declare const grids: Rule<Theme>[];
-
-declare const overflows: Rule[];
-
-declare const positions: Rule[];
-declare const justifies: StaticRule[];
-declare const orders: Rule[];
-declare const alignments: StaticRule[];
-declare const placements: StaticRule[];
-/**
- * This is to add `flex-` and `grid-` prefix to the alignment rules,
- * supporting `flex="~ items-center"` in attributify mode.
- */
-declare const flexGridJustifiesAlignments: StaticRule[];
-declare const insets: Rule[];
-declare const floats: Rule[];
-declare const zIndexes: Rule[];
-declare const boxSizing: Rule[];
-
-/**
- * Used for debugging, only available in development mode.
- *
- * @example `?` / `where`
- */
-declare const questionMark: Rule[];
-
-declare const ringBase: {
-    '--un-ring-inset': string;
-    '--un-ring-offset-width': string;
-    '--un-ring-offset-color': string;
-    '--un-ring-width': string;
-    '--un-ring-color': string;
-    '--un-shadow': string;
-};
-declare const rings: Rule<Theme>[];
-
-declare const boxShadowsBase: {
-    '--un-ring-offset-shadow': string;
-    '--un-ring-shadow': string;
-    '--un-shadow-inset': string;
-    '--un-shadow': string;
-};
-declare const boxShadows: Rule<Theme>[];
-
-declare const sizes: Rule<Theme>[];
-declare const aspectRatio: Rule[];
-
-declare const paddings: Rule[];
-declare const margins: Rule[];
-
-declare const varEmpty = " ";
-declare const displays: Rule[];
-declare const appearances: Rule[];
-declare const cursors: Rule[];
-declare const contains: Rule[];
-declare const pointerEvents: Rule[];
-declare const resizes: Rule[];
-declare const userSelects: Rule[];
-declare const whitespaces: Rule[];
-declare const contentVisibility: Rule[];
-declare const contents: Rule[];
-declare const breaks: Rule[];
-declare const textWraps: Rule[];
-declare const textOverflows: Rule[];
-declare const textTransforms: Rule[];
-declare const fontStyles: Rule[];
-declare const fontSmoothings: Rule[];
-
-declare const svgUtilities: Rule<Theme>[];
-
-declare const transformBase: {
-    '--un-rotate': number;
-    '--un-rotate-x': number;
-    '--un-rotate-y': number;
-    '--un-rotate-z': number;
-    '--un-scale-x': number;
-    '--un-scale-y': number;
-    '--un-scale-z': number;
-    '--un-skew-x': number;
-    '--un-skew-y': number;
-    '--un-translate-x': number;
-    '--un-translate-y': number;
-    '--un-translate-z': number;
-};
-declare const transforms: Rule[];
-
-declare const transitions: Rule<Theme>[];
-
-declare const fonts: Rule<Theme>[];
-declare const tabSizes: Rule<Theme>[];
-declare const textIndents: Rule<Theme>[];
-declare const textStrokes: Rule<Theme>[];
-declare const textShadows: Rule<Theme>[];
-
-declare const cssVariables: Rule[];
-declare const cssProperty: Rule[];
-
-export { alignments, appearance, appearances, aspectRatio, bgColors, borderStyles, borders, boxShadows, boxShadowsBase, boxSizing, breaks, colorScheme, containerParent, contains, contentVisibility, contents, cssProperty, cssVariables, cursors, displays, flex, flexGridJustifiesAlignments, floats, fontSmoothings, fontStyles, fonts, gaps, grids, handlerBorderStyle, insets, justifies, margins, opacity, orders, outline, overflows, paddings, placements, pointerEvents, positions, questionMark, resizes, ringBase, rings, rules, sizes, svgUtilities, tabSizes, textAligns, textDecorations, textIndents, textOverflows, textShadows, textStrokes, textTransforms, textWraps, transformBase, transforms, transitions, userSelects, varEmpty, verticalAligns, whitespaces, willChange, zIndexes };

package/dist/shared/preset-mini.BCYTcd-i.cjs

@@ -1,582 +0,0 @@
-'use strict';
-
-const core = require('@unocss/core');
-const ruleUtils = require('@unocss/rule-utils');
-
-const directionMap = {
-  "l": ["-left"],
-  "r": ["-right"],
-  "t": ["-top"],
-  "b": ["-bottom"],
-  "s": ["-inline-start"],
-  "e": ["-inline-end"],
-  "x": ["-left", "-right"],
-  "y": ["-top", "-bottom"],
-  "": [""],
-  "bs": ["-block-start"],
-  "be": ["-block-end"],
-  "is": ["-inline-start"],
-  "ie": ["-inline-end"],
-  "block": ["-block-start", "-block-end"],
-  "inline": ["-inline-start", "-inline-end"]
-};
-const insetMap = {
-  ...directionMap,
-  s: ["-inset-inline-start"],
-  start: ["-inset-inline-start"],
-  e: ["-inset-inline-end"],
-  end: ["-inset-inline-end"],
-  bs: ["-inset-block-start"],
-  be: ["-inset-block-end"],
-  is: ["-inset-inline-start"],
-  ie: ["-inset-inline-end"],
-  block: ["-inset-block-start", "-inset-block-end"],
-  inline: ["-inset-inline-start", "-inset-inline-end"]
-};
-const cornerMap = {
-  "l": ["-top-left", "-bottom-left"],
-  "r": ["-top-right", "-bottom-right"],
-  "t": ["-top-left", "-top-right"],
-  "b": ["-bottom-left", "-bottom-right"],
-  "tl": ["-top-left"],
-  "lt": ["-top-left"],
-  "tr": ["-top-right"],
-  "rt": ["-top-right"],
-  "bl": ["-bottom-left"],
-  "lb": ["-bottom-left"],
-  "br": ["-bottom-right"],
-  "rb": ["-bottom-right"],
-  "": [""],
-  "bs": ["-start-start", "-start-end"],
-  "be": ["-end-start", "-end-end"],
-  "s": ["-end-start", "-start-start"],
-  "is": ["-end-start", "-start-start"],
-  "e": ["-start-end", "-end-end"],
-  "ie": ["-start-end", "-end-end"],
-  "ss": ["-start-start"],
-  "bs-is": ["-start-start"],
-  "is-bs": ["-start-start"],
-  "se": ["-start-end"],
-  "bs-ie": ["-start-end"],
-  "ie-bs": ["-start-end"],
-  "es": ["-end-start"],
-  "be-is": ["-end-start"],
-  "is-be": ["-end-start"],
-  "ee": ["-end-end"],
-  "be-ie": ["-end-end"],
-  "ie-be": ["-end-end"]
-};
-const xyzMap = {
-  "x": ["-x"],
-  "y": ["-y"],
-  "z": ["-z"],
-  "": ["-x", "-y"]
-};
-const xyzArray = ["x", "y", "z"];
-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 globalKeywords = [
-  "inherit",
-  "initial",
-  "revert",
-  "revert-layer",
-  "unset"
-];
-const cssMathFnRE = /^(calc|clamp|min|max)\s*\((.+)\)(.*)/;
-
-const numberWithUnitRE = /^(-?\d*(?:\.\d+)?)(px|pt|pc|%|r?(?:em|ex|lh|cap|ch|ic)|(?:[sld]?v|cq)(?:[whib]|min|max)|in|cm|mm|rpx)?$/i;
-const numberRE = /^(-?\d*(?:\.\d+)?)$/i;
-const unitOnlyRE = /^(px)$/i;
-const bracketTypeRe = /^\[(color|length|size|position|quoted|string):/i;
-const splitComma = /,(?![^()]*\))/g;
-
-const cssProps = [
-  // basic props
-  "color",
-  "border-color",
-  "background-color",
-  "flex-grow",
-  "flex",
-  "flex-shrink",
-  "caret-color",
-  "font",
-  "gap",
-  "opacity",
-  "visibility",
-  "z-index",
-  "font-weight",
-  "zoom",
-  "text-shadow",
-  "transform",
-  "box-shadow",
-  // positions
-  "background-position",
-  "left",
-  "right",
-  "top",
-  "bottom",
-  "object-position",
-  // sizes
-  "max-height",
-  "min-height",
-  "max-width",
-  "min-width",
-  "height",
-  "width",
-  "border-width",
-  "margin",
-  "padding",
-  "outline-width",
-  "outline-offset",
-  "font-size",
-  "line-height",
-  "text-indent",
-  "vertical-align",
-  "border-spacing",
-  "letter-spacing",
-  "word-spacing",
-  // enhances
-  "stroke",
-  "filter",
-  "backdrop-filter",
-  "fill",
-  "mask",
-  "mask-size",
-  "mask-border",
-  "clip-path",
-  "clip",
-  "border-radius"
-];
-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 [, n, unit] = match;
-  const num = Number.parseFloat(n);
-  if (unit && !Number.isNaN(num))
-    return `${round(num)}${unit}`;
-}
-function auto(str) {
-  if (str === "auto" || str === "a")
-    return "auto";
-}
-function rem(str) {
-  if (!str)
-    return;
-  if (unitOnlyRE.test(str))
-    return `1${str}`;
-  const match = str.match(numberWithUnitRE);
-  if (!match)
-    return;
-  const [, n, unit] = match;
-  const num = Number.parseFloat(n);
-  if (!Number.isNaN(num)) {
-    if (num === 0)
-      return "0";
-    return unit ? `${round(num)}${unit}` : `${round(num / 4)}rem`;
-  }
-}
-function px(str) {
-  if (unitOnlyRE.test(str))
-    return `1${str}`;
-  const match = str.match(numberWithUnitRE);
-  if (!match)
-    return;
-  const [, n, unit] = match;
-  const num = Number.parseFloat(n);
-  if (!Number.isNaN(num))
-    return unit ? `${round(num)}${unit}` : `${round(num)}px`;
-}
-function number(str) {
-  if (!numberRE.test(str))
-    return;
-  const num = Number.parseFloat(str);
-  if (!Number.isNaN(num))
-    return round(num);
-}
-function percent(str) {
-  if (str.endsWith("%"))
-    str = str.slice(0, -1);
-  if (!numberRE.test(str))
-    return;
-  const num = Number.parseFloat(str);
-  if (!Number.isNaN(num))
-    return `${round(num / 100)}`;
-}
-function fraction(str) {
-  if (!str)
-    return;
-  if (str === "full")
-    return "100%";
-  const [left, right] = str.split("/");
-  const num = Number.parseFloat(left) / Number.parseFloat(right);
-  if (!Number.isNaN(num)) {
-    if (num === 0)
-      return "0";
-    return `${round(num * 100)}%`;
-  }
-}
-function bracketWithType(str, requiredType) {
-  if (str && str.startsWith("[") && str.endsWith("]")) {
-    let base;
-    let hintedType;
-    const match = str.match(bracketTypeRe);
-    if (!match) {
-      base = str.slice(1, -1);
-    } else {
-      if (!requiredType)
-        hintedType = match[1];
-      base = str.slice(match[0].length, -1);
-    }
-    if (!base)
-      return;
-    if (base === '=""')
-      return;
-    if (base.startsWith("--"))
-      base = `var(${base})`;
-    let curly = 0;
-    for (const i of base) {
-      if (i === "[") {
-        curly += 1;
-      } else if (i === "]") {
-        curly -= 1;
-        if (curly < 0)
-          return;
-      }
-    }
-    if (curly)
-      return;
-    switch (hintedType) {
-      case "string":
-        return base.replace(/(^|[^\\])_/g, "$1 ").replace(/\\_/g, "_");
-      case "quoted":
-        return base.replace(/(^|[^\\])_/g, "$1 ").replace(/\\_/g, "_").replace(/(["\\])/g, "\\$1").replace(/^(.+)$/, '"$1"');
-    }
-    return base.replace(/(url\(.*?\))/g, (v) => v.replace(/_/g, "\\_")).replace(/(^|[^\\])_/g, "$1 ").replace(/\\_/g, "_").replace(/(?:calc|clamp|max|min)\((.*)/g, (match2) => {
-      const vars = [];
-      return match2.replace(/var\((--.+?)[,)]/g, (match3, g1) => {
-        vars.push(g1);
-        return match3.replace(g1, "--un-calc");
-      }).replace(/(-?\d*\.?\d(?!\b-\d.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ").replace(/--un-calc/g, () => vars.shift());
-    });
-  }
-}
-function bracket(str) {
-  return bracketWithType(str);
-}
-function bracketOfColor(str) {
-  return bracketWithType(str, "color");
-}
-function bracketOfLength(str) {
-  return bracketWithType(str, "length");
-}
-function bracketOfPosition(str) {
-  return bracketWithType(str, "position");
-}
-function cssvar(str) {
-  if (/^\$[^\s'"`;{}]/.test(str)) {
-    const [name, defaultValue] = str.slice(1).split(",");
-    return `var(--${core.escapeSelector(name)}${defaultValue ? `, ${defaultValue}` : ""})`;
-  }
-}
-function time(str) {
-  const match = str.match(/^(-?[0-9.]+)(s|ms)?$/i);
-  if (!match)
-    return;
-  const [, n, unit] = match;
-  const num = Number.parseFloat(n);
-  if (!Number.isNaN(num)) {
-    if (num === 0 && !unit)
-      return "0s";
-    return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
-  }
-}
-function degree(str) {
-  const match = str.match(/^(-?[0-9.]+)(deg|rad|grad|turn)?$/i);
-  if (!match)
-    return;
-  const [, n, unit] = match;
-  const num = Number.parseFloat(n);
-  if (!Number.isNaN(num)) {
-    if (num === 0)
-      return "0";
-    return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
-  }
-}
-function global(str) {
-  if (globalKeywords.includes(str))
-    return str;
-}
-function properties(str) {
-  if (str.split(",").every((prop) => cssProps.includes(prop)))
-    return str;
-}
-function position(str) {
-  if (["top", "left", "right", "bottom", "center"].includes(str))
-    return str;
-}
-
-const valueHandlers = {
-  __proto__: null,
-  auto: auto,
-  bracket: bracket,
-  bracketOfColor: bracketOfColor,
-  bracketOfLength: bracketOfLength,
-  bracketOfPosition: bracketOfPosition,
-  cssvar: cssvar,
-  degree: degree,
-  fraction: fraction,
-  global: global,
-  number: number,
-  numberWithUnit: numberWithUnit,
-  percent: percent,
-  position: position,
-  properties: properties,
-  px: px,
-  rem: rem,
-  time: time
-};
-
-const handler = ruleUtils.createValueHandler(valueHandlers);
-const h = handler;
-
-const CONTROL_MINI_NO_NEGATIVE = "$$mini-no-negative";
-function directionSize(propertyPrefix) {
-  return ([_, direction, size], { theme }) => {
-    const v = theme.spacing?.[size || "DEFAULT"] ?? h.bracket.cssvar.global.auto.fraction.rem(size);
-    if (v != null)
-      return directionMap[direction].map((i) => [`${propertyPrefix}${i}`, v]);
-  };
-}
-function getThemeColorForKey(theme, colors, key = "colors") {
-  let obj = theme[key];
-  let index = -1;
-  for (const c of colors) {
-    index += 1;
-    if (obj && typeof obj !== "string") {
-      const camel = colors.slice(index).join("-").replace(/(-[a-z])/g, (n) => n.slice(1).toUpperCase());
-      if (obj[camel])
-        return obj[camel];
-      if (obj[c]) {
-        obj = obj[c];
-        continue;
-      }
-    }
-    return void 0;
-  }
-  return obj;
-}
-function getThemeColor(theme, colors, key) {
-  return getThemeColorForKey(theme, colors, key) || getThemeColorForKey(theme, colors, "colors");
-}
-function splitShorthand(body, type) {
-  const [front, rest] = ruleUtils.getStringComponent(body, "[", "]", ["/", ":"]) ?? [];
-  if (front != null) {
-    const match = (front.match(bracketTypeRe) ?? [])[1];
-    if (match == null || match === type)
-      return [front, rest];
-  }
-}
-function parseColor(body, theme, key) {
-  const split = splitShorthand(body, "color");
-  if (!split)
-    return;
-  const [main, opacity] = split;
-  const colors = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
-  const [name] = colors;
-  if (!name)
-    return;
-  let color;
-  const bracket = h.bracketOfColor(main);
-  const bracketOrMain = bracket || main;
-  if (h.numberWithUnit(bracketOrMain))
-    return;
-  if (/^#[\da-fA-F]+$/.test(bracketOrMain))
-    color = bracketOrMain;
-  else if (/^hex-[\da-fA-F]+$/.test(bracketOrMain))
-    color = `#${bracketOrMain.slice(4)}`;
-  else if (main.startsWith("$"))
-    color = h.cssvar(main);
-  color = color || bracket;
-  if (!color) {
-    const colorData = getThemeColor(theme, [main], key);
-    if (typeof colorData === "string")
-      color = colorData;
-  }
-  let no = "DEFAULT";
-  if (!color) {
-    let colorData;
-    const [scale] = colors.slice(-1);
-    if (/^\d+$/.test(scale)) {
-      no = scale;
-      colorData = getThemeColor(theme, colors.slice(0, -1), key);
-      if (!colorData || typeof colorData === "string")
-        color = void 0;
-      else
-        color = colorData[no];
-    } else {
-      colorData = getThemeColor(theme, colors, key);
-      if (!colorData && colors.length <= 2) {
-        [, no = no] = colors;
-        colorData = getThemeColor(theme, [name], key);
-      }
-      if (typeof colorData === "string")
-        color = colorData;
-      else if (no && colorData)
-        color = colorData[no];
-    }
-  }
-  return {
-    opacity,
-    name,
-    no,
-    color,
-    cssColor: ruleUtils.parseCssColor(color),
-    alpha: h.bracket.cssvar.percent(opacity ?? "")
-  };
-}
-function colorResolver(property, varName, key, shouldPass) {
-  return ([, body], { theme }) => {
-    const data = parseColor(body, theme, key);
-    if (!data)
-      return;
-    const { alpha, color, cssColor } = data;
-    const css = {};
-    if (cssColor) {
-      if (alpha != null) {
-        css[property] = ruleUtils.colorToString(cssColor, alpha);
-      } else {
-        const opacityVar = `--un-${varName}-opacity`;
-        const result = ruleUtils.colorToString(cssColor, `var(${opacityVar})`);
-        if (result.includes(opacityVar))
-          css[opacityVar] = ruleUtils.colorOpacityToString(cssColor);
-        css[property] = result;
-      }
-    } else if (color) {
-      if (alpha != null) {
-        css[property] = ruleUtils.colorToString(color, alpha);
-      } else {
-        const opacityVar = `--un-${varName}-opacity`;
-        const result = ruleUtils.colorToString(color, `var(${opacityVar})`);
-        if (result.includes(opacityVar))
-          css[opacityVar] = 1;
-        css[property] = result;
-      }
-    }
-    if (shouldPass?.(css) !== false)
-      return css;
-  };
-}
-function colorableShadows(shadows, colorVar) {
-  const colored = [];
-  shadows = core.toArray(shadows);
-  for (let i = 0; i < shadows.length; i++) {
-    const components = ruleUtils.getStringComponents(shadows[i], " ", 6);
-    if (!components || components.length < 3)
-      return shadows;
-    let isInset = false;
-    const pos = components.indexOf("inset");
-    if (pos !== -1) {
-      components.splice(pos, 1);
-      isInset = true;
-    }
-    let colorVarValue = "";
-    if (ruleUtils.parseCssColor(components.at(0))) {
-      const color = ruleUtils.parseCssColor(components.shift());
-      if (color)
-        colorVarValue = `, ${ruleUtils.colorToString(color)}`;
-    } else if (ruleUtils.parseCssColor(components.at(-1))) {
-      const color = ruleUtils.parseCssColor(components.pop());
-      if (color)
-        colorVarValue = `, ${ruleUtils.colorToString(color)}`;
-    }
-    colored.push(`${isInset ? "inset " : ""}${components.join(" ")} var(${colorVar}${colorVarValue})`);
-  }
-  return colored;
-}
-function hasParseableColor(color, theme, key) {
-  return color != null && !!parseColor(color, theme, key)?.color;
-}
-function resolveBreakpoints({ theme, generator }, key = "breakpoints") {
-  let breakpoints;
-  if (generator.userConfig && generator.userConfig.theme)
-    breakpoints = generator.userConfig.theme[key];
-  if (!breakpoints)
-    breakpoints = theme[key];
-  return breakpoints ? Object.entries(breakpoints).sort((a, b) => Number.parseInt(a[1].replace(/[a-z]+/gi, "")) - Number.parseInt(b[1].replace(/[a-z]+/gi, ""))).map(([point, size]) => ({ point, size })) : void 0;
-}
-function resolveVerticalBreakpoints(context) {
-  return resolveBreakpoints(context, "verticalBreakpoints");
-}
-function makeGlobalStaticRules(prefix, property) {
-  return globalKeywords.map((keyword) => [`${prefix}-${keyword}`, { [property ?? prefix]: keyword }]);
-}
-function isCSSMathFn(value) {
-  return value != null && cssMathFnRE.test(value);
-}
-function isSize(str) {
-  if (str[0] === "[" && str.slice(-1) === "]")
-    str = str.slice(1, -1);
-  return cssMathFnRE.test(str) || numberWithUnitRE.test(str);
-}
-function transformXYZ(d, v, name) {
-  const values = v.split(splitComma);
-  if (d || !d && values.length === 1)
-    return xyzMap[d].map((i) => [`--un-${name}${i}`, v]);
-  return values.map((v2, i) => [`--un-${name}-${xyzArray[i]}`, v2]);
-}
-
-exports.CONTROL_MINI_NO_NEGATIVE = CONTROL_MINI_NO_NEGATIVE;
-exports.colorResolver = colorResolver;
-exports.colorableShadows = colorableShadows;
-exports.cornerMap = cornerMap;
-exports.cssMathFnRE = cssMathFnRE;
-exports.directionMap = directionMap;
-exports.directionSize = directionSize;
-exports.globalKeywords = globalKeywords;
-exports.h = h;
-exports.handler = handler;
-exports.hasParseableColor = hasParseableColor;
-exports.insetMap = insetMap;
-exports.isCSSMathFn = isCSSMathFn;
-exports.isSize = isSize;
-exports.makeGlobalStaticRules = makeGlobalStaticRules;
-exports.parseColor = parseColor;
-exports.positionMap = positionMap;
-exports.resolveBreakpoints = resolveBreakpoints;
-exports.resolveVerticalBreakpoints = resolveVerticalBreakpoints;
-exports.splitShorthand = splitShorthand;
-exports.transformXYZ = transformXYZ;
-exports.valueHandlers = valueHandlers;
-exports.xyzArray = xyzArray;
-exports.xyzMap = xyzMap;