@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/src/node_modules/htmlparser2/lib/esm/index.js

@@ -1,18 +0,0 @@
-import { Parser } from './Parser.js';
-import { DomHandler } from '../../../domhandler/lib/esm/index.js';
-export { default as Tokenizer } from './Tokenizer.js';
-
-// Helper methods
-/**
- * Parses the data, returns the resulting document.
- *
- * @param data The data that should be parsed.
- * @param options Optional options for the parser and DOM builder.
- */
-function parseDocument(data, options) {
-    const handler = new DomHandler(undefined, options);
-    new Parser(handler, options).end(data);
-    return handler.root;
-}
-
-export { DomHandler as DefaultHandler, DomHandler, Parser, parseDocument };

package/dist/src/node_modules/leac/lib/leac.js

@@ -1,3 +0,0 @@
-const e=/\n/g;function n(n){const o=[...n.matchAll(e)].map((e=>e.index||0));o.unshift(-1);const s=t(o,0,o.length);return e=>r(s,e)}function t(e,n,r){if(r-n==1)return {offset:e[n],index:n+1};const o=Math.ceil((n+r)/2),s=t(e,n,o),l=t(e,o,r);return {offset:s.offset,low:s,high:l}}function r(e,n){return function(e){return Object.prototype.hasOwnProperty.call(e,"index")}(e)?{line:e.index,column:n-e.offset}:r(e.high.offset<n?e.high:e.low,n)}function o(e,t="",r={}){const o="string"!=typeof t?t:r,l="string"==typeof t?t:"",c=e.map(s),f=!!o.lineNumbers;return function(e,t=0){const r=f?n(e):()=>({line:0,column:0});let o=t;const s=[];e:for(;o<e.length;){let n=false;for(const t of c){t.regex.lastIndex=o;const c=t.regex.exec(e);if(c&&c[0].length>0){if(!t.discard){const e=r(o),n="string"==typeof t.replace?c[0].replace(new RegExp(t.regex.source,t.regex.flags),t.replace):c[0];s.push({state:l,name:t.name,text:n,offset:o,len:c[0].length,line:e.line,column:e.column});}if(o=t.regex.lastIndex,n=true,t.push){const n=t.push(e,o);s.push(...n.tokens),o=n.offset;}if(t.pop)break e;break}}if(!n)break}return {tokens:s,offset:o,complete:e.length<=o}}}function s(e,n){return {...e,regex:l(e,n)}}function l(e,n){if(0===e.name.length)throw new Error(`Rule #${n} has empty name, which is not allowed.`);if(function(e){return Object.prototype.hasOwnProperty.call(e,"regex")}(e))return function(e){if(e.global)throw new Error(`Regular expression /${e.source}/${e.flags} contains the global flag, which is not allowed.`);return e.sticky?e:new RegExp(e.source,e.flags+"y")}(e.regex);if(function(e){return Object.prototype.hasOwnProperty.call(e,"str")}(e)){if(0===e.str.length)throw new Error(`Rule #${n} ("${e.name}") has empty "str" property, which is not allowed.`);return new RegExp(c(e.str),"y")}return new RegExp(c(e.name),"y")}function c(e){return e.replace(/[-[\]{}()*+!<=:?./\\^$|#\s,]/g,"\\$&")}
-
-export { o as createLexer };

package/dist/src/node_modules/parseley/lib/parseley.js

@@ -1,270 +0,0 @@
-import { createLexer as o } from '../../leac/lib/leac.js';
-import { middle, map, many, choice, option, eitherOr as otherwise, flatten, leftAssoc2, token, ab, many1, abc, left, right } from '../../peberminta/lib/core.js';
-
-const ws = `(?:[ \\t\\r\\n\\f]*)`;
-const nl = `(?:\\n|\\r\\n|\\r|\\f)`;
-const nonascii = `[^\\x00-\\x7F]`;
-const unicode = `(?:\\\\[0-9a-f]{1,6}(?:\\r\\n|[ \\n\\r\\t\\f])?)`;
-const escape = `(?:\\\\[^\\n\\r\\f0-9a-f])`;
-const nmstart = `(?:[_a-z]|${nonascii}|${unicode}|${escape})`;
-const nmchar = `(?:[_a-z0-9-]|${nonascii}|${unicode}|${escape})`;
-const name = `(?:${nmchar}+)`;
-const ident = `(?:[-]?${nmstart}${nmchar}*)`;
-const string1 = `'([^\\n\\r\\f\\\\']|\\\\${nl}|${nonascii}|${unicode}|${escape})*'`;
-const string2 = `"([^\\n\\r\\f\\\\"]|\\\\${nl}|${nonascii}|${unicode}|${escape})*"`;
-const lexSelector = o([
-    { name: 'ws', regex: new RegExp(ws) },
-    { name: 'hash', regex: new RegExp(`#${name}`, 'i') },
-    { name: 'ident', regex: new RegExp(ident, 'i') },
-    { name: 'str1', regex: new RegExp(string1, 'i') },
-    { name: 'str2', regex: new RegExp(string2, 'i') },
-    { name: '*' },
-    { name: '.' },
-    { name: ',' },
-    { name: '[' },
-    { name: ']' },
-    { name: '=' },
-    { name: '>' },
-    { name: '|' },
-    { name: '+' },
-    { name: '~' },
-    { name: '^' },
-    { name: '$' },
-]);
-const lexEscapedString = o([
-    { name: 'unicode', regex: new RegExp(unicode, 'i') },
-    { name: 'escape', regex: new RegExp(escape, 'i') },
-    { name: 'any', regex: new RegExp('[\\s\\S]', 'i') }
-]);
-function sumSpec([a0, a1, a2], [b0, b1, b2]) {
-    return [a0 + b0, a1 + b1, a2 + b2];
-}
-function sumAllSpec(ss) {
-    return ss.reduce(sumSpec, [0, 0, 0]);
-}
-const unicodeEscapedSequence_ = token((t) => t.name === 'unicode' ? String.fromCodePoint(parseInt(t.text.slice(1), 16)) : undefined);
-const escapedSequence_ = token((t) => t.name === 'escape' ? t.text.slice(1) : undefined);
-const anyChar_ = token((t) => t.name === 'any' ? t.text : undefined);
-const escapedString_ = map(many(choice(unicodeEscapedSequence_, escapedSequence_, anyChar_)), (cs) => cs.join(''));
-function unescape(escapedString) {
-    const lexerResult = lexEscapedString(escapedString);
-    const result = escapedString_({ tokens: lexerResult.tokens, options: undefined }, 0);
-    return result.value;
-}
-function literal(name) {
-    return token((t) => t.name === name ? true : undefined);
-}
-const whitespace_ = token((t) => t.name === 'ws' ? null : undefined);
-const optionalWhitespace_ = option(whitespace_, null);
-function optionallySpaced(parser) {
-    return middle(optionalWhitespace_, parser, optionalWhitespace_);
-}
-const identifier_ = token((t) => t.name === 'ident' ? unescape(t.text) : undefined);
-const hashId_ = token((t) => t.name === 'hash' ? unescape(t.text.slice(1)) : undefined);
-const string_ = token((t) => t.name.startsWith('str') ? unescape(t.text.slice(1, -1)) : undefined);
-const namespace_ = left(option(identifier_, ''), literal('|'));
-const qualifiedName_ = otherwise(ab(namespace_, identifier_, (ns, name) => ({ name: name, namespace: ns })), map(identifier_, (name) => ({ name: name, namespace: null })));
-const uniSelector_ = otherwise(ab(namespace_, literal('*'), (ns) => ({ type: 'universal', namespace: ns, specificity: [0, 0, 0] })), map(literal('*'), () => ({ type: 'universal', namespace: null, specificity: [0, 0, 0] })));
-const tagSelector_ = map(qualifiedName_, ({ name, namespace }) => ({
-    type: 'tag',
-    name: name,
-    namespace: namespace,
-    specificity: [0, 0, 1]
-}));
-const classSelector_ = ab(literal('.'), identifier_, (fullstop, name) => ({
-    type: 'class',
-    name: name,
-    specificity: [0, 1, 0]
-}));
-const idSelector_ = map(hashId_, (name) => ({
-    type: 'id',
-    name: name,
-    specificity: [1, 0, 0]
-}));
-const attrModifier_ = token((t) => {
-    if (t.name === 'ident') {
-        if (t.text === 'i' || t.text === 'I') {
-            return 'i';
-        }
-        if (t.text === 's' || t.text === 'S') {
-            return 's';
-        }
-    }
-    return undefined;
-});
-const attrValue_ = otherwise(ab(string_, option(right(optionalWhitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })), ab(identifier_, option(right(whitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })));
-const attrMatcher_ = choice(map(literal('='), () => '='), ab(literal('~'), literal('='), () => '~='), ab(literal('|'), literal('='), () => '|='), ab(literal('^'), literal('='), () => '^='), ab(literal('$'), literal('='), () => '$='), ab(literal('*'), literal('='), () => '*='));
-const attrPresenceSelector_ = abc(literal('['), optionallySpaced(qualifiedName_), literal(']'), (lbr, { name, namespace }) => ({
-    type: 'attrPresence',
-    name: name,
-    namespace: namespace,
-    specificity: [0, 1, 0]
-}));
-const attrValueSelector_ = middle(literal('['), abc(optionallySpaced(qualifiedName_), attrMatcher_, optionallySpaced(attrValue_), ({ name, namespace }, matcher, { value, modifier }) => ({
-    type: 'attrValue',
-    name: name,
-    namespace: namespace,
-    matcher: matcher,
-    value: value,
-    modifier: modifier,
-    specificity: [0, 1, 0]
-})), literal(']'));
-const attrSelector_ = otherwise(attrPresenceSelector_, attrValueSelector_);
-const typeSelector_ = otherwise(uniSelector_, tagSelector_);
-const subclassSelector_ = choice(idSelector_, classSelector_, attrSelector_);
-const compoundSelector_ = map(otherwise(flatten(typeSelector_, many(subclassSelector_)), many1(subclassSelector_)), (ss) => {
-    return {
-        type: 'compound',
-        list: ss,
-        specificity: sumAllSpec(ss.map(s => s.specificity))
-    };
-});
-const combinator_ = choice(map(literal('>'), () => '>'), map(literal('+'), () => '+'), map(literal('~'), () => '~'), ab(literal('|'), literal('|'), () => '||'));
-const combinatorSeparator_ = otherwise(optionallySpaced(combinator_), map(whitespace_, () => ' '));
-const complexSelector_ = leftAssoc2(compoundSelector_, map(combinatorSeparator_, (c) => (left, right) => ({
-    type: 'compound',
-    list: [...right.list, { type: 'combinator', combinator: c, left: left, specificity: left.specificity }],
-    specificity: sumSpec(left.specificity, right.specificity)
-})), compoundSelector_);
-function parse_(parser, str) {
-    if (!(typeof str === 'string' || str instanceof String)) {
-        throw new Error('Expected a selector string. Actual input is not a string!');
-    }
-    const lexerResult = lexSelector(str);
-    if (!lexerResult.complete) {
-        throw new Error(`The input "${str}" was only partially tokenized, stopped at offset ${lexerResult.offset}!\n` +
-            prettyPrintPosition(str, lexerResult.offset));
-    }
-    const result = optionallySpaced(parser)({ tokens: lexerResult.tokens, options: undefined }, 0);
-    if (!result.matched) {
-        throw new Error(`No match for "${str}" input!`);
-    }
-    if (result.position < lexerResult.tokens.length) {
-        const token = lexerResult.tokens[result.position];
-        throw new Error(`The input "${str}" was only partially parsed, stopped at offset ${token.offset}!\n` +
-            prettyPrintPosition(str, token.offset, token.len));
-    }
-    return result.value;
-}
-function prettyPrintPosition(str, offset, len = 1) {
-    return `${str.replace(/(\t)|(\r)|(\n)/g, (m, t, r) => t ? '\u2409' : r ? '\u240d' : '\u240a')}\n${''.padEnd(offset)}${'^'.repeat(len)}`;
-}
-function parse1(str) {
-    return parse_(complexSelector_, str);
-}
-
-function serialize(selector) {
-    if (!selector.type) {
-        throw new Error('This is not an AST node.');
-    }
-    switch (selector.type) {
-        case 'universal':
-            return _serNs(selector.namespace) + '*';
-        case 'tag':
-            return _serNs(selector.namespace) + _serIdent(selector.name);
-        case 'class':
-            return '.' + _serIdent(selector.name);
-        case 'id':
-            return '#' + _serIdent(selector.name);
-        case 'attrPresence':
-            return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}]`;
-        case 'attrValue':
-            return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}${selector.matcher}"${_serStr(selector.value)}"${(selector.modifier ? selector.modifier : '')}]`;
-        case 'combinator':
-            return serialize(selector.left) + selector.combinator;
-        case 'compound':
-            return selector.list.reduce((acc, node) => {
-                if (node.type === 'combinator') {
-                    return serialize(node) + acc;
-                }
-                else {
-                    return acc + serialize(node);
-                }
-            }, '');
-        case 'list':
-            return selector.list.map(serialize).join(',');
-    }
-}
-function _serNs(ns) {
-    return (ns || ns === '')
-        ? _serIdent(ns) + '|'
-        : '';
-}
-function _codePoint(char) {
-    return `\\${char.codePointAt(0).toString(16)} `;
-}
-function _serIdent(str) {
-    return str.replace(
-    /(^[0-9])|(^-[0-9])|(^-$)|([-0-9a-zA-Z_]|[^\x00-\x7F])|(\x00)|([\x01-\x1f]|\x7f)|([\s\S])/g, (m, d1, d2, hy, safe, nl, ctrl, other) => d1 ? _codePoint(d1) :
-        d2 ? '-' + _codePoint(d2.slice(1)) :
-            hy ? '\\-' :
-                safe ? safe :
-                    nl ? '\ufffd' :
-                        ctrl ? _codePoint(ctrl) :
-                            '\\' + other);
-}
-function _serStr(str) {
-    return str.replace(
-    /(")|(\\)|(\x00)|([\x01-\x1f]|\x7f)/g, (m, dq, bs, nl, ctrl) => dq ? '\\"' :
-        bs ? '\\\\' :
-            nl ? '\ufffd' :
-                _codePoint(ctrl));
-}
-function normalize(selector) {
-    if (!selector.type) {
-        throw new Error('This is not an AST node.');
-    }
-    switch (selector.type) {
-        case 'compound': {
-            selector.list.forEach(normalize);
-            selector.list.sort((a, b) => _compareArrays(_getSelectorPriority(a), _getSelectorPriority(b)));
-            break;
-        }
-        case 'combinator': {
-            normalize(selector.left);
-            break;
-        }
-        case 'list': {
-            selector.list.forEach(normalize);
-            selector.list.sort((a, b) => (serialize(a) < serialize(b)) ? -1 : 1);
-            break;
-        }
-    }
-    return selector;
-}
-function _getSelectorPriority(selector) {
-    switch (selector.type) {
-        case 'universal':
-            return [1];
-        case 'tag':
-            return [1];
-        case 'id':
-            return [2];
-        case 'class':
-            return [3, selector.name];
-        case 'attrPresence':
-            return [4, serialize(selector)];
-        case 'attrValue':
-            return [5, serialize(selector)];
-        case 'combinator':
-            return [15, serialize(selector)];
-    }
-}
-function compareSpecificity(a, b) {
-    return _compareArrays(a, b);
-}
-function _compareArrays(a, b) {
-    if (!Array.isArray(a) || !Array.isArray(b)) {
-        throw new Error('Arguments must be arrays.');
-    }
-    const shorter = (a.length < b.length) ? a.length : b.length;
-    for (let i = 0; i < shorter; i++) {
-        if (a[i] === b[i]) {
-            continue;
-        }
-        return (a[i] < b[i]) ? -1 : 1;
-    }
-    return a.length - b.length;
-}
-
-export { compareSpecificity, normalize, parse1, serialize };

package/dist/src/node_modules/peberminta/lib/core.js

@@ -1,171 +0,0 @@
-function token(
-onToken,
-onEnd) {
-    return (data, i) => {
-        let position = i;
-        let value = undefined;
-        if (i < data.tokens.length) {
-            value = onToken(data.tokens[i], data, i);
-            if (value !== undefined) {
-                position++;
-            }
-        }
-        return (value === undefined)
-            ? { matched: false }
-            : {
-                matched: true,
-                position: position,
-                value: value
-            };
-    };
-}
-function mapInner(r, f) {
-    return (r.matched) ? ({
-        matched: true,
-        position: r.position,
-        value: f(r.value, r.position)
-    }) : r;
-}
-function mapOuter(r, f) {
-    return (r.matched) ? f(r) : r;
-}
-function map(p, mapper) {
-    return (data, i) => mapInner(p(data, i), (v, j) => mapper(v, data, i, j));
-}
-function option(p, def) {
-    return (data, i) => {
-        const r = p(data, i);
-        return (r.matched)
-            ? r
-            : {
-                matched: true,
-                position: i,
-                value: def
-            };
-    };
-}
-function choice(...ps) {
-    return (data, i) => {
-        for (const p of ps) {
-            const result = p(data, i);
-            if (result.matched) {
-                return result;
-            }
-        }
-        return { matched: false };
-    };
-}
-function otherwise(pa, pb) {
-    return (data, i) => {
-        const r1 = pa(data, i);
-        return (r1.matched)
-            ? r1
-            : pb(data, i);
-    };
-}
-function takeWhile(p,
-test) {
-    return (data, i) => {
-        const values = [];
-        let success = true;
-        do {
-            const r = p(data, i);
-            if (r.matched && test(r.value, values.length + 1, data, i, r.position)) {
-                values.push(r.value);
-                i = r.position;
-            }
-            else {
-                success = false;
-            }
-        } while (success);
-        return {
-            matched: true,
-            position: i,
-            value: values
-        };
-    };
-}
-function many(p) {
-    return takeWhile(p, () => true);
-}
-function many1(p) {
-    return ab(p, many(p), (head, tail) => [head, ...tail]);
-}
-function ab(pa, pb, join) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join(ma.value, vb, data, i, j)));
-}
-function left(pa, pb) {
-    return ab(pa, pb, (va) => va);
-}
-function right(pa, pb) {
-    return ab(pa, pb, (va, vb) => vb);
-}
-function abc(pa, pb, pc, join) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join(ma.value, mb.value, vc, data, i, j))));
-}
-function middle(pa, pb, pc) {
-    return abc(pa, pb, pc, (ra, rb) => rb);
-}
-function all(...ps) {
-    return (data, i) => {
-        const result = [];
-        let position = i;
-        for (const p of ps) {
-            const r1 = p(data, position);
-            if (r1.matched) {
-                result.push(r1.value);
-                position = r1.position;
-            }
-            else {
-                return { matched: false };
-            }
-        }
-        return {
-            matched: true,
-            position: position,
-            value: result
-        };
-    };
-}
-function flatten(...ps) {
-    return flatten1(all(...ps));
-}
-function flatten1(p) {
-    return map(p, (vs) => vs.flatMap((v) => v));
-}
-function chainReduce(acc,
-f) {
-    return (data, i) => {
-        let loop = true;
-        let acc1 = acc;
-        let pos = i;
-        do {
-            const r = f(acc1, data, pos)(data, pos);
-            if (r.matched) {
-                acc1 = r.value;
-                pos = r.position;
-            }
-            else {
-                loop = false;
-            }
-        } while (loop);
-        return {
-            matched: true,
-            position: pos,
-            value: acc1
-        };
-    };
-}
-function reduceLeft(acc, p,
-reducer) {
-    return chainReduce(acc, (acc) => map(p, (v, data, i, j) => reducer(acc, v, data, i, j)));
-}
-function leftAssoc2(pLeft, pOper, pRight) {
-    return chain(pLeft, (v0) => reduceLeft(v0, ab(pOper, pRight, (f, y) => [f, y]), (acc, [f, y]) => f(acc, y)));
-}
-function chain(p,
-f) {
-    return (data, i) => mapOuter(p(data, i), (m1) => f(m1.value, data, i, m1.position)(data, m1.position));
-}
-
-export { ab, abc, all, all as and, chain, chainReduce, choice, otherwise as eitherOr, flatten, flatten1, left, leftAssoc2, many, many1, map, middle, option, choice as or, otherwise, reduceLeft, right, many1 as some, takeWhile, token };