armtek-uikit-react 1.0.268 → 1.0.269

package/lib/esm/node_modules/pretty-format/build/plugins/Immutable.js

@@ -0,0 +1,161 @@
+import { __exports as Immutable } from "../../../../_virtual/Immutable.js";
+import { __require as requireCollections } from "../collections.js";
+var hasRequiredImmutable;
+function requireImmutable() {
+  if (hasRequiredImmutable) return Immutable;
+  hasRequiredImmutable = 1;
+  Object.defineProperty(Immutable, "__esModule", {
+    value: true
+  });
+  Immutable.test = Immutable.serialize = Immutable.default = void 0;
+  var _collections = requireCollections();
+  const IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
+  const IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
+  const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+  const IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";
+  const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+  const IS_RECORD_SENTINEL = "@@__IMMUTABLE_RECORD__@@";
+  const IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";
+  const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+  const IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";
+  const getImmutableName = (name) => "Immutable." + name;
+  const printAsLeaf = (name) => "[" + name + "]";
+  const SPACE = " ";
+  const LAZY = "…";
+  const printImmutableEntries = (val, config, indentation, depth, refs, printer, type) => ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE + "{" + (0, _collections.printIteratorEntries)(
+    val.entries(),
+    config,
+    indentation,
+    depth,
+    refs,
+    printer
+  ) + "}";
+  function getRecordEntries(val) {
+    let i = 0;
+    return {
+      next() {
+        if (i < val._keys.length) {
+          const key = val._keys[i++];
+          return {
+            done: false,
+            value: [key, val.get(key)]
+          };
+        }
+        return {
+          done: true,
+          value: void 0
+        };
+      }
+    };
+  }
+  const printImmutableRecord = (val, config, indentation, depth, refs, printer) => {
+    const name = getImmutableName(val._name || "Record");
+    return ++depth > config.maxDepth ? printAsLeaf(name) : name + SPACE + "{" + (0, _collections.printIteratorEntries)(
+      getRecordEntries(val),
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    ) + "}";
+  };
+  const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
+    const name = getImmutableName("Seq");
+    if (++depth > config.maxDepth) {
+      return printAsLeaf(name);
+    }
+    if (val[IS_KEYED_SENTINEL]) {
+      return name + SPACE + "{" + // from Immutable collection of entries or from ECMAScript object
+      (val._iter || val._object ? (0, _collections.printIteratorEntries)(
+        val.entries(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) : LAZY) + "}";
+    }
+    return name + SPACE + "[" + (val._iter || // from Immutable collection of values
+    val._array || // from ECMAScript array
+    val._collection || // from ECMAScript collection in immutable v4
+    val._iterable ? (0, _collections.printIteratorValues)(
+      val.values(),
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    ) : LAZY) + "]";
+  };
+  const printImmutableValues = (val, config, indentation, depth, refs, printer, type) => ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE + "[" + (0, _collections.printIteratorValues)(
+    val.values(),
+    config,
+    indentation,
+    depth,
+    refs,
+    printer
+  ) + "]";
+  const serialize = (val, config, indentation, depth, refs, printer) => {
+    if (val[IS_MAP_SENTINEL]) {
+      return printImmutableEntries(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer,
+        val[IS_ORDERED_SENTINEL] ? "OrderedMap" : "Map"
+      );
+    }
+    if (val[IS_LIST_SENTINEL]) {
+      return printImmutableValues(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer,
+        "List"
+      );
+    }
+    if (val[IS_SET_SENTINEL]) {
+      return printImmutableValues(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer,
+        val[IS_ORDERED_SENTINEL] ? "OrderedSet" : "Set"
+      );
+    }
+    if (val[IS_STACK_SENTINEL]) {
+      return printImmutableValues(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer,
+        "Stack"
+      );
+    }
+    if (val[IS_SEQ_SENTINEL]) {
+      return printImmutableSeq(val, config, indentation, depth, refs, printer);
+    }
+    return printImmutableRecord(val, config, indentation, depth, refs, printer);
+  };
+  Immutable.serialize = serialize;
+  const test = (val) => val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+  Immutable.test = test;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  Immutable.default = _default;
+  return Immutable;
+}
+export {
+  requireImmutable as __require
+};

package/lib/esm/node_modules/pretty-format/build/plugins/ReactElement.js

@@ -0,0 +1,135 @@
+import { __exports as ReactElement } from "../../../../_virtual/ReactElement.js";
+import { __require as requireReactIs } from "../../../react-is/index.js";
+import { __require as requireMarkup } from "./lib/markup.js";
+var hasRequiredReactElement;
+function requireReactElement() {
+  if (hasRequiredReactElement) return ReactElement;
+  hasRequiredReactElement = 1;
+  Object.defineProperty(ReactElement, "__esModule", {
+    value: true
+  });
+  ReactElement.test = ReactElement.serialize = ReactElement.default = void 0;
+  var ReactIs = _interopRequireWildcard(requireReactIs());
+  var _markup = requireMarkup();
+  function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+    var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop2) {
+      return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+  }
+  function _interopRequireWildcard(obj, nodeInterop) {
+    if (obj && obj.__esModule) {
+      return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+      return { default: obj };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+      return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var key in obj) {
+      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        if (desc && (desc.get || desc.set)) {
+          Object.defineProperty(newObj, key, desc);
+        } else {
+          newObj[key] = obj[key];
+        }
+      }
+    }
+    newObj.default = obj;
+    if (cache) {
+      cache.set(obj, newObj);
+    }
+    return newObj;
+  }
+  const getChildren = (arg, children = []) => {
+    if (Array.isArray(arg)) {
+      arg.forEach((item) => {
+        getChildren(item, children);
+      });
+    } else if (arg != null && arg !== false) {
+      children.push(arg);
+    }
+    return children;
+  };
+  const getType = (element) => {
+    const type = element.type;
+    if (typeof type === "string") {
+      return type;
+    }
+    if (typeof type === "function") {
+      return type.displayName || type.name || "Unknown";
+    }
+    if (ReactIs.isFragment(element)) {
+      return "React.Fragment";
+    }
+    if (ReactIs.isSuspense(element)) {
+      return "React.Suspense";
+    }
+    if (typeof type === "object" && type !== null) {
+      if (ReactIs.isContextProvider(element)) {
+        return "Context.Provider";
+      }
+      if (ReactIs.isContextConsumer(element)) {
+        return "Context.Consumer";
+      }
+      if (ReactIs.isForwardRef(element)) {
+        if (type.displayName) {
+          return type.displayName;
+        }
+        const functionName = type.render.displayName || type.render.name || "";
+        return functionName !== "" ? "ForwardRef(" + functionName + ")" : "ForwardRef";
+      }
+      if (ReactIs.isMemo(element)) {
+        const functionName = type.displayName || type.type.displayName || type.type.name || "";
+        return functionName !== "" ? "Memo(" + functionName + ")" : "Memo";
+      }
+    }
+    return "UNDEFINED";
+  };
+  const getPropKeys = (element) => {
+    const { props } = element;
+    return Object.keys(props).filter((key) => key !== "children" && props[key] !== void 0).sort();
+  };
+  const serialize = (element, config, indentation, depth, refs, printer) => ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(getType(element), config) : (0, _markup.printElement)(
+    getType(element),
+    (0, _markup.printProps)(
+      getPropKeys(element),
+      element.props,
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    (0, _markup.printChildren)(
+      getChildren(element.props.children),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    config,
+    indentation
+  );
+  ReactElement.serialize = serialize;
+  const test = (val) => val != null && ReactIs.isElement(val);
+  ReactElement.test = test;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  ReactElement.default = _default;
+  return ReactElement;
+}
+export {
+  requireReactElement as __require
+};

package/lib/esm/node_modules/pretty-format/build/plugins/ReactTestComponent.js

@@ -0,0 +1,66 @@
+import { __exports as ReactTestComponent } from "../../../../_virtual/ReactTestComponent.js";
+import { __require as requireMarkup } from "./lib/markup.js";
+var hasRequiredReactTestComponent;
+function requireReactTestComponent() {
+  if (hasRequiredReactTestComponent) return ReactTestComponent;
+  hasRequiredReactTestComponent = 1;
+  Object.defineProperty(ReactTestComponent, "__esModule", {
+    value: true
+  });
+  ReactTestComponent.test = ReactTestComponent.serialize = ReactTestComponent.default = void 0;
+  var _markup = requireMarkup();
+  var global = (function() {
+    if (typeof globalThis !== "undefined") {
+      return globalThis;
+    } else if (typeof global !== "undefined") {
+      return global;
+    } else if (typeof self !== "undefined") {
+      return self;
+    } else if (typeof window !== "undefined") {
+      return window;
+    } else {
+      return Function("return this")();
+    }
+  })();
+  var Symbol = global["jest-symbol-do-not-touch"] || global.Symbol;
+  const testSymbol = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
+  const getPropKeys = (object) => {
+    const { props } = object;
+    return props ? Object.keys(props).filter((key) => props[key] !== void 0).sort() : [];
+  };
+  const serialize = (object, config, indentation, depth, refs, printer) => ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(object.type, config) : (0, _markup.printElement)(
+    object.type,
+    object.props ? (0, _markup.printProps)(
+      getPropKeys(object),
+      object.props,
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ) : "",
+    object.children ? (0, _markup.printChildren)(
+      object.children,
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ) : "",
+    config,
+    indentation
+  );
+  ReactTestComponent.serialize = serialize;
+  const test = (val) => val && val.$$typeof === testSymbol;
+  ReactTestComponent.test = test;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  ReactTestComponent.default = _default;
+  return ReactTestComponent;
+}
+export {
+  requireReactTestComponent as __require
+};

package/lib/esm/node_modules/pretty-format/build/plugins/lib/escapeHTML.js

@@ -0,0 +1,17 @@
+import { __exports as escapeHTML } from "../../../../../_virtual/escapeHTML.js";
+var hasRequiredEscapeHTML;
+function requireEscapeHTML() {
+  if (hasRequiredEscapeHTML) return escapeHTML;
+  hasRequiredEscapeHTML = 1;
+  Object.defineProperty(escapeHTML, "__esModule", {
+    value: true
+  });
+  escapeHTML.default = escapeHTML$1;
+  function escapeHTML$1(str) {
+    return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  return escapeHTML;
+}
+export {
+  requireEscapeHTML as __require
+};

package/lib/esm/node_modules/pretty-format/build/plugins/lib/markup.js

@@ -0,0 +1,59 @@
+import { __exports as markup } from "../../../../../_virtual/markup.js";
+import { __require as requireEscapeHTML } from "./escapeHTML.js";
+var hasRequiredMarkup;
+function requireMarkup() {
+  if (hasRequiredMarkup) return markup;
+  hasRequiredMarkup = 1;
+  Object.defineProperty(markup, "__esModule", {
+    value: true
+  });
+  markup.printText = markup.printProps = markup.printElementAsLeaf = markup.printElement = markup.printComment = markup.printChildren = void 0;
+  var _escapeHTML = _interopRequireDefault(requireEscapeHTML());
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  const printProps = (keys, props, config, indentation, depth, refs, printer) => {
+    const indentationNext = indentation + config.indent;
+    const colors = config.colors;
+    return keys.map((key) => {
+      const value = props[key];
+      let printed = printer(value, config, indentationNext, depth, refs);
+      if (typeof value !== "string") {
+        if (printed.indexOf("\n") !== -1) {
+          printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+        }
+        printed = "{" + printed + "}";
+      }
+      return config.spacingInner + indentation + colors.prop.open + key + colors.prop.close + "=" + colors.value.open + printed + colors.value.close;
+    }).join("");
+  };
+  markup.printProps = printProps;
+  const printChildren = (children, config, indentation, depth, refs, printer) => children.map(
+    (child) => config.spacingOuter + indentation + (typeof child === "string" ? printText(child, config) : printer(child, config, indentation, depth, refs))
+  ).join("");
+  markup.printChildren = printChildren;
+  const printText = (text, config) => {
+    const contentColor = config.colors.content;
+    return contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close;
+  };
+  markup.printText = printText;
+  const printComment = (comment, config) => {
+    const commentColor = config.colors.comment;
+    return commentColor.open + "<!--" + (0, _escapeHTML.default)(comment) + "-->" + commentColor.close;
+  };
+  markup.printComment = printComment;
+  const printElement = (type, printedProps, printedChildren, config, indentation) => {
+    const tagColor = config.colors.tag;
+    return tagColor.open + "<" + type + (printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open) + (printedChildren ? ">" + tagColor.close + printedChildren + config.spacingOuter + indentation + tagColor.open + "</" + type : (printedProps && !config.min ? "" : " ") + "/") + ">" + tagColor.close;
+  };
+  markup.printElement = printElement;
+  const printElementAsLeaf = (type, config) => {
+    const tagColor = config.colors.tag;
+    return tagColor.open + "<" + type + tagColor.close + " …" + tagColor.open + " />" + tagColor.close;
+  };
+  markup.printElementAsLeaf = printElementAsLeaf;
+  return markup;
+}
+export {
+  requireMarkup as __require
+};

package/lib/esm/node_modules/pretty-format/node_modules/ansi-styles/index.js

@@ -0,0 +1,144 @@
+import { __module as ansiStyles } from "../../../../_virtual/index5.js";
+ansiStyles.exports;
+var hasRequiredAnsiStyles;
+function requireAnsiStyles() {
+  if (hasRequiredAnsiStyles) return ansiStyles.exports;
+  hasRequiredAnsiStyles = 1;
+  (function(module) {
+    const ANSI_BACKGROUND_OFFSET = 10;
+    const wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          overline: [53, 55],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+          styles[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+          value: group,
+          enumerable: false
+        });
+      }
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      styles.color.ansi256 = wrapAnsi256();
+      styles.color.ansi16m = wrapAnsi16m();
+      styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+      styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+      Object.defineProperties(styles, {
+        rgbToAnsi256: {
+          value: (red, green, blue) => {
+            if (red === green && green === blue) {
+              if (red < 8) {
+                return 16;
+              }
+              if (red > 248) {
+                return 231;
+              }
+              return Math.round((red - 8) / 247 * 24) + 232;
+            }
+            return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+          },
+          enumerable: false
+        },
+        hexToRgb: {
+          value: (hex) => {
+            const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+            if (!matches) {
+              return [0, 0, 0];
+            }
+            let { colorString } = matches.groups;
+            if (colorString.length === 3) {
+              colorString = colorString.split("").map((character) => character + character).join("");
+            }
+            const integer = Number.parseInt(colorString, 16);
+            return [
+              integer >> 16 & 255,
+              integer >> 8 & 255,
+              integer & 255
+            ];
+          },
+          enumerable: false
+        },
+        hexToAnsi256: {
+          value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+          enumerable: false
+        }
+      });
+      return styles;
+    }
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: assembleStyles
+    });
+  })(ansiStyles);
+  return ansiStyles.exports;
+}
+export {
+  requireAnsiStyles as __require
+};