@jacfrost/autopm 0.0.1

package/node_modules/linkedom/cjs/shared/parse-from-string.js

@@ -0,0 +1,125 @@
+'use strict';
+const HTMLParser2 = require('htmlparser2');
+
+const {ELEMENT_NODE, SVG_NAMESPACE} = require('./constants.js');
+const {CUSTOM_ELEMENTS, PREV, END, VALUE} = require('./symbols.js');
+const {keys} = require('./object.js');
+
+const {knownBoundaries, knownSiblings} = require('./utils.js');
+const {attributeChangedCallback, connectedCallback} = require('../interface/custom-element-registry.js');
+
+const {Parser} = HTMLParser2;
+
+// import {Mime} from './mime.js';
+// const VOID_SOURCE = Mime['text/html'].voidElements.source.slice(4, -2);
+// const VOID_ELEMENTS = new RegExp(`<(${VOID_SOURCE})([^>]*?)>`, 'gi');
+// const VOID_SANITIZER = (_, $1, $2) => `<${$1}${$2}${/\/$/.test($2) ? '' : ' /'}>`;
+// const voidSanitizer = html => html.replace(VOID_ELEMENTS, VOID_SANITIZER);
+
+let notParsing = true;
+
+const append = (self, node, active) => {
+  const end = self[END];
+  node.parentNode = self;
+  knownBoundaries(end[PREV], node, end);
+  if (active && node.nodeType === ELEMENT_NODE)
+    connectedCallback(node);
+  return node;
+};
+
+const attribute = (element, end, attribute, value, active) => {
+  attribute[VALUE] = value;
+  attribute.ownerElement = element;
+  knownSiblings(end[PREV], attribute, end);
+  if (attribute.name === 'class')
+    element.className = value;
+  if (active)
+    attributeChangedCallback(element, attribute.name, null, value);
+};
+
+const isNotParsing = () => notParsing;
+exports.isNotParsing = isNotParsing;
+
+const parseFromString = (document, isHTML, markupLanguage) => {
+  const {active, registry} = document[CUSTOM_ELEMENTS];
+
+  let node = document;
+  let ownerSVGElement = null;
+  let parsingCData = false;
+
+  notParsing = false;
+
+  const content = new Parser({
+    // <!DOCTYPE ...>
+    onprocessinginstruction(name, data) {
+      if (name.toLowerCase() === '!doctype')
+        document.doctype = data.slice(name.length).trim();
+    },
+
+    // <tagName>
+    onopentag(name, attributes) {
+      let create = true;
+      if (isHTML) {
+        if (ownerSVGElement) {
+          node = append(node, document.createElementNS(SVG_NAMESPACE, name), active);
+          node.ownerSVGElement = ownerSVGElement;
+          create = false;
+        }
+        else if (name === 'svg' || name === 'SVG') {
+          ownerSVGElement = document.createElementNS(SVG_NAMESPACE, name);
+          node = append(node, ownerSVGElement, active);
+          create = false;
+        }
+        else if (active) {
+          const ce = name.includes('-') ? name : (attributes.is || '');
+          if (ce && registry.has(ce)) {
+            const {Class} = registry.get(ce);
+            node = append(node, new Class, active);
+            delete attributes.is;
+            create = false;
+          }
+        }
+      }
+
+      if (create)
+        node = append(node, document.createElement(name), false);
+
+      let end = node[END];
+      for (const name of keys(attributes))
+        attribute(node, end, document.createAttribute(name), attributes[name], active);
+    },
+
+    // #text, #comment
+    oncomment(data) { append(node, document.createComment(data), active); },
+    ontext(text) {
+      if (parsingCData) {
+        append(node, document.createCDATASection(text), active);
+      } else {
+        append(node, document.createTextNode(text), active);
+      }
+    },
+
+    // #cdata
+    oncdatastart() { parsingCData = true; },
+    oncdataend() { parsingCData = false; },
+
+    // </tagName>
+    onclosetag() {
+      if (isHTML && node === ownerSVGElement)
+        ownerSVGElement = null;
+      node = node.parentNode;
+    }
+  }, {
+    lowerCaseAttributeNames: false,
+    decodeEntities: true,
+    xmlMode: !isHTML
+  });
+
+  content.write(markupLanguage);
+  content.end();
+
+  notParsing = true;
+
+  return document;
+};
+exports.parseFromString = parseFromString;

package/node_modules/linkedom/cjs/shared/parse-json.js

@@ -0,0 +1,134 @@
+'use strict';
+const {
+  NODE_END,
+  ELEMENT_NODE,
+  ATTRIBUTE_NODE,
+  TEXT_NODE,
+  CDATA_SECTION_NODE,
+  COMMENT_NODE,
+  DOCUMENT_NODE,
+  DOCUMENT_TYPE_NODE,
+  DOCUMENT_FRAGMENT_NODE
+} = require('./constants.js');
+
+const {END, PREV} = require('./symbols.js');
+
+const {htmlClasses} = require('./register-html-class.js');
+const {knownBoundaries, knownSiblings} = require('./utils.js');
+
+const {Attr} = require('../interface/attr.js');
+const {CDATASection} = require('../interface/cdata-section.js');
+const {Comment} = require('../interface/comment.js');
+const {DocumentType} = require('../interface/document-type.js');
+const {Text} = require('../interface/text.js');
+
+const {HTMLDocument} = require('../html/document.js');
+const {HTMLElement} = require('../html/element.js');
+const {SVGElement} = require('../svg/element.js');
+
+const {parse} = JSON;
+
+const append = (parentNode, node, end) => {
+  node.parentNode = parentNode;
+  knownSiblings(end[PREV], node, end);
+};
+
+const createHTMLElement = (ownerDocument, localName) => {
+  if (htmlClasses.has(localName)) {
+    const Class = htmlClasses.get(localName);
+    return new Class(ownerDocument, localName);
+  }
+  return new HTMLElement(ownerDocument, localName);
+};
+
+/**
+ * @typedef {number|string} jsdonValue - either a node type or its content
+ */
+
+/**
+ * Given a stringified, or arrayfied DOM element, returns an HTMLDocument
+ * that represent the content of such string, or array.
+ * @param {string|jsdonValue[]} value
+ * @returns {HTMLDocument}
+ */
+const parseJSON = value => {
+  const array = typeof value === 'string' ? parse(value) : value;
+  const {length} = array;
+  const document = new HTMLDocument;
+  let parentNode = document, end = parentNode[END], svg = false, i = 0;
+  while (i < length) {
+    let nodeType = array[i++];
+    switch (nodeType) {
+      case ELEMENT_NODE: {
+        const localName = array[i++];
+        const isSVG = svg || localName === 'svg' || localName === 'SVG';
+        const element = isSVG ?
+                          new SVGElement(document, localName, parentNode.ownerSVGElement || null) :
+                          createHTMLElement(document, localName);
+        knownBoundaries(end[PREV], element, end);
+        element.parentNode = parentNode;
+        parentNode = element;
+        end = parentNode[END];
+        svg = isSVG;
+        break;
+      }
+      case ATTRIBUTE_NODE: {
+        const name = array[i++];
+        const value = typeof array[i] === 'string' ? array[i++] : '';
+        const attr = new Attr(document, name, value);
+        attr.ownerElement = parentNode;
+        knownSiblings(end[PREV], attr, end);
+        break;
+      }
+      case TEXT_NODE:
+        append(parentNode, new Text(document, array[i++]), end);
+        break;
+      case COMMENT_NODE:
+        append(parentNode, new Comment(document, array[i++]), end);
+        break;
+      case CDATA_SECTION_NODE:
+        append(parentNode, new CDATASection(document, array[i++]), end);
+        break;
+      case DOCUMENT_TYPE_NODE: {
+        const args = [document];
+        while (typeof array[i] === 'string')
+          args.push(array[i++]);
+        if (args.length === 3 && /\.dtd$/i.test(args[2]))
+          args.splice(2, 0, '');
+        append(parentNode, new DocumentType(...args), end);
+        break;
+      }
+      case DOCUMENT_FRAGMENT_NODE:
+        parentNode = document.createDocumentFragment();
+        end = parentNode[END];
+      /* eslint no-fallthrough:0 */
+      case DOCUMENT_NODE:
+        break;
+      default:
+        do {
+          nodeType -= NODE_END;
+          if (svg && !parentNode.ownerSVGElement)
+            svg = false;
+          parentNode = parentNode.parentNode || parentNode;
+        } while (nodeType < 0);
+        end = parentNode[END];
+        break;
+    }
+  }
+  switch (i && array[0]) {
+    case ELEMENT_NODE:
+      return document.firstElementChild;
+    case DOCUMENT_FRAGMENT_NODE:
+      return parentNode;
+  }
+  return document;
+};
+exports.parseJSON = parseJSON;
+
+/**
+ * 
+ * @param {Document|Element} node the Document or Element to serialize
+ * @returns {jsdonValue[]} the linear jsdon serialized array
+ */
+const toJSON = node => node.toJSON();
+exports.toJSON = toJSON;

package/node_modules/linkedom/cjs/shared/register-html-class.js

@@ -0,0 +1,11 @@
+'use strict';
+const htmlClasses = new Map;
+exports.htmlClasses = htmlClasses;
+
+const registerHTMLClass = (names, Class) => {
+  for (const name of [].concat(names)) {
+    htmlClasses.set(name, Class);
+    htmlClasses.set(name.toUpperCase(), Class);
+  }
+};
+exports.registerHTMLClass = registerHTMLClass;

package/node_modules/linkedom/cjs/shared/shadow-roots.js

@@ -0,0 +1,3 @@
+'use strict';
+const shadowRoots = new WeakMap;
+exports.shadowRoots = shadowRoots;

package/node_modules/linkedom/cjs/shared/symbols.js

@@ -0,0 +1,88 @@
+'use strict';
+// used in Attr to signal changes
+const CHANGED = Symbol('changed');
+exports.CHANGED = CHANGED;
+
+// used in Element to setup once classList
+const CLASS_LIST = Symbol('classList');
+exports.CLASS_LIST = CLASS_LIST;
+
+// used in Document to attach once customElements
+const CUSTOM_ELEMENTS = Symbol('CustomElements');
+exports.CUSTOM_ELEMENTS = CUSTOM_ELEMENTS;
+
+// used in HTMLTemplateElement
+const CONTENT = Symbol('content');
+exports.CONTENT = CONTENT;
+
+// used in Element for data attributes
+const DATASET = Symbol('dataset');
+exports.DATASET = DATASET;
+
+// used in Document to attach the DocType
+const DOCTYPE = Symbol('doctype');
+exports.DOCTYPE = DOCTYPE;
+
+// used in parser and Document to attach once a DOMParser
+const DOM_PARSER = Symbol('DOMParser');
+exports.DOM_PARSER = DOM_PARSER;
+
+// used to reference an end node
+const END = Symbol('end');
+exports.END = END;
+
+// used in Document to make the globalThis an event target
+const EVENT_TARGET = Symbol('EventTarget');
+exports.EVENT_TARGET = EVENT_TARGET;
+
+// used to augment a created document defaultView
+const GLOBALS = Symbol('globals');
+exports.GLOBALS = GLOBALS;
+
+// used in both Canvas and Document to provide images
+const IMAGE = Symbol('image');
+exports.IMAGE = IMAGE;
+
+// used to define Document mime type
+const MIME = Symbol('mime');
+exports.MIME = MIME;
+
+// used in Document to attach once MutationObserver
+const MUTATION_OBSERVER = Symbol('MutationObserver');
+exports.MUTATION_OBSERVER = MUTATION_OBSERVER;
+
+// used to define next node reference
+const NEXT = Symbol('next');
+exports.NEXT = NEXT;
+
+// used to define Attr owner elements
+const OWNER_ELEMENT = Symbol('ownerElement');
+exports.OWNER_ELEMENT = OWNER_ELEMENT;
+
+// used to define previous node reference
+const PREV = Symbol('prev');
+exports.PREV = PREV;
+
+// used to define various "private" properties
+const PRIVATE = Symbol('private');
+exports.PRIVATE = PRIVATE;
+
+// used to define the CSSStyleSheet.sheet
+const SHEET = Symbol('sheet');
+exports.SHEET = SHEET;
+
+// used to define start node reference
+const START = Symbol('start');
+exports.START = START;
+
+// used to define special CSS style attribute
+const STYLE = Symbol('style');
+exports.STYLE = STYLE;
+
+// used to upgrade Custom Elements
+const UPGRADE = Symbol('upgrade');
+exports.UPGRADE = UPGRADE;
+
+// used to define generic values
+const VALUE = Symbol('value');
+exports.VALUE = VALUE;

package/node_modules/linkedom/cjs/shared/text-escaper.js

@@ -0,0 +1,24 @@
+'use strict';
+const {replace} = '';
+
+// escape
+const ca = /[<>&\xA0]/g;
+
+const esca = {
+  '\xA0': '&#160;',
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;'
+};
+
+const pe = m => esca[m];
+
+/**
+ * Safely escape HTML entities such as `&`, `<`, `>` only.
+ * @param {string} es the input to safely escape
+ * @returns {string} the escaped input, and it **throws** an error if
+ *  the input type is unexpected, except for boolean and numbers,
+ *  converted as string.
+ */
+const escape = es => replace.call(es, ca, pe);
+exports.escape = escape;

package/node_modules/linkedom/cjs/shared/utils.js

@@ -0,0 +1,49 @@
+'use strict';
+const {ELEMENT_NODE} = require('./constants.js');
+const {END, MIME, NEXT, PREV} = require('./symbols.js');
+
+const $String = String;
+exports.String = $String;
+
+const getEnd = node => node.nodeType === ELEMENT_NODE ? node[END] : node;
+exports.getEnd = getEnd;
+
+const ignoreCase = ({ownerDocument}) => ownerDocument[MIME].ignoreCase;
+exports.ignoreCase = ignoreCase;
+
+const knownAdjacent = (prev, next) => {
+  prev[NEXT] = next;
+  next[PREV] = prev;
+};
+exports.knownAdjacent = knownAdjacent;
+
+const knownBoundaries = (prev, current, next) => {
+  knownAdjacent(prev, current);
+  knownAdjacent(getEnd(current), next);
+};
+exports.knownBoundaries = knownBoundaries;
+
+const knownSegment = (prev, start, end, next) => {
+  knownAdjacent(prev, start);
+  knownAdjacent(getEnd(end), next);
+};
+exports.knownSegment = knownSegment;
+
+const knownSiblings = (prev, current, next) => {
+  knownAdjacent(prev, current);
+  knownAdjacent(current, next);
+};
+exports.knownSiblings = knownSiblings;
+
+const localCase = ({localName, ownerDocument}) => {
+  return ownerDocument[MIME].ignoreCase ? localName.toUpperCase() : localName;
+};
+exports.localCase = localCase;
+
+const setAdjacent = (prev, next) => {
+  if (prev)
+    prev[NEXT] = next;
+  if (next)
+    next[PREV] = prev;
+};
+exports.setAdjacent = setAdjacent;

package/node_modules/linkedom/cjs/svg/document.js

@@ -0,0 +1,14 @@
+'use strict';
+const {MIME} = require('../shared/symbols.js');
+const {Document} = require('../interface/document.js');
+
+/**
+ * @implements globalThis.Document
+ */
+class SVGDocument extends Document {
+  constructor() { super('image/svg+xml'); }
+  toString() {
+    return this[MIME].docType + super.toString();
+  }
+}
+exports.SVGDocument = SVGDocument

package/node_modules/linkedom/cjs/svg/element.js

@@ -0,0 +1,60 @@
+'use strict';
+const {Element} = require('../interface/element.js');
+const {String} = require('../shared/utils.js');
+
+const classNames = new WeakMap;
+
+const handler = {
+  get(target, name) {
+    return target[name];
+  },
+  set(target, name, value) {
+    target[name] = value;
+    return true;
+  }
+};
+
+/**
+ * @implements globalThis.SVGElement
+ */
+class SVGElement extends Element {
+  constructor(ownerDocument, localName, ownerSVGElement = null) {
+    super(ownerDocument, localName);
+    this.ownerSVGElement = ownerSVGElement;
+  }
+
+  get className() {
+    if (!classNames.has(this))
+      classNames.set(this, new Proxy({baseVal: '', animVal: ''}, handler));
+    return classNames.get(this);
+  }
+
+  /* c8 ignore start */
+  set className(value) {
+    const {classList} = this;
+    classList.clear();
+    classList.add(...(String(value).split(/\s+/)));
+  }
+  /* c8 ignore stop */
+
+  get namespaceURI() {
+    return 'http://www.w3.org/2000/svg';
+  }
+
+  getAttribute(name) {
+    return name === 'class' ?
+      [...this.classList].join(' ') :
+      super.getAttribute(name);
+  }
+
+  setAttribute(name, value) {
+    if (name === 'class')
+      this.className = value;
+    else if (name === 'style') {
+      const {className} = this;
+      className.baseVal = className.animVal = value;
+    }
+    super.setAttribute(name, value);
+  }
+}
+exports.SVGElement = SVGElement

package/node_modules/linkedom/cjs/xml/document.js

@@ -0,0 +1,14 @@
+'use strict';
+const {MIME} = require('../shared/symbols.js');
+const {Document} = require('../interface/document.js');
+
+/**
+ * @implements globalThis.XMLDocument
+ */
+class XMLDocument extends Document {
+  constructor() { super('text/xml'); }
+  toString() {
+    return this[MIME].docType + super.toString();
+  }
+}
+exports.XMLDocument = XMLDocument

package/node_modules/linkedom/commonjs/canvas-shim.cjs

@@ -0,0 +1,16 @@
+class Canvas {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+  getContext() {
+    return null;
+  }
+  toDataURL() {
+    return '';
+  }
+}
+
+module.exports = {
+  createCanvas: (width, height) => new Canvas(width, height),
+};

package/node_modules/linkedom/commonjs/canvas.cjs

@@ -0,0 +1,7 @@
+/* c8 ignore start */
+try {
+  module.exports = require('canvas');
+} catch (fallback) {
+  module.exports = require('./canvas-shim.cjs');
+}
+/* c8 ignore stop */

package/node_modules/linkedom/commonjs/perf_hooks.cjs

@@ -0,0 +1,9 @@
+/* c8 ignore start */
+try {
+  const {performance} = require('perf_hooks');
+  exports.performance = performance;
+}
+catch (fallback) {
+  exports.performance = {now() { return +new Date; }};
+}
+/* c8 ignore stop */