@mtkruto/node 0.1.191 → 0.1.201

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.js

@@ -1,301 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attributeNames = exports.elementNames = void 0;
-/*
- * Module dependencies
- */
-const ElementType = __importStar(require("./ElementType.js"));
-const mod_js_1 = require("./utils/entities/mod.js");
-/**
- * Mixed-case SVG and MathML tags & attributes
- * recognized by the HTML parser.
- *
- * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
- */
-exports.elementNames = new Map([
-    ['altglyph', 'altGlyph'],
-    ['altglyphdef', 'altGlyphDef'],
-    ['altglyphitem', 'altGlyphItem'],
-    ['animatecolor', 'animateColor'],
-    ['animatemotion', 'animateMotion'],
-    ['animatetransform', 'animateTransform'],
-    ['clippath', 'clipPath'],
-    ['feblend', 'feBlend'],
-    ['fecolormatrix', 'feColorMatrix'],
-    ['fecomponenttransfer', 'feComponentTransfer'],
-    ['fecomposite', 'feComposite'],
-    ['feconvolvematrix', 'feConvolveMatrix'],
-    ['fediffuselighting', 'feDiffuseLighting'],
-    ['fedisplacementmap', 'feDisplacementMap'],
-    ['fedistantlight', 'feDistantLight'],
-    ['fedropshadow', 'feDropShadow'],
-    ['feflood', 'feFlood'],
-    ['fefunca', 'feFuncA'],
-    ['fefuncb', 'feFuncB'],
-    ['fefuncg', 'feFuncG'],
-    ['fefuncr', 'feFuncR'],
-    ['fegaussianblur', 'feGaussianBlur'],
-    ['feimage', 'feImage'],
-    ['femerge', 'feMerge'],
-    ['femergenode', 'feMergeNode'],
-    ['femorphology', 'feMorphology'],
-    ['feoffset', 'feOffset'],
-    ['fepointlight', 'fePointLight'],
-    ['fespecularlighting', 'feSpecularLighting'],
-    ['fespotlight', 'feSpotLight'],
-    ['fetile', 'feTile'],
-    ['feturbulence', 'feTurbulence'],
-    ['foreignobject', 'foreignObject'],
-    ['glyphref', 'glyphRef'],
-    ['lineargradient', 'linearGradient'],
-    ['radialgradient', 'radialGradient'],
-    ['textpath', 'textPath'],
-]);
-exports.attributeNames = new Map([
-    ['definitionurl', 'definitionURL'],
-    ['attributename', 'attributeName'],
-    ['attributetype', 'attributeType'],
-    ['basefrequency', 'baseFrequency'],
-    ['baseprofile', 'baseProfile'],
-    ['calcmode', 'calcMode'],
-    ['clippathunits', 'clipPathUnits'],
-    ['diffuseconstant', 'diffuseConstant'],
-    ['edgemode', 'edgeMode'],
-    ['filterunits', 'filterUnits'],
-    ['glyphref', 'glyphRef'],
-    ['gradienttransform', 'gradientTransform'],
-    ['gradientunits', 'gradientUnits'],
-    ['kernelmatrix', 'kernelMatrix'],
-    ['kernelunitlength', 'kernelUnitLength'],
-    ['keypoints', 'keyPoints'],
-    ['keysplines', 'keySplines'],
-    ['keytimes', 'keyTimes'],
-    ['lengthadjust', 'lengthAdjust'],
-    ['limitingconeangle', 'limitingConeAngle'],
-    ['markerheight', 'markerHeight'],
-    ['markerunits', 'markerUnits'],
-    ['markerwidth', 'markerWidth'],
-    ['maskcontentunits', 'maskContentUnits'],
-    ['maskunits', 'maskUnits'],
-    ['numoctaves', 'numOctaves'],
-    ['pathlength', 'pathLength'],
-    ['patterncontentunits', 'patternContentUnits'],
-    ['patterntransform', 'patternTransform'],
-    ['patternunits', 'patternUnits'],
-    ['pointsatx', 'pointsAtX'],
-    ['pointsaty', 'pointsAtY'],
-    ['pointsatz', 'pointsAtZ'],
-    ['preservealpha', 'preserveAlpha'],
-    ['preserveaspectratio', 'preserveAspectRatio'],
-    ['primitiveunits', 'primitiveUnits'],
-    ['refx', 'refX'],
-    ['refy', 'refY'],
-    ['repeatcount', 'repeatCount'],
-    ['repeatdur', 'repeatDur'],
-    ['requiredextensions', 'requiredExtensions'],
-    ['requiredfeatures', 'requiredFeatures'],
-    ['specularconstant', 'specularConstant'],
-    ['specularexponent', 'specularExponent'],
-    ['spreadmethod', 'spreadMethod'],
-    ['startoffset', 'startOffset'],
-    ['stddeviation', 'stdDeviation'],
-    ['stitchtiles', 'stitchTiles'],
-    ['surfacescale', 'surfaceScale'],
-    ['systemlanguage', 'systemLanguage'],
-    ['tablevalues', 'tableValues'],
-    ['targetx', 'targetX'],
-    ['targety', 'targetY'],
-    ['textlength', 'textLength'],
-    ['viewbox', 'viewBox'],
-    ['viewtarget', 'viewTarget'],
-    ['xchannelselector', 'xChannelSelector'],
-    ['ychannelselector', 'yChannelSelector'],
-    ['zoomandpan', 'zoomAndPan'],
-]);
-const unencodedElements = new Set([
-    'style',
-    'script',
-    'xmp',
-    'iframe',
-    'noembed',
-    'noframes',
-    'plaintext',
-    'noscript',
-]);
-/**
- * Format attributes
- */
-function formatAttributes(attributes, opts) {
-    if (!attributes)
-        return;
-    return Object.keys(attributes)
-        .map(key => {
-        const value = attributes[key] ?? '';
-        if (opts.xmlMode === 'foreign') {
-            /* Fix up mixed-case attribute names */
-            key = exports.attributeNames.get(key) ?? key;
-        }
-        if (!opts.emptyAttrs && !opts.xmlMode && value === '') {
-            return key;
-        }
-        return `${key}="${opts.decodeEntities !== false
-            ? (0, mod_js_1.encodeXML)(value)
-            : value.replace(/"/g, '"')}"`;
-    })
-        .join(' ');
-}
-/**
- * Self-enclosing tags
- */
-const singleTag = new Set([
-    'area',
-    'base',
-    'basefont',
-    'br',
-    'col',
-    'command',
-    'embed',
-    'frame',
-    'hr',
-    'img',
-    'input',
-    'isindex',
-    'keygen',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-]);
-/**
- * Renders a DOM node or an array of DOM nodes to a string.
- *
- * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
- *
- * @param node Node to be rendered.
- * @param options Changes serialization behavior
- */
-function render(node, options = {}) {
-    const nodes = 'length' in node ? node : [node];
-    let output = '';
-    for (let i = 0; i < nodes.length; i++) {
-        output += renderNode(nodes[i], options);
-    }
-    return output;
-}
-exports.default = render;
-function renderNode(node, options) {
-    switch (node.type) {
-        case ElementType.Root:
-            return render(node.children, options);
-        case ElementType.Directive:
-        case ElementType.Doctype:
-            return renderDirective(node);
-        case ElementType.Comment:
-            return renderComment(node);
-        case ElementType.CDATA:
-            return renderCdata(node);
-        case ElementType.Script:
-        case ElementType.Style:
-        case ElementType.Tag:
-            return renderTag(node, options);
-        case ElementType.Text:
-            return renderText(node, options);
-    }
-}
-const foreignModeIntegrationPoints = new Set([
-    'mi',
-    'mo',
-    'mn',
-    'ms',
-    'mtext',
-    'annotation-xml',
-    'foreignObject',
-    'desc',
-    'title',
-]);
-const foreignElements = new Set(['svg', 'math']);
-function renderTag(elem, opts) {
-    // Handle SVG / MathML in HTML
-    if (opts.xmlMode === 'foreign') {
-        /* Fix up mixed-case element names */
-        elem.name = exports.elementNames.get(elem.name) ?? elem.name;
-        /* Exit foreign mode at integration points */
-        if (elem.parent &&
-            foreignModeIntegrationPoints.has(elem.parent.name)) {
-            opts = { ...opts, xmlMode: false };
-        }
-    }
-    if (!opts.xmlMode && foreignElements.has(elem.name)) {
-        opts = { ...opts, xmlMode: 'foreign' };
-    }
-    let tag = `<${elem.name}`;
-    const attribs = formatAttributes(elem.attribs, opts);
-    if (attribs) {
-        tag += ` ${attribs}`;
-    }
-    if (elem.children.length === 0 &&
-        (opts.xmlMode
-            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
-                opts.selfClosingTags !== false
-            : // User explicitly asked for self-closing tags, even in HTML mode
-                opts.selfClosingTags && singleTag.has(elem.name))) {
-        if (!opts.xmlMode)
-            tag += ' ';
-        tag += '/>';
-    }
-    else {
-        tag += '>';
-        if (elem.children.length > 0) {
-            tag += render(elem.children, opts);
-        }
-        if (opts.xmlMode || !singleTag.has(elem.name)) {
-            tag += `</${elem.name}>`;
-        }
-    }
-    return tag;
-}
-function renderDirective(elem) {
-    return `<${elem.data}>`;
-}
-function renderText(elem, opts) {
-    let data = elem.data || '';
-    // If entities weren't decoded, no need to encode them back
-    if (opts.decodeEntities !== false &&
-        !(!opts.xmlMode &&
-            elem.parent &&
-            unencodedElements.has(elem.parent.name))) {
-        data = (0, mod_js_1.encodeXML)(data);
-    }
-    return data;
-}
-function renderCdata(elem) {
-    return `<![CDATA[${elem.children[0].data}]]>`;
-}
-function renderComment(elem) {
-    return `<!--${elem.data}-->`;
-}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.d.ts

@@ -1,47 +0,0 @@
-/** Types of elements found in htmlparser2's DOM */
-export declare enum ElementType {
-    /** Type for the root element of a document */
-    Root = "root",
-    /** Type for Text */
-    Text = "text",
-    /** Type for <? ... ?> */
-    Directive = "directive",
-    /** Type for <!-- ... --> */
-    Comment = "comment",
-    /** Type for <script> tags */
-    Script = "script",
-    /** Type for <style> tags */
-    Style = "style",
-    /** Type for Any tag */
-    Tag = "tag",
-    /** Type for <![CDATA[ ... ]]> */
-    CDATA = "cdata",
-    /** Type for <!doctype ...> */
-    Doctype = "doctype"
-}
-/**
- * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
- */
-export declare function isTag(elem: {
-    type: ElementType;
-}): boolean;
-/** Type for the root element of a document */
-export declare const Root = ElementType.Root;
-/** Type for Text */
-export declare const Text = ElementType.Text;
-/** Type for <? ... ?> */
-export declare const Directive = ElementType.Directive;
-/** Type for <!-- ... --> */
-export declare const Comment = ElementType.Comment;
-/** Type for <script> tags */
-export declare const Script = ElementType.Script;
-/** Type for <style> tags */
-export declare const Style = ElementType.Style;
-/** Type for Any tag */
-export declare const Tag = ElementType.Tag;
-/** Type for <![CDATA[ ... ]]> */
-export declare const CDATA = ElementType.CDATA;
-/** Type for <!doctype ...> */
-export declare const Doctype = ElementType.Doctype;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;
-/** Types of elements found in htmlparser2's DOM */
-var ElementType;
-(function (ElementType) {
-    /** Type for the root element of a document */
-    ElementType["Root"] = "root";
-    /** Type for Text */
-    ElementType["Text"] = "text";
-    /** Type for <? ... ?> */
-    ElementType["Directive"] = "directive";
-    /** Type for <!-- ... --> */
-    ElementType["Comment"] = "comment";
-    /** Type for <script> tags */
-    ElementType["Script"] = "script";
-    /** Type for <style> tags */
-    ElementType["Style"] = "style";
-    /** Type for Any tag */
-    ElementType["Tag"] = "tag";
-    /** Type for <![CDATA[ ... ]]> */
-    ElementType["CDATA"] = "cdata";
-    /** Type for <!doctype ...> */
-    ElementType["Doctype"] = "doctype";
-})(ElementType || (exports.ElementType = ElementType = {}));
-/**
- * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
- */
-function isTag(elem) {
-    return (elem.type === ElementType.Tag ||
-        elem.type === ElementType.Script ||
-        elem.type === ElementType.Style);
-}
-exports.isTag = isTag;
-// Exports for backwards compatibility
-/** Type for the root element of a document */
-exports.Root = ElementType.Root;
-/** Type for Text */
-exports.Text = ElementType.Text;
-/** Type for <? ... ?> */
-exports.Directive = ElementType.Directive;
-/** Type for <!-- ... --> */
-exports.Comment = ElementType.Comment;
-/** Type for <script> tags */
-exports.Script = ElementType.Script;
-/** Type for <style> tags */
-exports.Style = ElementType.Style;
-/** Type for Any tag */
-exports.Tag = ElementType.Tag;
-/** Type for <![CDATA[ ... ]]> */
-exports.CDATA = ElementType.CDATA;
-/** Type for <!doctype ...> */
-exports.Doctype = ElementType.Doctype;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/FeedHandler.d.ts

@@ -1,66 +0,0 @@
-import DomHandler, { DomHandlerOptions } from './DomHandler.js';
-import { ParserOptions } from './Parser.js';
-declare enum FeedItemMediaMedium {
-    image = 0,
-    audio = 1,
-    video = 2,
-    document = 3,
-    executable = 4
-}
-declare enum FeedItemMediaExpression {
-    sample = 0,
-    full = 1,
-    nonstop = 2
-}
-interface FeedItemMedia {
-    url?: string;
-    fileSize?: number;
-    type?: string;
-    medium: FeedItemMediaMedium | undefined;
-    isDefault: boolean;
-    expression?: FeedItemMediaExpression;
-    bitrate?: number;
-    framerate?: number;
-    samplingrate?: number;
-    channels?: number;
-    duration?: number;
-    height?: number;
-    width?: number;
-    lang?: string;
-}
-interface FeedItem {
-    id?: string;
-    title?: string;
-    link?: string;
-    description?: string;
-    pubDate?: Date;
-    media?: FeedItemMedia[];
-}
-interface Feed {
-    type?: string;
-    id?: string;
-    title?: string;
-    link?: string;
-    description?: string;
-    updated?: Date;
-    author?: string;
-    items?: FeedItem[];
-}
-export declare class FeedHandler extends DomHandler {
-    feed?: Feed;
-    /**
-     *
-     * @param callback
-     * @param options
-     */
-    constructor(callback?: ((error: Error | null) => void) | DomHandlerOptions, options?: DomHandlerOptions);
-    onend(): void;
-}
-/**
- * Parse a feed.
- *
- * @param feed The feed that should be parsed, as a string.
- * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
- */
-export declare function parseFeed(feed: string, options?: ParserOptions & DomHandlerOptions): Feed | undefined;
-export {};

package/script/deps/deno.land/x/html_parser@v0.1.3/src/FeedHandler.js

@@ -1,222 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFeed = exports.FeedHandler = void 0;
-const DomHandler_js_1 = __importDefault(require("./DomHandler.js"));
-const DomUtils = __importStar(require("./utils/mod.js"));
-const Parser_js_1 = require("./Parser.js");
-var FeedItemMediaMedium;
-(function (FeedItemMediaMedium) {
-    FeedItemMediaMedium[FeedItemMediaMedium["image"] = 0] = "image";
-    FeedItemMediaMedium[FeedItemMediaMedium["audio"] = 1] = "audio";
-    FeedItemMediaMedium[FeedItemMediaMedium["video"] = 2] = "video";
-    FeedItemMediaMedium[FeedItemMediaMedium["document"] = 3] = "document";
-    FeedItemMediaMedium[FeedItemMediaMedium["executable"] = 4] = "executable";
-})(FeedItemMediaMedium || (FeedItemMediaMedium = {}));
-var FeedItemMediaExpression;
-(function (FeedItemMediaExpression) {
-    FeedItemMediaExpression[FeedItemMediaExpression["sample"] = 0] = "sample";
-    FeedItemMediaExpression[FeedItemMediaExpression["full"] = 1] = "full";
-    FeedItemMediaExpression[FeedItemMediaExpression["nonstop"] = 2] = "nonstop";
-})(FeedItemMediaExpression || (FeedItemMediaExpression = {}));
-// TODO: Consume data as it is coming in
-class FeedHandler extends DomHandler_js_1.default {
-    /**
-     *
-     * @param callback
-     * @param options
-     */
-    constructor(callback, options) {
-        if (typeof callback === 'object') {
-            callback = undefined;
-            options = callback;
-        }
-        super(callback, options);
-        Object.defineProperty(this, "feed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    onend() {
-        const feedRoot = getOneElement(isValidFeed, this.dom);
-        if (!feedRoot) {
-            this.handleCallback(new Error("couldn't find root of feed"));
-            return;
-        }
-        const feed = {};
-        if (feedRoot.name === 'feed') {
-            const childs = feedRoot.children;
-            feed.type = 'atom';
-            addConditionally(feed, 'id', 'id', childs);
-            addConditionally(feed, 'title', 'title', childs);
-            const href = getAttribute('href', getOneElement('link', childs));
-            if (href) {
-                feed.link = href;
-            }
-            addConditionally(feed, 'description', 'subtitle', childs);
-            const updated = fetch('updated', childs);
-            if (updated) {
-                feed.updated = new Date(updated);
-            }
-            addConditionally(feed, 'author', 'email', childs, true);
-            feed.items = getElements('entry', childs).map(item => {
-                const entry = {};
-                const { children } = item;
-                addConditionally(entry, 'id', 'id', children);
-                addConditionally(entry, 'title', 'title', children);
-                const href = getAttribute('href', getOneElement('link', children));
-                if (href) {
-                    entry.link = href;
-                }
-                const description = fetch('summary', children) || fetch('content', children);
-                if (description) {
-                    entry.description = description;
-                }
-                const pubDate = fetch('updated', children);
-                if (pubDate) {
-                    entry.pubDate = new Date(pubDate);
-                }
-                entry.media = getMediaElements(children);
-                return entry;
-            });
-        }
-        else {
-            const childs = getOneElement('channel', feedRoot.children)?.children ?? [];
-            feed.type = feedRoot.name.substr(0, 3);
-            feed.id = '';
-            addConditionally(feed, 'title', 'title', childs);
-            addConditionally(feed, 'link', 'link', childs);
-            addConditionally(feed, 'description', 'description', childs);
-            const updated = fetch('lastBuildDate', childs);
-            if (updated) {
-                feed.updated = new Date(updated);
-            }
-            addConditionally(feed, 'author', 'managingEditor', childs, true);
-            feed.items = getElements('item', feedRoot.children).map((item) => {
-                const entry = {};
-                const { children } = item;
-                addConditionally(entry, 'id', 'guid', children);
-                addConditionally(entry, 'title', 'title', children);
-                addConditionally(entry, 'link', 'link', children);
-                addConditionally(entry, 'description', 'description', children);
-                const pubDate = fetch('pubDate', children);
-                if (pubDate)
-                    entry.pubDate = new Date(pubDate);
-                entry.media = getMediaElements(children);
-                return entry;
-            });
-        }
-        this.feed = feed;
-        this.handleCallback(null);
-    }
-}
-exports.FeedHandler = FeedHandler;
-function getMediaElements(where) {
-    return getElements('media:content', where).map(elem => {
-        const media = {
-            medium: elem.attribs.medium,
-            isDefault: !!elem.attribs.isDefault,
-        };
-        if (elem.attribs.url) {
-            media.url = elem.attribs.url;
-        }
-        if (elem.attribs.fileSize) {
-            media.fileSize = parseInt(elem.attribs.fileSize, 10);
-        }
-        if (elem.attribs.type) {
-            media.type = elem.attribs.type;
-        }
-        if (elem.attribs.expression) {
-            media.expression = elem.attribs
-                .expression;
-        }
-        if (elem.attribs.bitrate) {
-            media.bitrate = parseInt(elem.attribs.bitrate, 10);
-        }
-        if (elem.attribs.framerate) {
-            media.framerate = parseInt(elem.attribs.framerate, 10);
-        }
-        if (elem.attribs.samplingrate) {
-            media.samplingrate = parseInt(elem.attribs.samplingrate, 10);
-        }
-        if (elem.attribs.channels) {
-            media.channels = parseInt(elem.attribs.channels, 10);
-        }
-        if (elem.attribs.duration) {
-            media.duration = parseInt(elem.attribs.duration, 10);
-        }
-        if (elem.attribs.height) {
-            media.height = parseInt(elem.attribs.height, 10);
-        }
-        if (elem.attribs.width) {
-            media.width = parseInt(elem.attribs.width, 10);
-        }
-        if (elem.attribs.lang) {
-            media.lang = elem.attribs.lang;
-        }
-        return media;
-    });
-}
-function getElements(tagName, where) {
-    return DomUtils.getElementsByTagName(tagName, where, true);
-}
-function getOneElement(tagName, node) {
-    return DomUtils.getElementsByTagName(tagName, node, true, 1)[0];
-}
-function fetch(tagName, where, recurse = false) {
-    return DomUtils.getText(DomUtils.getElementsByTagName(tagName, where, recurse, 1)).trim();
-}
-function getAttribute(name, elem) {
-    if (!elem) {
-        return null;
-    }
-    const { attribs } = elem;
-    return attribs[name];
-}
-function addConditionally(obj, prop, what, where, recurse = false) {
-    const tmp = fetch(what, where, recurse);
-    if (tmp)
-        obj[prop] = tmp;
-}
-function isValidFeed(value) {
-    return value === 'rss' || value === 'feed' || value === 'rdf:RDF';
-}
-/**
- * Parse a feed.
- *
- * @param feed The feed that should be parsed, as a string.
- * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
- */
-function parseFeed(feed, options = { xmlMode: true }) {
-    const handler = new FeedHandler(options);
-    new Parser_js_1.Parser(handler, options).end(feed);
-    return handler.feed;
-}
-exports.parseFeed = parseFeed;