create-monolayer-app 0.2.2 → 0.3.0

package/template/vendor/file-bucket/xml.ts

@@ -0,0 +1,325 @@
+/**
+ * Zero-dependency XML parser, DOM builder, and serializer for S3 XML payloads.
+ */
+
+// oxlint-disable-next-line max-classes-per-file
+export const S3_NS = "http://s3.amazonaws.com/doc/2006-03-01/";
+export const XML_DECL = '<?xml version="1.0" encoding="UTF-8"?>';
+
+export class ParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ParseError";
+  }
+}
+
+export function escapeXml(
+  str: string | number | boolean | null | undefined
+): string {
+  if (str === null || str === undefined) return "";
+  return String(str)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+export function unescapeXml(str: string): string {
+  return str
+    .replaceAll("&quot;", '"')
+    .replaceAll("&apos;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&")
+    .replaceAll(/&#(\d+);/gu, (_, dec) =>
+      String.fromCodePoint(Math.trunc(Number(dec)))
+    )
+    .replaceAll(/&#x([0-9a-fA-F]+);/gu, (_, hex) =>
+      String.fromCodePoint(Number.parseInt(hex, 16))
+    );
+}
+
+/**
+ * Strips namespace prefix or Clark notation from a tag name.
+ * e.g. "{http://...}Rule" -> "Rule", "s3:Rule" -> "Rule", "Rule" -> "Rule"
+ */
+export function localTagName(tag: string): string {
+  if (tag.startsWith("{")) {
+    const idx = tag.indexOf("}");
+    if (idx !== -1) return tag.slice(idx + 1);
+  }
+  const colonIdx = tag.indexOf(":");
+  if (colonIdx !== -1) {
+    return tag.slice(colonIdx + 1);
+  }
+  return tag;
+}
+
+function isString(
+  value: string | Record<string, string> | undefined
+): value is string {
+  return typeof value === "string";
+}
+
+export class XmlElement {
+  public tag: string;
+  public attrs: Record<string, string>;
+  public text?: string;
+  public children: XmlElement[];
+
+  constructor(tag: string, attrs: Record<string, string> = {}, text?: string) {
+    this.tag = tag;
+    this.attrs = { ...attrs };
+    this.text = text;
+    this.children = [];
+  }
+
+  public localName(): string {
+    return localTagName(this.tag);
+  }
+
+  public subElement(
+    tag: string,
+    textOrAttrs?: string | Record<string, string>,
+    text?: string
+  ): XmlElement {
+    const el = isString(textOrAttrs)
+      ? new XmlElement(tag, {}, textOrAttrs)
+      : new XmlElement(tag, textOrAttrs || {}, text);
+
+    this.children.push(el);
+    return el;
+  }
+
+  public find(tag: string): XmlElement | undefined {
+    const targetLocal = localTagName(tag);
+    return this.children.find(
+      (c) => c.tag === tag || c.localName() === targetLocal
+    );
+  }
+
+  public findAll(tag: string): XmlElement[] {
+    const targetLocal = localTagName(tag);
+    return this.children.filter(
+      (c) => c.tag === tag || c.localName() === targetLocal
+    );
+  }
+
+  public findText(tag: string): string | undefined {
+    const el = this.find(tag);
+    return el?.text;
+  }
+
+  public findDescendant(tag: string): XmlElement | undefined {
+    const targetLocal = localTagName(tag);
+    for (const c of this.children) {
+      if (c.tag === tag || c.localName() === targetLocal) {
+        return c;
+      }
+      const deep = c.findDescendant(tag);
+      if (deep) return deep;
+    }
+    return undefined;
+  }
+
+  public findAllDescendants(tag: string): XmlElement[] {
+    const targetLocal = localTagName(tag);
+    const result: XmlElement[] = [];
+    for (const c of this.children) {
+      if (c.tag === tag || c.localName() === targetLocal) {
+        result.push(c);
+      }
+      result.push(...c.findAllDescendants(tag));
+    }
+    return result;
+  }
+
+  public iter(): XmlElement[] {
+    const result: XmlElement[] = [this];
+    for (const child of this.children) {
+      result.push(...child.iter());
+    }
+    return result;
+  }
+
+  public toXml(includeDeclaration = false): string {
+    let s = includeDeclaration ? `${XML_DECL}\n` : "";
+    s += `<${this.tag}`;
+    for (const [k, v] of Object.entries(this.attrs)) {
+      s += ` ${k}="${escapeXml(v)}"`;
+    }
+    if (this.children.length === 0 && this.text === undefined) {
+      s += "/>";
+      return s;
+    }
+    s += ">";
+    if (this.text !== undefined) {
+      s += escapeXml(this.text);
+    }
+    for (const child of this.children) {
+      s += child.toXml(false);
+    }
+    s += `</${this.tag}>`;
+    return s;
+  }
+}
+
+export function subElement(
+  parent: XmlElement,
+  tag: string,
+  textOrAttrs?: string | Record<string, string>,
+  text?: string
+): XmlElement {
+  return parent.subElement(tag, textOrAttrs, text);
+}
+
+// oxlint-disable-next-line complexity
+export function parseXml(xml: string | Buffer): XmlElement {
+  // String inputs are also used by browser upload handles.
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof
+  let str = (typeof xml === "string" ? xml : xml.toString("utf-8")).trim();
+  if (!str) {
+    throw new ParseError("Empty XML document");
+  }
+
+  // Strip XML declaration if present
+  if (str.startsWith("<?xml")) {
+    const end = str.indexOf("?>");
+    if (end !== -1) {
+      str = str.slice(end + 2).trim();
+    }
+  }
+
+  let pos = 0;
+  const len = str.length;
+  let root: XmlElement | null = null;
+  const stack: XmlElement[] = [];
+
+  while (pos < len) {
+    const lt = str.indexOf("<", pos);
+    if (lt === -1) {
+      if (stack.length > 0) {
+        const text = unescapeXml(str.slice(pos).trim());
+        const top = stack.at(-1);
+        if (text && top) {
+          top.text = (top.text || "") + text;
+        }
+      }
+      break;
+    }
+
+    if (lt > pos && stack.length > 0) {
+      const text = unescapeXml(str.slice(pos, lt).trim());
+      const top = stack.at(-1);
+      if (text && top) {
+        top.text = (top.text || "") + text;
+      }
+    }
+
+    pos = lt + 1;
+
+    // Comment
+    if (str.startsWith("!--", pos)) {
+      const end = str.indexOf("-->", pos + 3);
+      pos = end === -1 ? len : end + 3;
+      continue;
+    }
+
+    // CDATA
+    if (str.startsWith("![CDATA[", pos)) {
+      const end = str.indexOf("]]>", pos + 8);
+      const cdata = end === -1 ? str.slice(pos + 8) : str.slice(pos + 8, end);
+      const top = stack.at(-1);
+      if (top) {
+        top.text = (top.text || "") + cdata;
+      }
+      pos = end === -1 ? len : end + 3;
+      continue;
+    }
+
+    // Processing instructions or DOCTYPE
+    if (str.startsWith("?", pos) || str.startsWith("!", pos)) {
+      const gt = str.indexOf(">", pos);
+      pos = gt === -1 ? len : gt + 1;
+      continue;
+    }
+
+    // Closing tag: </tag>
+    if (str[pos] === "/") {
+      const gt = str.indexOf(">", pos);
+      if (gt === -1) throw new ParseError("Unclosed closing tag");
+      const closeTag = str.slice(pos + 1, gt).trim();
+      const open = stack.pop();
+      if (!open) {
+        throw new ParseError(`Unexpected closing tag: </${closeTag}>`);
+      }
+      if (
+        localTagName(open.tag) !== localTagName(closeTag) &&
+        open.tag !== closeTag
+      ) {
+        throw new ParseError(
+          `Mismatched closing tag: expected </${open.tag}>, got </${closeTag}>`
+        );
+      }
+      pos = gt + 1;
+      continue;
+    }
+
+    // Opening tag: <tag ...>
+    const gt = str.indexOf(">", pos);
+    if (gt === -1) {
+      throw new ParseError("Unclosed opening tag");
+    }
+
+    let tagBody = str.slice(pos, gt).trim();
+    const selfClosing = tagBody.endsWith("/");
+    if (selfClosing) {
+      tagBody = tagBody.slice(0, -1).trim();
+    }
+
+    const spaceIdx = tagBody.search(/\s/u);
+    const tagName = spaceIdx === -1 ? tagBody : tagBody.slice(0, spaceIdx);
+    const attrs: Record<string, string> = {};
+
+    if (spaceIdx !== -1) {
+      const attrStr = tagBody.slice(spaceIdx).trim();
+      const attrRegex =
+        /([a-zA-Z0-9_:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gu;
+      let m: RegExpExecArray | null;
+      while ((m = attrRegex.exec(attrStr)) !== null) {
+        attrs[m[1]] = unescapeXml(m[2] ?? m[3] ?? m[4] ?? "");
+      }
+    }
+
+    const el = new XmlElement(tagName, attrs);
+    const top = stack.at(-1);
+    if (top) {
+      top.children.push(el);
+    } else {
+      if (root) {
+        throw new ParseError("Multiple root elements found in XML document");
+      }
+      root = el;
+    }
+
+    if (!selfClosing) {
+      stack.push(el);
+    }
+    pos = gt + 1;
+  }
+
+  const lastUnclosed = stack.at(-1);
+  if (lastUnclosed) {
+    throw new ParseError(`Unclosed element: <${lastUnclosed.tag}>`);
+  }
+  if (!root) {
+    throw new ParseError("Empty XML document");
+  }
+
+  return root;
+}
+
+export function xmlBody(root: XmlElement): Buffer {
+  return Buffer.from(`${XML_DECL}\n${root.toXml(false)}`, "utf-8");
+}