@zipify/wysiwyg 1.2.1-0 → 1.2.1-1

package/node_modules_lambda/w3c-xmlserializer/lib/serialize.js

@@ -1,365 +0,0 @@
-"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]))*$/u;
-const PUBID_CHAR = /^(\x20|\x0D|\x0A|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%])*$/u;
-
-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 = `<!DOCTYPE ${node.name}`;
-  if (node.publicId !== "") {
-    markup += ` PUBLIC "${node.publicId}"`;
-  } else if (node.systemId !== "") {
-    markup += " SYSTEM";
-  }
-  if (node.systemId !== "") {
-    markup += ` "${node.systemId}"`;
-  }
-  return `${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 `<?${node.target} ${node.data}?>`;
-}
-
-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(/&/ug, "&amp;")
-    .replace(/</ug, "&lt;")
-    .replace(/>/ug, "&gt;");
-}
-
-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 `<!--${node.data}-->`;
-}
-
-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 = { ...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 += `</${qualifiedName}>`;
-  return markup;
-}
-
-function serializeCDATASection(node) {
-  return `<![CDATA[${node.data}]]>`;
-}
-
-/**
- * @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
-  });
-};

package/node_modules_lambda/w3c-xmlserializer/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "w3c-xmlserializer",
-  "description": "A per-spec XML serializer implementation",
-  "keywords": [
-    "dom",
-    "w3c",
-    "xml",
-    "xmlserializer"
-  ],
-  "version": "3.0.0",
-  "license": "MIT",
-  "dependencies": {
-    "xml-name-validator": "^4.0.0"
-  },
-  "devDependencies": {
-    "@domenic/eslint-config": "^1.4.0",
-    "eslint": "^7.32.0",
-    "jest": "^27.2.0",
-    "jsdom": "^17.0.0"
-  },
-  "repository": "jsdom/w3c-xmlserializer",
-  "files": [
-    "lib/"
-  ],
-  "main": "lib/serialize.js",
-  "scripts": {
-    "test": "jest",
-    "lint": "eslint ."
-  },
-  "engines": {
-    "node": ">=12"
-  }
-}

package/node_modules_lambda/webidl-conversions/LICENSE.md

@@ -1,12 +0,0 @@
-# The BSD 2-Clause License
-
-Copyright (c) 2014, Domenic Denicola
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules_lambda/webidl-conversions/README.md

@@ -1,99 +0,0 @@
-# Web IDL Type Conversions on JavaScript Values
-
-This package implements, in JavaScript, the algorithms to convert a given JavaScript value according to a given [Web IDL](http://heycam.github.io/webidl/) [type](http://heycam.github.io/webidl/#idl-types).
-
-The goal is that you should be able to write code like
-
-```js
-"use strict";
-const conversions = require("webidl-conversions");
-
-function doStuff(x, y) {
-    x = conversions["boolean"](x);
-    y = conversions["unsigned long"](y);
-    // actual algorithm code here
-}
-```
-
-and your function `doStuff` will behave the same as a Web IDL operation declared as
-
-```webidl
-undefined doStuff(boolean x, unsigned long y);
-```
-
-## API
-
-This package's main module's default export is an object with a variety of methods, each corresponding to a different Web IDL type. Each method, when invoked on a JavaScript value, will give back the new JavaScript value that results after passing through the Web IDL conversion rules. (See below for more details on what that means.) Alternately, the method could throw an error, if the Web IDL algorithm is specified to do so: for example `conversions["float"](NaN)` [will throw a `TypeError`](http://heycam.github.io/webidl/#es-float).
-
-Each method also accepts a second, optional, parameter for miscellaneous options. For conversion methods that throw errors, a string option `{ context }` may be provided to provide more information in the error message. (For example, `conversions["float"](NaN, { context: "Argument 1 of Interface's operation" })` will throw an error with message `"Argument 1 of Interface's operation is not a finite floating-point value."`)
-
-If we are dealing with multiple JavaScript realms (such as those created using Node.js' [vm](https://nodejs.org/api/vm.html) module or the HTML `iframe` element), and exceptions from another realm need to be thrown, one can supply an object option `globals` containing the following properties:
-
-```js
-{
-  globals: {
-    Number,
-    String,
-    TypeError
-  }
-}
-```
-
-Those specific functions will be used when throwing exceptions.
-
-Specific conversions may also accept other options, the details of which can be found below.
-
-## Conversions implemented
-
-Conversions for all of the basic types from the Web IDL specification are implemented:
-
-- [`any`](https://heycam.github.io/webidl/#es-any)
-- [`undefined`](https://heycam.github.io/webidl/#es-undefined)
-- [`boolean`](https://heycam.github.io/webidl/#es-boolean)
-- [Integer types](https://heycam.github.io/webidl/#es-integer-types), which can additionally be provided the boolean options `{ clamp, enforceRange }` as a second parameter
-- [`float`](https://heycam.github.io/webidl/#es-float), [`unrestricted float`](https://heycam.github.io/webidl/#es-unrestricted-float)
-- [`double`](https://heycam.github.io/webidl/#es-double), [`unrestricted double`](https://heycam.github.io/webidl/#es-unrestricted-double)
-- [`DOMString`](https://heycam.github.io/webidl/#es-DOMString), which can additionally be provided the boolean option `{ treatNullAsEmptyString }` as a second parameter
-- [`ByteString`](https://heycam.github.io/webidl/#es-ByteString), [`USVString`](https://heycam.github.io/webidl/#es-USVString)
-- [`object`](https://heycam.github.io/webidl/#es-object)
-- [Buffer source types](https://heycam.github.io/webidl/#es-buffer-source-types), which can additionally be provided with the boolean option `{ allowShared }` as a second parameter
-
-Additionally, for convenience, the following derived type definitions are implemented:
-
-- [`ArrayBufferView`](https://heycam.github.io/webidl/#ArrayBufferView), which can additionally be provided with the boolean option `{ allowShared }` as a second parameter
-- [`BufferSource`](https://heycam.github.io/webidl/#BufferSource)
-- [`DOMTimeStamp`](https://heycam.github.io/webidl/#DOMTimeStamp)
-
-Derived types, such as nullable types, promise types, sequences, records, etc. are not handled by this library. You may wish to investigate the [webidl2js](https://github.com/jsdom/webidl2js) project.
-
-### A note on the `long long` types
-
-The `long long` and `unsigned long long` Web IDL types can hold values that cannot be stored in JavaScript numbers. Conversions are still accurate as we make use of BigInt in the conversion process, but in the case of `unsigned long long` we simply cannot represent some possible output values in JavaScript. For example, converting the JavaScript number `-1` to a Web IDL `unsigned long long` is supposed to produce the Web IDL value `18446744073709551615`. Since we are representing our Web IDL values in JavaScript, we can't represent `18446744073709551615`, so we instead the best we could do is `18446744073709551616` as the output.
-
-To mitigate this, we could return the raw BigInt value from the conversion function, but right now it is not implemented. If your use case requires such precision, [file an issue](https://github.com/jsdom/webidl-conversions/issues/new).
-
-On the other hand, `long long` conversion is always accurate, since the input value can never be more precise than the output value.
-
-### A note on `BufferSource` types
-
-All of the `BufferSource` types will throw when the relevant `ArrayBuffer` has been detached. This technically is not part of the [specified conversion algorithm](https://heycam.github.io/webidl/#es-buffer-source-types), but instead part of the [getting a reference/getting a copy](https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-reference%E2%91%A0) algorithms. We've consolidated them here for convenience and ease of implementation, but if there is a need to separate them in the future, please open an issue so we can investigate.
-
-## Background
-
-What's actually going on here, conceptually, is pretty weird. Let's try to explain.
-
-Web IDL, as part of its madness-inducing design, has its own type system. When people write algorithms in web platform specs, they usually operate on Web IDL values, i.e. instances of Web IDL types. For example, if they were specifying the algorithm for our `doStuff` operation above, they would treat `x` as a Web IDL value of [Web IDL type `boolean`](http://heycam.github.io/webidl/#idl-boolean). Crucially, they would _not_ treat `x` as a JavaScript variable whose value is either the JavaScript `true` or `false`. They're instead working in a different type system altogether, with its own rules.
-
-Separately from its type system, Web IDL defines a ["binding"](http://heycam.github.io/webidl/#ecmascript-binding) of the type system into JavaScript. This contains rules like: when you pass a JavaScript value to the JavaScript method that manifests a given Web IDL operation, how does that get converted into a Web IDL value? For example, a JavaScript `true` passed in the position of a Web IDL `boolean` argument becomes a Web IDL `true`. But, a JavaScript `true` passed in the position of a [Web IDL `unsigned long`](http://heycam.github.io/webidl/#idl-unsigned-long) becomes a Web IDL `1`. And so on.
-
-Finally, we have the actual implementation code. This is usually C++, although these days [some smart people are using Rust](https://github.com/servo/servo). The implementation, of course, has its own type system. So when they implement the Web IDL algorithms, they don't actually use Web IDL values, since those aren't "real" outside of specs. Instead, implementations apply the Web IDL binding rules in such a way as to convert incoming JavaScript values into C++ values. For example, if code in the browser called `doStuff(true, true)`, then the implementation code would eventually receive a C++ `bool` containing `true` and a C++ `uint32_t` containing `1`.
-
-The upside of all this is that implementations can abstract all the conversion logic away, letting Web IDL handle it, and focus on implementing the relevant methods in C++ with values of the correct type already provided. That is payoff of Web IDL, in a nutshell.
-
-And getting to that payoff is the goal of _this_ project—but for JavaScript implementations, instead of C++ ones. That is, this library is designed to make it easier for JavaScript developers to write functions that behave like a given Web IDL operation. So conceptually, the conversion pipeline, which in its general form is JavaScript values ↦ Web IDL values ↦ implementation-language values, in this case becomes JavaScript values ↦ Web IDL values ↦ JavaScript values. And that intermediate step is where all the logic is performed: a JavaScript `true` becomes a Web IDL `1` in an unsigned long context, which then becomes a JavaScript `1`.
-
-## Don't use this
-
-Seriously, why would you ever use this? You really shouldn't. Web IDL is … strange, and you shouldn't be emulating its semantics. If you're looking for a generic argument-processing library, you should find one with better rules than those from Web IDL. In general, your JavaScript should not be trying to become more like Web IDL; if anything, we should fix Web IDL to make it more like JavaScript.
-
-The _only_ people who should use this are those trying to create faithful implementations (or polyfills) of web platform interfaces defined in Web IDL. Its main consumer is the [jsdom](https://github.com/jsdom/jsdom) project.