From 51a7d0939e73603f3b27005fc5e948f476e3eca5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Sun, 16 Jan 2022 00:08:55 +0000
Subject: [PATCH 01/11] Assemble string from serializer

---
 .../parse5-serializer-stream/lib/index.ts     |  11 +-
 packages/parse5/lib/serializer/index.ts       | 131 +++++++++---------
 2 files changed, 69 insertions(+), 73 deletions(-)

diff --git a/packages/parse5-serializer-stream/lib/index.ts b/packages/parse5-serializer-stream/lib/index.ts
index c0d7863cb..9d1ac5b65 100644
--- a/packages/parse5-serializer-stream/lib/index.ts
+++ b/packages/parse5-serializer-stream/lib/index.ts
@@ -34,20 +34,11 @@ export class SerializerStream<T extends TreeAdapterTypeMap> extends Readable {
         super({ encoding: 'utf8' });
 
         this.serializer = new Serializer(node, options);
-
-        Object.defineProperty(this.serializer, 'html', {
-            //NOTE: To make `+=` concat operator work properly we define
-            //getter which always returns empty string
-            get() {
-                return '';
-            },
-            set: (data: string) => this.push(data),
-        });
     }
 
     //Readable stream implementation
     override _read(): void {
-        this.serializer.serialize();
+        this.push(this.serializer.serialize());
         this.push(null);
     }
 }
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index bf60a7049..09fe95f2f 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -1,4 +1,3 @@
-import * as defaultTreeAdapter from '../tree-adapters/default.js';
 import * as doctype from '../common/doctype.js';
 import { TAG_NAMES as $, NAMESPACES as NS } from '../common/html.js';
 import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface';
@@ -48,117 +47,123 @@ export interface SerializerOptions<T extends TreeAdapterTypeMap> {
      *
      * @default `treeAdapters.default`
      */
-    treeAdapter?: TreeAdapter<T>;
+    treeAdapter: TreeAdapter<T>;
 }
 
 //Serializer
 export class Serializer<T extends TreeAdapterTypeMap> {
-    html = '';
-    treeAdapter: TreeAdapter<T>;
-
-    constructor(
-        private startNode: T['parentNode'],
-        { treeAdapter = defaultTreeAdapter as TreeAdapter<T> }: SerializerOptions<T>
-    ) {
-        this.treeAdapter = treeAdapter;
-    }
+    constructor(private startNode: T['parentNode'], private options: SerializerOptions<T>) {}
 
     //API
     serialize(): string {
-        this._serializeChildNodes(this.startNode);
-
-        return this.html;
+        return this._serializeChildNodes(this.startNode, this.options);
     }
 
     //Internals
-    private _serializeChildNodes(parentNode: T['parentNode']): void {
-        const childNodes = this.treeAdapter.getChildNodes(parentNode);
+    private _serializeChildNodes<T extends TreeAdapterTypeMap>(
+        parentNode: T['parentNode'],
+        options: SerializerOptions<T>
+    ): string {
+        let html = '';
+        const childNodes = options.treeAdapter.getChildNodes(parentNode);
 
         if (childNodes) {
             for (const currentNode of childNodes) {
-                if (this.treeAdapter.isElementNode(currentNode)) {
-                    this._serializeElement(currentNode);
-                } else if (this.treeAdapter.isTextNode(currentNode)) {
-                    this._serializeTextNode(currentNode);
-                } else if (this.treeAdapter.isCommentNode(currentNode)) {
-                    this._serializeCommentNode(currentNode);
-                } else if (this.treeAdapter.isDocumentTypeNode(currentNode)) {
-                    this._serializeDocumentTypeNode(currentNode);
+                if (options.treeAdapter.isElementNode(currentNode)) {
+                    html += this._serializeElement(currentNode, options);
+                } else if (options.treeAdapter.isTextNode(currentNode)) {
+                    html += this._serializeTextNode(currentNode, options);
+                } else if (options.treeAdapter.isCommentNode(currentNode)) {
+                    html += this._serializeCommentNode(currentNode, options);
+                } else if (options.treeAdapter.isDocumentTypeNode(currentNode)) {
+                    html += this._serializeDocumentTypeNode(currentNode, options);
                 }
             }
         }
-    }
 
-    private _serializeElement(node: T['element']): void {
-        const tn = this.treeAdapter.getTagName(node);
-        const ns = this.treeAdapter.getNamespaceURI(node);
-
-        this.html += `<${tn}`;
-        this._serializeAttributes(node);
-        this.html += '>';
-
-        if (!VOID_ELEMENTS.has(tn)) {
-            const childNodesHolder =
-                tn === $.TEMPLATE && ns === NS.HTML ? this.treeAdapter.getTemplateContent(node) : node;
-
-            this._serializeChildNodes(childNodesHolder);
-            this.html += `</${tn}>`;
-        }
+        return html;
     }
 
-    private _serializeAttributes(node: T['element']): void {
-        for (const attr of this.treeAdapter.getAttrList(node)) {
-            const value = escapeString(attr.value, true);
+    private _serializeElement<T extends TreeAdapterTypeMap>(node: T['element'], options: SerializerOptions<T>): string {
+        const tn = options.treeAdapter.getTagName(node);
+        const ns = options.treeAdapter.getNamespaceURI(node);
+
+        return `<${tn}${this._serializeAttributes(node, options)}>${
+            VOID_ELEMENTS.has(tn)
+                ? ''
+                : `${this._serializeChildNodes(
+                      // Get container of the child nodes
+                      tn === $.TEMPLATE && ns === NS.HTML ? options.treeAdapter.getTemplateContent(node) : node,
+                      options
+                  )}</${tn}>`
+        }`;
+    }
 
-            this.html += ' ';
+    private _serializeAttributes<T extends TreeAdapterTypeMap>(
+        node: T['element'],
+        { treeAdapter }: SerializerOptions<T>
+    ): string {
+        let html = '';
+        for (const attr of treeAdapter.getAttrList(node)) {
+            html += ' ';
 
             if (!attr.namespace) {
-                this.html += attr.name;
+                html += attr.name;
             } else
                 switch (attr.namespace) {
                     case NS.XML: {
-                        this.html += `xml:${attr.name}`;
+                        html += `xml:${attr.name}`;
                         break;
                     }
                     case NS.XMLNS: {
                         if (attr.name !== 'xmlns') {
-                            this.html += 'xmlns:';
+                            html += 'xmlns:';
                         }
 
-                        this.html += attr.name;
+                        html += attr.name;
                         break;
                     }
                     case NS.XLINK: {
-                        this.html += `xlink:${attr.name}`;
+                        html += `xlink:${attr.name}`;
                         break;
                     }
                     default: {
-                        this.html += `${attr.prefix}:${attr.name}`;
+                        html += `${attr.prefix}:${attr.name}`;
                     }
                 }
 
-            this.html += `="${value}"`;
+            html += `="${escapeString(attr.value, true)}"`;
         }
+
+        return html;
     }
 
-    private _serializeTextNode(node: T['textNode']): void {
-        const content = this.treeAdapter.getTextNodeContent(node);
-        const parent = this.treeAdapter.getParentNode(node);
+    private _serializeTextNode<T extends TreeAdapterTypeMap>(
+        node: T['textNode'],
+        { treeAdapter }: SerializerOptions<T>
+    ): string {
+        const content = treeAdapter.getTextNodeContent(node);
+        const parent = treeAdapter.getParentNode(node);
 
-        this.html +=
-            parent && this.treeAdapter.isElementNode(parent) && UNESCAPED_TEXT.has(this.treeAdapter.getTagName(parent))
-                ? content
-                : escapeString(content, false);
+        return parent && treeAdapter.isElementNode(parent) && UNESCAPED_TEXT.has(treeAdapter.getTagName(parent))
+            ? content
+            : escapeString(content, false);
     }
 
-    private _serializeCommentNode(node: T['commentNode']): void {
-        this.html += `<!--${this.treeAdapter.getCommentNodeContent(node)}-->`;
+    private _serializeCommentNode<T extends TreeAdapterTypeMap>(
+        node: T['commentNode'],
+        { treeAdapter }: SerializerOptions<T>
+    ): string {
+        return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;
     }
 
-    private _serializeDocumentTypeNode(node: T['documentType']): void {
-        const name = this.treeAdapter.getDocumentTypeNodeName(node);
+    private _serializeDocumentTypeNode<T extends TreeAdapterTypeMap>(
+        node: T['documentType'],
+        { treeAdapter }: SerializerOptions<T>
+    ): string {
+        const name = treeAdapter.getDocumentTypeNodeName(node);
 
-        this.html += `<${doctype.serializeContent(name, null, null)}>`;
+        return `<${doctype.serializeContent(name, null, null)}>`;
     }
 }
 

From 3cccead476e95a004dc668e7d9427902a913d6f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Sun, 16 Jan 2022 00:18:10 +0000
Subject: [PATCH 02/11] Remove unnecessary `Serializer` class

---
 .../parse5-serializer-stream/lib/index.ts     |  10 +-
 packages/parse5/lib/index.ts                  |  10 +-
 packages/parse5/lib/serializer/index.ts       | 191 +++++++++---------
 3 files changed, 100 insertions(+), 111 deletions(-)

diff --git a/packages/parse5-serializer-stream/lib/index.ts b/packages/parse5-serializer-stream/lib/index.ts
index 9d1ac5b65..6d659102b 100644
--- a/packages/parse5-serializer-stream/lib/index.ts
+++ b/packages/parse5-serializer-stream/lib/index.ts
@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import { Serializer, SerializerOptions } from 'parse5/dist/serializer/index.js';
+import { serializeChildNodes, SerializerOptions } from 'parse5/dist/serializer/index.js';
 import type { TreeAdapterTypeMap } from 'parse5/dist/tree-adapters/interface.js';
 
 /**
@@ -22,23 +22,19 @@ import type { TreeAdapterTypeMap } from 'parse5/dist/tree-adapters/interface.js'
  * ```
  */
 export class SerializerStream<T extends TreeAdapterTypeMap> extends Readable {
-    private serializer: Serializer<T>;
-
     /**
      * Streaming AST node to an HTML serializer. A readable stream.
      *
      * @param node Node to serialize.
      * @param options Serialization options.
      */
-    constructor(node: T['parentNode'], options: SerializerOptions<T>) {
+    constructor(private node: T['parentNode'], private options: SerializerOptions<T>) {
         super({ encoding: 'utf8' });
-
-        this.serializer = new Serializer(node, options);
     }
 
     //Readable stream implementation
     override _read(): void {
-        this.push(this.serializer.serialize());
+        this.push(serializeChildNodes(this.node, this.options));
         this.push(null);
     }
 }
diff --git a/packages/parse5/lib/index.ts b/packages/parse5/lib/index.ts
index 1e770816e..44490fd84 100644
--- a/packages/parse5/lib/index.ts
+++ b/packages/parse5/lib/index.ts
@@ -1,6 +1,7 @@
 import { Parser, ParserOptions } from './parser/index.js';
-import { Serializer, SerializerOptions } from './serializer/index.js';
+import { serializeChildNodes, SerializerOptions } from './serializer/index.js';
 import type { DefaultTreeAdapterMap } from './tree-adapters/default.js';
+import * as DefaultTreeAdapter from './tree-adapters/default.js';
 import type { TreeAdapterTypeMap } from './tree-adapters/interface.js';
 
 export { ParserOptions } from './parser/index.js';
@@ -106,9 +107,8 @@ export function parseFragment<T extends TreeAdapterTypeMap = DefaultTreeAdapterM
  */
 export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(
     node: T['parentNode'],
-    options: SerializerOptions<T>
+    options: Partial<SerializerOptions<T>>
 ): string {
-    const serializer = new Serializer(node, options);
-
-    return serializer.serialize();
+    const opts = { treeAdapter: DefaultTreeAdapter, ...options };
+    return serializeChildNodes(node, opts);
 }
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index 09fe95f2f..9b4a1b214 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -51,120 +51,113 @@ export interface SerializerOptions<T extends TreeAdapterTypeMap> {
 }
 
 //Serializer
-export class Serializer<T extends TreeAdapterTypeMap> {
-    constructor(private startNode: T['parentNode'], private options: SerializerOptions<T>) {}
-
-    //API
-    serialize(): string {
-        return this._serializeChildNodes(this.startNode, this.options);
-    }
-
-    //Internals
-    private _serializeChildNodes<T extends TreeAdapterTypeMap>(
-        parentNode: T['parentNode'],
-        options: SerializerOptions<T>
-    ): string {
-        let html = '';
-        const childNodes = options.treeAdapter.getChildNodes(parentNode);
-
-        if (childNodes) {
-            for (const currentNode of childNodes) {
-                if (options.treeAdapter.isElementNode(currentNode)) {
-                    html += this._serializeElement(currentNode, options);
-                } else if (options.treeAdapter.isTextNode(currentNode)) {
-                    html += this._serializeTextNode(currentNode, options);
-                } else if (options.treeAdapter.isCommentNode(currentNode)) {
-                    html += this._serializeCommentNode(currentNode, options);
-                } else if (options.treeAdapter.isDocumentTypeNode(currentNode)) {
-                    html += this._serializeDocumentTypeNode(currentNode, options);
-                }
+export function serializeChildNodes<T extends TreeAdapterTypeMap>(
+    parentNode: T['parentNode'],
+    options: SerializerOptions<T>
+): string {
+    let html = '';
+    const childNodes = options.treeAdapter.getChildNodes(parentNode);
+
+    if (childNodes) {
+        for (const currentNode of childNodes) {
+            if (options.treeAdapter.isElementNode(currentNode)) {
+                html += serializeElement(currentNode, options);
+            } else if (options.treeAdapter.isTextNode(currentNode)) {
+                html += serializeTextNode(currentNode, options);
+            } else if (options.treeAdapter.isCommentNode(currentNode)) {
+                html += serializeCommentNode(currentNode, options);
+            } else if (options.treeAdapter.isDocumentTypeNode(currentNode)) {
+                html += serializeDocumentTypeNode(currentNode, options);
             }
         }
-
-        return html;
     }
 
-    private _serializeElement<T extends TreeAdapterTypeMap>(node: T['element'], options: SerializerOptions<T>): string {
-        const tn = options.treeAdapter.getTagName(node);
-        const ns = options.treeAdapter.getNamespaceURI(node);
-
-        return `<${tn}${this._serializeAttributes(node, options)}>${
-            VOID_ELEMENTS.has(tn)
-                ? ''
-                : `${this._serializeChildNodes(
-                      // Get container of the child nodes
-                      tn === $.TEMPLATE && ns === NS.HTML ? options.treeAdapter.getTemplateContent(node) : node,
-                      options
-                  )}</${tn}>`
-        }`;
-    }
+    return html;
+}
 
-    private _serializeAttributes<T extends TreeAdapterTypeMap>(
-        node: T['element'],
-        { treeAdapter }: SerializerOptions<T>
-    ): string {
-        let html = '';
-        for (const attr of treeAdapter.getAttrList(node)) {
-            html += ' ';
-
-            if (!attr.namespace) {
-                html += attr.name;
-            } else
-                switch (attr.namespace) {
-                    case NS.XML: {
-                        html += `xml:${attr.name}`;
-                        break;
-                    }
-                    case NS.XMLNS: {
-                        if (attr.name !== 'xmlns') {
-                            html += 'xmlns:';
-                        }
+export function serializeElement<T extends TreeAdapterTypeMap>(
+    node: T['element'],
+    options: SerializerOptions<T>
+): string {
+    const tn = options.treeAdapter.getTagName(node);
+    const ns = options.treeAdapter.getNamespaceURI(node);
+
+    return `<${tn}${serializeAttributes(node, options)}>${
+        VOID_ELEMENTS.has(tn)
+            ? ''
+            : `${serializeChildNodes(
+                  // Get container of the child nodes
+                  tn === $.TEMPLATE && ns === NS.HTML ? options.treeAdapter.getTemplateContent(node) : node,
+                  options
+              )}</${tn}>`
+    }`;
+}
 
-                        html += attr.name;
-                        break;
-                    }
-                    case NS.XLINK: {
-                        html += `xlink:${attr.name}`;
-                        break;
-                    }
-                    default: {
-                        html += `${attr.prefix}:${attr.name}`;
-                    }
+function serializeAttributes<T extends TreeAdapterTypeMap>(
+    node: T['element'],
+    { treeAdapter }: SerializerOptions<T>
+): string {
+    let html = '';
+    for (const attr of treeAdapter.getAttrList(node)) {
+        html += ' ';
+
+        if (!attr.namespace) {
+            html += attr.name;
+        } else
+            switch (attr.namespace) {
+                case NS.XML: {
+                    html += `xml:${attr.name}`;
+                    break;
                 }
+                case NS.XMLNS: {
+                    if (attr.name !== 'xmlns') {
+                        html += 'xmlns:';
+                    }
 
-            html += `="${escapeString(attr.value, true)}"`;
-        }
+                    html += attr.name;
+                    break;
+                }
+                case NS.XLINK: {
+                    html += `xlink:${attr.name}`;
+                    break;
+                }
+                default: {
+                    html += `${attr.prefix}:${attr.name}`;
+                }
+            }
 
-        return html;
+        html += `="${escapeString(attr.value, true)}"`;
     }
 
-    private _serializeTextNode<T extends TreeAdapterTypeMap>(
-        node: T['textNode'],
-        { treeAdapter }: SerializerOptions<T>
-    ): string {
-        const content = treeAdapter.getTextNodeContent(node);
-        const parent = treeAdapter.getParentNode(node);
+    return html;
+}
+
+function serializeTextNode<T extends TreeAdapterTypeMap>(
+    node: T['textNode'],
+    { treeAdapter }: SerializerOptions<T>
+): string {
+    const content = treeAdapter.getTextNodeContent(node);
+    const parent = treeAdapter.getParentNode(node);
 
-        return parent && treeAdapter.isElementNode(parent) && UNESCAPED_TEXT.has(treeAdapter.getTagName(parent))
-            ? content
-            : escapeString(content, false);
-    }
+    return parent && treeAdapter.isElementNode(parent) && UNESCAPED_TEXT.has(treeAdapter.getTagName(parent))
+        ? content
+        : escapeString(content, false);
+}
 
-    private _serializeCommentNode<T extends TreeAdapterTypeMap>(
-        node: T['commentNode'],
-        { treeAdapter }: SerializerOptions<T>
-    ): string {
-        return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;
-    }
+function serializeCommentNode<T extends TreeAdapterTypeMap>(
+    node: T['commentNode'],
+    { treeAdapter }: SerializerOptions<T>
+): string {
+    return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;
+}
 
-    private _serializeDocumentTypeNode<T extends TreeAdapterTypeMap>(
-        node: T['documentType'],
-        { treeAdapter }: SerializerOptions<T>
-    ): string {
-        const name = treeAdapter.getDocumentTypeNodeName(node);
+function serializeDocumentTypeNode<T extends TreeAdapterTypeMap>(
+    node: T['documentType'],
+    { treeAdapter }: SerializerOptions<T>
+): string {
+    const name = treeAdapter.getDocumentTypeNodeName(node);
 
-        return `<${doctype.serializeContent(name, null, null)}>`;
-    }
+    return `<${doctype.serializeContent(name, null, null)}>`;
 }
 
 // NOTE: used in tests and by rewriting stream

From a00379af5937f1dc59d81ae550bf5c9678217eb5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Sun, 16 Jan 2022 00:19:26 +0000
Subject: [PATCH 03/11] Simplify `serializeDocumentTypeNode`

---
 packages/parse5/lib/serializer/index.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index 9b4a1b214..9a1c45875 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -1,4 +1,3 @@
-import * as doctype from '../common/doctype.js';
 import { TAG_NAMES as $, NAMESPACES as NS } from '../common/html.js';
 import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface';
 
@@ -155,9 +154,7 @@ function serializeDocumentTypeNode<T extends TreeAdapterTypeMap>(
     node: T['documentType'],
     { treeAdapter }: SerializerOptions<T>
 ): string {
-    const name = treeAdapter.getDocumentTypeNodeName(node);
-
-    return `<${doctype.serializeContent(name, null, null)}>`;
+    return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;
 }
 
 // NOTE: used in tests and by rewriting stream

From cf0b73148866715295b45166ad064ee84102c9f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Sun, 16 Jan 2022 00:26:35 +0000
Subject: [PATCH 04/11] Delay ns lookup

---
 packages/parse5/lib/serializer/index.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index 9a1c45875..b692cb68e 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -79,14 +79,15 @@ export function serializeElement<T extends TreeAdapterTypeMap>(
     options: SerializerOptions<T>
 ): string {
     const tn = options.treeAdapter.getTagName(node);
-    const ns = options.treeAdapter.getNamespaceURI(node);
 
     return `<${tn}${serializeAttributes(node, options)}>${
         VOID_ELEMENTS.has(tn)
             ? ''
             : `${serializeChildNodes(
                   // Get container of the child nodes
-                  tn === $.TEMPLATE && ns === NS.HTML ? options.treeAdapter.getTemplateContent(node) : node,
+                  tn === $.TEMPLATE && options.treeAdapter.getNamespaceURI(node) === NS.HTML
+                      ? options.treeAdapter.getTemplateContent(node)
+                      : node,
                   options
               )}</${tn}>`
     }`;

From 677d83a213eddb0216d08266e900bd1697206aea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Mon, 17 Jan 2022 23:06:22 +0000
Subject: [PATCH 05/11] Move `serialize` fn to serializer file

and improve the options type
---
 .../parse5-serializer-stream/lib/index.ts     |  4 +--
 packages/parse5/lib/index.ts                  | 35 ++-----------------
 2 files changed, 4 insertions(+), 35 deletions(-)

diff --git a/packages/parse5-serializer-stream/lib/index.ts b/packages/parse5-serializer-stream/lib/index.ts
index 6d659102b..2cbf9f550 100644
--- a/packages/parse5-serializer-stream/lib/index.ts
+++ b/packages/parse5-serializer-stream/lib/index.ts
@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import { serializeChildNodes, SerializerOptions } from 'parse5/dist/serializer/index.js';
+import { serialize, type SerializerOptions } from 'parse5/dist/serializer/index.js';
 import type { TreeAdapterTypeMap } from 'parse5/dist/tree-adapters/interface.js';
 
 /**
@@ -34,7 +34,7 @@ export class SerializerStream<T extends TreeAdapterTypeMap> extends Readable {
 
     //Readable stream implementation
     override _read(): void {
-        this.push(serializeChildNodes(this.node, this.options));
+        this.push(serialize(this.node, this.options));
         this.push(null);
     }
 }
diff --git a/packages/parse5/lib/index.ts b/packages/parse5/lib/index.ts
index 44490fd84..25a4fb8b4 100644
--- a/packages/parse5/lib/index.ts
+++ b/packages/parse5/lib/index.ts
@@ -1,11 +1,10 @@
 import { Parser, ParserOptions } from './parser/index.js';
-import { serializeChildNodes, SerializerOptions } from './serializer/index.js';
+
 import type { DefaultTreeAdapterMap } from './tree-adapters/default.js';
-import * as DefaultTreeAdapter from './tree-adapters/default.js';
 import type { TreeAdapterTypeMap } from './tree-adapters/interface.js';
 
 export { ParserOptions } from './parser/index.js';
-export { SerializerOptions } from './serializer/index.js';
+export { serialize, SerializerOptions } from './serializer/index.js';
 
 // Shorthands
 
@@ -82,33 +81,3 @@ export function parseFragment<T extends TreeAdapterTypeMap = DefaultTreeAdapterM
 
     return parser.parseFragment(html as string, fragmentContext);
 }
-
-/**
- * Serializes an AST node to an HTML string.
- *
- * @example
- *
- * ```js
- * const parse5 = require('parse5');
- *
- * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
- *
- * // Serializes a document.
- * const html = parse5.serialize(document);
- *
- * // Serializes the <html> element content.
- * const str = parse5.serialize(document.childNodes[1]);
- *
- * console.log(str); //> '<head></head><body>Hi there!</body>'
- * ```
- *
- * @param node Node to serialize.
- * @param options Serialization options.
- */
-export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(
-    node: T['parentNode'],
-    options: Partial<SerializerOptions<T>>
-): string {
-    const opts = { treeAdapter: DefaultTreeAdapter, ...options };
-    return serializeChildNodes(node, opts);
-}

From 18f170c9b36ae17596bde459b08b1b6e71b9b41c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Mon, 17 Jan 2022 23:07:17 +0000
Subject: [PATCH 06/11] Add `scriptingEnabled` flag to serializer

Fixes #332
---
 packages/parse5/lib/serializer/index.test.ts | 12 +++
 packages/parse5/lib/serializer/index.ts      | 78 +++++++++++++-------
 2 files changed, 64 insertions(+), 26 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.test.ts b/packages/parse5/lib/serializer/index.test.ts
index 3fc221817..3ea76d129 100644
--- a/packages/parse5/lib/serializer/index.test.ts
+++ b/packages/parse5/lib/serializer/index.test.ts
@@ -22,4 +22,16 @@ describe('serializer', () => {
             parse5.serialize(document, { treeAdapter });
         });
     });
+
+    describe('Scripting flag (GH-332)', () => {
+        it('should serialize with the scripting flag', () => {
+            const document = parse5.parse('&amp;<noscript>&amp;</noscript>');
+            expect(parse5.serialize(document, { scriptingEnabled: false })).toBe(
+                '<html><head></head><body>&amp;<noscript>&amp;amp;</noscript></body></html>'
+            );
+            expect(parse5.serialize(document, { scriptingEnabled: true })).toBe(
+                '<html><head></head><body>&amp;<noscript>&amp;</noscript></body></html>'
+            );
+        });
+    });
 });
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index b692cb68e..303976bbd 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -1,5 +1,6 @@
 import { TAG_NAMES as $, NAMESPACES as NS } from '../common/html.js';
 import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface';
+import * as DefaultTreeAdapter from '../tree-adapters/default.js';
 
 //Escaping regexes
 const AMP_REGEX = /&/g;
@@ -29,16 +30,7 @@ const VOID_ELEMENTS = new Set<string>([
     $.TRACK,
     $.WBR,
 ]);
-const UNESCAPED_TEXT = new Set<string>([
-    $.STYLE,
-    $.SCRIPT,
-    $.XMP,
-    $.IFRAME,
-    $.NOEMBED,
-    $.NOFRAMES,
-    $.PLAINTEXT,
-    $.NOSCRIPT,
-]);
+const UNESCAPED_TEXT = new Set<string>([$.STYLE, $.SCRIPT, $.XMP, $.IFRAME, $.NOEMBED, $.NOFRAMES, $.PLAINTEXT]);
 
 export interface SerializerOptions<T extends TreeAdapterTypeMap> {
     /**
@@ -46,13 +38,51 @@ export interface SerializerOptions<T extends TreeAdapterTypeMap> {
      *
      * @default `treeAdapters.default`
      */
-    treeAdapter: TreeAdapter<T>;
+    treeAdapter?: TreeAdapter<T>;
+    /**
+     * The [scripting flag](https://html.spec.whatwg.org/multipage/parsing.html#scripting-flag). If set
+     * to `true`, `noscript` element content will not be escaped.
+     *
+     *  @default `true`
+     */
+    scriptingEnabled?: boolean;
 }
 
-//Serializer
-export function serializeChildNodes<T extends TreeAdapterTypeMap>(
-    parentNode: T['parentNode'],
+type InternalOptions<T extends TreeAdapterTypeMap> = Required<SerializerOptions<T>>;
+
+/**
+ * Serializes an AST node to an HTML string.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * // Serializes a document.
+ * const html = parse5.serialize(document);
+ *
+ * // Serializes the <html> element content.
+ * const str = parse5.serialize(document.childNodes[1]);
+ *
+ * console.log(str); //> '<head></head><body>Hi there!</body>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapter.DefaultTreeAdapterMap>(
+    node: T['parentNode'],
     options: SerializerOptions<T>
+): string {
+    const opts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true, ...options };
+    return serializeChildNodes(node, opts);
+}
+
+function serializeChildNodes<T extends TreeAdapterTypeMap>(
+    parentNode: T['parentNode'],
+    options: InternalOptions<T>
 ): string {
     let html = '';
     const childNodes = options.treeAdapter.getChildNodes(parentNode);
@@ -74,10 +104,7 @@ export function serializeChildNodes<T extends TreeAdapterTypeMap>(
     return html;
 }
 
-export function serializeElement<T extends TreeAdapterTypeMap>(
-    node: T['element'],
-    options: SerializerOptions<T>
-): string {
+function serializeElement<T extends TreeAdapterTypeMap>(node: T['element'], options: InternalOptions<T>): string {
     const tn = options.treeAdapter.getTagName(node);
 
     return `<${tn}${serializeAttributes(node, options)}>${
@@ -95,7 +122,7 @@ export function serializeElement<T extends TreeAdapterTypeMap>(
 
 function serializeAttributes<T extends TreeAdapterTypeMap>(
     node: T['element'],
-    { treeAdapter }: SerializerOptions<T>
+    { treeAdapter }: InternalOptions<T>
 ): string {
     let html = '';
     for (const attr of treeAdapter.getAttrList(node)) {
@@ -132,28 +159,27 @@ function serializeAttributes<T extends TreeAdapterTypeMap>(
     return html;
 }
 
-function serializeTextNode<T extends TreeAdapterTypeMap>(
-    node: T['textNode'],
-    { treeAdapter }: SerializerOptions<T>
-): string {
+function serializeTextNode<T extends TreeAdapterTypeMap>(node: T['textNode'], options: InternalOptions<T>): string {
+    const { treeAdapter } = options;
     const content = treeAdapter.getTextNodeContent(node);
     const parent = treeAdapter.getParentNode(node);
+    const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent);
 
-    return parent && treeAdapter.isElementNode(parent) && UNESCAPED_TEXT.has(treeAdapter.getTagName(parent))
+    return parentTn && (UNESCAPED_TEXT.has(parentTn) || (options.scriptingEnabled && parentTn === $.NOSCRIPT))
         ? content
         : escapeString(content, false);
 }
 
 function serializeCommentNode<T extends TreeAdapterTypeMap>(
     node: T['commentNode'],
-    { treeAdapter }: SerializerOptions<T>
+    { treeAdapter }: InternalOptions<T>
 ): string {
     return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;
 }
 
 function serializeDocumentTypeNode<T extends TreeAdapterTypeMap>(
     node: T['documentType'],
-    { treeAdapter }: SerializerOptions<T>
+    { treeAdapter }: InternalOptions<T>
 ): string {
     return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;
 }

From 67dbf7233847e9187c866149762b1bfaf76970d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Mon, 17 Jan 2022 23:15:24 +0000
Subject: [PATCH 07/11] Fix serializing mixed content

Fixes #333
---
 packages/parse5/lib/serializer/index.test.ts | 15 +++++++++++++++
 packages/parse5/lib/serializer/index.ts      |  8 +++++---
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.test.ts b/packages/parse5/lib/serializer/index.test.ts
index 3ea76d129..7fbab9585 100644
--- a/packages/parse5/lib/serializer/index.test.ts
+++ b/packages/parse5/lib/serializer/index.test.ts
@@ -1,5 +1,6 @@
 import * as assert from 'node:assert';
 import * as parse5 from 'parse5';
+import outdent from 'outdent';
 import { generateSerializerTests } from 'parse5-test-utils/utils/generate-serializer-tests.js';
 import { treeAdapters } from 'parse5-test-utils/utils/common.js';
 import type { Element } from 'parse5/dist/tree-adapters/default';
@@ -34,4 +35,18 @@ describe('serializer', () => {
             );
         });
     });
+
+    describe('Mixed content (GH-333)', () => {
+        it('should serialize mixed content', () => {
+            const input = outdent`
+              <svg><style>&lt;</style></svg>
+              <style>&lt;</style>
+
+              <svg><script>&lt;</script></svg>
+              <script>&lt;</script>
+            `;
+            const document = parse5.parse(input);
+            expect(parse5.serialize(document)).toContain(input);
+        });
+    });
 });
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index 303976bbd..e02c976f9 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -74,7 +74,7 @@ type InternalOptions<T extends TreeAdapterTypeMap> = Required<SerializerOptions<
  */
 export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapter.DefaultTreeAdapterMap>(
     node: T['parentNode'],
-    options: SerializerOptions<T>
+    options?: SerializerOptions<T>
 ): string {
     const opts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true, ...options };
     return serializeChildNodes(node, opts);
@@ -108,7 +108,7 @@ function serializeElement<T extends TreeAdapterTypeMap>(node: T['element'], opti
     const tn = options.treeAdapter.getTagName(node);
 
     return `<${tn}${serializeAttributes(node, options)}>${
-        VOID_ELEMENTS.has(tn)
+        options.treeAdapter.getNamespaceURI(node) === NS.HTML && VOID_ELEMENTS.has(tn)
             ? ''
             : `${serializeChildNodes(
                   // Get container of the child nodes
@@ -165,7 +165,9 @@ function serializeTextNode<T extends TreeAdapterTypeMap>(node: T['textNode'], op
     const parent = treeAdapter.getParentNode(node);
     const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent);
 
-    return parentTn && (UNESCAPED_TEXT.has(parentTn) || (options.scriptingEnabled && parentTn === $.NOSCRIPT))
+    return parentTn &&
+        treeAdapter.getNamespaceURI(parent) === NS.HTML &&
+        (UNESCAPED_TEXT.has(parentTn) || (options.scriptingEnabled && parentTn === $.NOSCRIPT))
         ? content
         : escapeString(content, false);
 }

From 844f0724799bffb41753ed0a64bb28f300649164 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Mon, 17 Jan 2022 23:35:19 +0000
Subject: [PATCH 08/11] feat: Add serializeOuter method

Fixes #230, #378

Uses the test case from #378, by @joeldenning

Co-Authored-By: Joel Denning <5524384+joeldenning@users.noreply.github.com>
---
 packages/parse5/lib/index.ts                 |  2 +-
 packages/parse5/lib/serializer/index.test.ts | 13 +++++++-
 packages/parse5/lib/serializer/index.ts      | 31 +++++++++++++++++++-
 3 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/packages/parse5/lib/index.ts b/packages/parse5/lib/index.ts
index 25a4fb8b4..dd3744b2c 100644
--- a/packages/parse5/lib/index.ts
+++ b/packages/parse5/lib/index.ts
@@ -4,7 +4,7 @@ import type { DefaultTreeAdapterMap } from './tree-adapters/default.js';
 import type { TreeAdapterTypeMap } from './tree-adapters/interface.js';
 
 export { ParserOptions } from './parser/index.js';
-export { serialize, SerializerOptions } from './serializer/index.js';
+export { serialize, serializeOuter, SerializerOptions } from './serializer/index.js';
 
 // Shorthands
 
diff --git a/packages/parse5/lib/serializer/index.test.ts b/packages/parse5/lib/serializer/index.test.ts
index 7fbab9585..1e6403684 100644
--- a/packages/parse5/lib/serializer/index.test.ts
+++ b/packages/parse5/lib/serializer/index.test.ts
@@ -3,7 +3,7 @@ import * as parse5 from 'parse5';
 import outdent from 'outdent';
 import { generateSerializerTests } from 'parse5-test-utils/utils/generate-serializer-tests.js';
 import { treeAdapters } from 'parse5-test-utils/utils/common.js';
-import type { Element } from 'parse5/dist/tree-adapters/default';
+import { type Element, isElementNode } from 'parse5/dist/tree-adapters/default';
 
 generateSerializerTests('serializer', 'Serializer', parse5.serialize);
 
@@ -49,4 +49,15 @@ describe('serializer', () => {
             expect(parse5.serialize(document)).toContain(input);
         });
     });
+
+    describe('serializeOuter', () => {
+        it('serializes outerHTML correctly', () => {
+            const document = parse5.parseFragment('<div><button>Hello</button></div>');
+            const div = document.childNodes[0];
+            assert.ok(isElementNode(div));
+            const html = parse5.serializeOuter(div);
+
+            assert.equal(html, '<div><button>Hello</button></div>');
+        });
+    });
 });
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index e02c976f9..6019a0286 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -50,6 +50,8 @@ export interface SerializerOptions<T extends TreeAdapterTypeMap> {
 
 type InternalOptions<T extends TreeAdapterTypeMap> = Required<SerializerOptions<T>>;
 
+const defaultOpts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true };
+
 /**
  * Serializes an AST node to an HTML string.
  *
@@ -76,10 +78,37 @@ export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapter.Defa
     node: T['parentNode'],
     options?: SerializerOptions<T>
 ): string {
-    const opts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true, ...options };
+    const opts = { ...defaultOpts, ...options };
     return serializeChildNodes(node, opts);
 }
 
+/**
+ * Serializes an AST element node to an HTML string, including the element node.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
+ *
+ * // Serializes the <div> element.
+ * const html = parse5.serializeOuter(document.childNodes[0]);
+ *
+ * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export function serializeOuter<T extends TreeAdapterTypeMap = DefaultTreeAdapter.DefaultTreeAdapterMap>(
+    node: T['element'],
+    options?: SerializerOptions<T>
+): string {
+    const opts = { ...defaultOpts, ...options };
+    return serializeElement(node, opts);
+}
+
 function serializeChildNodes<T extends TreeAdapterTypeMap>(
     parentNode: T['parentNode'],
     options: InternalOptions<T>

From 9424821eed4bbcd106ac5b5eaec7e8fe051f5f3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Tue, 18 Jan 2022 14:46:45 +0000
Subject: [PATCH 09/11] Move serializer tests to data file

---
 packages/parse5/lib/serializer/index.test.ts | 27 --------------------
 test/data/serialization/tests.json           | 11 ++++++++
 test/utils/generate-serializer-tests.ts      |  3 ++-
 3 files changed, 13 insertions(+), 28 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.test.ts b/packages/parse5/lib/serializer/index.test.ts
index 1e6403684..233419ea4 100644
--- a/packages/parse5/lib/serializer/index.test.ts
+++ b/packages/parse5/lib/serializer/index.test.ts
@@ -1,6 +1,5 @@
 import * as assert from 'node:assert';
 import * as parse5 from 'parse5';
-import outdent from 'outdent';
 import { generateSerializerTests } from 'parse5-test-utils/utils/generate-serializer-tests.js';
 import { treeAdapters } from 'parse5-test-utils/utils/common.js';
 import { type Element, isElementNode } from 'parse5/dist/tree-adapters/default';
@@ -24,32 +23,6 @@ describe('serializer', () => {
         });
     });
 
-    describe('Scripting flag (GH-332)', () => {
-        it('should serialize with the scripting flag', () => {
-            const document = parse5.parse('&amp;<noscript>&amp;</noscript>');
-            expect(parse5.serialize(document, { scriptingEnabled: false })).toBe(
-                '<html><head></head><body>&amp;<noscript>&amp;amp;</noscript></body></html>'
-            );
-            expect(parse5.serialize(document, { scriptingEnabled: true })).toBe(
-                '<html><head></head><body>&amp;<noscript>&amp;</noscript></body></html>'
-            );
-        });
-    });
-
-    describe('Mixed content (GH-333)', () => {
-        it('should serialize mixed content', () => {
-            const input = outdent`
-              <svg><style>&lt;</style></svg>
-              <style>&lt;</style>
-
-              <svg><script>&lt;</script></svg>
-              <script>&lt;</script>
-            `;
-            const document = parse5.parse(input);
-            expect(parse5.serialize(document)).toContain(input);
-        });
-    });
-
     describe('serializeOuter', () => {
         it('serializes outerHTML correctly', () => {
             const document = parse5.parseFragment('<div><button>Hello</button></div>');
diff --git a/test/data/serialization/tests.json b/test/data/serialization/tests.json
index f06300fbb..c563f340e 100644
--- a/test/data/serialization/tests.json
+++ b/test/data/serialization/tests.json
@@ -99,6 +99,12 @@
         "input": "<body><noscript>& ><</noscript></body>",
         "expected": "<html><head></head><body><noscript>& ><</noscript></body></html>"
     },
+    {
+        "name": "Text nodes escaping - <noscript> with scripting disabled (GH-332)",
+        "options": { "scriptingEnabled": false },
+        "input": "<body><noscript>& ><</noscript></body>",
+        "expected": "<html><head></head><body><noscript>&amp; &gt;&lt;</noscript></body></html>"
+    },
     {
         "name": "Comment nodes",
         "input": "<!-- Hey --><html><head></head><!-- &\u00A0>< --><body><!-- 42 --></body></html>",
@@ -133,5 +139,10 @@
         "name": "<pre>, <textarea>, <listing> with initial LF (see: https://github.com/whatwg/html/pull/1815)",
         "input": "<pre>\n1</pre><pre>\n\n2</pre><textarea>\n3</textarea><textarea>\n\n4</textarea><listing>\n5</listing><listing>\n\n6</listing>",
         "expected": "<html><head></head><body><pre>1</pre><pre>\n2</pre><textarea>3</textarea><textarea>\n4</textarea><listing>5</listing><listing>\n6</listing></body></html>"
+    },
+    {
+        "name": "Mixed content",
+        "input": "<svg><style>&lt;</style></svg><style>&lt;</style><svg><script>&lt;</script></svg><script>&lt;</script>",
+        "expected": "<html><head></head><body><svg><style>&lt;</style></svg><style>&lt;</style><svg><script>&lt;</script></svg><script>&lt;</script></body></html>"
     }
 ]
diff --git a/test/utils/generate-serializer-tests.ts b/test/utils/generate-serializer-tests.ts
index c16cf28af..e08a8b2da 100644
--- a/test/utils/generate-serializer-tests.ts
+++ b/test/utils/generate-serializer-tests.ts
@@ -15,6 +15,7 @@ export function generateSerializerTests(
     const data = fs.readFileSync(new URL('../data/serialization/tests.json', import.meta.url)).toString('utf-8');
     const tests = JSON.parse(data) as {
         name: string;
+        options?: parse5.SerializerOptions<TreeAdapterTypeMap>;
         input: string;
         expected: string;
     }[];
@@ -22,7 +23,7 @@ export function generateSerializerTests(
     generateTestsForEachTreeAdapter(name, (treeAdapter) => {
         for (const [idx, test] of tests.entries()) {
             it(`${prefix} - ${idx}.${test.name}`, async () => {
-                const opts = { treeAdapter };
+                const opts = { ...test.options, treeAdapter };
                 const document = parse5.parse(test.input, opts);
                 const serializedResult = await serialize(document, opts);
 

From feaf5092aee413cc31929a436d383bf014b80930 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Tue, 18 Jan 2022 14:47:59 +0000
Subject: [PATCH 10/11] Add missing issue reference

---
 test/data/serialization/tests.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/data/serialization/tests.json b/test/data/serialization/tests.json
index c563f340e..35affb1bc 100644
--- a/test/data/serialization/tests.json
+++ b/test/data/serialization/tests.json
@@ -141,7 +141,7 @@
         "expected": "<html><head></head><body><pre>1</pre><pre>\n2</pre><textarea>3</textarea><textarea>\n4</textarea><listing>5</listing><listing>\n6</listing></body></html>"
     },
     {
-        "name": "Mixed content",
+        "name": "Mixed content (GH-333)",
         "input": "<svg><style>&lt;</style></svg><style>&lt;</style><svg><script>&lt;</script></svg><script>&lt;</script>",
         "expected": "<html><head></head><body><svg><style>&lt;</style></svg><style>&lt;</style><svg><script>&lt;</script></svg><script>&lt;</script></body></html>"
     }

From a6f4b620a25345b45e043faf33cdbcca39f33c90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <188768+fb55@users.noreply.github.com>
Date: Fri, 4 Feb 2022 21:18:01 -0600
Subject: [PATCH 11/11] fix: `serialize` top-level template contents

Before this, passing a `template` tag to `serialize` would result in an empty string.
---
 packages/parse5/lib/serializer/index.test.ts |  9 +++++++++
 packages/parse5/lib/serializer/index.ts      | 17 +++++++++--------
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/packages/parse5/lib/serializer/index.test.ts b/packages/parse5/lib/serializer/index.test.ts
index 233419ea4..5d9dc5516 100644
--- a/packages/parse5/lib/serializer/index.test.ts
+++ b/packages/parse5/lib/serializer/index.test.ts
@@ -33,4 +33,13 @@ describe('serializer', () => {
             assert.equal(html, '<div><button>Hello</button></div>');
         });
     });
+
+    it('serializes <template> elements inner content', () => {
+        const document = parse5.parseFragment('<template><button>Hello</button></template>');
+        const template = document.childNodes[0];
+        assert.ok(isElementNode(template));
+        const html = parse5.serialize(template);
+
+        assert.equal(html, '<button>Hello</button>');
+    });
 });
diff --git a/packages/parse5/lib/serializer/index.ts b/packages/parse5/lib/serializer/index.ts
index 6019a0286..65a9ca57b 100644
--- a/packages/parse5/lib/serializer/index.ts
+++ b/packages/parse5/lib/serializer/index.ts
@@ -114,7 +114,14 @@ function serializeChildNodes<T extends TreeAdapterTypeMap>(
     options: InternalOptions<T>
 ): string {
     let html = '';
-    const childNodes = options.treeAdapter.getChildNodes(parentNode);
+    // Get container of the child nodes
+    const container =
+        options.treeAdapter.isElementNode(parentNode) &&
+        options.treeAdapter.getTagName(parentNode) === $.TEMPLATE &&
+        options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML
+            ? options.treeAdapter.getTemplateContent(parentNode)
+            : parentNode;
+    const childNodes = options.treeAdapter.getChildNodes(container);
 
     if (childNodes) {
         for (const currentNode of childNodes) {
@@ -139,13 +146,7 @@ function serializeElement<T extends TreeAdapterTypeMap>(node: T['element'], opti
     return `<${tn}${serializeAttributes(node, options)}>${
         options.treeAdapter.getNamespaceURI(node) === NS.HTML && VOID_ELEMENTS.has(tn)
             ? ''
-            : `${serializeChildNodes(
-                  // Get container of the child nodes
-                  tn === $.TEMPLATE && options.treeAdapter.getNamespaceURI(node) === NS.HTML
-                      ? options.treeAdapter.getTemplateContent(node)
-                      : node,
-                  options
-              )}</${tn}>`
+            : `${serializeChildNodes(node, options)}</${tn}>`
     }`;
 }