@mtkruto/node 0.1.703 → 0.1.707

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.d.ts

@@ -0,0 +1,110 @@
+declare const _default: {
+    Aacute: string;
+    aacute: string;
+    Acirc: string;
+    acirc: string;
+    acute: string;
+    AElig: string;
+    aelig: string;
+    Agrave: string;
+    agrave: string;
+    amp: string;
+    AMP: string;
+    Aring: string;
+    aring: string;
+    Atilde: string;
+    atilde: string;
+    Auml: string;
+    auml: string;
+    brvbar: string;
+    Ccedil: string;
+    ccedil: string;
+    cedil: string;
+    cent: string;
+    copy: string;
+    COPY: string;
+    curren: string;
+    deg: string;
+    divide: string;
+    Eacute: string;
+    eacute: string;
+    Ecirc: string;
+    ecirc: string;
+    Egrave: string;
+    egrave: string;
+    ETH: string;
+    eth: string;
+    Euml: string;
+    euml: string;
+    frac12: string;
+    frac14: string;
+    frac34: string;
+    gt: string;
+    GT: string;
+    Iacute: string;
+    iacute: string;
+    Icirc: string;
+    icirc: string;
+    iexcl: string;
+    Igrave: string;
+    igrave: string;
+    iquest: string;
+    Iuml: string;
+    iuml: string;
+    laquo: string;
+    lt: string;
+    LT: string;
+    macr: string;
+    micro: string;
+    middot: string;
+    nbsp: string;
+    not: string;
+    Ntilde: string;
+    ntilde: string;
+    Oacute: string;
+    oacute: string;
+    Ocirc: string;
+    ocirc: string;
+    Ograve: string;
+    ograve: string;
+    ordf: string;
+    ordm: string;
+    Oslash: string;
+    oslash: string;
+    Otilde: string;
+    otilde: string;
+    Ouml: string;
+    ouml: string;
+    para: string;
+    plusmn: string;
+    pound: string;
+    quot: string;
+    QUOT: string;
+    raquo: string;
+    reg: string;
+    REG: string;
+    sect: string;
+    shy: string;
+    sup1: string;
+    sup2: string;
+    sup3: string;
+    szlig: string;
+    THORN: string;
+    thorn: string;
+    times: string;
+    Uacute: string;
+    uacute: string;
+    Ucirc: string;
+    ucirc: string;
+    Ugrave: string;
+    ugrave: string;
+    uml: string;
+    Uuml: string;
+    uuml: string;
+    Yacute: string;
+    yacute: string;
+    yen: string;
+    yuml: string;
+};
+export default _default;
+//# sourceMappingURL=legacy.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA2GC"}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    Aacute: 'Á',
+    aacute: 'á',
+    Acirc: 'Â',
+    acirc: 'â',
+    acute: '´',
+    AElig: 'Æ',
+    aelig: 'æ',
+    Agrave: 'À',
+    agrave: 'à',
+    amp: '&',
+    AMP: '&',
+    Aring: 'Å',
+    aring: 'å',
+    Atilde: 'Ã',
+    atilde: 'ã',
+    Auml: 'Ä',
+    auml: 'ä',
+    brvbar: '¦',
+    Ccedil: 'Ç',
+    ccedil: 'ç',
+    cedil: '¸',
+    cent: '¢',
+    copy: '©',
+    COPY: '©',
+    curren: '¤',
+    deg: '°',
+    divide: '÷',
+    Eacute: 'É',
+    eacute: 'é',
+    Ecirc: 'Ê',
+    ecirc: 'ê',
+    Egrave: 'È',
+    egrave: 'è',
+    ETH: 'Ð',
+    eth: 'ð',
+    Euml: 'Ë',
+    euml: 'ë',
+    frac12: '½',
+    frac14: '¼',
+    frac34: '¾',
+    gt: '>',
+    GT: '>',
+    Iacute: 'Í',
+    iacute: 'í',
+    Icirc: 'Î',
+    icirc: 'î',
+    iexcl: '¡',
+    Igrave: 'Ì',
+    igrave: 'ì',
+    iquest: '¿',
+    Iuml: 'Ï',
+    iuml: 'ï',
+    laquo: '«',
+    lt: '<',
+    LT: '<',
+    macr: '¯',
+    micro: 'µ',
+    middot: '·',
+    nbsp: ' ',
+    not: '¬',
+    Ntilde: 'Ñ',
+    ntilde: 'ñ',
+    Oacute: 'Ó',
+    oacute: 'ó',
+    Ocirc: 'Ô',
+    ocirc: 'ô',
+    Ograve: 'Ò',
+    ograve: 'ò',
+    ordf: 'ª',
+    ordm: 'º',
+    Oslash: 'Ø',
+    oslash: 'ø',
+    Otilde: 'Õ',
+    otilde: 'õ',
+    Ouml: 'Ö',
+    ouml: 'ö',
+    para: '¶',
+    plusmn: '±',
+    pound: '£',
+    quot: '"',
+    QUOT: '"',
+    raquo: '»',
+    reg: '®',
+    REG: '®',
+    sect: '§',
+    shy: '­',
+    sup1: '¹',
+    sup2: '²',
+    sup3: '³',
+    szlig: 'ß',
+    THORN: 'Þ',
+    thorn: 'þ',
+    times: '×',
+    Uacute: 'Ú',
+    uacute: 'ú',
+    Ucirc: 'Û',
+    ucirc: 'û',
+    Ugrave: 'Ù',
+    ugrave: 'ù',
+    uml: '¨',
+    Uuml: 'Ü',
+    uuml: 'ü',
+    Yacute: 'Ý',
+    yacute: 'ý',
+    yen: '¥',
+    yuml: 'ÿ',
+};

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    amp: string;
+    apos: string;
+    gt: string;
+    lt: string;
+    quot: string;
+};
+export default _default;
+//# sourceMappingURL=xml.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.ts"],"names":[],"mappings":";;;;;;;AAAA,wBAAmE"}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = { amp: '&', apos: "'", gt: '>', lt: '<', quot: '"' };

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.d.ts

@@ -0,0 +1,91 @@
+/** The level of entities to support. */
+export declare enum EntityLevel {
+    /** Support only XML entities. */
+    XML = 0,
+    /** Support HTML entities, which are a superset of XML entities. */
+    HTML = 1
+}
+/** Determines whether some entities are allowed to be written without a trailing `;`. */
+export declare enum DecodingMode {
+    /** Support legacy HTML entities. */
+    Legacy = 0,
+    /** Do not support legacy HTML entities. */
+    Strict = 1
+}
+export declare enum EncodingMode {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * HTML will be escaped.
+     */
+    UTF8 = 0,
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    ASCII = 1,
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    Extensive = 2
+}
+interface DecodingOptions {
+    /**
+     * The level of entities to support.
+     * @default EntityLevel.XML
+     */
+    level?: EntityLevel;
+    /**
+     * Decoding mode. If `Legacy`, will support legacy entities not terminated
+     * with a semicolon (`;`).
+     *
+     * Always `Strict` for XML. For HTML, set this to `true` if you are parsing
+     * an attribute value.
+     *
+     * The deprecated `decodeStrict` function defaults this to `Strict`.
+     *
+     * @default DecodingMode.Legacy
+     */
+    mode?: DecodingMode;
+}
+/**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ */
+export declare function decode(data: string, options?: DecodingOptions | EntityLevel): string;
+/**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ * @deprecated Use `decode` with the `mode` set to `Strict`.
+ */
+export declare function decodeStrict(data: string, options?: DecodingOptions | EntityLevel): string;
+/**
+ * Options for `encode`.
+ */
+export interface EncodingOptions {
+    /**
+     * The level of entities to support.
+     * @default EntityLevel.XML
+     */
+    level?: EntityLevel;
+    /**
+     * Output format.
+     * @default EncodingMode.Extensive
+     */
+    mode?: EncodingMode;
+}
+/**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param options Encoding options.
+ */
+export declare function encode(data: string, options?: EncodingOptions | EntityLevel): string;
+export { encodeXML, encodeHTML, encodeNonAsciiHTML, escape, escapeUTF8, encodeHTML as encodeHTML4, encodeHTML as encodeHTML5, } from './encode.js';
+export { decodeXML, decodeHTML, decodeHTMLStrict, decodeHTML as decodeHTML4, decodeHTML as decodeHTML5, decodeHTMLStrict as decodeHTML4Strict, decodeHTMLStrict as decodeHTML5Strict, decodeXML as decodeXMLStrict, } from './decode.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.ts"],"names":[],"mappings":"AAGA,wCAAwC;AACxC,oBAAY,WAAW;IACnB,iCAAiC;IACjC,GAAG,IAAI;IACP,mEAAmE;IACnE,IAAI,IAAI;CACX;AAED,yFAAyF;AACzF,oBAAY,YAAY;IACpB,oCAAoC;IACpC,MAAM,IAAI;IACV,2CAA2C;IAC3C,MAAM,IAAI;CACb;AAED,oBAAY,YAAY;IACpB;;;OAGG;IACH,IAAI,IAAA;IACJ;;;;OAIG;IACH,KAAK,IAAA;IACL;;;OAGG;IACH,SAAS,IAAA;CACZ;AAED,UAAU,eAAe;IACrB;;;OAGG;IACH,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAe,GAAG,WAA6B,GACzD,MAAM,CAWR;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAe,GAAG,WAA6B,GACzD,MAAM,CAWR;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B;;;OAGG;IACH,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB;;;OAGG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAe,GAAG,WAA6B,GACzD,MAAM,CAiBR;AAED,OAAO,EACH,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,MAAM,EACN,UAAU,EAEV,UAAU,IAAI,WAAW,EACzB,UAAU,IAAI,WAAW,GAC5B,MAAM,aAAa,CAAA;AAEpB,OAAO,EACH,SAAS,EACT,UAAU,EACV,gBAAgB,EAEhB,UAAU,IAAI,WAAW,EACzB,UAAU,IAAI,WAAW,EACzB,gBAAgB,IAAI,iBAAiB,EACrC,gBAAgB,IAAI,iBAAiB,EACrC,SAAS,IAAI,eAAe,GAC/B,MAAM,aAAa,CAAA"}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = exports.EncodingMode = exports.DecodingMode = exports.EntityLevel = void 0;
+const decode_js_1 = require("./decode.js");
+const encode_js_1 = require("./encode.js");
+/** The level of entities to support. */
+var EntityLevel;
+(function (EntityLevel) {
+    /** Support only XML entities. */
+    EntityLevel[EntityLevel["XML"] = 0] = "XML";
+    /** Support HTML entities, which are a superset of XML entities. */
+    EntityLevel[EntityLevel["HTML"] = 1] = "HTML";
+})(EntityLevel || (exports.EntityLevel = EntityLevel = {}));
+/** Determines whether some entities are allowed to be written without a trailing `;`. */
+var DecodingMode;
+(function (DecodingMode) {
+    /** Support legacy HTML entities. */
+    DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+    /** Do not support legacy HTML entities. */
+    DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+})(DecodingMode || (exports.DecodingMode = DecodingMode = {}));
+var EncodingMode;
+(function (EncodingMode) {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * HTML will be escaped.
+     */
+    EncodingMode[EncodingMode["UTF8"] = 0] = "UTF8";
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    EncodingMode[EncodingMode["ASCII"] = 1] = "ASCII";
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    EncodingMode[EncodingMode["Extensive"] = 2] = "Extensive";
+})(EncodingMode || (exports.EncodingMode = EncodingMode = {}));
+/**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ */
+function decode(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === DecodingMode.Strict) {
+            return (0, decode_js_1.decodeHTMLStrict)(data);
+        }
+        return (0, decode_js_1.decodeHTML)(data);
+    }
+    return (0, decode_js_1.decodeXML)(data);
+}
+exports.decode = decode;
+/**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ * @deprecated Use `decode` with the `mode` set to `Strict`.
+ */
+function decodeStrict(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === DecodingMode.Legacy) {
+            return (0, decode_js_1.decodeHTML)(data);
+        }
+        return (0, decode_js_1.decodeHTMLStrict)(data);
+    }
+    return (0, decode_js_1.decodeXML)(data);
+}
+exports.decodeStrict = decodeStrict;
+/**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param options Encoding options.
+ */
+function encode(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === EncodingMode.ASCII) {
+            return (0, encode_js_1.encodeNonAsciiHTML)(data);
+        }
+        // TODO Support opts.mode === 'UTF8'
+        return (0, encode_js_1.encodeHTML)(data);
+    }
+    // TODO Support opts.mode === 'UTF8'
+    // ASCII and Extensive are equivalent
+    return (0, encode_js_1.encodeXML)(data);
+}
+exports.encode = encode;
+var encode_js_2 = require("./encode.js");
+Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function () { return encode_js_2.encodeXML; } });
+Object.defineProperty(exports, "encodeHTML", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+Object.defineProperty(exports, "encodeNonAsciiHTML", { enumerable: true, get: function () { return encode_js_2.encodeNonAsciiHTML; } });
+Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return encode_js_2.escape; } });
+Object.defineProperty(exports, "escapeUTF8", { enumerable: true, get: function () { return encode_js_2.escapeUTF8; } });
+// Legacy aliases (deprecated)
+Object.defineProperty(exports, "encodeHTML4", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+Object.defineProperty(exports, "encodeHTML5", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+var decode_js_2 = require("./decode.js");
+Object.defineProperty(exports, "decodeXML", { enumerable: true, get: function () { return decode_js_2.decodeXML; } });
+Object.defineProperty(exports, "decodeHTML", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTMLStrict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+// Legacy aliases (deprecated)
+Object.defineProperty(exports, "decodeHTML4", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTML5", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTML4Strict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+Object.defineProperty(exports, "decodeHTML5Strict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+Object.defineProperty(exports, "decodeXMLStrict", { enumerable: true, get: function () { return decode_js_2.decodeXML; } });

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

@@ -0,0 +1,51 @@
+import { Node } from '../Node.js';
+/**
+ * Given an array of nodes, remove any member that is contained by another.
+ *
+ * @param nodes Nodes to filter.
+ * @returns Remaining nodes that aren't subtrees of each other.
+ */
+export declare function removeSubsets(nodes: Node[]): Node[];
+export declare const enum DocumentPosition {
+    DISCONNECTED = 1,
+    PRECEDING = 2,
+    FOLLOWING = 4,
+    CONTAINS = 8,
+    CONTAINED_BY = 16
+}
+/**
+ * Compare the position of one node against another node in any other document.
+ * The return value is a bitmask with the following values:
+ *
+ * Document order:
+ * > There is an ordering, document order, defined on all the nodes in the
+ * > document corresponding to the order in which the first character of the
+ * > XML representation of each node occurs in the XML representation of the
+ * > document after expansion of general entities. Thus, the document element
+ * > node will be the first node. Element nodes occur before their children.
+ * > Thus, document order orders element nodes in order of the occurrence of
+ * > their start-tag in the XML (after expansion of entities). The attribute
+ * > nodes of an element occur after the element and before its children. The
+ * > relative order of attribute nodes is implementation-dependent./
+ *
+ * Source:
+ * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
+ *
+ * @param nodeA The first node to use in the comparison
+ * @param nodeB The second node to use in the comparison
+ * @returns A bitmask describing the input nodes' relative position.
+ *
+ * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
+ * a description of these values.
+ */
+export declare function compareDocumentPosition(nodeA: Node, nodeB: Node): number;
+/**
+ * Sort an array of nodes based on their relative position in the document and
+ * remove any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
+ *
+ * @param nodes Array of DOM nodes.
+ * @returns Collection of unique nodes, sorted in document order.
+ */
+export declare function uniqueSort<T extends Node>(nodes: T[]): T[];
+//# sourceMappingURL=helpers.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/utils/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,IAAI,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CA6BnD;AAGD,0BAAkB,gBAAgB;IAC9B,YAAY,IAAI;IAChB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,QAAQ,IAAI;IACZ,YAAY,KAAK;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,MAAM,CA4CxE;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAc1D"}

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueSort = exports.compareDocumentPosition = exports.DocumentPosition = exports.removeSubsets = void 0;
+const Node_js_1 = require("../Node.js");
+/**
+ * Given an array of nodes, remove any member that is contained by another.
+ *
+ * @param nodes Nodes to filter.
+ * @returns Remaining nodes that aren't subtrees of each other.
+ */
+function removeSubsets(nodes) {
+    let idx = nodes.length;
+    /*
+     * Check if each node (or one of its ancestors) is already contained in the
+     * array.
+     */
+    while (--idx >= 0) {
+        const node = nodes[idx];
+        /*
+         * Remove the node if it is not unique.
+         * We are going through the array from the end, so we only
+         * have to check nodes that preceed the node under consideration in the array.
+         */
+        if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
+            nodes.splice(idx, 1);
+            continue;
+        }
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+            if (nodes.includes(ancestor)) {
+                nodes.splice(idx, 1);
+                break;
+            }
+        }
+    }
+    return nodes;
+}
+exports.removeSubsets = removeSubsets;
+// Source: http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
+var DocumentPosition;
+(function (DocumentPosition) {
+    DocumentPosition[DocumentPosition["DISCONNECTED"] = 1] = "DISCONNECTED";
+    DocumentPosition[DocumentPosition["PRECEDING"] = 2] = "PRECEDING";
+    DocumentPosition[DocumentPosition["FOLLOWING"] = 4] = "FOLLOWING";
+    DocumentPosition[DocumentPosition["CONTAINS"] = 8] = "CONTAINS";
+    DocumentPosition[DocumentPosition["CONTAINED_BY"] = 16] = "CONTAINED_BY";
+})(DocumentPosition || (exports.DocumentPosition = DocumentPosition = {}));
+/**
+ * Compare the position of one node against another node in any other document.
+ * The return value is a bitmask with the following values:
+ *
+ * Document order:
+ * > There is an ordering, document order, defined on all the nodes in the
+ * > document corresponding to the order in which the first character of the
+ * > XML representation of each node occurs in the XML representation of the
+ * > document after expansion of general entities. Thus, the document element
+ * > node will be the first node. Element nodes occur before their children.
+ * > Thus, document order orders element nodes in order of the occurrence of
+ * > their start-tag in the XML (after expansion of entities). The attribute
+ * > nodes of an element occur after the element and before its children. The
+ * > relative order of attribute nodes is implementation-dependent./
+ *
+ * Source:
+ * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
+ *
+ * @param nodeA The first node to use in the comparison
+ * @param nodeB The second node to use in the comparison
+ * @returns A bitmask describing the input nodes' relative position.
+ *
+ * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
+ * a description of these values.
+ */
+function compareDocumentPosition(nodeA, nodeB) {
+    const aParents = [];
+    const bParents = [];
+    if (nodeA === nodeB) {
+        return 0;
+    }
+    let current = (0, Node_js_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
+    while (current) {
+        aParents.unshift(current);
+        current = current.parent;
+    }
+    current = (0, Node_js_1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
+    while (current) {
+        bParents.unshift(current);
+        current = current.parent;
+    }
+    const maxIdx = Math.min(aParents.length, bParents.length);
+    let idx = 0;
+    while (idx < maxIdx && aParents[idx] === bParents[idx]) {
+        idx++;
+    }
+    if (idx === 0) {
+        return DocumentPosition.DISCONNECTED;
+    }
+    const sharedParent = aParents[idx - 1];
+    const siblings = sharedParent.children;
+    const aSibling = aParents[idx];
+    const bSibling = bParents[idx];
+    if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
+        if (sharedParent === nodeB) {
+            return DocumentPosition.FOLLOWING | DocumentPosition.CONTAINED_BY;
+        }
+        return DocumentPosition.FOLLOWING;
+    }
+    if (sharedParent === nodeA) {
+        return DocumentPosition.PRECEDING | DocumentPosition.CONTAINS;
+    }
+    return DocumentPosition.PRECEDING;
+}
+exports.compareDocumentPosition = compareDocumentPosition;
+/**
+ * Sort an array of nodes based on their relative position in the document and
+ * remove any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
+ *
+ * @param nodes Array of DOM nodes.
+ * @returns Collection of unique nodes, sorted in document order.
+ */
+function uniqueSort(nodes) {
+    nodes = nodes.filter((node, i, arr) => !arr.includes(node, i + 1));
+    nodes.sort((a, b) => {
+        const relative = compareDocumentPosition(a, b);
+        if (relative & DocumentPosition.PRECEDING) {
+            return -1;
+        }
+        else if (relative & DocumentPosition.FOLLOWING) {
+            return 1;
+        }
+        return 0;
+    });
+    return nodes;
+}
+exports.uniqueSort = uniqueSort;