nhj

more

unified-ai-platform/node_modules/@sideway/address/lib/decode.js

@@ -0,0 +1,120 @@
+'use strict';
+
+// Adapted from:
+// Copyright (c) 2017-2019 Justin Ridgewell, MIT Licensed, https://github.com/jridgewell/safe-decode-string-component
+// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>, MIT Licensed, http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+
+
+const internals = {};
+
+
+exports.decode = function (string) {
+
+    let percentPos = string.indexOf('%');
+    if (percentPos === -1) {
+        return string;
+    }
+
+    let decoded = '';
+    let last = 0;
+    let codepoint = 0;
+    let startOfOctets = percentPos;
+    let state = internals.utf8.accept;
+
+    while (percentPos > -1 &&
+        percentPos < string.length) {
+
+        const high = internals.resolveHex(string[percentPos + 1], 4);
+        const low = internals.resolveHex(string[percentPos + 2], 0);
+        const byte = high | low;
+        const type = internals.utf8.data[byte];
+        state = internals.utf8.data[256 + state + type];
+        codepoint = (codepoint << 6) | (byte & internals.utf8.data[364 + type]);
+
+        if (state === internals.utf8.accept) {
+            decoded += string.slice(last, startOfOctets);
+            decoded += codepoint <= 0xFFFF
+                ? String.fromCharCode(codepoint)
+                : String.fromCharCode(0xD7C0 + (codepoint >> 10), 0xDC00 + (codepoint & 0x3FF));
+
+            codepoint = 0;
+            last = percentPos + 3;
+            percentPos = string.indexOf('%', last);
+            startOfOctets = percentPos;
+            continue;
+        }
+
+        if (state === internals.utf8.reject) {
+            return null;
+        }
+
+        percentPos += 3;
+
+        if (percentPos >= string.length ||
+            string[percentPos] !== '%') {
+
+            return null;
+        }
+    }
+
+    return decoded + string.slice(last);
+};
+
+
+internals.resolveHex = function (char, shift) {
+
+    const i = internals.hex[char];
+    return i === undefined ? 255 : i << shift;
+};
+
+
+internals.hex = {
+    '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
+    '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+    'a': 10, 'A': 10, 'b': 11, 'B': 11, 'c': 12,
+    'C': 12, 'd': 13, 'D': 13, 'e': 14, 'E': 14,
+    'f': 15, 'F': 15
+};
+
+
+internals.utf8 = {
+    accept: 12,
+    reject: 0,
+    data: [
+
+        // Maps bytes to character to a transition
+
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7,
+        10, 9, 9, 9, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+
+        // Maps a state to a new state when adding a transition
+
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        12, 0, 0, 0, 0, 24, 36, 48, 60, 72, 84, 96,
+        0, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+        // Maps the current transition to a mask that needs to apply to the byte
+
+        0x7F, 0x3F, 0x3F, 0x3F, 0x00, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x07
+    ]
+};

unified-ai-platform/node_modules/@sideway/address/lib/domain.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const Url = require('url');
+
+const Errors = require('./errors');
+
+
+const internals = {
+    minDomainSegments: 2,
+    nonAsciiRx: /[^\x00-\x7f]/,
+    domainControlRx: /[\x00-\x20@\:\/\\#!\$&\'\(\)\*\+,;=\?]/,                          // Control + space + separators
+    tldSegmentRx: /^[a-zA-Z](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?$/,
+    domainSegmentRx: /^[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?$/,
+    URL: Url.URL || URL                                                                 // $lab:coverage:ignore$
+};
+
+
+exports.analyze = function (domain, options = {}) {
+
+    if (!domain) {                                                                      // Catch null / undefined
+        return Errors.code('DOMAIN_NON_EMPTY_STRING');
+    }
+
+    if (typeof domain !== 'string') {
+        throw new Error('Invalid input: domain must be a string');
+    }
+
+    if (domain.length > 256) {
+        return Errors.code('DOMAIN_TOO_LONG');
+    }
+
+    const ascii = !internals.nonAsciiRx.test(domain);
+    if (!ascii) {
+        if (options.allowUnicode === false) {                                           // Defaults to true
+            return Errors.code('DOMAIN_INVALID_UNICODE_CHARS');
+        }
+
+        domain = domain.normalize('NFC');
+    }
+
+    if (internals.domainControlRx.test(domain)) {
+        return Errors.code('DOMAIN_INVALID_CHARS');
+    }
+
+    domain = internals.punycode(domain);
+
+    // https://tools.ietf.org/html/rfc1035 section 2.3.1
+
+    if (options.allowFullyQualified &&
+        domain[domain.length - 1] === '.') {
+
+        domain = domain.slice(0, -1);
+    }
+
+    const minDomainSegments = options.minDomainSegments || internals.minDomainSegments;
+
+    const segments = domain.split('.');
+    if (segments.length < minDomainSegments) {
+        return Errors.code('DOMAIN_SEGMENTS_COUNT');
+    }
+
+    if (options.maxDomainSegments) {
+        if (segments.length > options.maxDomainSegments) {
+            return Errors.code('DOMAIN_SEGMENTS_COUNT_MAX');
+        }
+    }
+
+    const tlds = options.tlds;
+    if (tlds) {
+        const tld = segments[segments.length - 1].toLowerCase();
+        if (tlds.deny && tlds.deny.has(tld) ||
+            tlds.allow && !tlds.allow.has(tld)) {
+
+            return Errors.code('DOMAIN_FORBIDDEN_TLDS');
+        }
+    }
+
+    for (let i = 0; i < segments.length; ++i) {
+        const segment = segments[i];
+
+        if (!segment.length) {
+            return Errors.code('DOMAIN_EMPTY_SEGMENT');
+        }
+
+        if (segment.length > 63) {
+            return Errors.code('DOMAIN_LONG_SEGMENT');
+        }
+
+        if (i < segments.length - 1) {
+            if (!internals.domainSegmentRx.test(segment)) {
+                return Errors.code('DOMAIN_INVALID_CHARS');
+            }
+        }
+        else {
+            if (!internals.tldSegmentRx.test(segment)) {
+                return Errors.code('DOMAIN_INVALID_TLDS_CHARS');
+            }
+        }
+    }
+
+    return null;
+};
+
+
+exports.isValid = function (domain, options) {
+
+    return !exports.analyze(domain, options);
+};
+
+
+internals.punycode = function (domain) {
+
+    if (domain.includes('%')) {
+        domain = domain.replace(/%/g, '%25');
+    }
+
+    try {
+        return new internals.URL(`http://${domain}`).host;
+    }
+    catch (err) {
+        return domain;
+    }
+};

unified-ai-platform/node_modules/@sideway/address/lib/email.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const Util = require('util');
+
+const Domain = require('./domain');
+const Errors = require('./errors');
+
+
+const internals = {
+    nonAsciiRx: /[^\x00-\x7f]/,
+    encoder: new (Util.TextEncoder || TextEncoder)()                                            // $lab:coverage:ignore$
+};
+
+
+exports.analyze = function (email, options) {
+
+    return internals.email(email, options);
+};
+
+
+exports.isValid = function (email, options) {
+
+    return !internals.email(email, options);
+};
+
+
+internals.email = function (email, options = {}) {
+
+    if (typeof email !== 'string') {
+        throw new Error('Invalid input: email must be a string');
+    }
+
+    if (!email) {
+        return Errors.code('EMPTY_STRING');
+    }
+
+    // Unicode
+
+    const ascii = !internals.nonAsciiRx.test(email);
+    if (!ascii) {
+        if (options.allowUnicode === false) {                                                   // Defaults to true
+            return Errors.code('FORBIDDEN_UNICODE');
+        }
+
+        email = email.normalize('NFC');
+    }
+
+    // Basic structure
+
+    const parts = email.split('@');
+    if (parts.length !== 2) {
+        return parts.length > 2 ? Errors.code('MULTIPLE_AT_CHAR') : Errors.code('MISSING_AT_CHAR');
+    }
+
+    const [local, domain] = parts;
+
+    if (!local) {
+        return Errors.code('EMPTY_LOCAL');
+    }
+
+    if (!options.ignoreLength) {
+        if (email.length > 254) {                                           // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.3
+            return Errors.code('ADDRESS_TOO_LONG');
+        }
+
+        if (internals.encoder.encode(local).length > 64) {                  // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.1
+            return Errors.code('LOCAL_TOO_LONG');
+        }
+    }
+
+    // Validate parts
+
+    return internals.local(local, ascii) || Domain.analyze(domain, options);
+};
+
+
+internals.local = function (local, ascii) {
+
+    const segments = local.split('.');
+    for (const segment of segments) {
+        if (!segment.length) {
+            return Errors.code('EMPTY_LOCAL_SEGMENT');
+        }
+
+        if (ascii) {
+            if (!internals.atextRx.test(segment)) {
+                return Errors.code('INVALID_LOCAL_CHARS');
+            }
+
+            continue;
+        }
+
+        for (const char of segment) {
+            if (internals.atextRx.test(char)) {
+                continue;
+            }
+
+            const binary = internals.binary(char);
+            if (!internals.atomRx.test(binary)) {
+                return Errors.code('INVALID_LOCAL_CHARS');
+            }
+        }
+    }
+};
+
+
+internals.binary = function (char) {
+
+    return Array.from(internals.encoder.encode(char)).map((v) => String.fromCharCode(v)).join('');
+};
+
+
+/*
+    From RFC 5321:
+
+        Mailbox         =   Local-part "@" ( Domain / address-literal )
+
+        Local-part      =   Dot-string / Quoted-string
+        Dot-string      =   Atom *("."  Atom)
+        Atom            =   1*atext
+        atext           =   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
+
+        Domain          =   sub-domain *("." sub-domain)
+        sub-domain      =   Let-dig [Ldh-str]
+        Let-dig         =   ALPHA / DIGIT
+        Ldh-str         =   *( ALPHA / DIGIT / "-" ) Let-dig
+
+        ALPHA           =   %x41-5A / %x61-7A        ; a-z, A-Z
+        DIGIT           =   %x30-39                  ; 0-9
+
+    From RFC 6531:
+
+        sub-domain      =/  U-label
+        atext           =/  UTF8-non-ascii
+
+        UTF8-non-ascii  =   UTF8-2 / UTF8-3 / UTF8-4
+
+        UTF8-2          =   %xC2-DF UTF8-tail
+        UTF8-3          =   %xE0 %xA0-BF UTF8-tail /
+                            %xE1-EC 2( UTF8-tail ) /
+                            %xED %x80-9F UTF8-tail /
+                            %xEE-EF 2( UTF8-tail )
+        UTF8-4          =   %xF0 %x90-BF 2( UTF8-tail ) /
+                            %xF1-F3 3( UTF8-tail ) /
+                            %xF4 %x80-8F 2( UTF8-tail )
+
+        UTF8-tail       =   %x80-BF
+
+    Note: The following are not supported:
+
+        RFC 5321: address-literal, Quoted-string
+        RFC 5322: obs-*, CFWS
+*/
+
+
+internals.atextRx = /^[\w!#\$%&'\*\+\-/=\?\^`\{\|\}~]+$/;               // _ included in \w
+
+
+internals.atomRx = new RegExp([
+
+    //  %xC2-DF UTF8-tail
+    '(?:[\\xc2-\\xdf][\\x80-\\xbf])',
+
+    //  %xE0 %xA0-BF UTF8-tail              %xE1-EC 2( UTF8-tail )            %xED %x80-9F UTF8-tail              %xEE-EF 2( UTF8-tail )
+    '(?:\\xe0[\\xa0-\\xbf][\\x80-\\xbf])|(?:[\\xe1-\\xec][\\x80-\\xbf]{2})|(?:\\xed[\\x80-\\x9f][\\x80-\\xbf])|(?:[\\xee-\\xef][\\x80-\\xbf]{2})',
+
+    //  %xF0 %x90-BF 2( UTF8-tail )            %xF1-F3 3( UTF8-tail )            %xF4 %x80-8F 2( UTF8-tail )
+    '(?:\\xf0[\\x90-\\xbf][\\x80-\\xbf]{2})|(?:[\\xf1-\\xf3][\\x80-\\xbf]{3})|(?:\\xf4[\\x80-\\x8f][\\x80-\\xbf]{2})'
+
+].join('|'));

unified-ai-platform/node_modules/@sideway/address/lib/errors.js

@@ -0,0 +1,29 @@
+'use strict';
+
+exports.codes = {
+    EMPTY_STRING: 'Address must be a non-empty string',
+    FORBIDDEN_UNICODE: 'Address contains forbidden Unicode characters',
+    MULTIPLE_AT_CHAR: 'Address cannot contain more than one @ character',
+    MISSING_AT_CHAR: 'Address must contain one @ character',
+    EMPTY_LOCAL: 'Address local part cannot be empty',
+    ADDRESS_TOO_LONG: 'Address too long',
+    LOCAL_TOO_LONG: 'Address local part too long',
+    EMPTY_LOCAL_SEGMENT: 'Address local part contains empty dot-separated segment',
+    INVALID_LOCAL_CHARS: 'Address local part contains invalid character',
+    DOMAIN_NON_EMPTY_STRING: 'Domain must be a non-empty string',
+    DOMAIN_TOO_LONG: 'Domain too long',
+    DOMAIN_INVALID_UNICODE_CHARS: 'Domain contains forbidden Unicode characters',
+    DOMAIN_INVALID_CHARS: 'Domain contains invalid character',
+    DOMAIN_INVALID_TLDS_CHARS: 'Domain contains invalid tld character',
+    DOMAIN_SEGMENTS_COUNT: 'Domain lacks the minimum required number of segments',
+    DOMAIN_SEGMENTS_COUNT_MAX: 'Domain contains too many segments',
+    DOMAIN_FORBIDDEN_TLDS: 'Domain uses forbidden TLD',
+    DOMAIN_EMPTY_SEGMENT: 'Domain contains empty dot-separated segment',
+    DOMAIN_LONG_SEGMENT: 'Domain contains dot-separated segment that is too long'
+};
+
+
+exports.code = function (code) {
+
+    return { code, error: exports.codes[code] };
+};

unified-ai-platform/node_modules/@sideway/formula/LICENSE.md

@@ -0,0 +1,9 @@
+Copyright (c) 2019-2020, Sideway. Inc, and project contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ * The names of any contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

unified-ai-platform/node_modules/@sideway/formula/lib/index.js

@@ -0,0 +1,456 @@
+'use strict';
+
+const internals = {
+    operators: ['!', '^', '*', '/', '%', '+', '-', '<', '<=', '>', '>=', '==', '!=', '&&', '||', '??'],
+    operatorCharacters: ['!', '^', '*', '/', '%', '+', '-', '<', '=', '>', '&', '|', '?'],
+    operatorsOrder: [['^'], ['*', '/', '%'], ['+', '-'], ['<', '<=', '>', '>='], ['==', '!='], ['&&'], ['||', '??']],
+    operatorsPrefix: ['!', 'n'],
+
+    literals: {
+        '"': '"',
+        '`': '`',
+        '\'': '\'',
+        '[': ']'
+    },
+
+    numberRx: /^(?:[0-9]*(\.[0-9]*)?){1}$/,
+    tokenRx: /^[\w\$\#\.\@\:\{\}]+$/,
+
+    symbol: Symbol('formula'),
+    settings: Symbol('settings')
+};
+
+
+exports.Parser = class {
+
+    constructor(string, options = {}) {
+
+        if (!options[internals.settings] &&
+            options.constants) {
+
+            for (const constant in options.constants) {
+                const value = options.constants[constant];
+                if (value !== null &&
+                    !['boolean', 'number', 'string'].includes(typeof value)) {
+
+                    throw new Error(`Formula constant ${constant} contains invalid ${typeof value} value type`);
+                }
+            }
+        }
+
+        this.settings = options[internals.settings] ? options : Object.assign({ [internals.settings]: true, constants: {}, functions: {} }, options);
+        this.single = null;
+
+        this._parts = null;
+        this._parse(string);
+    }
+
+    _parse(string) {
+
+        let parts = [];
+        let current = '';
+        let parenthesis = 0;
+        let literal = false;
+
+        const flush = (inner) => {
+
+            if (parenthesis) {
+                throw new Error('Formula missing closing parenthesis');
+            }
+
+            const last = parts.length ? parts[parts.length - 1] : null;
+
+            if (!literal &&
+                !current &&
+                !inner) {
+
+                return;
+            }
+
+            if (last &&
+                last.type === 'reference' &&
+                inner === ')') {                                                                // Function
+
+                last.type = 'function';
+                last.value = this._subFormula(current, last.value);
+                current = '';
+                return;
+            }
+
+            if (inner === ')') {                                                                // Segment
+                const sub = new exports.Parser(current, this.settings);
+                parts.push({ type: 'segment', value: sub });
+            }
+            else if (literal) {
+                if (literal === ']') {                                                          // Reference
+                    parts.push({ type: 'reference', value: current });
+                    current = '';
+                    return;
+                }
+
+                parts.push({ type: 'literal', value: current });                                // Literal
+            }
+            else if (internals.operatorCharacters.includes(current)) {                          // Operator
+                if (last &&
+                    last.type === 'operator' &&
+                    internals.operators.includes(last.value + current)) {                       // 2 characters operator
+
+                    last.value += current;
+                }
+                else {
+                    parts.push({ type: 'operator', value: current });
+                }
+            }
+            else if (current.match(internals.numberRx)) {                                       // Number
+                parts.push({ type: 'constant', value: parseFloat(current) });
+            }
+            else if (this.settings.constants[current] !== undefined) {                          // Constant
+                parts.push({ type: 'constant', value: this.settings.constants[current] });
+            }
+            else {                                                                              // Reference
+                if (!current.match(internals.tokenRx)) {
+                    throw new Error(`Formula contains invalid token: ${current}`);
+                }
+
+                parts.push({ type: 'reference', value: current });
+            }
+
+            current = '';
+        };
+
+        for (const c of string) {
+            if (literal) {
+                if (c === literal) {
+                    flush();
+                    literal = false;
+                }
+                else {
+                    current += c;
+                }
+            }
+            else if (parenthesis) {
+                if (c === '(') {
+                    current += c;
+                    ++parenthesis;
+                }
+                else if (c === ')') {
+                    --parenthesis;
+                    if (!parenthesis) {
+                        flush(c);
+                    }
+                    else {
+                        current += c;
+                    }
+                }
+                else {
+                    current += c;
+                }
+            }
+            else if (c in internals.literals) {
+                literal = internals.literals[c];
+            }
+            else if (c === '(') {
+                flush();
+                ++parenthesis;
+            }
+            else if (internals.operatorCharacters.includes(c)) {
+                flush();
+                current = c;
+                flush();
+            }
+            else if (c !== ' ') {
+                current += c;
+            }
+            else {
+                flush();
+            }
+        }
+
+        flush();
+
+        // Replace prefix - to internal negative operator
+
+        parts = parts.map((part, i) => {
+
+            if (part.type !== 'operator' ||
+                part.value !== '-' ||
+                i && parts[i - 1].type !== 'operator') {
+
+                return part;
+            }
+
+            return { type: 'operator', value: 'n' };
+        });
+
+        // Validate tokens order
+
+        let operator = false;
+        for (const part of parts) {
+            if (part.type === 'operator') {
+                if (internals.operatorsPrefix.includes(part.value)) {
+                    continue;
+                }
+
+                if (!operator) {
+                    throw new Error('Formula contains an operator in invalid position');
+                }
+
+                if (!internals.operators.includes(part.value)) {
+                    throw new Error(`Formula contains an unknown operator ${part.value}`);
+                }
+            }
+            else if (operator) {
+                throw new Error('Formula missing expected operator');
+            }
+
+            operator = !operator;
+        }
+
+        if (!operator) {
+            throw new Error('Formula contains invalid trailing operator');
+        }
+
+        // Identify single part
+
+        if (parts.length === 1 &&
+            ['reference', 'literal', 'constant'].includes(parts[0].type)) {
+
+            this.single = { type: parts[0].type === 'reference' ? 'reference' : 'value', value: parts[0].value };
+        }
+
+        // Process parts
+
+        this._parts = parts.map((part) => {
+
+            // Operators
+
+            if (part.type === 'operator') {
+                return internals.operatorsPrefix.includes(part.value) ? part : part.value;
+            }
+
+            // Literals, constants, segments
+
+            if (part.type !== 'reference') {
+                return part.value;
+            }
+
+            // References
+
+            if (this.settings.tokenRx &&
+                !this.settings.tokenRx.test(part.value)) {
+
+                throw new Error(`Formula contains invalid reference ${part.value}`);
+            }
+
+            if (this.settings.reference) {
+                return this.settings.reference(part.value);
+            }
+
+            return internals.reference(part.value);
+        });
+    }
+
+    _subFormula(string, name) {
+
+        const method = this.settings.functions[name];
+        if (typeof method !== 'function') {
+            throw new Error(`Formula contains unknown function ${name}`);
+        }
+
+        let args = [];
+        if (string) {
+            let current = '';
+            let parenthesis = 0;
+            let literal = false;
+
+            const flush = () => {
+
+                if (!current) {
+                    throw new Error(`Formula contains function ${name} with invalid arguments ${string}`);
+                }
+
+                args.push(current);
+                current = '';
+            };
+
+            for (let i = 0; i < string.length; ++i) {
+                const c = string[i];
+                if (literal) {
+                    current += c;
+                    if (c === literal) {
+                        literal = false;
+                    }
+                }
+                else if (c in internals.literals &&
+                    !parenthesis) {
+
+                    current += c;
+                    literal = internals.literals[c];
+                }
+                else if (c === ',' &&
+                    !parenthesis) {
+
+                    flush();
+                }
+                else {
+                    current += c;
+                    if (c === '(') {
+                        ++parenthesis;
+                    }
+                    else if (c === ')') {
+                        --parenthesis;
+                    }
+                }
+            }
+
+            flush();
+        }
+
+        args = args.map((arg) => new exports.Parser(arg, this.settings));
+
+        return function (context) {
+
+            const innerValues = [];
+            for (const arg of args) {
+                innerValues.push(arg.evaluate(context));
+            }
+
+            return method.call(context, ...innerValues);
+        };
+    }
+
+    evaluate(context) {
+
+        const parts = this._parts.slice();
+
+        // Prefix operators
+
+        for (let i = parts.length - 2; i >= 0; --i) {
+            const part = parts[i];
+            if (part &&
+                part.type === 'operator') {
+
+                const current = parts[i + 1];
+                parts.splice(i + 1, 1);
+                const value = internals.evaluate(current, context);
+                parts[i] = internals.single(part.value, value);
+            }
+        }
+
+        // Left-right operators
+
+        internals.operatorsOrder.forEach((set) => {
+
+            for (let i = 1; i < parts.length - 1;) {
+                if (set.includes(parts[i])) {
+                    const operator = parts[i];
+                    const left = internals.evaluate(parts[i - 1], context);
+                    const right = internals.evaluate(parts[i + 1], context);
+
+                    parts.splice(i, 2);
+                    const result = internals.calculate(operator, left, right);
+                    parts[i - 1] = result === 0 ? 0 : result;                               // Convert -0
+                }
+                else {
+                    i += 2;
+                }
+            }
+        });
+
+        return internals.evaluate(parts[0], context);
+    }
+};
+
+
+exports.Parser.prototype[internals.symbol] = true;
+
+
+internals.reference = function (name) {
+
+    return function (context) {
+
+        return context && context[name] !== undefined ? context[name] : null;
+    };
+};
+
+
+internals.evaluate = function (part, context) {
+
+    if (part === null) {
+        return null;
+    }
+
+    if (typeof part === 'function') {
+        return part(context);
+    }
+
+    if (part[internals.symbol]) {
+        return part.evaluate(context);
+    }
+
+    return part;
+};
+
+
+internals.single = function (operator, value) {
+
+    if (operator === '!') {
+        return value ? false : true;
+    }
+
+    // operator === 'n'
+
+    const negative = -value;
+    if (negative === 0) {       // Override -0
+        return 0;
+    }
+
+    return negative;
+};
+
+
+internals.calculate = function (operator, left, right) {
+
+    if (operator === '??') {
+        return internals.exists(left) ? left : right;
+    }
+
+    if (typeof left === 'string' ||
+        typeof right === 'string') {
+
+        if (operator === '+') {
+            left = internals.exists(left) ? left : '';
+            right = internals.exists(right) ? right : '';
+            return left + right;
+        }
+    }
+    else {
+        switch (operator) {
+            case '^': return Math.pow(left, right);
+            case '*': return left * right;
+            case '/': return left / right;
+            case '%': return left % right;
+            case '+': return left + right;
+            case '-': return left - right;
+        }
+    }
+
+    switch (operator) {
+        case '<': return left < right;
+        case '<=': return left <= right;
+        case '>': return left > right;
+        case '>=': return left >= right;
+        case '==': return left === right;
+        case '!=': return left !== right;
+        case '&&': return left && right;
+        case '||': return left || right;
+    }
+
+    return null;
+};
+
+
+internals.exists = function (value) {
+
+    return value !== null && value !== undefined;
+};

unified-ai-platform/node_modules/@sideway/formula/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@sideway/formula",
+    "description": "Math and string formula parser.",
+    "version": "3.0.1",
+    "repository": "git://github.com/sideway/formula",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "keywords": [
+        "formula",
+        "parser",
+        "math",
+        "string"
+    ],
+    "files": [
+        "lib"
+    ],
+    "dependencies": {},
+    "devDependencies": {
+        "typescript": "4.0.x",
+        "@hapi/code": "8.x.x",
+        "@hapi/lab": "24.x.x"
+    },
+    "scripts": {
+        "test": "lab -a @hapi/code -t 100 -L -Y",
+        "test-cov-html": "lab -a @hapi/code -t 100 -L -r html -o coverage.html"
+    },
+    "license": "BSD-3-Clause"
+}

unified-ai-platform/node_modules/@sideway/pinpoint/LICENSE.md

@@ -0,0 +1,10 @@
+Copyright (c) 2019-2020, Sideway. Inc, and project contributors  
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* The names of any contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS OFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

unified-ai-platform/node_modules/@sideway/pinpoint/README.md

@@ -0,0 +1,14 @@
+# @sideway/pinpoint
+
+#### Return the filename and line number of the calling function.
+
+**pinpoint** is part of the **joi** ecosystem.
+
+### Visit the [joi.dev](https://joi.dev) Developer Portal for tutorials, documentation, and support
+
+## Useful resources
+
+- [Documentation and API](https://joi.dev/module/pinpoint/)
+- [Version status](https://joi.dev/resources/status/#pinpoint) (builds, dependencies, node versions, licenses, eol)
+- [Changelog](https://joi.dev/module/pinpoint/changelog/)
+- [Project policies](https://joi.dev/policies/)

unified-ai-platform/node_modules/@sideway/pinpoint/lib/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const internals = {};
+
+
+exports.location = function (depth = 0) {
+
+    const orig = Error.prepareStackTrace;
+    Error.prepareStackTrace = (ignore, stack) => stack;
+
+    const capture = {};
+    Error.captureStackTrace(capture, this);
+    const line = capture.stack[depth + 1];
+
+    Error.prepareStackTrace = orig;
+
+    return {
+        filename: line.getFileName(),
+        line: line.getLineNumber()
+    };
+};

unified-ai-platform/node_modules/@sideway/pinpoint/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@sideway/pinpoint",
+    "description": "Return the filename and line number of the calling function",
+    "version": "2.0.0",
+    "repository": "git://github.com/sideway/pinpoint",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "files": [
+        "lib"
+    ],
+    "keywords": [
+        "utilities"
+    ],
+    "dependencies": {},
+    "devDependencies": {
+        "typescript": "4.0.x",
+        "@hapi/code": "8.x.x",
+        "@hapi/lab": "24.x.x"
+    },
+    "scripts": {
+        "test": "lab -a @hapi/code -t 100 -L -Y",
+        "test-cov-html": "lab -a @hapi/code -t 100 -L -r html -o coverage.html"
+    },
+    "license": "BSD-3-Clause"
+}