funda-ui 4.7.620 → 4.7.624

package/publish/lib/cjs/Utils/dom.js

@@ -0,0 +1,215 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["RPB"] = factory();
+	else
+		root["RPB"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "getAllSiblings": () => (/* binding */ getAllSiblings),
+/* harmony export */   "getChildren": () => (/* binding */ getChildren),
+/* harmony export */   "getDocument": () => (/* binding */ getDocument),
+/* harmony export */   "getNextSiblings": () => (/* binding */ getNextSiblings),
+/* harmony export */   "getParents": () => (/* binding */ getParents),
+/* harmony export */   "getPreviousSiblings": () => (/* binding */ getPreviousSiblings),
+/* harmony export */   "isElement": () => (/* binding */ isElement),
+/* harmony export */   "isHTMLElement": () => (/* binding */ isHTMLElement),
+/* harmony export */   "isNode": () => (/* binding */ isNode),
+/* harmony export */   "isRootElement": () => (/* binding */ isRootElement),
+/* harmony export */   "isShadowRoot": () => (/* binding */ isShadowRoot),
+/* harmony export */   "nodeContains": () => (/* binding */ nodeContains)
+/* harmony export */ });
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * Dom Utilities
+ * @param {HTMLElement} el      - Element
+ * @param  {?String} filter      - A filter string
+ * @returns HtmlElementCollection
+ */
+function matches(el, filter) {
+  if (el && el.nodeType === 1) {
+    if (filter) {
+      return el.matches(filter);
+    }
+    return true;
+  }
+  return false;
+}
+
+// the next siblings
+function getNextSiblings(el) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var sibs = [];
+  while (el = el.nextSibling) {
+    if (matches(el, filter)) {
+      sibs.push(el);
+    }
+  }
+  return sibs;
+}
+
+// previous siblings
+function getPreviousSiblings(el) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var sibs = [];
+  while (el = el.previousSibling) {
+    if (matches(el, filter)) {
+      sibs.push(el);
+    }
+  }
+  return sibs;
+}
+
+// parent and get all the siblings
+function getAllSiblings(el) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var sibs = [];
+  el = el.parentNode.firstChild;
+  while (el = el.nextSibling) {
+    if (matches(el, filter)) {
+      sibs.push(el);
+    }
+  }
+  return sibs;
+}
+
+// all parent nodes
+function getParents(el) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var parents = [];
+  while (el = el.parentNode) {
+    if (matches(el, filter)) {
+      parents.push(el);
+    }
+  }
+  return parents;
+}
+
+// all child nodes
+function getChildren(el) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var all = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  all.push.apply(all, _toConsumableArray(el.childNodes));
+  var _iterator = _createForOfIteratorHelper(el.childNodes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      getChildren(child, filter, all);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var res = all.filter(function (item) {
+    return matches(item, filter);
+  });
+  return res;
+}
+function isRootElement(element) {
+  return element.matches('html,body');
+}
+function getDocument(node) {
+  if (typeof node === 'undefined') {
+    return document;
+  } else {
+    return node.ownerDocument;
+  }
+}
+function isNode(value) {
+  return value instanceof Node;
+}
+function isElement(value) {
+  return value instanceof Element;
+}
+function isHTMLElement(value) {
+  return value instanceof HTMLElement;
+}
+function isShadowRoot(value) {
+  // Browsers without `ShadowRoot` support.
+  if (typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot;
+}
+
+/* console.log(nodeContains(document.body, document.getElementById('obj'))) */
+function nodeContains(parent, child) {
+  var _child$getRootNode;
+  if (!parent || !child) {
+    return false;
+  }
+  var rootNode = (_child$getRootNode = child.getRootNode) === null || _child$getRootNode === void 0 ? void 0 : _child$getRootNode.call(child);
+
+  // First, attempt with faster native method
+  if (parent.contains(child)) {
+    return true;
+  }
+
+  // then fallback to custom implementation with Shadow DOM support
+  if (rootNode && isShadowRoot(rootNode)) {
+    var next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      // @ts-ignore
+      next = next.parentNode || next.host;
+    }
+  }
+
+  // Give up, the result is false
+  return false;
+}
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/publish/lib/cjs/Utils/easing.d.ts

@@ -0,0 +1,29 @@
+declare function easeLinear(t: number, b: number, c: number, d: number): number;
+declare function easeInQuad(t: number, b: number, c: number, d: number): number;
+declare function easeOutQuad(t: number, b: number, c: number, d: number): number;
+declare function easeInOutQuad(t: number, b: number, c: number, d: number): number;
+declare function easeInSine(t: number, b: number, c: number, d: number): number;
+declare function easeOutSine(t: number, b: number, c: number, d: number): number;
+declare function easeInOutSine(t: number, b: number, c: number, d: number): number;
+declare function easeInExpo(t: number, b: number, c: number, d: number): number;
+declare function easeOutExpo(t: number, b: number, c: number, d: number): number;
+declare function easeInOutExpo(t: number, b: number, c: number, d: number): number;
+declare function easeInCirc(t: number, b: number, c: number, d: number): number;
+declare function easeOutCirc(t: number, b: number, c: number, d: number): number;
+declare function easeInOutCirc(t: number, b: number, c: number, d: number): number;
+declare function easeInCubic(t: number, b: number, c: number, d: number): number;
+declare function easeOutCubic(t: number, b: number, c: number, d: number): number;
+declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;
+declare function easeInQuart(t: number, b: number, c: number, d: number): number;
+declare function easeOutQuart(t: number, b: number, c: number, d: number): number;
+declare function easeInOutQuart(t: number, b: number, c: number, d: number): number;
+declare function easeInQuint(t: number, b: number, c: number, d: number): number;
+declare function easeOutQuint(t: number, b: number, c: number, d: number): number;
+declare function easeInOutQuint(t: number, b: number, c: number, d: number): number;
+declare function easeInElastic(t: number, b: number, c: number, d: number): number;
+declare function easeOutElastic(t: number, b: number, c: number, d: number): number;
+declare function easeInOutElastic(t: number, b: number, c: number, d: number): number;
+declare function easeInBack(t: number, b: number, c: number, d: number): number;
+declare function easeOutBack(t: number, b: number, c: number, d: number): number;
+declare function easeInOutBack(t: number, b: number, c: number, d: number): number;
+export { easeLinear, easeInQuad, easeOutQuad, easeInOutQuad, easeInSine, easeOutSine, easeInOutSine, easeInExpo, easeOutExpo, easeInOutExpo, easeInCirc, easeOutCirc, easeInOutCirc, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint, easeInElastic, easeOutElastic, easeInOutElastic, easeInBack, easeOutBack, easeInOutBack };

package/publish/lib/cjs/Utils/easing.js

@@ -0,0 +1,221 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["RPB"] = factory();
+	else
+		root["RPB"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "easeInBack": () => (/* binding */ easeInBack),
+/* harmony export */   "easeInCirc": () => (/* binding */ easeInCirc),
+/* harmony export */   "easeInCubic": () => (/* binding */ easeInCubic),
+/* harmony export */   "easeInElastic": () => (/* binding */ easeInElastic),
+/* harmony export */   "easeInExpo": () => (/* binding */ easeInExpo),
+/* harmony export */   "easeInOutBack": () => (/* binding */ easeInOutBack),
+/* harmony export */   "easeInOutCirc": () => (/* binding */ easeInOutCirc),
+/* harmony export */   "easeInOutCubic": () => (/* binding */ easeInOutCubic),
+/* harmony export */   "easeInOutElastic": () => (/* binding */ easeInOutElastic),
+/* harmony export */   "easeInOutExpo": () => (/* binding */ easeInOutExpo),
+/* harmony export */   "easeInOutQuad": () => (/* binding */ easeInOutQuad),
+/* harmony export */   "easeInOutQuart": () => (/* binding */ easeInOutQuart),
+/* harmony export */   "easeInOutQuint": () => (/* binding */ easeInOutQuint),
+/* harmony export */   "easeInOutSine": () => (/* binding */ easeInOutSine),
+/* harmony export */   "easeInQuad": () => (/* binding */ easeInQuad),
+/* harmony export */   "easeInQuart": () => (/* binding */ easeInQuart),
+/* harmony export */   "easeInQuint": () => (/* binding */ easeInQuint),
+/* harmony export */   "easeInSine": () => (/* binding */ easeInSine),
+/* harmony export */   "easeLinear": () => (/* binding */ easeLinear),
+/* harmony export */   "easeOutBack": () => (/* binding */ easeOutBack),
+/* harmony export */   "easeOutCirc": () => (/* binding */ easeOutCirc),
+/* harmony export */   "easeOutCubic": () => (/* binding */ easeOutCubic),
+/* harmony export */   "easeOutElastic": () => (/* binding */ easeOutElastic),
+/* harmony export */   "easeOutExpo": () => (/* binding */ easeOutExpo),
+/* harmony export */   "easeOutQuad": () => (/* binding */ easeOutQuad),
+/* harmony export */   "easeOutQuart": () => (/* binding */ easeOutQuart),
+/* harmony export */   "easeOutQuint": () => (/* binding */ easeOutQuint),
+/* harmony export */   "easeOutSine": () => (/* binding */ easeOutSine)
+/* harmony export */ });
+/*
+ * All easing functions
+ * @link: https://easings.net
+ * @param {Number} t   - time (Amount of time that has passed since the beginning of the animation. Usually starts at 0 and is slowly increased using a game loop or other update function.)
+ * @param {Number} b   - beginning value (The starting point of the animation. Usually it's a static value, you can start at 0 for example.)
+ * @param {Number} c   - change in value (The amount of change needed to go from starting point to end point. It's also usually a static value.)
+ * @param {Number} d   - duration (Amount of time the animation will take. Usually a static value aswell.)
+ * @return {number}
+ */
+function easeLinear(t, b, c, d) {
+  return c * t / d + b;
+}
+function easeInQuad(t, b, c, d) {
+  return c * (t /= d) * t + b;
+}
+function easeOutQuad(t, b, c, d) {
+  return -c * (t /= d) * (t - 2) + b;
+}
+function easeInOutQuad(t, b, c, d) {
+  if ((t /= d / 2) < 1) return c / 2 * t * t + b;
+  return -c / 2 * (--t * (t - 2) - 1) + b;
+}
+function easeInSine(t, b, c, d) {
+  return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
+}
+function easeOutSine(t, b, c, d) {
+  return c * Math.sin(t / d * (Math.PI / 2)) + b;
+}
+function easeInOutSine(t, b, c, d) {
+  return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
+}
+function easeInExpo(t, b, c, d) {
+  return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
+}
+function easeOutExpo(t, b, c, d) {
+  return t == d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
+}
+function easeInOutExpo(t, b, c, d) {
+  if (t == 0) return b;
+  if (t == d) return b + c;
+  if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
+  return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
+}
+function easeInCirc(t, b, c, d) {
+  return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
+}
+function easeOutCirc(t, b, c, d) {
+  return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
+}
+function easeInOutCirc(t, b, c, d) {
+  if ((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
+  return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
+}
+function easeInCubic(t, b, c, d) {
+  return c * (t /= d) * t * t + b;
+}
+function easeOutCubic(t, b, c, d) {
+  return c * ((t = t / d - 1) * t * t + 1) + b;
+}
+function easeInOutCubic(t, b, c, d) {
+  if ((t /= d / 2) < 1) return c / 2 * t * t * t + b;
+  return c / 2 * ((t -= 2) * t * t + 2) + b;
+}
+function easeInQuart(t, b, c, d) {
+  return c * (t /= d) * t * t * t + b;
+}
+function easeOutQuart(t, b, c, d) {
+  return -c * ((t = t / d - 1) * t * t * t - 1) + b;
+}
+function easeInOutQuart(t, b, c, d) {
+  if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
+  return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
+}
+function easeInQuint(t, b, c, d) {
+  return c * (t /= d) * t * t * t * t + b;
+}
+function easeOutQuint(t, b, c, d) {
+  return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+}
+function easeInOutQuint(t, b, c, d) {
+  if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
+  return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
+}
+function easeInElastic(t, b, c, d) {
+  var s = 1.70158;
+  var p = 0;
+  var a = c;
+  if (t == 0) return b;
+  if ((t /= d) == 1) return b + c;
+  if (!p) p = d * .3;
+  if (a < Math.abs(c)) {
+    a = c;
+    var s = p / 4;
+  } else var s = p / (2 * Math.PI) * Math.asin(c / a);
+  return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+}
+function easeOutElastic(t, b, c, d) {
+  var s = 1.70158;
+  var p = 0;
+  var a = c;
+  if (t == 0) return b;
+  if ((t /= d) == 1) return b + c;
+  if (!p) p = d * .3;
+  if (a < Math.abs(c)) {
+    a = c;
+    var s = p / 4;
+  } else var s = p / (2 * Math.PI) * Math.asin(c / a);
+  return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b;
+}
+function easeInOutElastic(t, b, c, d) {
+  var s = 1.70158;
+  var p = 0;
+  var a = c;
+  if (t == 0) return b;
+  if ((t /= d / 2) == 2) return b + c;
+  if (!p) p = d * (.3 * 1.5);
+  if (a < Math.abs(c)) {
+    a = c;
+    var s = p / 4;
+  } else var s = p / (2 * Math.PI) * Math.asin(c / a);
+  if (t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+  return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
+}
+function easeInBack(t, b, c, d) {
+  var s = 1.70158;
+  if (s == undefined) s = 1.70158;
+  return c * (t /= d) * t * ((s + 1) * t - s) + b;
+}
+function easeOutBack(t, b, c, d) {
+  var s = 1.70158;
+  if (s == undefined) s = 1.70158;
+  return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+}
+function easeInOutBack(t, b, c, d) {
+  var s = 1.70158;
+  if (s == undefined) s = 1.70158;
+  if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
+  return c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;
+}
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/publish/lib/cjs/Utils/extract.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Determine whether an extractor is included
+ * @param {String} str    =>  input string. such as 'a[1], b[2]', '{a[1]}'
+ * @returns {Boolean}
+ */
+declare function extractorExist(str: string | undefined | null): boolean;
+/**
+ * Extract the contents of square brackets
+ * @param {String} str    =>  input string. such as '[1,2] [f][c]'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+declare function extractContentsOfBrackets(str: string, commaSeparated?: boolean): Array<string> | string;
+/**
+ * Extract the contents of curly braces
+ * @param {String} str    =>  input string. such as '{1,2} {f}{c}'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+declare function extractContentsOfBraces(str: string, commaSeparated?: boolean): Array<string> | string;
+/**
+ * Extract the contents of parentheses
+ * @param {String} str    =>  input string. such as '(1,2) (f)(c)'
+ * @param {Boolean} commaSeparated    =>  flag to determine if the result should be comma separated or not
+ * @returns {Array<string>|string} such as: ['1,2','f','c']
+ */
+declare function extractContentsOfParentheses(str: string, commaSeparated?: boolean): Array<string> | string;
+/**
+ * Parses a braces-separated string of `{label[value]}` pairs into an array of objects.
+ *
+ * Example:
+ *   Input: "{Poor[c]}{Sub-option 4[c-2]}{Empty[]}"
+ *   Input: "{{Poor[c]}{Sub-option 4[c-2]}{Empty[]}[]}"
+ *
+ *   Output: [
+ *     { label: "Poor", value: "c" },
+ *     { label: "Sub-option 4", value: "c-2" },
+ *     { label: "Empty", value: "" }
+ *   ]
+ *
+ * @param {string} str - The input string containing one or more `{label[value]}` segments.
+ * @returns {Array<{label: string, value: string}>} - An array of extracted label-value objects.
+ */
+declare function extractContentsOfMixedCharactersWithBraces(str: string): {
+    label: string;
+    value: string | number;
+}[];
+/**
+ * Parses a comma-separated string of `label[value]` pairs into an array of objects.
+ *
+ * Example:
+ *   Input: "Poor[c],Sub-option 4[c-2],Empty[]"
+ *   Output: [
+ *     { label: "Poor", value: "c" },
+ *     { label: "Sub-option 4", value: "c-2" },
+ *     { label: "Empty", value: "" }
+ *   ]
+ *
+ * @param {string} str - A string containing label-value pairs in the format `label[value]`, separated by commas.
+ * @returns {Array<{ label: string, value: string }>} - An array of parsed objects.
+ */
+declare function extractContentsOfMixedCharactersWithComma(str: string): {
+    label: string;
+    value: string | number;
+}[];
+export { extractorExist, extractContentsOfBrackets, extractContentsOfBraces, extractContentsOfParentheses, extractContentsOfMixedCharactersWithBraces, extractContentsOfMixedCharactersWithComma };