@helm2/poc_jenki_rce 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2009, Squish Tech, LLC. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

package/Makefile

@@ -0,0 +1,18 @@
+
+target=./build/Release/xmljs.node
+
+all: $(target)
+
+build/:
+	node-gyp configure
+
+$(target): build/ src/*.cc src/*.h
+	node-gyp build
+
+clean:
+	rm -rf build
+
+test: clean $(target)
+	npm test
+
+.PHONY: test clean

package/README.md

@@ -0,0 +1,52 @@
+# Libxmljs2
+
+LibXML bindings for [node.js](http://nodejs.org/)
+This package was forked as the original one is fairly unmaintained.
+
+```javascript
+var libxmljs = require('libxmljs2');
+var xml =
+  '<?xml version="1.0" encoding="UTF-8"?>' +
+  '<root>' +
+  '<child foo="bar">' +
+  '<grandchild baz="fizbuzz">grandchild content</grandchild>' +
+  '</child>' +
+  '<sibling>with content!</sibling>' +
+  '</root>';
+
+var xmlDoc = libxmljs.parseXml(xml);
+
+// xpath queries
+var gchild = xmlDoc.get('//grandchild');
+
+console.log(gchild.text()); // prints "grandchild content"
+
+var children = xmlDoc.root().childNodes();
+var child = children[0];
+
+console.log(child.attr('foo').value()); // prints "bar"
+```
+
+## Support
+
+- Docs - [http://github.com/marudor/libxmljs2/wiki](http://github.com/marudor/libxmljs2/wiki)
+
+## API and Examples
+
+Check out the wiki [http://github.com/marudor/libxmljs2/wiki](https://github.com/marudor/libxmljs2/wiki).
+
+See the [examples](https://github.com/marudor/libxmljs2/tree/main/examples) folder.
+
+## Installation via [npm](https://npmjs.org)
+
+```shell
+npm install libxmljs2
+```
+
+## Contribute
+
+Start by checking out the [open issues](https://github.com/marudor/libxmljs2/issues?labels=&page=1&state=open). Specifically the [desired feature](https://github.com/marudor/libxmljs2/issues?labels=desired+feature&page=1&state=open) ones.
+
+### Requirements
+
+Make sure you have met the requirements for [node-gyp](https://github.com/TooTallNate/node-gyp#installation). You DO NOT need to manually install node-gyp; it comes bundled with node.

package/binding.gyp

@@ -0,0 +1,81 @@
+{
+    "targets": [
+        {
+            "target_name": "xmljs",
+            "product_extension": "node",
+            "type": "shared_library",
+            "include_dirs": ["vendor/libxml/include", "<!(node -e \"require('nan')\")"],
+            "cflags": ["-Wall"],
+            "xcode_settings": {"OTHER_CFLAGS": ["-Wall"]},
+            "win_delay_load_hook": "true",
+            "defines": ["LIBXML_XINCLUDE_ENABLED", "LIBXML_SCHEMATRON_ENABLED", "BUILDING_NODE_EXTENSION"],
+            "sources": [
+                "src/libxmljs.cc",
+                "src/xml_attribute.cc",
+                "src/xml_document.cc",
+                "src/xml_element.cc",
+                "src/xml_comment.cc",
+                "src/xml_namespace.cc",
+                "src/xml_node.cc",
+                "src/xml_sax_parser.cc",
+                "src/xml_syntax_error.cc",
+                "src/xml_textwriter.cc",
+                "src/xml_text.cc",
+                "src/xml_pi.cc",
+                "src/xml_xpath_context.cc",
+                "vendor/libxml/buf.c",
+                "vendor/libxml/catalog.c",
+                "vendor/libxml/chvalid.c",
+                "vendor/libxml/dict.c",
+                "vendor/libxml/encoding.c",
+                "vendor/libxml/entities.c",
+                "vendor/libxml/error.c",
+                "vendor/libxml/globals.c",
+                "vendor/libxml/hash.c",
+                "vendor/libxml/HTMLparser.c",
+                "vendor/libxml/HTMLtree.c",
+                "vendor/libxml/legacy.c",
+                "vendor/libxml/list.c",
+                "vendor/libxml/parser.c",
+                "vendor/libxml/parserInternals.c",
+                "vendor/libxml/pattern.c",
+                "vendor/libxml/relaxng.c",
+                "vendor/libxml/schematron.c",
+                "vendor/libxml/SAX2.c",
+                "vendor/libxml/SAX.c",
+                "vendor/libxml/tree.c",
+                "vendor/libxml/threads.c",
+                "vendor/libxml/uri.c",
+                "vendor/libxml/valid.c",
+                "vendor/libxml/xinclude.c",
+                "vendor/libxml/xlink.c",
+                "vendor/libxml/xmlIO.c",
+                "vendor/libxml/xmlmemory.c",
+                "vendor/libxml/xmlmodule.c",
+                "vendor/libxml/xmlreader.c",
+                "vendor/libxml/xmlregexp.c",
+                "vendor/libxml/xmlsave.c",
+                "vendor/libxml/xmlschemas.c",
+                "vendor/libxml/xmlschemastypes.c",
+                "vendor/libxml/xmlstring.c",
+                "vendor/libxml/xmlunicode.c",
+                "vendor/libxml/xmlwriter.c",
+                "vendor/libxml/xpath.c",
+                "vendor/libxml/xpointer.c",
+            ],
+            "conditions": [
+                [
+                    'OS=="mac"',
+                    {
+                        # node-gyp 2.x doesn't add this anymore
+                        # https://github.com/TooTallNate/node-gyp/pull/612
+                        "xcode_settings": {
+                            "CLANG_CXX_LANGUAGE_STANDARD": "c++14",
+                            "OTHER_LDFLAGS": ["-undefined dynamic_lookup"],
+                        },
+                    },
+                ]
+            ],
+        }
+    ]
+}

package/index.d.ts

@@ -0,0 +1,273 @@
+import { EventEmitter } from 'events';
+
+export const version: string;
+export const libxml_version: string;
+export const libxml_parser_version: string;
+
+interface StringMap {
+  [key: string]: string;
+}
+
+interface ParserOptions {
+  recover?: boolean;
+  noent?: boolean;
+  dtdload?: boolean;
+  doctype?: boolean;
+  dtdattr?: any;
+  dtdvalid?: boolean;
+  noerror?: boolean;
+  errors?: boolean;
+  nowarning?: boolean;
+  warnings?: boolean;
+  pedantic?: boolean;
+  noblanks?: boolean;
+  blanks?: boolean;
+  sax1?: boolean;
+  xinclude?: boolean;
+  nonet?: boolean;
+  net?: boolean;
+  nodict?: boolean;
+  dict?: boolean;
+  nsclean?: boolean;
+  implied?: boolean;
+  nocdata?: boolean;
+  cdata?: boolean;
+  noxincnode?: boolean;
+  compact?: boolean;
+  old?: boolean;
+  nobasefix?: boolean;
+  basefix?: boolean;
+  huge?: boolean;
+  oldsax?: boolean;
+  ignore_enc?: boolean;
+  big_lines?: boolean;
+  baseUrl?: string;
+}
+
+export function parseXml(source: string, options?: ParserOptions): Document;
+export function parseXmlString(
+  source: string,
+  options?: ParserOptions
+): Document;
+
+export function parseHtml(source: string, options?: ParserOptions): Document;
+export function parseHtmlString(
+  source: string,
+  options?: ParserOptions
+): Document;
+export function parseHtmlFragment(
+  source: string,
+  options?: ParserOptions
+): Document;
+
+export function memoryUsage(): number;
+export function nodeCount(): number;
+
+export class Document {
+  /**
+   * Create a new XML Document
+   * @param version XML document version, defaults to 1.0
+   * @param encoding Encoding, defaults to utf8
+   */
+  constructor(version?: string, encoding?: string);
+
+  errors: SyntaxError[];
+  validationErrors: ValidationError[];
+
+  child(idx: number): Node | null;
+  childNodes(): Node[];
+  encoding(): string;
+  encoding(enc: string): this;
+  find<T extends Node = Node>(xpath: string, ns_uri?: string): T[];
+  find<T extends Node = Node>(xpath: string, namespaces: StringMap): T[];
+  get<T extends Node = Node>(xpath: string, ns_uri?: string): T | null;
+  get<T extends Node = Node>(xpath: string, namespaces: StringMap): T | null;
+  node(name: string, content?: string): Element;
+  root(): Element | null;
+  root(newRoot: Node): Node;
+  toString(formatted?: boolean): string;
+  type(): 'document';
+  validate(xsdDoc: Document): boolean;
+  schematronValidate(schemaDoc: Document): boolean;
+  version(): string;
+  setDtd(name: string, ext: string, sys: string): void;
+  getDtd(): {
+    name: string;
+    externalId: string;
+    systemId: string;
+  };
+}
+
+export class Node {
+  doc(): Document;
+  parent(): Element | Document;
+  /**
+   * The namespace or null in case of comment nodes
+   */
+  namespace(): Namespace | null;
+
+  /**
+   * An array of namespaces that the object belongs to.
+   *
+   * @param local If it is true, only the namespace declarations local to this
+   *              node are returned, rather than all of the namespaces in scope
+   *              at this node (including the ones from the parent elements).
+   */
+  namespaces(local?: boolean): Namespace[];
+
+  prevSibling(): Node | null;
+  nextSibling(): Node | null;
+
+  line(): number;
+  type(): 'comment' | 'element' | 'text' | 'attribute' | 'pi';
+  remove(): this;
+  clone(): this;
+  /**
+   * Serializes the node to a string. The string will contain all contents of the node formatted as XML and can be used to print the node.
+   */
+  toString(
+    format?:
+      | boolean
+      | {
+          declaration: boolean;
+          selfCloseEmpty: boolean;
+          whitespace: boolean;
+          type: 'xml' | 'html' | 'xhtml';
+          encoding?:
+            | 'HTML'
+            | 'ASCII'
+            | 'UTF-8'
+            | 'UTF-16'
+            | 'ISO-Latin-1'
+            | 'ISO-8859-1';
+        }
+  ): string;
+}
+
+export class Element extends Node {
+  constructor(doc: Document, name: string, content?: string);
+  node(name: string, content?: string): Element;
+  name(): string;
+  name(newName: string): this;
+  text(): string;
+  text(newText: string): this;
+  attr(name: string): Attribute | null; //getter
+  attr(name: string, value: string): this; //setter
+  attr(attrObject: StringMap): this; //setter using stringMap
+  attrs(): Attribute[];
+  cdata(data: string): this;
+
+  doc(): Document;
+  child(idx: number): Node | null;
+  childNodes(): Node[];
+
+  /**
+   * @return The original element, not the child.
+   */
+  addChild(child: Node): this;
+
+  prevElement(): Element | null;
+  nextElement(): Element | null;
+  addNextSibling<T extends Node>(siblingNode: T): T;
+  addPrevSibling<T extends Node>(siblingNode: T): T;
+
+  find<T extends Node = Node>(xpath: string, ns_uri?: string): T[];
+  find<T extends Node = Node>(xpath: string, namespaces: StringMap): T[];
+  get<T extends Node = Node>(xpath: string, ns_uri?: string): T | null;
+  get<T extends Node = Node>(xpath: string, namespaces: StringMap): T | null;
+
+  defineNamespace(prefixOrHref: string, hrefInCaseOfPrefix?: string): Namespace;
+
+  namespace(): Namespace | null;
+  namespace(newNamespace: Namespace): this;
+  namespace(prefixOrHref: string, hrefInCaseOfPrefix?: string): this;
+
+  replace(replacement: string): string;
+  replace<T extends Node>(replacement: T): T;
+
+  path(): string;
+}
+
+declare class Attribute extends Node {
+  name(): string;
+  node(): Element;
+  value(): string;
+  value(newValue: string): Attribute;
+  namespace(): Namespace | null;
+}
+
+export class Text extends Node {
+  constructor(doc: Document, content: string);
+
+  addNextSibling<T extends Node>(siblingNode: T): T;
+  addPrevSibling<T extends Node>(siblingNode: T): T;
+  nextElement(): Element | null;
+  prevElement(): Element | null;
+
+  replace(replacement: string): string;
+  replace<T extends Node>(replacement: T): T;
+
+  text(): string;
+  text(newContent: string): this;
+}
+
+export class Comment extends Node {
+  constructor(doc: Document, content?: string);
+
+  text(): string;
+  text(newContent: string): this;
+}
+
+export class ProcessingInstruction extends Node {
+  constructor(doc: Document, name: string, content?: string);
+
+  name(): string;
+  name(newName: string): this;
+
+  text(): string;
+  text(newContent: string): this;
+}
+
+export class Namespace {
+  href(): string;
+  prefix(): string;
+}
+
+export class SaxParser extends EventEmitter {
+  constructor();
+  parseString(source: string): boolean;
+}
+
+export class SaxPushParser extends EventEmitter {
+  constructor();
+  push(source: string): boolean;
+}
+
+export interface SyntaxError extends Error {
+  domain: number | null;
+  code: number | null;
+  level: number | null;
+  file: string | null;
+  line: number | null;
+  /**
+   * 1-based column number, 0 if not applicable/available.
+   */
+  column: number;
+
+  str1: number | null;
+  str2: number | null;
+  str3: number | null;
+  int1: number | null;
+}
+
+export interface ValidationError extends Error {
+  domain: number | null;
+  code: number | null;
+  level: number | null;
+
+  line: number | null;
+  /**
+   * 1-based column number, 0 if not applicable/available.
+   */
+  column: number;
+}

package/index.js

@@ -0,0 +1,45 @@
+// js acts as a wrapper to the c++ bindings
+// prefer to do error handling and other abstrctions in the
+// js layer and only go to c++ when we need to hit libxml
+const bindings = require('./lib/bindings');
+
+// document parsing for backwards compat
+const Document = require('./lib/document');
+
+// / parse an xml string and return a Document
+module.exports.parseXml = Document.fromXml;
+
+// / parse an html string and return a Document
+module.exports.parseHtml = Document.fromHtml;
+module.exports.parseHtmlFragment = Document.fromHtmlFragment;
+
+// constants
+module.exports.version = require('./package.json').version;
+module.exports.libxml_version = bindings.libxml_version;
+module.exports.libxml_parser_version = bindings.libxml_parser_version;
+module.exports.libxml_debug_enabled = bindings.libxml_debug_enabled;
+module.exports.features = bindings.features;
+
+// lib exports
+module.exports.Comment = bindings.Comment;
+module.exports.Document = Document;
+module.exports.Element = require('./lib/element');
+module.exports.ProcessingInstruction = bindings.ProcessingInstruction;
+module.exports.Text = bindings.Text;
+
+// Compatibility synonyms
+Document.fromXmlString = Document.fromXml;
+Document.fromHtmlString = Document.fromHtml;
+module.exports.parseXmlString = module.exports.parseXml;
+module.exports.parseHtmlString = module.exports.parseHtml;
+
+const sax_parser = require('./lib/sax_parser');
+
+module.exports.SaxParser = sax_parser.SaxParser;
+module.exports.SaxPushParser = sax_parser.SaxPushParser;
+
+module.exports.memoryUsage = bindings.xmlMemUsed;
+
+module.exports.nodeCount = bindings.xmlNodeCount;
+
+module.exports.TextWriter = bindings.TextWriter;

package/lib/bindings.js

@@ -0,0 +1 @@
+module.exports = require('bindings')('xmljs');

package/lib/document.js

@@ -0,0 +1,118 @@
+/* eslint-disable no-underscore-dangle */
+const bindings = require('./bindings');
+
+const Element = require('./element');
+
+function assertRoot(doc) {
+  if (!doc.root()) {
+    throw new Error('Document has no root element');
+  }
+}
+
+const Document = bindings.Document;
+
+Document.prototype = bindings.Document.prototype;
+
+// / add a child node to the document
+// / this will set the document root
+Document.prototype.node = function node(name, content) {
+  return this.root(Element(this, name, content));
+};
+
+// / xpath search
+// / @return array of matching elements
+Document.prototype.find = function find(xpath, ns_uri) {
+  assertRoot(this);
+
+  return this.root().find(xpath, ns_uri);
+};
+
+// / xpath search
+// / @return first element matching
+Document.prototype.get = function get(xpath, ns_uri) {
+  assertRoot(this);
+
+  return this.root().get(xpath, ns_uri);
+};
+
+// / @return a given child
+Document.prototype.child = function child(id) {
+  if (id === undefined || typeof id !== 'number') {
+    throw new Error('id argument required for #child');
+  }
+
+  assertRoot(this);
+
+  return this.root().child(id);
+};
+
+// / @return an Array of child nodes of the document root
+Document.prototype.childNodes = function childNodes() {
+  assertRoot(this);
+
+  return this.root().childNodes();
+};
+
+Document.prototype.setDtd = function setDtd(name, ext, sys) {
+  if (!name) {
+    throw new Error('Must pass in a DTD name');
+  } else if (typeof name !== 'string') {
+    throw new Error('Must pass in a valid DTD name');
+  }
+
+  const params = [name];
+
+  if (typeof ext !== 'undefined') {
+    params.push(ext);
+  }
+  if (ext && typeof sys !== 'undefined') {
+    params.push(sys);
+  }
+
+  return this._setDtd(...params);
+};
+
+// / @return array of namespaces in document
+Document.prototype.namespaces = function namespaces() {
+  assertRoot(this);
+
+  return this.root().namespaces();
+};
+
+module.exports = Document;
+
+// / parse a string into a html document
+// / @param string html string to parse
+// / @param {encoding:string, baseUrl:string} opts html string to parse
+// / @return a Document
+module.exports.fromHtml = function fromHtml(string, opts = {}) {
+  // if for some reason user did not specify an object for the options
+  if (typeof opts !== 'object') {
+    throw new Error('fromHtml options must be an object');
+  }
+
+  return bindings.fromHtml(string, opts);
+};
+
+// / parse a string into a html document fragment
+// / @param string html string to parse
+// / @param {encoding:string, baseUrl:string} opts html string to parse
+// / @return a Document
+module.exports.fromHtmlFragment = function fromHtmlFragment(string, opts = {}) {
+  // if for some reason user did not specify an object for the options
+  if (typeof opts !== 'object') {
+    throw new Error('fromHtmlFragment options must be an object');
+  }
+
+  opts.doctype = false;
+  opts.implied = false;
+
+  return bindings.fromHtml(string, opts);
+};
+
+// / parse a string into a xml document
+// / @param string xml string to parse
+// / @return a Document
+module.exports.fromXml = function fromXml(string, options = {}) {
+  return bindings.fromXml(string, options);
+};

package/lib/element.js

@@ -0,0 +1,82 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-param-reassign */
+const bindings = require('./bindings');
+
+// / create a new element on the given document
+// / @param doc the Document to create the element for
+// / @param name the element name
+// / @param {String} [content] element content
+// / @constructor
+function Element(doc, name, content) {
+  if (!doc) {
+    throw new Error('document argument required');
+  } else if (!(doc instanceof bindings.Document)) {
+    throw new Error('document argument must be an instance of Document');
+  } else if (!name) {
+    throw new Error('name argument required');
+  }
+
+  return new bindings.Element(doc, name, content);
+}
+
+Element.prototype = bindings.Element.prototype;
+
+Element.prototype.attr = function attr(...args) {
+  if (args.length === 1) {
+    const arg = args[0];
+
+    if (typeof arg === 'object') {
+      // object setter
+      // iterate keys/value to set attributes
+      for (const k in arg) {
+        this._attr(k, arg[k]);
+      }
+
+      return this;
+    } else if (typeof arg === 'string') {
+      // getter
+      return this._attr(arg);
+    }
+  } else if (args.length === 2) {
+    // 2 arg setter
+    const name = args[0];
+    const value = args[1];
+
+    this._attr(name, value);
+
+    return this;
+  }
+};
+
+// / helper method to attach a new node to this element
+// / @param name the element name
+// / @param {String} [content] element content
+Element.prototype.node = function node(name, content) {
+  const elem = Element(this.doc(), name, content);
+
+  this.addChild(elem);
+
+  return elem;
+};
+
+Element.prototype.get = function get(...args) {
+  const res = this.find(...args);
+
+  if (Array.isArray(res)) {
+    return res[0];
+  }
+
+  return res;
+};
+
+Element.prototype.defineNamespace = function defineNamespace(prefix, href) {
+  // if no prefix specified
+  if (!href) {
+    href = prefix;
+    prefix = null;
+  }
+
+  return new bindings.Namespace(this, prefix, href);
+};
+
+module.exports = Element;