Index: frontend/node_modules/w3c-xmlserializer/LICENSE.md =================================================================== --- frontend/node_modules/w3c-xmlserializer/LICENSE.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/LICENSE.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,25 @@ +The MIT License (MIT) +===================== + +Copyright © 2016 Sebastian Mayr + +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. Index: frontend/node_modules/w3c-xmlserializer/README.md =================================================================== --- frontend/node_modules/w3c-xmlserializer/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,41 @@ +# w3c-xmlserializer + +An XML serializer that follows the [W3C specification](https://w3c.github.io/DOM-Parsing/). + +This package can be used in Node.js, as long as you feed it a DOM node, e.g. one produced by [jsdom](https://github.com/jsdom/jsdom). + +## Basic usage + +Assume you have a DOM tree rooted at a node `node`. In Node.js, you could create this using [jsdom](https://github.com/jsdom/jsdom) as follows: + +```js +const { JSDOM } = require("jsdom"); + +const { document } = new JSDOM().window; +const node = document.createElement("akomaNtoso"); +``` + +Then, you use this package as follows: + + +```js +const serialize = require("w3c-xmlserializer"); + +console.log(serialize(node)); +// => '' +``` + +## `requireWellFormed` option + +By default the input DOM tree is not required to be "well-formed"; any given input will serialize to some output string. You can instead require well-formedness via + +```js +serialize(node, { requireWellFormed: true }); +``` + +which will cause `Error`s to be thrown when non-well-formed constructs are encountered. [Per the spec](https://w3c.github.io/DOM-Parsing/#dfn-require-well-formed), this largely is about imposing constraints on the names of elements, attributes, etc. + +As a point of reference, on the web platform: + +* The [`innerHTML` getter](https://w3c.github.io/DOM-Parsing/#dom-innerhtml-innerhtml) uses the require-well-formed mode, i.e. trying to get the `innerHTML` of non-well-formed subtrees will throw. +* The [`xhr.send()` method](https://xhr.spec.whatwg.org/#the-send()-method) does not require well-formedness, i.e. sending non-well-formed `Document`s will serialize and send them anyway. Index: frontend/node_modules/w3c-xmlserializer/lib/attributes.js =================================================================== --- frontend/node_modules/w3c-xmlserializer/lib/attributes.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/lib/attributes.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,128 @@ +"use strict"; + +const xnv = require("xml-name-validator"); + +const { NAMESPACES } = require("./constants"); + +function generatePrefix(map, newNamespace, prefixIndex) { + const generatedPrefix = "ns" + prefixIndex; + map[newNamespace] = [generatedPrefix]; + return generatedPrefix; +} + +function preferredPrefixString(map, ns, preferredPrefix) { + const candidateList = map[ns]; + if (!candidateList) { + return null; + } + if (candidateList.includes(preferredPrefix)) { + return preferredPrefix; + } + return candidateList[candidateList.length - 1]; +} + +function serializeAttributeValue(value/* , requireWellFormed*/) { + if (value === null) { + return ""; + } + // TODO: Check well-formedness + return value + .replace(/&/g, "&") + .replace(/"/g, """) + .replace(//g, ">") + .replace(/\t/g, " ") + .replace(/\n/g, " ") + .replace(/\r/g, " "); +} + +function serializeAttributes( + element, + map, + localPrefixes, + ignoreNamespaceDefAttr, + requireWellFormed, + refs +) { + let result = ""; + const namespaceLocalnames = Object.create(null); + for (const attr of element.attributes) { + if ( + requireWellFormed && + namespaceLocalnames[attr.namespaceURI] && + namespaceLocalnames[attr.namespaceURI].has(attr.localName) + ) { + throw new Error("Found duplicated attribute"); + } + if (!namespaceLocalnames[attr.namespaceURI]) { + namespaceLocalnames[attr.namespaceURI] = new Set(); + } + namespaceLocalnames[attr.namespaceURI].add(attr.localName); + const attributeNamespace = attr.namespaceURI; + let candidatePrefix = null; + if (attributeNamespace !== null) { + candidatePrefix = preferredPrefixString( + map, + attributeNamespace, + attr.prefix + ); + if (attributeNamespace === NAMESPACES.XMLNS) { + if ( + attr.value === NAMESPACES.XML || + (attr.prefix === null && ignoreNamespaceDefAttr) || + (attr.prefix !== null && + localPrefixes[attr.localName] !== attr.value && + map[attr.value].includes(attr.localName)) + ) { + continue; + } + if (requireWellFormed && attr.value === NAMESPACES.XMLNS) { + throw new Error( + "The XMLNS namespace is reserved and cannot be applied as an element's namespace via XML parsing" + ); + } + if (requireWellFormed && attr.value === "") { + throw new Error( + "Namespace prefix declarations cannot be used to undeclare a namespace" + ); + } + if (attr.prefix === "xmlns") { + candidatePrefix = "xmlns"; + } + } else if (candidatePrefix === null) { + candidatePrefix = generatePrefix( + map, + attributeNamespace, + refs.prefixIndex++ + ); + result += ` xmlns:${candidatePrefix}="${serializeAttributeValue( + attributeNamespace, + requireWellFormed + )}"`; + } + } + + result += " "; + if (candidatePrefix !== null) { + result += candidatePrefix + ":"; + } + if ( + requireWellFormed && + (attr.localName.includes(":") || + !xnv.name(attr.localName) || + (attr.localName === "xmlns" && attributeNamespace === null)) + ) { + throw new Error("Invalid attribute localName value"); + } + result += `${attr.localName}="${serializeAttributeValue( + attr.value, + requireWellFormed + )}"`; + } + return result; +} + +module.exports.preferredPrefixString = preferredPrefixString; +module.exports.generatePrefix = generatePrefix; +module.exports.serializeAttributeValue = serializeAttributeValue; +module.exports.serializeAttributes = serializeAttributes; Index: frontend/node_modules/w3c-xmlserializer/lib/constants.js =================================================================== --- frontend/node_modules/w3c-xmlserializer/lib/constants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/lib/constants.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,44 @@ +"use strict"; + +module.exports.NAMESPACES = { + HTML: "http://www.w3.org/1999/xhtml", + XML: "http://www.w3.org/XML/1998/namespace", + XMLNS: "http://www.w3.org/2000/xmlns/" +}; + +module.exports.NODE_TYPES = { + ELEMENT_NODE: 1, + ATTRIBUTE_NODE: 2, // historical + TEXT_NODE: 3, + CDATA_SECTION_NODE: 4, + ENTITY_REFERENCE_NODE: 5, // historical + ENTITY_NODE: 6, // historical + PROCESSING_INSTRUCTION_NODE: 7, + COMMENT_NODE: 8, + DOCUMENT_NODE: 9, + DOCUMENT_TYPE_NODE: 10, + DOCUMENT_FRAGMENT_NODE: 11, + NOTATION_NODE: 12 // historical +}; + +module.exports.VOID_ELEMENTS = new Set([ + "area", + "base", + "basefont", + "bgsound", + "br", + "col", + "embed", + "frame", + "hr", + "img", + "input", + "keygen", + "link", + "menuitem", + "meta", + "param", + "source", + "track", + "wbr" +]); Index: frontend/node_modules/w3c-xmlserializer/lib/serialize.js =================================================================== --- frontend/node_modules/w3c-xmlserializer/lib/serialize.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/lib/serialize.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,371 @@ +"use strict"; + +const xnv = require("xml-name-validator"); + +const attributeUtils = require("./attributes"); +const { NAMESPACES, VOID_ELEMENTS, NODE_TYPES } = require("./constants"); + +const XML_CHAR = /^(\x09|\x0A|\x0D|[\x20-\uD7FF]|[\uE000-\uFFFD]|(?:[\uD800-\uDBFF][\uDC00-\uDFFF]))*$/; +const PUBID_CHAR = /^(\x20|\x0D|\x0A|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%])*$/; + +function asciiCaseInsensitiveMatch(a, b) { + if (a.length !== b.length) { + return false; + } + + for (let i = 0; i < a.length; ++i) { + if ((a.charCodeAt(i) | 32) !== (b.charCodeAt(i) | 32)) { + return false; + } + } + + return true; +} + +function recordNamespaceInformation(element, map, prefixMap) { + let defaultNamespaceAttrValue = null; + for (let i = 0; i < element.attributes.length; ++i) { + const attr = element.attributes[i]; + if (attr.namespaceURI === NAMESPACES.XMLNS) { + if (attr.prefix === null) { + defaultNamespaceAttrValue = attr.value; + continue; + } + let namespaceDefinition = attr.value; + if (namespaceDefinition === NAMESPACES.XML) { + continue; + } + // This is exactly the other way than the spec says, but that's intended. + // All the maps coalesce null to the empty string (explained in the + // spec), so instead of doing that every time, just do it once here. + if (namespaceDefinition === null) { + namespaceDefinition = ""; + } + + if ( + namespaceDefinition in map && + map[namespaceDefinition].includes(attr.localName) + ) { + continue; + } + if (!(namespaceDefinition in map)) { + map[namespaceDefinition] = []; + } + map[namespaceDefinition].push(attr.localName); + prefixMap[attr.localName] = namespaceDefinition; + } + } + return defaultNamespaceAttrValue; +} + +function serializeDocumentType(node, namespace, prefixMap, requireWellFormed) { + if (requireWellFormed && !PUBID_CHAR.test(node.publicId)) { + throw new Error("Failed to serialize XML: document type node publicId is not well-formed."); + } + + if ( + requireWellFormed && + (!XML_CHAR.test(node.systemId) || + (node.systemId.includes('"') && node.systemId.includes("'"))) + ) { + throw new Error("Failed to serialize XML: document type node systemId is not well-formed."); + } + + let markup = `"; +} + +function serializeProcessingInstruction( + node, + namespace, + prefixMap, + requireWellFormed +) { + if ( + requireWellFormed && + (node.target.includes(":") || asciiCaseInsensitiveMatch(node.target, "xml")) + ) { + throw new Error("Failed to serialize XML: processing instruction node target is not well-formed."); + } + if ( + requireWellFormed && + (!XML_CHAR.test(node.data) || node.data.includes("?>")) + ) { + throw new Error("Failed to serialize XML: processing instruction node data is not well-formed."); + } + return ``; +} + +function serializeDocument( + node, + namespace, + prefixMap, + requireWellFormed, + refs +) { + if (requireWellFormed && node.documentElement === null) { + throw new Error("Failed to serialize XML: document does not have a document element."); + } + let serializedDocument = ""; + for (const child of node.childNodes) { + serializedDocument += xmlSerialization( + child, + namespace, + prefixMap, + requireWellFormed, + refs + ); + } + return serializedDocument; +} + +function serializeDocumentFragment( + node, + namespace, + prefixMap, + requireWellFormed, + refs +) { + let markup = ""; + for (const child of node.childNodes) { + markup += xmlSerialization( + child, + namespace, + prefixMap, + requireWellFormed, + refs + ); + } + return markup; +} + +function serializeText(node, namespace, prefixMap, requireWellFormed) { + if (requireWellFormed && !XML_CHAR.test(node.data)) { + throw new Error("Failed to serialize XML: text node data is not well-formed."); + } + + return node.data + .replace(/&/g, "&") + .replace(//g, ">"); +} + +function serializeComment(node, namespace, prefixMap, requireWellFormed) { + if (requireWellFormed && !XML_CHAR.test(node.data)) { + throw new Error("Failed to serialize XML: comment node data is not well-formed."); + } + + if ( + requireWellFormed && + (node.data.includes("--") || node.data.endsWith("-")) + ) { + throw new Error("Failed to serialize XML: found hyphens in illegal places in comment node data."); + } + return ``; +} + +function serializeElement(node, namespace, prefixMap, requireWellFormed, refs) { + if ( + requireWellFormed && + (node.localName.includes(":") || !xnv.name(node.localName)) + ) { + throw new Error("Failed to serialize XML: element node localName is not a valid XML name."); + } + let markup = "<"; + let qualifiedName = ""; + let skipEndTag = false; + let ignoreNamespaceDefinitionAttr = false; + const map = Object.assign({}, prefixMap); + const localPrefixesMap = Object.create(null); + const localDefaultNamespace = recordNamespaceInformation( + node, + map, + localPrefixesMap + ); + let inheritedNs = namespace; + const ns = node.namespaceURI; + if (inheritedNs === ns) { + if (localDefaultNamespace !== null) { + ignoreNamespaceDefinitionAttr = true; + } + if (ns === NAMESPACES.XML) { + qualifiedName = "xml:" + node.localName; + } else { + qualifiedName = node.localName; + } + markup += qualifiedName; + } else { + let { prefix } = node; + let candidatePrefix = attributeUtils.preferredPrefixString(map, ns, prefix); + if (prefix === "xmlns") { + if (requireWellFormed) { + throw new Error("Failed to serialize XML: element nodes can't have a prefix of \"xmlns\"."); + } + candidatePrefix = "xmlns"; + } + if (candidatePrefix !== null) { + qualifiedName = candidatePrefix + ":" + node.localName; + if ( + localDefaultNamespace !== null && + localDefaultNamespace !== NAMESPACES.XML + ) { + inheritedNs = + localDefaultNamespace === "" ? null : localDefaultNamespace; + } + markup += qualifiedName; + } else if (prefix !== null) { + if (prefix in localPrefixesMap) { + prefix = attributeUtils.generatePrefix(map, ns, refs.prefixIndex++); + } + if (map[ns]) { + map[ns].push(prefix); + } else { + map[ns] = [prefix]; + } + qualifiedName = prefix + ":" + node.localName; + markup += `${qualifiedName} xmlns:${prefix}="${attributeUtils.serializeAttributeValue( + ns, + requireWellFormed + )}"`; + if (localDefaultNamespace !== null) { + inheritedNs = + localDefaultNamespace === "" ? null : localDefaultNamespace; + } + } else if (localDefaultNamespace === null || localDefaultNamespace !== ns) { + ignoreNamespaceDefinitionAttr = true; + qualifiedName = node.localName; + inheritedNs = ns; + markup += `${qualifiedName} xmlns="${attributeUtils.serializeAttributeValue( + ns, + requireWellFormed + )}"`; + } else { + qualifiedName = node.localName; + inheritedNs = ns; + markup += qualifiedName; + } + } + + markup += attributeUtils.serializeAttributes( + node, + map, + localPrefixesMap, + ignoreNamespaceDefinitionAttr, + requireWellFormed, + refs + ); + + if ( + ns === NAMESPACES.HTML && + node.childNodes.length === 0 && + VOID_ELEMENTS.has(node.localName) + ) { + markup += " /"; + skipEndTag = true; + } else if (ns !== NAMESPACES.HTML && node.childNodes.length === 0) { + markup += "/"; + skipEndTag = true; + } + markup += ">"; + if (skipEndTag) { + return markup; + } + + if (ns === NAMESPACES.HTML && node.localName === "template") { + markup += xmlSerialization( + node.content, + inheritedNs, + map, + requireWellFormed, + refs + ); + } else { + for (const child of node.childNodes) { + markup += xmlSerialization( + child, + inheritedNs, + map, + requireWellFormed, + refs + ); + } + } + markup += ``; + return markup; +} + +function serializeCDATASection(node) { + return ""; +} + +/** + * @param {{prefixIndex: number}} refs + */ +function xmlSerialization(node, namespace, prefixMap, requireWellFormed, refs) { + switch (node.nodeType) { + case NODE_TYPES.ELEMENT_NODE: + return serializeElement( + node, + namespace, + prefixMap, + requireWellFormed, + refs + ); + case NODE_TYPES.DOCUMENT_NODE: + return serializeDocument( + node, + namespace, + prefixMap, + requireWellFormed, + refs + ); + case NODE_TYPES.COMMENT_NODE: + return serializeComment(node, namespace, prefixMap, requireWellFormed); + case NODE_TYPES.TEXT_NODE: + return serializeText(node, namespace, prefixMap, requireWellFormed); + case NODE_TYPES.DOCUMENT_FRAGMENT_NODE: + return serializeDocumentFragment( + node, + namespace, + prefixMap, + requireWellFormed, + refs + ); + case NODE_TYPES.DOCUMENT_TYPE_NODE: + return serializeDocumentType( + node, + namespace, + prefixMap, + requireWellFormed + ); + case NODE_TYPES.PROCESSING_INSTRUCTION_NODE: + return serializeProcessingInstruction( + node, + namespace, + prefixMap, + requireWellFormed + ); + case NODE_TYPES.ATTRIBUTE_NODE: + return ""; + case NODE_TYPES.CDATA_SECTION_NODE: + return serializeCDATASection(node); + default: + throw new TypeError("Failed to serialize XML: only Nodes can be serialized."); + } +} + +module.exports = (root, { requireWellFormed = false } = {}) => { + const namespacePrefixMap = Object.create(null); + namespacePrefixMap["http://www.w3.org/XML/1998/namespace"] = ["xml"]; + return xmlSerialization(root, null, namespacePrefixMap, requireWellFormed, { + prefixIndex: 1 + }); +}; Index: frontend/node_modules/w3c-xmlserializer/package.json =================================================================== --- frontend/node_modules/w3c-xmlserializer/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/w3c-xmlserializer/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,32 @@ +{ + "name": "w3c-xmlserializer", + "description": "A per-spec XML serializer implementation", + "keywords": [ + "dom", + "w3c", + "xml", + "xmlserializer" + ], + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "xml-name-validator": "^3.0.0" + }, + "devDependencies": { + "eslint": "^6.8.0", + "jest": "^24.9.0", + "jsdom": "^15.2.1" + }, + "repository": "jsdom/w3c-xmlserializer", + "files": [ + "lib/" + ], + "main": "lib/serialize.js", + "scripts": { + "test": "jest", + "lint": "eslint ." + }, + "engines": { + "node": ">=10" + } +}