@mjhls/mjh-framework 1.0.98 → 1.0.99-0.next12

package/dist/cjs/entities-3f9d0f2f.js

@@ -0,0 +1,506 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+
+var striptags = _commonjsHelpers.createCommonjsModule(function (module) {
+
+(function (global) {
+
+    // minimal symbol polyfill for IE11 and others
+    if (typeof Symbol !== 'function') {
+        var Symbol = function(name) {
+            return name;
+        };
+
+        Symbol.nonNative = true;
+    }
+
+    const STATE_PLAINTEXT = Symbol('plaintext');
+    const STATE_HTML      = Symbol('html');
+    const STATE_COMMENT   = Symbol('comment');
+
+    const ALLOWED_TAGS_REGEX  = /<(\w*)>/g;
+    const NORMALIZE_TAG_REGEX = /<\/?([^\s\/>]+)/;
+
+    function striptags(html, allowable_tags, tag_replacement) {
+        html            = html || '';
+        allowable_tags  = allowable_tags || [];
+        tag_replacement = tag_replacement || '';
+
+        let context = init_context(allowable_tags, tag_replacement);
+
+        return striptags_internal(html, context);
+    }
+
+    function init_striptags_stream(allowable_tags, tag_replacement) {
+        allowable_tags  = allowable_tags || [];
+        tag_replacement = tag_replacement || '';
+
+        let context = init_context(allowable_tags, tag_replacement);
+
+        return function striptags_stream(html) {
+            return striptags_internal(html || '', context);
+        };
+    }
+
+    striptags.init_streaming_mode = init_striptags_stream;
+
+    function init_context(allowable_tags, tag_replacement) {
+        allowable_tags = parse_allowable_tags(allowable_tags);
+
+        return {
+            allowable_tags : allowable_tags,
+            tag_replacement: tag_replacement,
+
+            state         : STATE_PLAINTEXT,
+            tag_buffer    : '',
+            depth         : 0,
+            in_quote_char : ''
+        };
+    }
+
+    function striptags_internal(html, context) {
+        let allowable_tags  = context.allowable_tags;
+        let tag_replacement = context.tag_replacement;
+
+        let state         = context.state;
+        let tag_buffer    = context.tag_buffer;
+        let depth         = context.depth;
+        let in_quote_char = context.in_quote_char;
+        let output        = '';
+
+        for (let idx = 0, length = html.length; idx < length; idx++) {
+            let char = html[idx];
+
+            if (state === STATE_PLAINTEXT) {
+                switch (char) {
+                    case '<':
+                        state       = STATE_HTML;
+                        tag_buffer += char;
+                        break;
+
+                    default:
+                        output += char;
+                        break;
+                }
+            }
+
+            else if (state === STATE_HTML) {
+                switch (char) {
+                    case '<':
+                        // ignore '<' if inside a quote
+                        if (in_quote_char) {
+                            break;
+                        }
+
+                        // we're seeing a nested '<'
+                        depth++;
+                        break;
+
+                    case '>':
+                        // ignore '>' if inside a quote
+                        if (in_quote_char) {
+                            break;
+                        }
+
+                        // something like this is happening: '<<>>'
+                        if (depth) {
+                            depth--;
+
+                            break;
+                        }
+
+                        // this is closing the tag in tag_buffer
+                        in_quote_char = '';
+                        state         = STATE_PLAINTEXT;
+                        tag_buffer   += '>';
+
+                        if (allowable_tags.has(normalize_tag(tag_buffer))) {
+                            output += tag_buffer;
+                        } else {
+                            output += tag_replacement;
+                        }
+
+                        tag_buffer = '';
+                        break;
+
+                    case '"':
+                    case '\'':
+                        // catch both single and double quotes
+
+                        if (char === in_quote_char) {
+                            in_quote_char = '';
+                        } else {
+                            in_quote_char = in_quote_char || char;
+                        }
+
+                        tag_buffer += char;
+                        break;
+
+                    case '-':
+                        if (tag_buffer === '<!-') {
+                            state = STATE_COMMENT;
+                        }
+
+                        tag_buffer += char;
+                        break;
+
+                    case ' ':
+                    case '\n':
+                        if (tag_buffer === '<') {
+                            state      = STATE_PLAINTEXT;
+                            output    += '< ';
+                            tag_buffer = '';
+
+                            break;
+                        }
+
+                        tag_buffer += char;
+                        break;
+
+                    default:
+                        tag_buffer += char;
+                        break;
+                }
+            }
+
+            else if (state === STATE_COMMENT) {
+                switch (char) {
+                    case '>':
+                        if (tag_buffer.slice(-2) == '--') {
+                            // close the comment
+                            state = STATE_PLAINTEXT;
+                        }
+
+                        tag_buffer = '';
+                        break;
+
+                    default:
+                        tag_buffer += char;
+                        break;
+                }
+            }
+        }
+
+        // save the context for future iterations
+        context.state         = state;
+        context.tag_buffer    = tag_buffer;
+        context.depth         = depth;
+        context.in_quote_char = in_quote_char;
+
+        return output;
+    }
+
+    function parse_allowable_tags(allowable_tags) {
+        let tag_set = new Set();
+
+        if (typeof allowable_tags === 'string') {
+            let match;
+
+            while ((match = ALLOWED_TAGS_REGEX.exec(allowable_tags))) {
+                tag_set.add(match[1]);
+            }
+        }
+
+        else if (!Symbol.nonNative &&
+                 typeof allowable_tags[Symbol.iterator] === 'function') {
+
+            tag_set = new Set(allowable_tags);
+        }
+
+        else if (typeof allowable_tags.forEach === 'function') {
+            // IE11 compatible
+            allowable_tags.forEach(tag_set.add, tag_set);
+        }
+
+        return tag_set;
+    }
+
+    function normalize_tag(tag_buffer) {
+        let match = NORMALIZE_TAG_REGEX.exec(tag_buffer);
+
+        return match ? match[1].toLowerCase() : null;
+    }
+
+    if (module.exports) {
+        // Node
+        module.exports = striptags;
+    }
+
+    else {
+        // Browser
+        global.striptags = striptags;
+    }
+}(_commonjsHelpers.commonjsGlobal));
+});
+
+var html_map = {
+    "'": "&apos;",
+    "<": "&lt;",
+    ">": "&gt;",
+    " ": "&nbsp;",
+    "¡": "&iexcl;",
+    "¢": "&cent;",
+    "£": "&pound;",
+    "¤": "&curren;",
+    "¥": "&yen;",
+    "¦": "&brvbar;",
+    "§": "&sect;",
+    "¨": "&uml;",
+    "©": "&copy;",
+    "ª": "&ordf;",
+    "«": "&laquo;",
+    "¬": "&not;",
+    "®": "&reg;",
+    "¯": "&macr;",
+    "°": "&deg;",
+    "±": "&plusmn;",
+    "²": "&sup2;",
+    "³": "&sup3;",
+    "´": "&acute;",
+    "µ": "&micro;",
+    "¶": "&para;",
+    "·": "&middot;",
+    "¸": "&cedil;",
+    "¹": "&sup1;",
+    "º": "&ordm;",
+    "»": "&raquo;",
+    "¼": "&frac14;",
+    "½": "&frac12;",
+    "¾": "&frac34;",
+    "¿": "&iquest;",
+    "À": "&Agrave;",
+    "Á": "&Aacute;",
+    "Â": "&Acirc;",
+    "Ã": "&Atilde;",
+    "Ä": "&Auml;",
+    "Å": "&Aring;",
+    "Æ": "&AElig;",
+    "Ç": "&Ccedil;",
+    "È": "&Egrave;",
+    "É": "&Eacute;",
+    "Ê": "&Ecirc;",
+    "Ë": "&Euml;",
+    "Ì": "&Igrave;",
+    "Í": "&Iacute;",
+    "Î": "&Icirc;",
+    "Ï": "&Iuml;",
+    "Ð": "&ETH;",
+    "Ñ": "&Ntilde;",
+    "Ò": "&Ograve;",
+    "Ó": "&Oacute;",
+    "Ô": "&Ocirc;",
+    "Õ": "&Otilde;",
+    "Ö": "&Ouml;",
+    "×": "&times;",
+    "Ø": "&Oslash;",
+    "Ù": "&Ugrave;",
+    "Ú": "&Uacute;",
+    "Û": "&Ucirc;",
+    "Ü": "&Uuml;",
+    "Ý": "&Yacute;",
+    "Þ": "&THORN;",
+    "ß": "&szlig;",
+    "à": "&agrave;",
+    "á": "&aacute;",
+    "â": "&acirc;",
+    "ã": "&atilde;",
+    "ä": "&auml;",
+    "å": "&aring;",
+    "æ": "&aelig;",
+    "ç": "&ccedil;",
+    "è": "&egrave;",
+    "é": "&eacute;",
+    "ê": "&ecirc;",
+    "ë": "&euml;",
+    "ì": "&igrave;",
+    "í": "&iacute;",
+    "î": "&icirc;",
+    "ï": "&iuml;",
+    "ð": "&eth;",
+    "ñ": "&ntilde;",
+    "ò": "&ograve;",
+    "ó": "&oacute;",
+    "ô": "&ocirc;",
+    "õ": "&otilde;",
+    "ö": "&ouml;",
+    "÷": "&divide;",
+    "ø": "&oslash;",
+    "ù": "&ugrave;",
+    "ú": "&uacute;",
+    "û": "&ucirc;",
+    "ü": "&uuml;",
+    "ý": "&yacute;",
+    "þ": "&thorn;",
+    "ÿ": "&yuml;",
+    "Œ": "&OElig;",
+    "œ": "&oelig;",
+    "Š": "&Scaron;",
+    "š": "&scaron;",
+    "Ÿ": "&Yuml;",
+    "ƒ": "&fnof;",
+    "ˆ": "&circ;",
+    "˜": "&tilde;",
+    "Α": "&Alpha;",
+    "Β": "&Beta;",
+    "Γ": "&Gamma;",
+    "Δ": "&Delta;",
+    "Ε": "&Epsilon;",
+    "Ζ": "&Zeta;",
+    "Η": "&Eta;",
+    "Θ": "&Theta;",
+    "Ι": "&Iota;",
+    "Κ": "&Kappa;",
+    "Λ": "&Lambda;",
+    "Μ": "&Mu;",
+    "Ν": "&Nu;",
+    "Ξ": "&Xi;",
+    "Ο": "&Omicron;",
+    "Π": "&Pi;",
+    "Ρ": "&Rho;",
+    "Σ": "&Sigma;",
+    "Τ": "&Tau;",
+    "Υ": "&Upsilon;",
+    "Φ": "&Phi;",
+    "Χ": "&Chi;",
+    "Ψ": "&Psi;",
+    "Ω": "&Omega;",
+    "α": "&alpha;",
+    "β": "&beta;",
+    "γ": "&gamma;",
+    "δ": "&delta;",
+    "ε": "&epsilon;",
+    "ζ": "&zeta;",
+    "η": "&eta;",
+    "θ": "&theta;",
+    "ι": "&iota;",
+    "κ": "&kappa;",
+    "λ": "&lambda;",
+    "μ": "&mu;",
+    "ν": "&nu;",
+    "ξ": "&xi;",
+    "ο": "&omicron;",
+    "π": "&pi;",
+    "ρ": "&rho;",
+    "ς": "&sigmaf;",
+    "σ": "&sigma;",
+    "τ": "&tau;",
+    "υ": "&upsilon;",
+    "φ": "&phi;",
+    "χ": "&chi;",
+    "ψ": "&psi;",
+    "ω": "&omega;",
+    "ϑ": "&thetasym;",
+    "ϒ": "&Upsih;",
+    "ϖ": "&piv;",
+    "–": "&ndash;",
+    "—": "&mdash;",
+    "‘": "&lsquo;",
+    "’": "&rsquo;",
+    "‚": "&sbquo;",
+    "“": "&ldquo;",
+    "”": "&rdquo;",
+    "„": "&bdquo;",
+    "†": "&dagger;",
+    "‡": "&Dagger;",
+    "•": "&bull;",
+    "…": "&hellip;",
+    "‰": "&permil;",
+    "′": "&prime;",
+    "″": "&Prime;",
+    "‹": "&lsaquo;",
+    "›": "&rsaquo;",
+    "‾": "&oline;",
+    "⁄": "&frasl;",
+    "€": "&euro;",
+    "ℑ": "&image;",
+    "℘": "&weierp;",
+    "ℜ": "&real;",
+    "™": "&trade;",
+    "ℵ": "&alefsym;",
+    "←": "&larr;",
+    "↑": "&uarr;",
+    "→": "&rarr;",
+    "↓": "&darr;",
+    "↔": "&harr;",
+    "↵": "&crarr;",
+    "⇐": "&lArr;",
+    "⇑": "&UArr;",
+    "⇒": "&rArr;",
+    "⇓": "&dArr;",
+    "⇔": "&hArr;",
+    "∀": "&forall;",
+    "∂": "&part;",
+    "∃": "&exist;",
+    "∅": "&empty;",
+    "∇": "&nabla;",
+    "∈": "&isin;",
+    "∉": "&notin;",
+    "∋": "&ni;",
+    "∏": "&prod;",
+    "∑": "&sum;",
+    "−": "&minus;",
+    "∗": "&lowast;",
+    "√": "&radic;",
+    "∝": "&prop;",
+    "∞": "&infin;",
+    "∠": "&ang;",
+    "∧": "&and;",
+    "∨": "&or;",
+    "∩": "&cap;",
+    "∪": "&cup;",
+    "∫": "&int;",
+    "∴": "&there4;",
+    "∼": "&sim;",
+    "≅": "&cong;",
+    "≈": "&asymp;",
+    "≠": "&ne;",
+    "≡": "&equiv;",
+    "≤": "&le;",
+    "≥": "&ge;",
+    "⊂": "&sub;",
+    "⊃": "&sup;",
+    "⊄": "&nsub;",
+    "⊆": "&sube;",
+    "⊇": "&supe;",
+    "⊕": "&oplus;",
+    "⊗": "&otimes;",
+    "⊥": "&perp;",
+    "⋅": "&sdot;",
+    "⌈": "&lceil;",
+    "⌉": "&rceil;",
+    "⌊": "&lfloor;",
+    "⌋": "&rfloor;",
+    "⟨": "&lang;",
+    "⟩": "&rang;",
+    "◊": "&loz;",
+    "♠": "&spades;",
+    "♣": "&clubs;",
+    "♥": "&hearts;",
+    "♦": "&diams;"
+};
+
+var html_decode = function html_decode(string) {
+    if (!string) {
+        return string;
+    }
+
+    var entityMap = html_map;
+    for (var key in entityMap) {
+        var entity = entityMap[key];
+        var regex = new RegExp(entity, 'g');
+        string = string.replace(regex, key);
+    }
+    string = string.replace(/&quot;/g, '"');
+    string = string.replace(/&amp;/g, '&');
+    return string;
+};
+
+var clean_html = function clean_html(string) {
+    return striptags(html_decode(string));
+};
+var html_decode_1 = html_decode;
+var clean_html_1 = clean_html;
+
+exports.clean_html_1 = clean_html_1;
+exports.html_decode_1 = html_decode_1;

package/dist/cjs/eq-5fc26c07.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var isSymbol = require('./isSymbol-03abbdf0.js');
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  if (!isSymbol.isObject_1(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = isSymbol._baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+var isFunction_1 = isFunction;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+var eq_1 = eq;
+
+exports.eq_1 = eq_1;
+exports.isFunction_1 = isFunction_1;

package/dist/cjs/extends-7c86182f.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+var core_getIteratorMethod = require('./core.get-iterator-method-5643aa10.js');
+var _objectPie = require('./_object-pie-083f2dd6.js');
+
+// 19.1.2.1 Object.assign(target, source, ...)
+
+
+
+
+
+
+var $assign = Object.assign;
+
+// should work with symbols and should have deterministic property order (V8 bug)
+var _objectAssign = !$assign || core_getIteratorMethod._fails(function () {
+  var A = {};
+  var B = {};
+  // eslint-disable-next-line no-undef
+  var S = Symbol();
+  var K = 'abcdefghijklmnopqrst';
+  A[S] = 7;
+  K.split('').forEach(function (k) { B[k] = k; });
+  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
+  var T = core_getIteratorMethod._toObject(target);
+  var aLen = arguments.length;
+  var index = 1;
+  var getSymbols = _objectPie._objectGops.f;
+  var isEnum = _objectPie._objectPie.f;
+  while (aLen > index) {
+    var S = core_getIteratorMethod._iobject(arguments[index++]);
+    var keys = getSymbols ? core_getIteratorMethod._objectKeys(S).concat(getSymbols(S)) : core_getIteratorMethod._objectKeys(S);
+    var length = keys.length;
+    var j = 0;
+    var key;
+    while (length > j) {
+      key = keys[j++];
+      if (!core_getIteratorMethod._descriptors || isEnum.call(S, key)) T[key] = S[key];
+    }
+  } return T;
+} : $assign;
+
+// 19.1.3.1 Object.assign(target, source)
+
+
+core_getIteratorMethod._export(core_getIteratorMethod._export.S + core_getIteratorMethod._export.F, 'Object', { assign: _objectAssign });
+
+var assign$1 = core_getIteratorMethod._core.Object.assign;
+
+var assign = _commonjsHelpers.createCommonjsModule(function (module) {
+module.exports = { "default": assign$1, __esModule: true };
+});
+
+var _Object$assign = _commonjsHelpers.unwrapExports(assign);
+
+var _extends = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+
+exports.__esModule = true;
+
+
+
+var _assign2 = _interopRequireDefault(assign);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = _assign2.default || function (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  return target;
+};
+});
+
+var _extends$1 = _commonjsHelpers.unwrapExports(_extends);
+
+exports._Object$assign = _Object$assign;
+exports._extends = _extends$1;
+exports._extends$1 = _extends;