@pokash/n8n-nodes-ksef 0.2.15 → 0.2.16

package/node_modules/@oozcitak/dom/lib/algorithm/TextAlgorithm.js

@@ -0,0 +1,226 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DOMImpl_1 = require("../dom/DOMImpl");
+var util_1 = require("../util");
+var DOMException_1 = require("../dom/DOMException");
+var CreateAlgorithm_1 = require("./CreateAlgorithm");
+var TreeAlgorithm_1 = require("./TreeAlgorithm");
+var CharacterDataAlgorithm_1 = require("./CharacterDataAlgorithm");
+var MutationAlgorithm_1 = require("./MutationAlgorithm");
+/**
+ * Returns node with its adjacent text and cdata node siblings.
+ *
+ * @param node - a node
+ * @param self - whether to include node itself
+ */
+function text_contiguousTextNodes(node, self) {
+    var _a;
+    if (self === void 0) { self = false; }
+    /**
+     * The contiguous Text nodes of a node node are node, node’s previous
+     * sibling Text node, if any, and its contiguous Text nodes, and node’s next
+     * sibling Text node, if any, and its contiguous Text nodes, avoiding any
+     * duplicates.
+     */
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = node;
+            while (currentNode && util_1.Guard.isTextNode(currentNode._previousSibling)) {
+                currentNode = currentNode._previousSibling;
+            }
+            return {
+                next: function () {
+                    if (currentNode && (!self && currentNode === node)) {
+                        if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
+                            currentNode = currentNode._nextSibling;
+                        }
+                        else {
+                            currentNode = null;
+                        }
+                    }
+                    if (currentNode === null) {
+                        return { done: true, value: null };
+                    }
+                    else {
+                        var result = { done: false, value: currentNode };
+                        if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
+                            currentNode = currentNode._nextSibling;
+                        }
+                        else {
+                            currentNode = null;
+                        }
+                        return result;
+                    }
+                }
+            };
+        },
+        _a;
+}
+exports.text_contiguousTextNodes = text_contiguousTextNodes;
+/**
+ * Returns node with its adjacent text node siblings.
+ *
+ * @param node - a node
+ * @param self - whether to include node itself
+ */
+function text_contiguousExclusiveTextNodes(node, self) {
+    var _a;
+    if (self === void 0) { self = false; }
+    /**
+     * The contiguous exclusive Text nodes of a node node are node, node’s
+     * previous sibling exclusive Text node, if any, and its contiguous
+     * exclusive Text nodes, and node’s next sibling exclusive Text node,
+     * if any, and its contiguous exclusive Text nodes, avoiding any duplicates.
+     */
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = node;
+            while (currentNode && util_1.Guard.isExclusiveTextNode(currentNode._previousSibling)) {
+                currentNode = currentNode._previousSibling;
+            }
+            return {
+                next: function () {
+                    if (currentNode && (!self && currentNode === node)) {
+                        if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
+                            currentNode = currentNode._nextSibling;
+                        }
+                        else {
+                            currentNode = null;
+                        }
+                    }
+                    if (currentNode === null) {
+                        return { done: true, value: null };
+                    }
+                    else {
+                        var result = { done: false, value: currentNode };
+                        if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
+                            currentNode = currentNode._nextSibling;
+                        }
+                        else {
+                            currentNode = null;
+                        }
+                        return result;
+                    }
+                }
+            };
+        },
+        _a;
+}
+exports.text_contiguousExclusiveTextNodes = text_contiguousExclusiveTextNodes;
+/**
+ * Returns the concatenation of the data of all the Text node descendants of
+ * node, in tree order.
+ *
+ * @param node - a node
+ */
+function text_descendantTextContent(node) {
+    /**
+     * The descendant text content of a node node is the concatenation of the
+     * data of all the Text node descendants of node, in tree order.
+     */
+    var contents = '';
+    var text = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, false, function (e) { return util_1.Guard.isTextNode(e); });
+    while (text !== null) {
+        contents += text._data;
+        text = TreeAlgorithm_1.tree_getNextDescendantNode(node, text, false, false, function (e) { return util_1.Guard.isTextNode(e); });
+    }
+    return contents;
+}
+exports.text_descendantTextContent = text_descendantTextContent;
+/**
+ * Splits data at the given offset and returns the remainder as a text
+ * node.
+ *
+ * @param node - a text node
+ * @param offset - the offset at which to split the nodes.
+ */
+function text_split(node, offset) {
+    var e_1, _a;
+    /**
+     * 1. Let length be node’s length.
+     * 2. If offset is greater than length, then throw an "IndexSizeError"
+     * DOMException.
+     */
+    var length = node._data.length;
+    if (offset > length) {
+        throw new DOMException_1.IndexSizeError();
+    }
+    /**
+     * 3. Let count be length minus offset.
+     * 4. Let new data be the result of substringing data with node node,
+     * offset offset, and count count.
+     * 5. Let new node be a new Text node, with the same node document as node.
+     * Set new node’s data to new data.
+     * 6. Let parent be node’s parent.
+     * 7. If parent is not null, then:
+     */
+    var count = length - offset;
+    var newData = CharacterDataAlgorithm_1.characterData_substringData(node, offset, count);
+    var newNode = CreateAlgorithm_1.create_text(node._nodeDocument, newData);
+    var parent = node._parent;
+    if (parent !== null) {
+        /**
+         * 7.1. Insert new node into parent before node’s next sibling.
+         */
+        MutationAlgorithm_1.mutation_insert(newNode, parent, node._nextSibling);
+        try {
+            /**
+             * 7.2. For each live range whose start node is node and start offset is
+             * greater than offset, set its start node to new node and decrease its
+             * start offset by offset.
+             * 7.3. For each live range whose end node is node and end offset is greater
+             * than offset, set its end node to new node and decrease its end offset
+             * by offset.
+             * 7.4. For each live range whose start node is parent and start offset is
+             * equal to the index of node plus 1, increase its start offset by 1.
+             * 7.5. For each live range whose end node is parent and end offset is equal
+             * to the index of node plus 1, increase its end offset by 1.
+             */
+            for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var range = _c.value;
+                if (range._start[0] === node && range._start[1] > offset) {
+                    range._start[0] = newNode;
+                    range._start[1] -= offset;
+                }
+                if (range._end[0] === node && range._end[1] > offset) {
+                    range._end[0] = newNode;
+                    range._end[1] -= offset;
+                }
+                var index = TreeAlgorithm_1.tree_index(node);
+                if (range._start[0] === parent && range._start[1] === index + 1) {
+                    range._start[1]++;
+                }
+                if (range._end[0] === parent && range._end[1] === index + 1) {
+                    range._end[1]++;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    /**
+     * 8. Replace data with node node, offset offset, count count, and data
+     * the empty string.
+     * 9. Return new node.
+     */
+    CharacterDataAlgorithm_1.characterData_replaceData(node, offset, count, '');
+    return newNode;
+}
+exports.text_split = text_split;
+//# sourceMappingURL=TextAlgorithm.js.map

package/node_modules/@oozcitak/dom/lib/algorithm/TextAlgorithm.js.map

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

package/node_modules/@oozcitak/dom/lib/algorithm/TraversalAlgorithm.d.ts

@@ -0,0 +1,8 @@
+import { FilterResult, NodeIterator, Node, TreeWalker } from "../dom/interfaces";
+/**
+ * Applies the filter to the given node and returns the result.
+ *
+ * @param traverser - the `NodeIterator` or `TreeWalker` instance
+ * @param node - the node to filter
+ */
+export declare function traversal_filter(traverser: NodeIterator | TreeWalker, node: Node): FilterResult;

package/node_modules/@oozcitak/dom/lib/algorithm/TraversalAlgorithm.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var interfaces_1 = require("../dom/interfaces");
+var DOMException_1 = require("../dom/DOMException");
+/**
+ * Applies the filter to the given node and returns the result.
+ *
+ * @param traverser - the `NodeIterator` or `TreeWalker` instance
+ * @param node - the node to filter
+ */
+function traversal_filter(traverser, node) {
+    /**
+     * 1. If traverser’s active flag is set, then throw an "InvalidStateError"
+     * DOMException.
+     */
+    if (traverser._activeFlag) {
+        throw new DOMException_1.InvalidStateError();
+    }
+    /**
+     * 2. Let n be node’s nodeType attribute value − 1.
+     */
+    var n = node._nodeType - 1;
+    /**
+     * 3. If the nth bit (where 0 is the least significant bit) of traverser’s
+     * whatToShow is not set, then return FILTER_SKIP.
+     */
+    var mask = 1 << n;
+    if ((traverser.whatToShow & mask) === 0) {
+        return interfaces_1.FilterResult.Skip;
+    }
+    /**
+     * 4. If traverser’s filter is null, then return FILTER_ACCEPT.
+     */
+    if (!traverser.filter) {
+        return interfaces_1.FilterResult.Accept;
+    }
+    /**
+     * 5. Set traverser’s active flag.
+     */
+    traverser._activeFlag = true;
+    /**
+     * 6. Let result be the return value of call a user object’s operation with
+     * traverser’s filter, "acceptNode", and « node ». If this throws an
+     * exception, then unset traverser’s active flag and rethrow the exception.
+     */
+    var result = interfaces_1.FilterResult.Reject;
+    try {
+        result = traverser.filter.acceptNode(node);
+    }
+    catch (err) {
+        traverser._activeFlag = false;
+        throw err;
+    }
+    /**
+     * 7. Unset traverser’s active flag.
+     * 8. Return result.
+     */
+    traverser._activeFlag = false;
+    return result;
+}
+exports.traversal_filter = traversal_filter;
+//# sourceMappingURL=TraversalAlgorithm.js.map

package/node_modules/@oozcitak/dom/lib/algorithm/TraversalAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraversalAlgorithm.js","sourceRoot":"","sources":["../../src/algorithm/TraversalAlgorithm.ts"],"names":[],"mappings":";;AAAA,gDAAgF;AAChF,oDAAuD;AAEvD;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,SAAoC,EACnE,IAAU;IACV;;;OAGG;IACH,IAAI,SAAS,CAAC,WAAW,EAAE;QACzB,MAAM,IAAI,gCAAiB,EAAE,CAAA;KAC9B;IAED;;OAEG;IACH,IAAM,CAAC,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC,CAAA;IAE5B;;;OAGG;IACH,IAAM,IAAI,GAAG,CAAC,IAAI,CAAC,CAAA;IACnB,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE;QACvC,OAAO,yBAAY,CAAC,IAAI,CAAA;KACzB;IAED;;OAEG;IACH,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;QACrB,OAAO,yBAAY,CAAC,MAAM,CAAA;KAC3B;IAED;;OAEG;IACH,SAAS,CAAC,WAAW,GAAG,IAAI,CAAA;IAE5B;;;;OAIG;IACH,IAAI,MAAM,GAAG,yBAAY,CAAC,MAAM,CAAA;IAChC,IAAI;QACF,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;KAC3C;IAAC,OAAO,GAAG,EAAE;QACZ,SAAS,CAAC,WAAW,GAAG,KAAK,CAAA;QAC7B,MAAM,GAAG,CAAA;KACV;IAED;;;OAGG;IACH,SAAS,CAAC,WAAW,GAAG,KAAK,CAAA;IAC7B,OAAO,MAAM,CAAA;AACf,CAAC;AAvDD,4CAuDC"}

package/node_modules/@oozcitak/dom/lib/algorithm/TreeAlgorithm.d.ts

@@ -0,0 +1,268 @@
+import { Element, Node } from "../dom/interfaces";
+/**
+ * Returns the first descendant node of the tree rooted at `node` in
+ * depth-first pre-order.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param shadow - whether to visit shadow tree nodes
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getFirstDescendantNode(node: Node, self?: boolean, shadow?: boolean, filter?: ((childNode: Node) => boolean)): Node | null;
+/**
+ * Returns the next descendant node of the tree rooted at `node` in
+ * depth-first pre-order.
+ *
+ * @param node - root node of the tree
+ * @param currentNode - current descendant node
+ * @param self - whether to include `node` in traversal
+ * @param shadow - whether to visit shadow tree nodes
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getNextDescendantNode(node: Node, currentNode: Node, self?: boolean, shadow?: boolean, filter?: ((childNode: Node) => boolean)): Node | null;
+/**
+ * Traverses through all descendant nodes of the tree rooted at
+ * `node` in depth-first pre-order.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param shadow - whether to visit shadow tree nodes
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getDescendantNodes(node: Node, self?: boolean, shadow?: boolean, filter?: ((childNode: Node) => boolean)): Iterable<Node>;
+/**
+ * Traverses through all descendant element nodes of the tree rooted at
+ * `node` in depth-first preorder.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param shadow - whether to visit shadow tree nodes
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getDescendantElements(node: Node, self?: boolean, shadow?: boolean, filter?: ((childNode: Element) => boolean)): Iterable<Element>;
+/**
+ * Traverses through all sibling nodes of `node`.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getSiblingNodes(node: Node, self?: boolean, filter?: ((childNode: Node) => boolean)): Iterable<Node>;
+/**
+ * Gets the first ancestor of `node` in reverse tree order.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getFirstAncestorNode(node: Node, self?: boolean, filter?: ((ancestorNode: Node) => boolean)): Node | null;
+/**
+ * Gets the first ancestor of `node` in reverse tree order.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getNextAncestorNode(node: Node, currentNode: Node, self?: boolean, filter?: ((ancestorNode: Node) => boolean)): Node | null;
+/**
+ * Traverses through all ancestor nodes `node` in reverse tree order.
+ *
+ * @param node - root node of the tree
+ * @param self - whether to include `node` in traversal
+ * @param filter - a function to filter nodes
+ */
+export declare function tree_getAncestorNodes(node: Node, self?: boolean, filter?: ((ancestorNode: Node) => boolean)): Iterable<Node>;
+/**
+ * Returns the common ancestor of the given nodes.
+ *
+ * @param nodeA - a node
+ * @param nodeB - a node
+ */
+export declare function tree_getCommonAncestor(nodeA: Node, nodeB: Node): Node | null;
+/**
+ * Returns the node following `node` in depth-first preorder.
+ *
+ * @param root - root of the subtree
+ * @param node - a node
+ */
+export declare function tree_getFollowingNode(root: Node, node: Node): Node | null;
+/**
+ * Returns the node preceding `node` in depth-first preorder.
+ *
+ * @param root - root of the subtree
+ * @param node - a node
+ */
+export declare function tree_getPrecedingNode(root: Node, node: Node): Node | null;
+/**
+ * Determines if the node tree is constrained. A node tree is
+ * constrained as follows, expressed as a relationship between the
+ * type of node and its allowed children:
+ *  - Document (In tree order)
+ *    * Zero or more nodes each of which is ProcessingInstruction
+ *      or Comment.
+ *    * Optionally one DocumentType node.
+ *    * Zero or more nodes each of which is ProcessingInstruction
+ *      or Comment.
+ *    * Optionally one Element node.
+ *    * Zero or more nodes each of which is ProcessingInstruction
+ *      or Comment.
+ *  - DocumentFragment, Element
+ *    * Zero or more nodes each of which is Element, Text,
+ *      ProcessingInstruction, or Comment.
+ *  - DocumentType, Text, ProcessingInstruction, Comment
+ *    * None.
+ *
+ * @param node - the root of the tree
+ */
+export declare function tree_isConstrained(node: Node): boolean;
+/**
+ * Returns the length of a node.
+ *
+ * @param node - a node to check
+ */
+export declare function tree_nodeLength(node: Node): number;
+/**
+ * Determines if a node is empty.
+ *
+ * @param node - a node to check
+ */
+export declare function tree_isEmpty(node: Node): boolean;
+/**
+ * Returns the root node of a tree. The root of an object is itself,
+ * if its parent is `null`, or else it is the root of its parent.
+ * The root of a tree is any object participating in that tree
+ * whose parent is `null`.
+ *
+ * @param node - a node of the tree
+ * @param shadow - `true` to return shadow-including root, otherwise
+ * `false`
+ */
+export declare function tree_rootNode(node: Node, shadow?: boolean): Node;
+/**
+ * Determines whether `other` is a descendant of `node`. An object
+ * A is called a descendant of an object B, if either A is a child
+ * of B or A is a child of an object C that is a descendant of B.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ * @param self - if `true`, traversal includes `node` itself
+ * @param shadow - if `true`, traversal includes the
+ * node's and its descendant's shadow trees as well.
+ */
+export declare function tree_isDescendantOf(node: Node, other: Node, self?: boolean, shadow?: boolean): boolean;
+/**
+ * Determines whether `other` is an ancestor of `node`. An object A
+ * is called an ancestor of an object B if and only if B is a
+ * descendant of A.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ * @param self - if `true`, traversal includes `node` itself
+ * @param shadow - if `true`, traversal includes the
+ * node's and its descendant's shadow trees as well.
+ */
+export declare function tree_isAncestorOf(node: Node, other: Node, self?: boolean, shadow?: boolean): boolean;
+/**
+ * Determines whether `other` is a host-including ancestor of `node`. An
+ * object A is a host-including inclusive ancestor of an object B, if either
+ * A is an inclusive ancestor of B, or if B’s root has a non-null host and
+ * A is a host-including inclusive ancestor of B’s root’s host.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ * @param self - if `true`, traversal includes `node` itself
+ */
+export declare function tree_isHostIncludingAncestorOf(node: Node, other: Node, self?: boolean): boolean;
+/**
+ * Determines whether `other` is a sibling of `node`. An object A is
+ * called a sibling of an object B, if and only if B and A share
+ * the same non-null parent.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ * @param self - if `true`, traversal includes `node` itself
+ */
+export declare function tree_isSiblingOf(node: Node, other: Node, self?: boolean): boolean;
+/**
+ * Determines whether `other` is preceding `node`. An object A is
+ * preceding an object B if A and B are in the same tree and A comes
+ * before B in tree order.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ */
+export declare function tree_isPreceding(node: Node, other: Node): boolean;
+/**
+ * Determines whether `other` is following `node`. An object A is
+ * following an object B if A and B are in the same tree and A comes
+ * after B in tree order.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ */
+export declare function tree_isFollowing(node: Node, other: Node): boolean;
+/**
+ * Determines whether `other` is the parent node of `node`.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ */
+export declare function tree_isParentOf(node: Node, other: Node): boolean;
+/**
+ * Determines whether `other` is a child node of `node`.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ */
+export declare function tree_isChildOf(node: Node, other: Node): boolean;
+/**
+ * Returns the previous sibling node of `node` or null if it has no
+ * preceding sibling.
+ *
+ * @param node
+ */
+export declare function tree_previousSibling(node: Node): Node | null;
+/**
+ * Returns the next sibling node of `node` or null if it has no
+ * following sibling.
+ *
+ * @param node
+ */
+export declare function tree_nextSibling(node: Node): Node | null;
+/**
+ * Returns the first child node of `node` or null if it has no
+ * children.
+ *
+ * @param node
+ */
+export declare function tree_firstChild(node: Node): Node | null;
+/**
+ * Returns the last child node of `node` or null if it has no
+ * children.
+ *
+ * @param node
+ */
+export declare function tree_lastChild(node: Node): Node | null;
+/**
+ * Returns the zero-based index of `node` when counted preorder in
+ * the tree rooted at `root`. Returns `-1` if `node` is not in
+ * the tree.
+ *
+ * @param node - the node to get the index of
+ */
+export declare function tree_treePosition(node: Node): number;
+/**
+ * Determines the index of `node`. The index of an object is its number of
+ * preceding siblings, or 0 if it has none.
+ *
+ * @param node - a node
+ * @param other - the node to check
+ */
+export declare function tree_index(node: Node): number;
+/**
+ * Retargets an object against another object.
+ *
+ * @param a - an object to retarget
+ * @param b - an object to retarget against
+ */
+export declare function tree_retarget(a: any, b: any): any;