recker 1.0.2-0 → 1.0.3

package/dist/plugins/scrape.js

@@ -0,0 +1,87 @@
+let ScrapeDocumentClass = null;
+async function getScrapeDocument() {
+    if (!ScrapeDocumentClass) {
+        try {
+            const module = await import('../scrape/document.js');
+            ScrapeDocumentClass = module.ScrapeDocument;
+        }
+        catch (error) {
+            throw new Error('Failed to load scrape module. Make sure cheerio is installed: pnpm add cheerio');
+        }
+    }
+    return ScrapeDocumentClass;
+}
+export function scrape(promise) {
+    const basePromise = Promise.resolve(promise);
+    const getDocument = async (options) => {
+        const ScrapeDoc = await getScrapeDocument();
+        const response = await basePromise;
+        const html = await response.text();
+        return new ScrapeDoc(html, {
+            baseUrl: options?.baseUrl || response.url,
+            ...options,
+        });
+    };
+    const enhanced = basePromise;
+    enhanced.scrape = async (options) => {
+        return getDocument(options);
+    };
+    enhanced.links = async (options) => {
+        const doc = await getDocument();
+        return doc.links(options);
+    };
+    enhanced.images = async (options) => {
+        const doc = await getDocument();
+        return doc.images(options);
+    };
+    enhanced.meta = async () => {
+        const doc = await getDocument();
+        return doc.meta();
+    };
+    enhanced.openGraph = async () => {
+        const doc = await getDocument();
+        return doc.openGraph();
+    };
+    enhanced.twitterCard = async () => {
+        const doc = await getDocument();
+        return doc.twitterCard();
+    };
+    enhanced.jsonLd = async () => {
+        const doc = await getDocument();
+        return doc.jsonLd();
+    };
+    enhanced.forms = async (selector) => {
+        const doc = await getDocument();
+        return doc.forms(selector);
+    };
+    enhanced.tables = async (selector) => {
+        const doc = await getDocument();
+        return doc.tables(selector);
+    };
+    enhanced.scripts = async () => {
+        const doc = await getDocument();
+        return doc.scripts();
+    };
+    enhanced.styles = async () => {
+        const doc = await getDocument();
+        return doc.styles();
+    };
+    enhanced.extract = async (schema) => {
+        const doc = await getDocument();
+        return doc.extract(schema);
+    };
+    return enhanced;
+}
+export async function parseHtml(html, options) {
+    const ScrapeDoc = await getScrapeDocument();
+    return new ScrapeDoc(html, options);
+}
+export async function scrapeResponse(promise, options) {
+    const ScrapeDoc = await getScrapeDocument();
+    const response = await promise;
+    const html = await response.text();
+    return new ScrapeDoc(html, {
+        baseUrl: options?.baseUrl || response.url,
+        ...options,
+    });
+}

package/dist/plugins/soap.d.ts

@@ -0,0 +1,73 @@
+import type { Client } from '../core/client.js';
+import type { RequestOptions } from '../types/index.js';
+export interface XmlRpcValue {
+    type: 'int' | 'i4' | 'i8' | 'boolean' | 'string' | 'double' | 'dateTime.iso8601' | 'base64' | 'array' | 'struct' | 'nil';
+    value: unknown;
+}
+export interface XmlRpcResponse<T = unknown> {
+    success: boolean;
+    result?: T;
+    fault?: {
+        faultCode: number;
+        faultString: string;
+    };
+}
+export declare class XmlRpcClient {
+    private client;
+    private endpoint;
+    private requestOptions;
+    constructor(client: Client, options: {
+        endpoint: string;
+        requestOptions?: RequestOptions;
+    });
+    call<T = unknown>(method: string, params?: unknown[]): Promise<XmlRpcResponse<T>>;
+    private parseResponse;
+}
+export type SoapVersion = '1.1' | '1.2';
+export interface SoapOptions {
+    endpoint: string;
+    version?: SoapVersion;
+    namespace?: string;
+    namespacePrefix?: string;
+    wsdl?: string;
+    soapHeaders?: Record<string, unknown>;
+    requestOptions?: RequestOptions;
+}
+export interface SoapFault {
+    code: string;
+    string: string;
+    actor?: string;
+    detail?: unknown;
+}
+export interface SoapResponse<T = unknown> {
+    success: boolean;
+    result?: T;
+    fault?: SoapFault;
+    rawXml: string;
+}
+export declare class SoapClient {
+    private client;
+    private options;
+    constructor(client: Client, options: SoapOptions);
+    call<T = unknown>(method: string, params?: Record<string, unknown>, options?: {
+        soapHeaders?: Record<string, unknown>;
+        soapAction?: string;
+    }): Promise<SoapResponse<T>>;
+    getWsdl(): Promise<string | null>;
+    private objectToXml;
+    private parseResponse;
+    private parseXmlToObject;
+}
+export declare function createXmlRpcClient(client: Client, options: {
+    endpoint: string;
+    requestOptions?: RequestOptions;
+}): XmlRpcClient;
+export declare function createSoapClient(client: Client, options: SoapOptions): SoapClient;
+export declare function soap(): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        soap(options: SoapOptions): SoapClient;
+        xmlrpc(endpoint: string, requestOptions?: RequestOptions): XmlRpcClient;
+    }
+}
+//# sourceMappingURL=soap.d.ts.map

package/dist/plugins/soap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soap.d.ts","sourceRoot":"","sources":["../../src/plugins/soap.ts"],"names":[],"mappings":"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"}

package/dist/plugins/soap.js

@@ -0,0 +1,347 @@
+function jsToXmlRpcValue(value) {
+    if (value === null || value === undefined) {
+        return '<nil/>';
+    }
+    if (typeof value === 'boolean') {
+        return `<boolean>${value ? '1' : '0'}</boolean>`;
+    }
+    if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+            return `<int>${value}</int>`;
+        }
+        return `<double>${value}</double>`;
+    }
+    if (typeof value === 'string') {
+        return `<string>${escapeXml(value)}</string>`;
+    }
+    if (value instanceof Date) {
+        return `<dateTime.iso8601>${value.toISOString()}</dateTime.iso8601>`;
+    }
+    if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+        const base64 = Buffer.from(value).toString('base64');
+        return `<base64>${base64}</base64>`;
+    }
+    if (Array.isArray(value)) {
+        const items = value.map((item) => `<value>${jsToXmlRpcValue(item)}</value>`).join('');
+        return `<array><data>${items}</data></array>`;
+    }
+    if (typeof value === 'object') {
+        const members = Object.entries(value)
+            .map(([name, val]) => `<member><name>${escapeXml(name)}</name><value>${jsToXmlRpcValue(val)}</value></member>`)
+            .join('');
+        return `<struct>${members}</struct>`;
+    }
+    return `<string>${String(value)}</string>`;
+}
+function parseXmlRpcValue(xml) {
+    const trimmed = xml.trim();
+    if (trimmed.includes('<nil/>') || trimmed.includes('<nil></nil>')) {
+        return null;
+    }
+    if (trimmed.startsWith('<array>') || trimmed.includes('<array>')) {
+        const dataMatch = trimmed.match(/<array>\s*<data>([\s\S]*)<\/data>\s*<\/array>/);
+        if (dataMatch) {
+            const values = [];
+            const dataContent = dataMatch[1];
+            const valueParts = dataContent.split(/<\/value>/);
+            for (const part of valueParts) {
+                const valueStart = part.indexOf('<value>');
+                if (valueStart !== -1) {
+                    const content = part.slice(valueStart + 7);
+                    values.push(parseXmlRpcValue(content.trim()));
+                }
+            }
+            return values;
+        }
+    }
+    if (trimmed.startsWith('<struct>') || trimmed.includes('<struct>')) {
+        const structContent = trimmed.match(/<struct>([\s\S]*)<\/struct>/);
+        if (structContent) {
+            const obj = {};
+            const memberParts = structContent[1].split(/<\/member>/);
+            for (const part of memberParts) {
+                const memberStart = part.indexOf('<member>');
+                if (memberStart !== -1) {
+                    const memberContent = part.slice(memberStart + 8);
+                    const nameMatch = memberContent.match(/<name>([\s\S]*?)<\/name>/);
+                    const valueMatch = memberContent.match(/<value>([\s\S]*)<\/value>/s);
+                    if (nameMatch && valueMatch) {
+                        obj[unescapeXml(nameMatch[1].trim())] = parseXmlRpcValue(valueMatch[1].trim());
+                    }
+                }
+            }
+            return obj;
+        }
+    }
+    const intMatch = trimmed.match(/^<(?:int|i4|i8)>(-?\d+)<\/(?:int|i4|i8)>$/);
+    if (intMatch) {
+        return parseInt(intMatch[1], 10);
+    }
+    const boolMatch = trimmed.match(/^<boolean>([01])<\/boolean>$/);
+    if (boolMatch) {
+        return boolMatch[1] === '1';
+    }
+    const doubleMatch = trimmed.match(/^<double>(-?[\d.]+(?:[eE][+-]?\d+)?)<\/double>$/);
+    if (doubleMatch) {
+        return parseFloat(doubleMatch[1]);
+    }
+    const stringMatch = trimmed.match(/^<string>([\s\S]*?)<\/string>$/);
+    if (stringMatch) {
+        return unescapeXml(stringMatch[1]);
+    }
+    const dateMatch = trimmed.match(/^<dateTime\.iso8601>([\s\S]*?)<\/dateTime\.iso8601>$/);
+    if (dateMatch) {
+        return new Date(dateMatch[1]);
+    }
+    const base64Match = trimmed.match(/^<base64>([\s\S]*?)<\/base64>$/);
+    if (base64Match) {
+        return Buffer.from(base64Match[1], 'base64');
+    }
+    return trimmed;
+}
+export class XmlRpcClient {
+    client;
+    endpoint;
+    requestOptions;
+    constructor(client, options) {
+        this.client = client;
+        this.endpoint = options.endpoint;
+        this.requestOptions = options.requestOptions ?? {};
+    }
+    async call(method, params = []) {
+        const paramsXml = params.map((p) => `<param><value>${jsToXmlRpcValue(p)}</value></param>`).join('');
+        const xml = `<?xml version="1.0"?>
+<methodCall>
+  <methodName>${escapeXml(method)}</methodName>
+  <params>${paramsXml}</params>
+</methodCall>`;
+        const response = await this.client.post(this.endpoint, xml, {
+            ...this.requestOptions,
+            headers: {
+                'Content-Type': 'text/xml',
+                ...this.requestOptions.headers,
+            },
+        });
+        const responseXml = await response.text();
+        return this.parseResponse(responseXml);
+    }
+    parseResponse(xml) {
+        const faultMatch = xml.match(/<fault>\s*<value>([\s\S]+)<\/value>\s*<\/fault>/);
+        if (faultMatch) {
+            const fault = parseXmlRpcValue(faultMatch[1]);
+            return {
+                success: false,
+                fault: {
+                    faultCode: fault.faultCode ?? 0,
+                    faultString: fault.faultString ?? 'Unknown error',
+                },
+            };
+        }
+        const paramsMatch = xml.match(/<params>\s*<param>\s*<value>([\s\S]+)<\/value>\s*<\/param>\s*<\/params>/);
+        if (paramsMatch) {
+            return {
+                success: true,
+                result: parseXmlRpcValue(paramsMatch[1]),
+            };
+        }
+        return { success: true };
+    }
+}
+const SOAP_NAMESPACES = {
+    '1.1': {
+        envelope: 'http://schemas.xmlsoap.org/soap/envelope/',
+        contentType: 'text/xml; charset=utf-8',
+    },
+    '1.2': {
+        envelope: 'http://www.w3.org/2003/05/soap-envelope',
+        contentType: 'application/soap+xml; charset=utf-8',
+    },
+};
+export class SoapClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            endpoint: options.endpoint,
+            version: options.version ?? '1.2',
+            namespace: options.namespace ?? '',
+            namespacePrefix: options.namespacePrefix ?? 'ns',
+            wsdl: options.wsdl,
+            soapHeaders: options.soapHeaders ?? {},
+            requestOptions: options.requestOptions ?? {},
+        };
+    }
+    async call(method, params = {}, options) {
+        const soapNs = SOAP_NAMESPACES[this.options.version];
+        const prefix = this.options.namespacePrefix;
+        const ns = this.options.namespace;
+        const soapHeaders = { ...this.options.soapHeaders, ...options?.soapHeaders };
+        let soapHeaderXml = '';
+        if (Object.keys(soapHeaders).length > 0) {
+            const headerContent = this.objectToXml(soapHeaders, prefix);
+            soapHeaderXml = `<soap:Header>${headerContent}</soap:Header>`;
+        }
+        const paramsXml = this.objectToXml(params, prefix);
+        const methodXml = ns
+            ? `<${prefix}:${method} xmlns:${prefix}="${ns}">${paramsXml}</${prefix}:${method}>`
+            : `<${method}>${paramsXml}</${method}>`;
+        const envelope = `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="${soapNs.envelope}">
+  ${soapHeaderXml}
+  <soap:Body>
+    ${methodXml}
+  </soap:Body>
+</soap:Envelope>`;
+        const headers = {
+            'Content-Type': soapNs.contentType,
+        };
+        if (this.options.version === '1.1') {
+            const action = options?.soapAction ?? `${ns}/${method}`;
+            headers['SOAPAction'] = `"${action}"`;
+        }
+        const response = await this.client.post(this.options.endpoint, envelope, {
+            ...this.options.requestOptions,
+            headers: {
+                ...headers,
+                ...this.options.requestOptions.headers,
+            },
+        });
+        const responseXml = await response.text();
+        return this.parseResponse(responseXml, method);
+    }
+    async getWsdl() {
+        if (!this.options.wsdl)
+            return null;
+        const response = await this.client.get(this.options.wsdl);
+        return response.text();
+    }
+    objectToXml(obj, prefix) {
+        return Object.entries(obj)
+            .map(([key, value]) => {
+            const tagName = prefix ? `${prefix}:${key}` : key;
+            if (value === null || value === undefined) {
+                return `<${tagName} xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>`;
+            }
+            if (typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                return `<${tagName}>${this.objectToXml(value)}</${tagName}>`;
+            }
+            if (Array.isArray(value)) {
+                return value.map((item) => {
+                    if (typeof item === 'object') {
+                        return `<${tagName}>${this.objectToXml(item)}</${tagName}>`;
+                    }
+                    return `<${tagName}>${escapeXml(String(item))}</${tagName}>`;
+                }).join('');
+            }
+            if (value instanceof Date) {
+                return `<${tagName}>${value.toISOString()}</${tagName}>`;
+            }
+            return `<${tagName}>${escapeXml(String(value))}</${tagName}>`;
+        })
+            .join('');
+    }
+    parseResponse(xml, method) {
+        const faultMatch = xml.match(/<(?:soap:|SOAP-ENV:|)[Ff]ault[^>]*>([\s\S]*?)<\/(?:soap:|SOAP-ENV:|)[Ff]ault>/i);
+        if (faultMatch) {
+            const faultXml = faultMatch[1];
+            const codeMatch = faultXml.match(/<faultcode[^>]*>([\s\S]*?)<\/faultcode>/i);
+            const stringMatch = faultXml.match(/<faultstring[^>]*>([\s\S]*?)<\/faultstring>/i);
+            const actorMatch = faultXml.match(/<faultactor[^>]*>([\s\S]*?)<\/faultactor>/i);
+            const detailMatch = faultXml.match(/<detail[^>]*>([\s\S]*?)<\/detail>/i);
+            const codeMatch12 = faultXml.match(/<(?:\w+:)?Code[^>]*>[\s\S]*?<(?:\w+:)?Value[^>]*>([\s\S]*?)<\/(?:\w+:)?Value>/i);
+            const reasonMatch12 = faultXml.match(/<(?:\w+:)?Reason[^>]*>[\s\S]*?<(?:\w+:)?Text[^>]*>([\s\S]*?)<\/(?:\w+:)?Text>/i);
+            return {
+                success: false,
+                fault: {
+                    code: unescapeXml(codeMatch?.[1] ?? codeMatch12?.[1] ?? 'Unknown'),
+                    string: unescapeXml(stringMatch?.[1] ?? reasonMatch12?.[1] ?? 'Unknown error'),
+                    actor: actorMatch ? unescapeXml(actorMatch[1]) : undefined,
+                    detail: detailMatch ? detailMatch[1] : undefined,
+                },
+                rawXml: xml,
+            };
+        }
+        const bodyMatch = xml.match(/<(?:soap:|SOAP-ENV:|)[Bb]ody[^>]*>([\s\S]*?)<\/(?:soap:|SOAP-ENV:|)[Bb]ody>/i);
+        if (!bodyMatch) {
+            return {
+                success: false,
+                fault: { code: 'ParseError', string: 'Could not parse SOAP response body' },
+                rawXml: xml,
+            };
+        }
+        const bodyContent = bodyMatch[1].trim();
+        const responseRegex = new RegExp(`<(?:\\w+:)?${method}(?:Response|Result)[^>]*>([\\s\\S]*?)<\\/(?:\\w+:)?${method}(?:Response|Result)>`, 'i');
+        const responseMatch = bodyContent.match(responseRegex);
+        const resultXml = responseMatch ? responseMatch[1] : bodyContent;
+        const result = this.parseXmlToObject(resultXml);
+        return {
+            success: true,
+            result: result,
+            rawXml: xml,
+        };
+    }
+    parseXmlToObject(xml) {
+        const trimmed = xml.trim();
+        if (!trimmed.startsWith('<')) {
+            return unescapeXml(trimmed);
+        }
+        const obj = {};
+        const elementRegex = /<([^\/][^>\s]*)[^>]*>([\s\S]*?)<\/\1>/g;
+        let match;
+        let hasElements = false;
+        while ((match = elementRegex.exec(trimmed)) !== null) {
+            hasElements = true;
+            const [, tagName, content] = match;
+            const key = tagName.includes(':') ? tagName.split(':')[1] : tagName;
+            const value = this.parseXmlToObject(content);
+            if (key in obj) {
+                if (Array.isArray(obj[key])) {
+                    obj[key].push(value);
+                }
+                else {
+                    obj[key] = [obj[key], value];
+                }
+            }
+            else {
+                obj[key] = value;
+            }
+        }
+        if (!hasElements) {
+            return unescapeXml(trimmed);
+        }
+        return obj;
+    }
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function unescapeXml(str) {
+    return str
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&amp;/g, '&');
+}
+export function createXmlRpcClient(client, options) {
+    return new XmlRpcClient(client, options);
+}
+export function createSoapClient(client, options) {
+    return new SoapClient(client, options);
+}
+export function soap() {
+    return (client) => {
+        client.soap = (options) => {
+            return createSoapClient(client, options);
+        };
+        client.xmlrpc = (endpoint, requestOptions) => {
+            return createXmlRpcClient(client, { endpoint, requestOptions });
+        };
+    };
+}

package/dist/plugins/user-agent.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '../types/index.js';
+export interface UserAgentOptions {
+    userAgents?: string[];
+    strategy?: 'random' | 'round-robin';
+}
+export declare function userAgentRotator(options?: UserAgentOptions): Plugin;
+export declare function browserHeaders(platform?: 'desktop' | 'mobile'): Record<string, string>;
+//# sourceMappingURL=user-agent.d.ts.map

package/dist/plugins/user-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-agent.d.ts","sourceRoot":"","sources":["../../src/plugins/user-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAU3C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;CACrC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,CAiBvE;AAMD,wBAAgB,cAAc,CAAC,QAAQ,GAAE,SAAS,GAAG,QAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBjG"}

package/dist/plugins/user-agent.js

@@ -0,0 +1,46 @@
+const DEFAULT_UAS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/121.0'
+];
+export function userAgentRotator(options = {}) {
+    const uas = options.userAgents || DEFAULT_UAS;
+    let index = 0;
+    return (client) => {
+        client.beforeRequest((req) => {
+            let selected;
+            if (options.strategy === 'round-robin') {
+                selected = uas[index];
+                index = (index + 1) % uas.length;
+            }
+            else {
+                selected = uas[Math.floor(Math.random() * uas.length)];
+            }
+            req.headers.set('User-Agent', selected);
+        });
+    };
+}
+export function browserHeaders(platform = 'desktop') {
+    return {
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+        'Sec-Fetch-Dest': 'document',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-Site': 'none',
+        'Sec-Fetch-User': '?1',
+        ...(platform === 'desktop' ? {
+            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
+            'Sec-Ch-Ua-Mobile': '?0',
+            'Sec-Ch-Ua-Platform': '"Windows"'
+        } : {
+            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
+            'Sec-Ch-Ua-Mobile': '?1',
+            'Sec-Ch-Ua-Platform': '"Android"'
+        })
+    };
+}

package/dist/plugins/xml.d.ts

@@ -0,0 +1,10 @@
+import { ReckerResponse } from '../types/index.js';
+export interface XMLPluginOptions {
+    parser?: (xml: string) => any;
+    serializer?: (obj: any) => string;
+}
+export declare function parseXML(xml: string): any;
+export declare function serializeXML(obj: any, rootName?: string): string;
+export declare function xmlResponse<T = any>(promise: Promise<ReckerResponse>, parser?: (xml: string) => any): Promise<T>;
+export { parseXML as parse, serializeXML as serialize };
+//# sourceMappingURL=xml.d.ts.map

package/dist/plugins/xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../src/plugins/xml.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAK/B,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;IAM9B,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;CACnC;AAOD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAQzC;AAiLD,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA+ChE;AAsBD,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,EAChC,MAAM,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAc,GACtC,OAAO,CAAC,CAAC,CAAC,CAIZ;AAGD,OAAO,EAAE,QAAQ,IAAI,KAAK,EAAE,YAAY,IAAI,SAAS,EAAE,CAAC"}