armtek-uikit-react 1.0.268 → 1.0.270

package/lib/esm/node_modules/pretty-format/build/index.js

@@ -0,0 +1,386 @@
+import { __exports as build } from "../../../_virtual/index3.js";
+import { __require as requireAnsiStyles } from "../node_modules/ansi-styles/index.js";
+import { __require as requireCollections } from "./collections.js";
+import { __require as requireAsymmetricMatcher } from "./plugins/AsymmetricMatcher.js";
+import { __require as requireConvertAnsi } from "./plugins/ConvertAnsi.js";
+import { __require as requireDOMCollection } from "./plugins/DOMCollection.js";
+import { __require as requireDOMElement } from "./plugins/DOMElement.js";
+import { __require as requireImmutable } from "./plugins/Immutable.js";
+import { __require as requireReactElement } from "./plugins/ReactElement.js";
+import { __require as requireReactTestComponent } from "./plugins/ReactTestComponent.js";
+var hasRequiredBuild;
+function requireBuild() {
+  if (hasRequiredBuild) return build;
+  hasRequiredBuild = 1;
+  Object.defineProperty(build, "__esModule", {
+    value: true
+  });
+  build.default = build.DEFAULT_OPTIONS = void 0;
+  build.format = format;
+  build.plugins = void 0;
+  var _ansiStyles = _interopRequireDefault(requireAnsiStyles());
+  var _collections = requireCollections();
+  var _AsymmetricMatcher = _interopRequireDefault(
+    requireAsymmetricMatcher()
+  );
+  var _ConvertAnsi = _interopRequireDefault(requireConvertAnsi());
+  var _DOMCollection = _interopRequireDefault(requireDOMCollection());
+  var _DOMElement = _interopRequireDefault(requireDOMElement());
+  var _Immutable = _interopRequireDefault(requireImmutable());
+  var _ReactElement = _interopRequireDefault(requireReactElement());
+  var _ReactTestComponent = _interopRequireDefault(
+    requireReactTestComponent()
+  );
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  const toString = Object.prototype.toString;
+  const toISOString = Date.prototype.toISOString;
+  const errorToString = Error.prototype.toString;
+  const regExpToString = RegExp.prototype.toString;
+  const getConstructorName = (val) => typeof val.constructor === "function" && val.constructor.name || "Object";
+  const isWindow = (val) => typeof window !== "undefined" && val === window;
+  const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+  const NEWLINE_REGEXP = /\n/gi;
+  class PrettyFormatPluginError extends Error {
+    constructor(message, stack) {
+      super(message);
+      this.stack = stack;
+      this.name = this.constructor.name;
+    }
+  }
+  function isToStringedArrayType(toStringed) {
+    return toStringed === "[object Array]" || toStringed === "[object ArrayBuffer]" || toStringed === "[object DataView]" || toStringed === "[object Float32Array]" || toStringed === "[object Float64Array]" || toStringed === "[object Int8Array]" || toStringed === "[object Int16Array]" || toStringed === "[object Int32Array]" || toStringed === "[object Uint8Array]" || toStringed === "[object Uint8ClampedArray]" || toStringed === "[object Uint16Array]" || toStringed === "[object Uint32Array]";
+  }
+  function printNumber(val) {
+    return Object.is(val, -0) ? "-0" : String(val);
+  }
+  function printBigInt(val) {
+    return String(`${val}n`);
+  }
+  function printFunction(val, printFunctionName) {
+    if (!printFunctionName) {
+      return "[Function]";
+    }
+    return "[Function " + (val.name || "anonymous") + "]";
+  }
+  function printSymbol(val) {
+    return String(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+  }
+  function printError(val) {
+    return "[" + errorToString.call(val) + "]";
+  }
+  function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+    if (val === true || val === false) {
+      return "" + val;
+    }
+    if (val === void 0) {
+      return "undefined";
+    }
+    if (val === null) {
+      return "null";
+    }
+    const typeOf = typeof val;
+    if (typeOf === "number") {
+      return printNumber(val);
+    }
+    if (typeOf === "bigint") {
+      return printBigInt(val);
+    }
+    if (typeOf === "string") {
+      if (escapeString) {
+        return '"' + val.replace(/"|\\/g, "\\$&") + '"';
+      }
+      return '"' + val + '"';
+    }
+    if (typeOf === "function") {
+      return printFunction(val, printFunctionName);
+    }
+    if (typeOf === "symbol") {
+      return printSymbol(val);
+    }
+    const toStringed = toString.call(val);
+    if (toStringed === "[object WeakMap]") {
+      return "WeakMap {}";
+    }
+    if (toStringed === "[object WeakSet]") {
+      return "WeakSet {}";
+    }
+    if (toStringed === "[object Function]" || toStringed === "[object GeneratorFunction]") {
+      return printFunction(val, printFunctionName);
+    }
+    if (toStringed === "[object Symbol]") {
+      return printSymbol(val);
+    }
+    if (toStringed === "[object Date]") {
+      return isNaN(+val) ? "Date { NaN }" : toISOString.call(val);
+    }
+    if (toStringed === "[object Error]") {
+      return printError(val);
+    }
+    if (toStringed === "[object RegExp]") {
+      if (escapeRegex) {
+        return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
+      }
+      return regExpToString.call(val);
+    }
+    if (val instanceof Error) {
+      return printError(val);
+    }
+    return null;
+  }
+  function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+    if (refs.indexOf(val) !== -1) {
+      return "[Circular]";
+    }
+    refs = refs.slice();
+    refs.push(val);
+    const hitMaxDepth = ++depth > config.maxDepth;
+    const min = config.min;
+    if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === "function" && !hasCalledToJSON) {
+      return printer(val.toJSON(), config, indentation, depth, refs, true);
+    }
+    const toStringed = toString.call(val);
+    if (toStringed === "[object Arguments]") {
+      return hitMaxDepth ? "[Arguments]" : (min ? "" : "Arguments ") + "[" + (0, _collections.printListItems)(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) + "]";
+    }
+    if (isToStringedArrayType(toStringed)) {
+      return hitMaxDepth ? "[" + val.constructor.name + "]" : (min ? "" : !config.printBasicPrototype && val.constructor.name === "Array" ? "" : val.constructor.name + " ") + "[" + (0, _collections.printListItems)(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) + "]";
+    }
+    if (toStringed === "[object Map]") {
+      return hitMaxDepth ? "[Map]" : "Map {" + (0, _collections.printIteratorEntries)(
+        val.entries(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer,
+        " => "
+      ) + "}";
+    }
+    if (toStringed === "[object Set]") {
+      return hitMaxDepth ? "[Set]" : "Set {" + (0, _collections.printIteratorValues)(
+        val.values(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) + "}";
+    }
+    return hitMaxDepth || isWindow(val) ? "[" + getConstructorName(val) + "]" : (min ? "" : !config.printBasicPrototype && getConstructorName(val) === "Object" ? "" : getConstructorName(val) + " ") + "{" + (0, _collections.printObjectProperties)(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    ) + "}";
+  }
+  function isNewPlugin(plugin) {
+    return plugin.serialize != null;
+  }
+  function printPlugin(plugin, val, config, indentation, depth, refs) {
+    let printed;
+    try {
+      printed = isNewPlugin(plugin) ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(
+        val,
+        (valChild) => printer(valChild, config, indentation, depth, refs),
+        (str) => {
+          const indentationNext = indentation + config.indent;
+          return indentationNext + str.replace(NEWLINE_REGEXP, "\n" + indentationNext);
+        },
+        {
+          edgeSpacing: config.spacingOuter,
+          min: config.min,
+          spacing: config.spacingInner
+        },
+        config.colors
+      );
+    } catch (error) {
+      throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+    if (typeof printed !== "string") {
+      throw new Error(
+        `pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`
+      );
+    }
+    return printed;
+  }
+  function findPlugin(plugins2, val) {
+    for (let p = 0; p < plugins2.length; p++) {
+      try {
+        if (plugins2[p].test(val)) {
+          return plugins2[p];
+        }
+      } catch (error) {
+        throw new PrettyFormatPluginError(error.message, error.stack);
+      }
+    }
+    return null;
+  }
+  function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+    const plugin = findPlugin(config.plugins, val);
+    if (plugin !== null) {
+      return printPlugin(plugin, val, config, indentation, depth, refs);
+    }
+    const basicResult = printBasicValue(
+      val,
+      config.printFunctionName,
+      config.escapeRegex,
+      config.escapeString
+    );
+    if (basicResult !== null) {
+      return basicResult;
+    }
+    return printComplexValue(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      hasCalledToJSON
+    );
+  }
+  const DEFAULT_THEME = {
+    comment: "gray",
+    content: "reset",
+    prop: "yellow",
+    tag: "cyan",
+    value: "green"
+  };
+  const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+  const DEFAULT_OPTIONS = {
+    callToJSON: true,
+    compareKeys: void 0,
+    escapeRegex: false,
+    escapeString: true,
+    highlight: false,
+    indent: 2,
+    maxDepth: Infinity,
+    min: false,
+    plugins: [],
+    printBasicPrototype: true,
+    printFunctionName: true,
+    theme: DEFAULT_THEME
+  };
+  build.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+  function validateOptions(options) {
+    Object.keys(options).forEach((key) => {
+      if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
+        throw new Error(`pretty-format: Unknown option "${key}".`);
+      }
+    });
+    if (options.min && options.indent !== void 0 && options.indent !== 0) {
+      throw new Error(
+        'pretty-format: Options "min" and "indent" cannot be used together.'
+      );
+    }
+    if (options.theme !== void 0) {
+      if (options.theme === null) {
+        throw new Error('pretty-format: Option "theme" must not be null.');
+      }
+      if (typeof options.theme !== "object") {
+        throw new Error(
+          `pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`
+        );
+      }
+    }
+  }
+  const getColorsHighlight = (options) => DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    const value = options.theme && options.theme[key] !== void 0 ? options.theme[key] : DEFAULT_THEME[key];
+    const color = value && _ansiStyles.default[value];
+    if (color && typeof color.close === "string" && typeof color.open === "string") {
+      colors[key] = color;
+    } else {
+      throw new Error(
+        `pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`
+      );
+    }
+    return colors;
+  }, /* @__PURE__ */ Object.create(null));
+  const getColorsEmpty = () => DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    colors[key] = {
+      close: "",
+      open: ""
+    };
+    return colors;
+  }, /* @__PURE__ */ Object.create(null));
+  const getPrintFunctionName = (options) => options && options.printFunctionName !== void 0 ? options.printFunctionName : DEFAULT_OPTIONS.printFunctionName;
+  const getEscapeRegex = (options) => options && options.escapeRegex !== void 0 ? options.escapeRegex : DEFAULT_OPTIONS.escapeRegex;
+  const getEscapeString = (options) => options && options.escapeString !== void 0 ? options.escapeString : DEFAULT_OPTIONS.escapeString;
+  const getConfig = (options) => {
+    var _options$printBasicPr;
+    return {
+      callToJSON: options && options.callToJSON !== void 0 ? options.callToJSON : DEFAULT_OPTIONS.callToJSON,
+      colors: options && options.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+      compareKeys: options && typeof options.compareKeys === "function" ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
+      escapeRegex: getEscapeRegex(options),
+      escapeString: getEscapeString(options),
+      indent: options && options.min ? "" : createIndent(
+        options && options.indent !== void 0 ? options.indent : DEFAULT_OPTIONS.indent
+      ),
+      maxDepth: options && options.maxDepth !== void 0 ? options.maxDepth : DEFAULT_OPTIONS.maxDepth,
+      min: options && options.min !== void 0 ? options.min : DEFAULT_OPTIONS.min,
+      plugins: options && options.plugins !== void 0 ? options.plugins : DEFAULT_OPTIONS.plugins,
+      printBasicPrototype: (_options$printBasicPr = options === null || options === void 0 ? void 0 : options.printBasicPrototype) !== null && _options$printBasicPr !== void 0 ? _options$printBasicPr : true,
+      printFunctionName: getPrintFunctionName(options),
+      spacingInner: options && options.min ? " " : "\n",
+      spacingOuter: options && options.min ? "" : "\n"
+    };
+  };
+  function createIndent(indent) {
+    return new Array(indent + 1).join(" ");
+  }
+  function format(val, options) {
+    if (options) {
+      validateOptions(options);
+      if (options.plugins) {
+        const plugin = findPlugin(options.plugins, val);
+        if (plugin !== null) {
+          return printPlugin(plugin, val, getConfig(options), "", 0, []);
+        }
+      }
+    }
+    const basicResult = printBasicValue(
+      val,
+      getPrintFunctionName(options),
+      getEscapeRegex(options),
+      getEscapeString(options)
+    );
+    if (basicResult !== null) {
+      return basicResult;
+    }
+    return printComplexValue(val, getConfig(options), "", 0, []);
+  }
+  const plugins = {
+    AsymmetricMatcher: _AsymmetricMatcher.default,
+    ConvertAnsi: _ConvertAnsi.default,
+    DOMCollection: _DOMCollection.default,
+    DOMElement: _DOMElement.default,
+    Immutable: _Immutable.default,
+    ReactElement: _ReactElement.default,
+    ReactTestComponent: _ReactTestComponent.default
+  };
+  build.plugins = plugins;
+  var _default = format;
+  build.default = _default;
+  return build;
+}
+export {
+  requireBuild as __require
+};

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

@@ -0,0 +1,77 @@
+import { __exports as AsymmetricMatcher } from "../../../../_virtual/AsymmetricMatcher.js";
+import { __require as requireCollections } from "../collections.js";
+var hasRequiredAsymmetricMatcher;
+function requireAsymmetricMatcher() {
+  if (hasRequiredAsymmetricMatcher) return AsymmetricMatcher;
+  hasRequiredAsymmetricMatcher = 1;
+  Object.defineProperty(AsymmetricMatcher, "__esModule", {
+    value: true
+  });
+  AsymmetricMatcher.test = AsymmetricMatcher.serialize = AsymmetricMatcher.default = void 0;
+  var _collections = requireCollections();
+  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 asymmetricMatcher = typeof Symbol === "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621;
+  const SPACE = " ";
+  const serialize = (val, config, indentation, depth, refs, printer) => {
+    const stringedValue = val.toString();
+    if (stringedValue === "ArrayContaining" || stringedValue === "ArrayNotContaining") {
+      if (++depth > config.maxDepth) {
+        return "[" + stringedValue + "]";
+      }
+      return stringedValue + SPACE + "[" + (0, _collections.printListItems)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) + "]";
+    }
+    if (stringedValue === "ObjectContaining" || stringedValue === "ObjectNotContaining") {
+      if (++depth > config.maxDepth) {
+        return "[" + stringedValue + "]";
+      }
+      return stringedValue + SPACE + "{" + (0, _collections.printObjectProperties)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) + "}";
+    }
+    if (stringedValue === "StringMatching" || stringedValue === "StringNotMatching") {
+      return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+    }
+    if (stringedValue === "StringContaining" || stringedValue === "StringNotContaining") {
+      return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+    }
+    return val.toAsymmetricMatcher();
+  };
+  AsymmetricMatcher.serialize = serialize;
+  const test = (val) => val && val.$$typeof === asymmetricMatcher;
+  AsymmetricMatcher.test = test;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  AsymmetricMatcher.default = _default;
+  return AsymmetricMatcher;
+}
+export {
+  requireAsymmetricMatcher as __require
+};

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

@@ -0,0 +1,76 @@
+import { __exports as ConvertAnsi } from "../../../../_virtual/ConvertAnsi.js";
+import { __require as requireAnsiRegex } from "../../../ansi-regex/index.js";
+import { __require as requireAnsiStyles } from "../../node_modules/ansi-styles/index.js";
+var hasRequiredConvertAnsi;
+function requireConvertAnsi() {
+  if (hasRequiredConvertAnsi) return ConvertAnsi;
+  hasRequiredConvertAnsi = 1;
+  Object.defineProperty(ConvertAnsi, "__esModule", {
+    value: true
+  });
+  ConvertAnsi.test = ConvertAnsi.serialize = ConvertAnsi.default = void 0;
+  var _ansiRegex = _interopRequireDefault(requireAnsiRegex());
+  var _ansiStyles = _interopRequireDefault(requireAnsiStyles());
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  const toHumanReadableAnsi = (text) => text.replace((0, _ansiRegex.default)(), (match) => {
+    switch (match) {
+      case _ansiStyles.default.red.close:
+      case _ansiStyles.default.green.close:
+      case _ansiStyles.default.cyan.close:
+      case _ansiStyles.default.gray.close:
+      case _ansiStyles.default.white.close:
+      case _ansiStyles.default.yellow.close:
+      case _ansiStyles.default.bgRed.close:
+      case _ansiStyles.default.bgGreen.close:
+      case _ansiStyles.default.bgYellow.close:
+      case _ansiStyles.default.inverse.close:
+      case _ansiStyles.default.dim.close:
+      case _ansiStyles.default.bold.close:
+      case _ansiStyles.default.reset.open:
+      case _ansiStyles.default.reset.close:
+        return "</>";
+      case _ansiStyles.default.red.open:
+        return "<red>";
+      case _ansiStyles.default.green.open:
+        return "<green>";
+      case _ansiStyles.default.cyan.open:
+        return "<cyan>";
+      case _ansiStyles.default.gray.open:
+        return "<gray>";
+      case _ansiStyles.default.white.open:
+        return "<white>";
+      case _ansiStyles.default.yellow.open:
+        return "<yellow>";
+      case _ansiStyles.default.bgRed.open:
+        return "<bgRed>";
+      case _ansiStyles.default.bgGreen.open:
+        return "<bgGreen>";
+      case _ansiStyles.default.bgYellow.open:
+        return "<bgYellow>";
+      case _ansiStyles.default.inverse.open:
+        return "<inverse>";
+      case _ansiStyles.default.dim.open:
+        return "<dim>";
+      case _ansiStyles.default.bold.open:
+        return "<bold>";
+      default:
+        return "";
+    }
+  });
+  const test = (val) => typeof val === "string" && !!val.match((0, _ansiRegex.default)());
+  ConvertAnsi.test = test;
+  const serialize = (val, config, indentation, depth, refs, printer) => printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
+  ConvertAnsi.serialize = serialize;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  ConvertAnsi.default = _default;
+  return ConvertAnsi;
+}
+export {
+  requireConvertAnsi as __require
+};

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

@@ -0,0 +1,54 @@
+import { __exports as DOMCollection } from "../../../../_virtual/DOMCollection.js";
+import { __require as requireCollections } from "../collections.js";
+var hasRequiredDOMCollection;
+function requireDOMCollection() {
+  if (hasRequiredDOMCollection) return DOMCollection;
+  hasRequiredDOMCollection = 1;
+  Object.defineProperty(DOMCollection, "__esModule", {
+    value: true
+  });
+  DOMCollection.test = DOMCollection.serialize = DOMCollection.default = void 0;
+  var _collections = requireCollections();
+  const SPACE = " ";
+  const OBJECT_NAMES = ["DOMStringMap", "NamedNodeMap"];
+  const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+  const testName = (name) => OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+  const test = (val) => val && val.constructor && !!val.constructor.name && testName(val.constructor.name);
+  DOMCollection.test = test;
+  const isNamedNodeMap = (collection) => collection.constructor.name === "NamedNodeMap";
+  const serialize = (collection, config, indentation, depth, refs, printer) => {
+    const name = collection.constructor.name;
+    if (++depth > config.maxDepth) {
+      return "[" + name + "]";
+    }
+    return (config.min ? "" : name + SPACE) + (OBJECT_NAMES.indexOf(name) !== -1 ? "{" + (0, _collections.printObjectProperties)(
+      isNamedNodeMap(collection) ? Array.from(collection).reduce((props, attribute) => {
+        props[attribute.name] = attribute.value;
+        return props;
+      }, {}) : { ...collection },
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    ) + "}" : "[" + (0, _collections.printListItems)(
+      Array.from(collection),
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    ) + "]");
+  };
+  DOMCollection.serialize = serialize;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  DOMCollection.default = _default;
+  return DOMCollection;
+}
+export {
+  requireDOMCollection as __require
+};

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

@@ -0,0 +1,92 @@
+import { __exports as DOMElement } from "../../../../_virtual/DOMElement.js";
+import { __require as requireMarkup } from "./lib/markup.js";
+var hasRequiredDOMElement;
+function requireDOMElement() {
+  if (hasRequiredDOMElement) return DOMElement;
+  hasRequiredDOMElement = 1;
+  Object.defineProperty(DOMElement, "__esModule", {
+    value: true
+  });
+  DOMElement.test = DOMElement.serialize = DOMElement.default = void 0;
+  var _markup = requireMarkup();
+  const ELEMENT_NODE = 1;
+  const TEXT_NODE = 3;
+  const COMMENT_NODE = 8;
+  const FRAGMENT_NODE = 11;
+  const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+  const testHasAttribute = (val) => {
+    try {
+      return typeof val.hasAttribute === "function" && val.hasAttribute("is");
+    } catch (e) {
+      return false;
+    }
+  };
+  const testNode = (val) => {
+    const constructorName = val.constructor.name;
+    const { nodeType, tagName } = val;
+    const isCustomElement = typeof tagName === "string" && tagName.includes("-") || testHasAttribute(val);
+    return nodeType === ELEMENT_NODE && (ELEMENT_REGEXP.test(constructorName) || isCustomElement) || nodeType === TEXT_NODE && constructorName === "Text" || nodeType === COMMENT_NODE && constructorName === "Comment" || nodeType === FRAGMENT_NODE && constructorName === "DocumentFragment";
+  };
+  const test = (val) => {
+    var _val$constructor;
+    return (val === null || val === void 0 ? void 0 : (_val$constructor = val.constructor) === null || _val$constructor === void 0 ? void 0 : _val$constructor.name) && testNode(val);
+  };
+  DOMElement.test = test;
+  function nodeIsText(node) {
+    return node.nodeType === TEXT_NODE;
+  }
+  function nodeIsComment(node) {
+    return node.nodeType === COMMENT_NODE;
+  }
+  function nodeIsFragment(node) {
+    return node.nodeType === FRAGMENT_NODE;
+  }
+  const serialize = (node, config, indentation, depth, refs, printer) => {
+    if (nodeIsText(node)) {
+      return (0, _markup.printText)(node.data, config);
+    }
+    if (nodeIsComment(node)) {
+      return (0, _markup.printComment)(node.data, config);
+    }
+    const type = nodeIsFragment(node) ? "DocumentFragment" : node.tagName.toLowerCase();
+    if (++depth > config.maxDepth) {
+      return (0, _markup.printElementAsLeaf)(type, config);
+    }
+    return (0, _markup.printElement)(
+      type,
+      (0, _markup.printProps)(
+        nodeIsFragment(node) ? [] : Array.from(node.attributes).map((attr) => attr.name).sort(),
+        nodeIsFragment(node) ? {} : Array.from(node.attributes).reduce((props, attribute) => {
+          props[attribute.name] = attribute.value;
+          return props;
+        }, {}),
+        config,
+        indentation + config.indent,
+        depth,
+        refs,
+        printer
+      ),
+      (0, _markup.printChildren)(
+        Array.prototype.slice.call(node.childNodes || node.children),
+        config,
+        indentation + config.indent,
+        depth,
+        refs,
+        printer
+      ),
+      config,
+      indentation
+    );
+  };
+  DOMElement.serialize = serialize;
+  const plugin = {
+    serialize,
+    test
+  };
+  var _default = plugin;
+  DOMElement.default = _default;
+  return DOMElement;
+}
+export {
+  requireDOMElement as __require
+};