@bbn/bbn 1.0.12 → 1.0.13

package/dist/fn/log.js

@@ -0,0 +1,34 @@
+import { bbn } from '../definitions';
+import { isFunction } from './isFunction';
+const log = function (...args) {
+    if (window.console !== undefined) {
+        let cfg;
+        let level = 5;
+        let fn = "log";
+        if (args[0] && (typeof args[0] === 'object') && args[0]._bbn_console_style) {
+            if (args[0]._bbn_console_mode && isFunction(console[args[0]._bbn_console_mode])) {
+                fn = args[0]._bbn_console_mode;
+            }
+            else {
+                cfg = args[0]._bbn_console_style;
+                level = args[0]._bbn_console_level;
+            }
+            args.shift();
+        }
+        if (bbn.env.loggingLevel >= level) {
+            let i = 0;
+            while (i < args.length) {
+                let t = typeof args[i];
+                if ((t === 'string') || (t === 'number')) {
+                    window.console[fn]("%c %s ", cfg, args[i]);
+                }
+                else {
+                    window.console[fn](args[i]);
+                }
+                i++;
+            }
+        }
+    }
+    return this;
+};
+export { log };

package/dist/fn/makeReactive.d.ts

@@ -0,0 +1,3 @@
+import { makeReactive } from './makeReactive';
+declare const makeReactive: (obj: any, onSet: any, parent: any, parentProp: any) => any;
+export { makeReactive };

package/dist/fn/makeReactive.js

@@ -0,0 +1,137 @@
+import { log } from './log';
+import { createObject } from './createObject';
+import { isSymbol } from './isSymbol';
+import { isNumber } from './isNumber';
+import { isArray } from './isArray';
+import { warning } from './warning';
+import { isFunction } from './isFunction';
+import { isSame } from './isSame';
+const makeReactive = function (obj, onSet, parent, parentProp) {
+    const parentString = (parent === null || parent === void 0 ? void 0 : parent.$cid) || '';
+    const prefix = '__bbn_' + (parentString ? parentString + '_' : '');
+    if (obj && (typeof obj === 'object') && [undefined, Object, Array].includes(obj.constructor)) {
+        if (obj.__bbnIsProxy && (obj.__bbnParent === parent)) {
+            return obj;
+        }
+        if (parent && parent.$options && (parent.$options.name === 'bbn-loadbar')) {
+            log(["MAKING bbn-loadbar", obj]);
+        }
+        if (!obj.__bbnWatchers) {
+            Reflect.defineProperty(obj, '__bbnWatchers', { value: createObject(), writable: true, configurable: true, enumerable: false });
+        }
+        const handler = { get(target, key) {
+                const realValue = Reflect.get(target, key);
+                const realTarget = target.__bbnRoot || target;
+                if (isSymbol(key)) {
+                    return Reflect.get(realTarget, key);
+                }
+                const propName = parentProp ? parentProp + '.' + key : key;
+                const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                if (['fill', 'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'].includes(key) && isArray(target)) {
+                    return function (...args) { let res = realTarget[key](...args); warning("DOING ARRAY STUFF"); log(target.__bbnParent); onSet(target, 'length', parent); return res; };
+                }
+                if (isFunction(realValue)) {
+                    return realValue;
+                }
+                if (key === '__bbnRoot') {
+                    let root = obj;
+                    while (root && (root === null || root === void 0 ? void 0 : root.__bbnTarget)) {
+                        root = root.__bbnTarget;
+                    }
+                    return root;
+                }
+                if (key === '__bbnIsProxy') {
+                    return true;
+                }
+                if (key === '__bbnTarget') {
+                    return target;
+                }
+                if (key === '__bbnParent') {
+                    return parent;
+                }
+                if (key === '__bbnWatchers') {
+                    return target.__bbnWatchers;
+                }
+                if (key.indexOf('__bbn_') === 0) {
+                    return Reflect.get(target, key);
+                }
+                if ((key === 'length') && isArray(target.__bbnRoot || target)) {
+                    return realTarget.length;
+                }
+                if (!Object.hasOwn(target, key)) {
+                    return realValue;
+                }
+                if (realValue && (typeof realValue === 'object') && [undefined, Object, Array].includes(realValue.constructor)) {
+                    if (realValue.__bbnIsProxy && (realValue.__bbnParent === parent)) {
+                        return realTarget[hiddenKey];
+                    }
+                    if (!Object.hasOwn(realTarget, hiddenKey)) {
+                        Reflect.defineProperty(realTarget, hiddenKey, { value: makeReactive(realValue, onSet, parent, propName), writable: true, configurable: true, enumerable: false });
+                    }
+                    if (realTarget[hiddenKey].__bbnIsProxy && !realTarget.__bbnWatchers[parentString]) {
+                        realTarget.__bbnWatchers[parentString] = propName;
+                    }
+                    return realTarget[hiddenKey];
+                }
+                return realValue;
+            }, set(target, key, value) {
+                if (isSymbol(key)) {
+                    return Reflect.get(target, key, value);
+                }
+                const realTarget = target.__bbnRoot || target;
+                const propName = parentProp ? parentProp + '.' + key : key;
+                if (isSymbol(key)) {
+                    return Reflect.get(target, key);
+                }
+                if (parent && parent.$options && (parent.$options.name === 'bbn-loadbar')) {
+                    log(['Setting proxy prop in ' + parent.$options.name, target, key, value]);
+                }
+                if (!isSame(realTarget[key], value)) {
+                    if (key.indexOf('__bbn_') === 0) {
+                        Reflect.defineProperty(realTarget, key, { value: makeReactive(value, onSet, parent, propName), writable: true, configurable: true, enumerable: false });
+                    }
+                    else {
+                        if (value && (typeof value === 'object') && [undefined, Object, Array].includes(value.constructor)) {
+                            const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                            Reflect.defineProperty(realTarget, hiddenKey, { value: makeReactive(value, onSet, parent, propName), writable: true, configurable: true, enumerable: false });
+                            if (realTarget[hiddenKey].__bbnIsProxy && !realTarget.__bbnWatchers[parentString]) {
+                                realTarget.__bbnWatchers[parentString] = propName;
+                            }
+                        }
+                    }
+                    if (parent && parent.$options && (parent.$options.name === 'bbn-loadbar')) {
+                        log(['Setting proxy prop in ' + parent.$options.name + ' ' + (isNumber(key) ? key.toString() : key), value, target]);
+                    }
+                    Reflect.set(realTarget, key, value);
+                    onSet(target, key, parent);
+                }
+                return true;
+            }, defineProperty(target, key, description) {
+                const realTarget = target;
+                const propName = parentProp ? parentProp + '.' + key : key;
+                if ((key === '__bbnWatchers') || isSymbol(key) || (key.indexOf('__bbn_') === 0)) {
+                    Reflect.defineProperty(realTarget, key, description);
+                }
+                else {
+                    const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                    Reflect.defineProperty(realTarget, hiddenKey, { value: makeReactive(description.value, onSet, parent, propName), writable: true, configurable: true, enumerable: false });
+                }
+                onSet(target, key, parent);
+                return true;
+            }, deleteProperty(target, key) {
+                const realTarget = target;
+                if (key.indexOf('__bbn_') === 0) {
+                    Reflect.deleteProperty(realTarget, key);
+                }
+                else {
+                    const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                    Reflect.deleteProperty(realTarget, hiddenKey);
+                    Reflect.deleteProperty(target, key);
+                }
+                return true;
+            } };
+        return (new Proxy(obj, handler));
+    }
+    return obj;
+};
+export { makeReactive };

package/dist/fn/map.d.ts

@@ -0,0 +1,3 @@
+import { map } from './map';
+declare const map: (arr: any, fn: any, deepProp: any, level?: number) => any;
+export { map };

package/dist/fn/map.js

@@ -0,0 +1,11 @@
+import { isArray } from './isArray';
+const map = function (arr, fn, deepProp, level = 0) {
+    return arr.map((a, i) => {
+        a = fn(a, i, level);
+        if (deepProp && a[deepProp] && isArray(a[deepProp])) {
+            a[deepProp] = map(a[deepProp], fn, deepProp, level + 1);
+        }
+        return a;
+    });
+};
+export { map };

package/dist/fn/md5.d.ts

@@ -0,0 +1,2 @@
+declare const md5: (st: any) => string;
+export { md5 };

package/dist/fn/md5.js

@@ -0,0 +1,92 @@
+const md5 = function (st) {
+    var hc = "0123456789abcdef";
+    function rh(n) { var j, s = ""; for (j = 0; j <= 3; j++)
+        s += hc.charAt((n >> (j * 8 + 4)) & 0x0F) + hc.charAt((n >> (j * 8)) & 0x0F); return s; }
+    function ad(x, y) { var l = (x & 0xFFFF) + (y & 0xFFFF); var m = (x >> 16) + (y >> 16) + (l >> 16); return (m << 16) | (l & 0xFFFF); }
+    function rl(n, c) { return (n << c) | (n >>> (32 - c)); }
+    function cm(q, a, b, x, s, t) { return ad(rl(ad(ad(a, q), ad(x, t)), s), b); }
+    function ff(a, b, c, d, x, s, t) { return cm((b & c) | ((~b) & d), a, b, x, s, t); }
+    function gg(a, b, c, d, x, s, t) { return cm((b & d) | (c & (~d)), a, b, x, s, t); }
+    function hh(a, b, c, d, x, s, t) { return cm(b ^ c ^ d, a, b, x, s, t); }
+    function ii(a, b, c, d, x, s, t) { return cm(c ^ (b | (~d)), a, b, x, s, t); }
+    function sb(x) { var i; var nblk = ((x.length + 8) >> 6) + 1; var blks = new Array(nblk * 16); for (i = 0; i < nblk * 16; i++)
+        blks[i] = 0; for (i = 0; i < x.length; i++)
+        blks[i >> 2] |= x.charCodeAt(i) << ((i % 4) * 8); blks[i >> 2] |= 0x80 << ((i % 4) * 8); blks[nblk * 16 - 2] = x.length * 8; return blks; }
+    var i, x = sb(st), a = 1732584193, b = -271733879, c = -1732584194, d = 271733878, olda, oldb, oldc, oldd;
+    for (i = 0; i < x.length; i += 16) {
+        olda = a;
+        oldb = b;
+        oldc = c;
+        oldd = d;
+        a = ff(a, b, c, d, x[i + 0], 7, -680876936);
+        d = ff(d, a, b, c, x[i + 1], 12, -389564586);
+        c = ff(c, d, a, b, x[i + 2], 17, 606105819);
+        b = ff(b, c, d, a, x[i + 3], 22, -1044525330);
+        a = ff(a, b, c, d, x[i + 4], 7, -176418897);
+        d = ff(d, a, b, c, x[i + 5], 12, 1200080426);
+        c = ff(c, d, a, b, x[i + 6], 17, -1473231341);
+        b = ff(b, c, d, a, x[i + 7], 22, -45705983);
+        a = ff(a, b, c, d, x[i + 8], 7, 1770035416);
+        d = ff(d, a, b, c, x[i + 9], 12, -1958414417);
+        c = ff(c, d, a, b, x[i + 10], 17, -42063);
+        b = ff(b, c, d, a, x[i + 11], 22, -1990404162);
+        a = ff(a, b, c, d, x[i + 12], 7, 1804603682);
+        d = ff(d, a, b, c, x[i + 13], 12, -40341101);
+        c = ff(c, d, a, b, x[i + 14], 17, -1502002290);
+        b = ff(b, c, d, a, x[i + 15], 22, 1236535329);
+        a = gg(a, b, c, d, x[i + 1], 5, -165796510);
+        d = gg(d, a, b, c, x[i + 6], 9, -1069501632);
+        c = gg(c, d, a, b, x[i + 11], 14, 643717713);
+        b = gg(b, c, d, a, x[i + 0], 20, -373897302);
+        a = gg(a, b, c, d, x[i + 5], 5, -701558691);
+        d = gg(d, a, b, c, x[i + 10], 9, 38016083);
+        c = gg(c, d, a, b, x[i + 15], 14, -660478335);
+        b = gg(b, c, d, a, x[i + 4], 20, -405537848);
+        a = gg(a, b, c, d, x[i + 9], 5, 568446438);
+        d = gg(d, a, b, c, x[i + 14], 9, -1019803690);
+        c = gg(c, d, a, b, x[i + 3], 14, -187363961);
+        b = gg(b, c, d, a, x[i + 8], 20, 1163531501);
+        a = gg(a, b, c, d, x[i + 13], 5, -1444681467);
+        d = gg(d, a, b, c, x[i + 2], 9, -51403784);
+        c = gg(c, d, a, b, x[i + 7], 14, 1735328473);
+        b = gg(b, c, d, a, x[i + 12], 20, -1926607734);
+        a = hh(a, b, c, d, x[i + 5], 4, -378558);
+        d = hh(d, a, b, c, x[i + 8], 11, -2022574463);
+        c = hh(c, d, a, b, x[i + 11], 16, 1839030562);
+        b = hh(b, c, d, a, x[i + 14], 23, -35309556);
+        a = hh(a, b, c, d, x[i + 1], 4, -1530992060);
+        d = hh(d, a, b, c, x[i + 4], 11, 1272893353);
+        c = hh(c, d, a, b, x[i + 7], 16, -155497632);
+        b = hh(b, c, d, a, x[i + 10], 23, -1094730640);
+        a = hh(a, b, c, d, x[i + 13], 4, 681279174);
+        d = hh(d, a, b, c, x[i + 0], 11, -358537222);
+        c = hh(c, d, a, b, x[i + 3], 16, -722521979);
+        b = hh(b, c, d, a, x[i + 6], 23, 76029189);
+        a = hh(a, b, c, d, x[i + 9], 4, -640364487);
+        d = hh(d, a, b, c, x[i + 12], 11, -421815835);
+        c = hh(c, d, a, b, x[i + 15], 16, 530742520);
+        b = hh(b, c, d, a, x[i + 2], 23, -995338651);
+        a = ii(a, b, c, d, x[i + 0], 6, -198630844);
+        d = ii(d, a, b, c, x[i + 7], 10, 1126891415);
+        c = ii(c, d, a, b, x[i + 14], 15, -1416354905);
+        b = ii(b, c, d, a, x[i + 5], 21, -57434055);
+        a = ii(a, b, c, d, x[i + 12], 6, 1700485571);
+        d = ii(d, a, b, c, x[i + 3], 10, -1894986606);
+        c = ii(c, d, a, b, x[i + 10], 15, -1051523);
+        b = ii(b, c, d, a, x[i + 1], 21, -2054922799);
+        a = ii(a, b, c, d, x[i + 8], 6, 1873313359);
+        d = ii(d, a, b, c, x[i + 15], 10, -30611744);
+        c = ii(c, d, a, b, x[i + 6], 15, -1560198380);
+        b = ii(b, c, d, a, x[i + 13], 21, 1309151649);
+        a = ii(a, b, c, d, x[i + 4], 6, -145523070);
+        d = ii(d, a, b, c, x[i + 11], 10, -1120210379);
+        c = ii(c, d, a, b, x[i + 2], 15, 718787259);
+        b = ii(b, c, d, a, x[i + 9], 21, -343485551);
+        a = ad(a, olda);
+        b = ad(b, oldb);
+        c = ad(c, oldc);
+        d = ad(d, oldd);
+    }
+    return rh(a) + rh(b) + rh(c) + rh(d);
+};
+export { md5 };

package/dist/fn/money.d.ts

@@ -0,0 +1,2 @@
+declare const money: (val: any, kilo: any, currency: any, novalue: any, decimal: any, thousands: any, precision: any) => any;
+export { money };

package/dist/fn/money.js

@@ -0,0 +1,63 @@
+import { bbn } from '../definitions';
+import { isNumber } from './isNumber';
+const money = function (val, kilo, currency, novalue, decimal, thousands, precision) {
+    if (!decimal) {
+        decimal = (decimal === undefined) && bbn.env.money && (bbn.env.money.decimal !== undefined) ? bbn.env.money.decimal : '.';
+    }
+    if (!currency) {
+        currency = (currency === undefined) && bbn.env.money && (bbn.env.money.currency !== undefined) ? bbn.env.money.currency : '';
+    }
+    if (!thousands) {
+        thousands = (thousands === undefined) && bbn.env.money && (bbn.env.money.thousands !== undefined) ? bbn.env.money.thousands : ' ';
+    }
+    if (!precision) {
+        precision = (precision === undefined) && bbn.env.money && (bbn.env.money.precision !== undefined) ? bbn.env.money.precision : false;
+    }
+    if (!kilo) {
+        kilo = (kilo === undefined) && bbn.env.money && (bbn.env.money.kilo !== undefined) ? bbn.env.money.kilo : false;
+    }
+    if (!novalue) {
+        novalue = (novalue === undefined) && bbn.env.money && (bbn.env.money.novalue !== undefined) ? bbn.env.money.novalue : false;
+    }
+    if (!isNumber(precision)) {
+        precision = kilo ? 3 : 0;
+    }
+    if (val === 0) {
+        let res = val.toFixed(precision).replace('.', decimal);
+        if (currency) {
+            res += ' ' + (kilo ? 'K' + currency : currency);
+        }
+        return res;
+    }
+    if ((isNaN(val) || !val) && novalue) {
+        return novalue;
+    }
+    if (isNaN(val) || !val) {
+        return 0 + (currency ? (' ' + currency) : '');
+    }
+    if (kilo && val) {
+        val = val / 1000;
+        if (currency) {
+            currency = 'K' + currency;
+        }
+    }
+    let v = parseFloat(val).toFixed(precision);
+    let decimalPosition = 0;
+    let decimalIdx = 10000;
+    if (v) {
+        decimalIdx = v.indexOf('.');
+        if (decimalIdx <= 0) {
+            decimalIdx = 10000;
+        }
+        else {
+            decimalPosition = v.length - decimalIdx;
+        }
+    }
+    return v.replace(/./g, function (c, i, a) {
+        if (c === '.') {
+            return decimal;
+        }
+        return i && ((a.length - i - decimalPosition) % 3 === 0) && (i < decimalIdx) ? thousands + c : c;
+    }) + (currency ? ' ' + currency : '');
+};
+export { money };

package/dist/fn/move.d.ts

@@ -0,0 +1,2 @@
+declare const move: (arr: any, fromIndex: any, toIndex: any) => any;
+export { move };

package/dist/fn/move.js

@@ -0,0 +1,11 @@
+const move = function (arr, fromIndex, toIndex) {
+    if (toIndex >= arr.length) {
+        let k = toIndex - arr.length;
+        while ((k--) + 1) {
+            arr.push(undefined);
+        }
+    }
+    arr.splice(toIndex, 0, arr.splice(fromIndex, 1)[0]);
+    return arr;
+};
+export { move };

package/dist/fn/multiorder.d.ts

@@ -0,0 +1,2 @@
+declare const multiorder: (arr: any, orders: any) => any;
+export { multiorder };

package/dist/fn/multiorder.js

@@ -0,0 +1,22 @@
+import { _compareValues } from './_compareValues';
+const multiorder = function (arr, orders) {
+    if (!Array.isArray(orders) && (typeof orders === 'object')) {
+        let tmp = [];
+        for (var n in orders) {
+            tmp.push({ field: n, dir: orders[n] });
+        }
+        orders = tmp;
+    }
+    let r = arr.slice();
+    return r.sort((a, b) => {
+        let res;
+        for (let order of orders) {
+            res = _compareValues(a, b, order.field, order.dir);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        return 0;
+    });
+};
+export { multiorder };

package/dist/fn/nl2br.d.ts

@@ -0,0 +1,2 @@
+declare const nl2br: (st: any, keepNl: any) => any;
+export { nl2br };

package/dist/fn/nl2br.js

@@ -0,0 +1,3 @@
+import { replaceAll } from './replaceAll';
+const nl2br = function (st, keepNl) { return replaceAll("\n", "<br>" + (keepNl ? "\n" : ""), st); };
+export { nl2br };

package/dist/fn/numProperties.d.ts

@@ -0,0 +1,2 @@
+declare const numProperties: (obj: any) => number;
+export { numProperties };

package/dist/fn/numProperties.js

@@ -0,0 +1,7 @@
+const numProperties = function (obj) {
+    if (!obj || (typeof obj !== 'object')) {
+        return 0;
+    }
+    return Object.keys(obj).length;
+};
+export { numProperties };

package/dist/fn/objectToFormData.d.ts

@@ -0,0 +1,2 @@
+declare const objectToFormData: (obj: any, key: any, ignoreList: any) => FormData;
+export { objectToFormData };

package/dist/fn/objectToFormData.js

@@ -0,0 +1,31 @@
+import { isArray } from './isArray';
+import { each } from './each';
+import { isObject } from './isObject';
+import { iterate } from './iterate';
+import { isNull } from './isNull';
+const objectToFormData = function (obj, key, ignoreList) {
+    let formData = new FormData();
+    let appendFormData = (data, key = '') => {
+        if (!ignoreList || (isArray(ignoreList) && !ignoreList.includes(key))) {
+            if (data instanceof File) {
+                formData.append(key, data);
+            }
+            else if (isArray(data)) {
+                each(data, (v, i) => { appendFormData(v, key + '[' + i + ']'); });
+            }
+            else if (isObject(data) && Object.keys(data).length) {
+                iterate(data, (v, i) => { if (Object.hasOwn(data, i)) {
+                    appendFormData(v, !key ? i : key + '[' + i + ']');
+                } });
+            }
+            else {
+                if (!isNull(data) && (data !== undefined)) {
+                    formData.append(key, data);
+                }
+            }
+        }
+    };
+    appendFormData(obj, key);
+    return formData;
+};
+export { objectToFormData };

package/dist/fn/order.d.ts

@@ -0,0 +1,2 @@
+declare const order: (arr: any, prop: any, dir?: string) => any;
+export { order };

package/dist/fn/order.js

@@ -0,0 +1,8 @@
+import { _compareValues } from './_compareValues';
+const order = function (arr, prop, dir = 'asc') {
+    if (arr) {
+        return arr.sort(function (a, b) { return _compareValues(a, b, prop, dir); });
+    }
+    return arr;
+};
+export { order };

package/dist/fn/outerHeight.d.ts

@@ -0,0 +1,2 @@
+declare const outerHeight: (ele: any) => number;
+export { outerHeight };

package/dist/fn/outerHeight.js

@@ -0,0 +1,9 @@
+import { selector } from './selector';
+const outerHeight = function (ele) {
+    ele = selector(ele);
+    let styles = window.getComputedStyle(ele);
+    let margin = parseFloat(styles['marginTop']) +
+        parseFloat(styles['marginBottom']);
+    return Math.ceil(ele.offsetHeight + margin);
+};
+export { outerHeight };

package/dist/fn/outerWidth.d.ts

@@ -0,0 +1,2 @@
+declare const outerWidth: (ele: any) => number;
+export { outerWidth };

package/dist/fn/outerWidth.js

@@ -0,0 +1,9 @@
+import { selector } from './selector';
+const outerWidth = function (ele) {
+    ele = selector(ele);
+    let styles = window.getComputedStyle(ele);
+    let margin = parseFloat(styles['marginLeft']) +
+        parseFloat(styles['marginRight']);
+    return Math.ceil(ele.offsetWidth + margin);
+};
+export { outerWidth };

package/dist/fn/percent.d.ts

@@ -0,0 +1,2 @@
+declare const percent: (percent: any, cent: any) => number;
+export { percent };

package/dist/fn/percent.js

@@ -0,0 +1,2 @@
+const percent = function (percent, cent) { return (cent / 100) * percent; };
+export { percent };

package/dist/fn/pickValue.d.ts

@@ -0,0 +1,2 @@
+declare const pickValue: (arr: any) => any;
+export { pickValue };

package/dist/fn/pickValue.js

@@ -0,0 +1,4 @@
+const pickValue = function (arr) { if (Array.isArray(arr) && arr.length) {
+    return arr[Math.floor(Math.random() * arr.length)];
+} };
+export { pickValue };

package/dist/fn/post.d.ts

@@ -0,0 +1,2 @@
+declare const post: () => any;
+export { post };

package/dist/fn/post.js

@@ -0,0 +1,7 @@
+import { treatAjaxArguments } from './treatAjaxArguments';
+import { ajax } from './ajax';
+import { callback } from './callback';
+const post = function () { let cfg = treatAjaxArguments(arguments); if (cfg.url) {
+    return ajax(cfg.url, cfg.datatype, cfg.obj, (res) => { callback(cfg.url, res, cfg.successFn, false, cfg.ele); }, cfg.errorFn, cfg.abortFn);
+} };
+export { post };

package/dist/fn/postOut.d.ts

@@ -0,0 +1,2 @@
+declare const postOut: (url: any, data: any, success: any, target: any) => void;
+export { postOut };

package/dist/fn/postOut.js

@@ -0,0 +1,30 @@
+import { createObject } from './createObject';
+import { addInputs } from './addInputs';
+const postOut = function (url, data, success, target) {
+    let form = document.getElementById("bbn-form_out");
+    if (!form) {
+        form = document.createElement('form');
+        form.classList.add('bbn-no');
+        form.setAttribute('id', 'bbn-form_out');
+        form.setAttribute('method', 'post');
+        form.setAttribute('enctype', 'multipart/form-data-encoded');
+        form.style.display = 'none';
+        document.body.appendChild(form);
+    }
+    form.innerHTML = '';
+    form.setAttribute('action', url);
+    form.setAttribute('target', target || "_blank");
+    if (!data) {
+        data = {};
+    }
+    data = createObject(data);
+    if (!data.bbn) {
+        data.bbn = 'public';
+    }
+    addInputs(form, data);
+    form.submit();
+    if (success) {
+        success();
+    }
+};
+export { postOut };

package/dist/fn/printf.d.ts

@@ -0,0 +1,2 @@
+declare const printf: (format: any) => any;
+export { printf };

package/dist/fn/printf.js

@@ -0,0 +1,2 @@
+const printf = function (format) { var args = Array.prototype.slice.call(arguments, 1); return format.replace(/{(\d+)}/g, function (match, number) { return typeof args[number] != 'undefined' ? args[number] : match; }); };
+export { printf };

package/dist/fn/quotes2html.d.ts

@@ -0,0 +1,2 @@
+declare const quotes2html: (st: any, type: any) => any;
+export { quotes2html };

package/dist/fn/quotes2html.js

@@ -0,0 +1,11 @@
+import { replaceAll } from './replaceAll';
+const quotes2html = function (st, type) {
+    if (!type || (type.toLowerCase().indexOf('s') === 0)) {
+        st = replaceAll("'", "'", st);
+    }
+    if (!type || (type.toLowerCase().indexOf('d') === 0)) {
+        st = replaceAll('"', '"', st);
+    }
+    return st;
+};
+export { quotes2html };

package/dist/fn/randomInt.d.ts

@@ -0,0 +1,2 @@
+declare const randomInt: (min: any, max: any) => number;
+export { randomInt };

package/dist/fn/randomInt.js

@@ -0,0 +1,2 @@
+const randomInt = function (min, max) { return Math.floor(Math.random() * (max - min + 1) + min); };
+export { randomInt };

package/dist/fn/randomString.d.ts

@@ -0,0 +1,2 @@
+declare const randomString: (min: any, max: any, types: any) => string;
+export { randomString };

package/dist/fn/randomString.js

@@ -0,0 +1,38 @@
+import { randomInt } from './randomInt';
+import { isString } from './isString';
+const randomString = function (min, max, types) {
+    let length, type, chars = { n: '0123456789', l: 'abcdefghijklmnopqrstuvwxyz', u: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' };
+    if (!types) {
+        types = 'nlu';
+    }
+    if (!min) {
+        length = randomInt(8, 14);
+    }
+    if (isString(max)) {
+        types = 'n';
+        chars = { n: max };
+        if (!length) {
+            length = min;
+        }
+    }
+    else if ((typeof (max) === 'number') && (min < max)) {
+        length = randomInt(min, max);
+    }
+    else if (min) {
+        length = min;
+    }
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        if (i === 0) {
+            if (types !== 'n') {
+                type = types.indexOf('u') === -1 ? 'l' : 'u';
+            }
+        }
+        else {
+            type = types[Math.floor(Math.random() * types.length)];
+        }
+        result += chars[type][Math.floor(Math.random() * chars[type].length)];
+    }
+    return result;
+};
+export { randomString };