@tkeron/html-parser 0.1.4 → 0.1.5

package/tests/cloneNode.test.ts

@@ -11,17 +11,17 @@ describe("cloneNode functionality", () => {
 
       const cloned = original.cloneNode(true);
 
-      // Verificar que el nodo clonado existe
+      
       expect(cloned).toBeTruthy();
       expect(cloned.nodeName).toBe("DIV");
 
-      // Verificar que los atributos se copian
+      
       expect(cloned.getAttribute("id")).toBe("original");
 
-      // Verificar que el contenido de texto se copia
+      
       expect(cloned.textContent).toBe("Hello World");
 
-      // Verificar que tiene los hijos correctos
+      
       expect(cloned.childNodes.length).toBeGreaterThan(0);
     });
 
@@ -38,20 +38,20 @@ describe("cloneNode functionality", () => {
 
       const cloned = parent.cloneNode(true);
 
-      // Verificar estructura básica
+      
       expect(cloned.nodeName).toBe("DIV");
       expect(cloned.getAttribute("id")).toBe("parent");
 
-      // Verificar que los hijos se clonaron
+      
       expect(cloned.childNodes.length).toBeGreaterThan(0);
       
-      // Verificar que el hijo div está presente
+      
       const childDiv = cloned.querySelector(".child");
       expect(childDiv).toBeTruthy();
       expect(childDiv?.nodeName).toBe("DIV");
       expect(childDiv?.getAttribute("class")).toBe("child");
 
-      // Verificar el nieto span
+      
       const span = cloned.querySelector("span");
       expect(span).toBeTruthy();
       expect(span?.textContent).toBe("Nested Text");
@@ -70,7 +70,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = list.cloneNode(true);
 
-      // Verificar que todos los items se clonaron
+      
       const items = cloned.querySelectorAll("li");
       expect(items.length).toBe(3);
       expect(items[0]?.textContent).toBe("Item 1");
@@ -89,18 +89,18 @@ describe("cloneNode functionality", () => {
       const doc = parseHTML(html);
       const container = doc.querySelector("#container")!;
 
-      // Guardar innerHTML original
+      
       const originalInnerHTML = container.innerHTML;
       expect(originalInnerHTML).toBeTruthy();
       expect(originalInnerHTML.length).toBeGreaterThan(0);
 
       const cloned = container.cloneNode(true);
 
-      // Verificar que innerHTML del clon no esté vacío
+      
       expect(cloned.innerHTML).toBeTruthy();
       expect(cloned.innerHTML.length).toBeGreaterThan(0);
 
-      // Verificar que el contenido es similar
+      
       expect(cloned.innerHTML).toContain("<h1>Title</h1>");
       expect(cloned.innerHTML).toContain("<p>Paragraph 1</p>");
       expect(cloned.innerHTML).toContain("<p>Paragraph 2</p>");
@@ -111,19 +111,19 @@ describe("cloneNode functionality", () => {
       const doc = parseHTML(html);
       const mixed = doc.querySelector("#mixed")!;
 
-      // Verificar estructura original
+      
       const originalChildCount = mixed.childNodes.length;
       expect(originalChildCount).toBeGreaterThan(0);
 
       const cloned = mixed.cloneNode(true);
 
-      // Verificar que tiene la misma cantidad de hijos
+      
       expect(cloned.childNodes.length).toBe(originalChildCount);
 
-      // Verificar contenido completo
+      
       expect(cloned.textContent).toBe("Text beforebold textText after");
 
-      // Verificar que el elemento strong existe
+      
       const strong = cloned.querySelector("strong");
       expect(strong).toBeTruthy();
       expect(strong?.textContent).toBe("bold text");
@@ -136,7 +136,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = element.cloneNode(true);
 
-      // Verificar todos los atributos
+      
       expect(cloned.getAttribute("id")).toBe("attrs");
       expect(cloned.getAttribute("class")).toBe("test");
       expect(cloned.getAttribute("data-value")).toBe("123");
@@ -161,11 +161,11 @@ describe("cloneNode functionality", () => {
 
       const cloned = article.cloneNode(true);
 
-      // Verificar estructura
+      
       expect(cloned.nodeName).toBe("ARTICLE");
       expect(cloned.getAttribute("id")).toBe("article");
 
-      // Verificar elementos
+      
       expect(cloned.querySelector("h2")?.textContent).toBe("Article Title");
       
       const paragraphs = cloned.querySelectorAll("p");
@@ -173,12 +173,12 @@ describe("cloneNode functionality", () => {
       expect(paragraphs[0]?.textContent).toBe("First paragraph");
       expect(paragraphs[1]?.textContent).toBe("Last paragraph");
 
-      // Verificar div anidado
+      
       const highlight = cloned.querySelector(".highlight");
       expect(highlight).toBeTruthy();
       expect(highlight?.querySelector("span")?.textContent).toBe("Highlighted");
 
-      // Verificar que se copió el comentario
+      
       const hasComment = Array.from(cloned.childNodes).some(
         (node: any) => node.nodeType === NodeType.COMMENT_NODE
       );
@@ -203,7 +203,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = section.cloneNode(true);
 
-      // Verificar outerHTML
+      
       expect(cloned.outerHTML).toBeTruthy();
       expect(cloned.outerHTML).toContain("section");
       expect(cloned.outerHTML).toContain("class=\"main\"");
@@ -220,7 +220,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = parent.cloneNode(false);
 
-      // Debe copiar el elemento pero no los hijos
+      
       expect(cloned.nodeName).toBe("DIV");
       expect(cloned.getAttribute("id")).toBe("parent");
       expect(cloned.childNodes.length).toBe(0);
@@ -234,12 +234,12 @@ describe("cloneNode functionality", () => {
 
       const cloned = element.cloneNode(false);
 
-      // Atributos deben copiarse
+      
       expect(cloned.getAttribute("id")).toBe("test");
       expect(cloned.getAttribute("class")).toBe("container");
       expect(cloned.getAttribute("data-value")).toBe("123");
 
-      // Hijos NO deben copiarse
+      
       expect(cloned.childNodes.length).toBe(0);
       expect(cloned.innerHTML).toBe("");
     });
@@ -253,7 +253,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = original.cloneNode(true);
 
-      // Modificar el clon no debe afectar el original
+      
       cloned.setAttribute("id", "cloned");
       cloned.setAttribute("data-modified", "true");
 
@@ -273,10 +273,10 @@ describe("cloneNode functionality", () => {
       
       expect(clonedChild).toBeTruthy();
       
-      // Modificar hijo del clon
+      
       clonedChild?.setAttribute("data-cloned", "yes");
 
-      // El hijo original no debe verse afectado
+      
       const originalChild = parent.querySelector("#child");
       expect(originalChild?.hasAttribute("data-cloned")).toBe(false);
     });
@@ -324,7 +324,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = level1.cloneNode(true);
 
-      // Verificar todos los niveles
+      
       expect(cloned.querySelector("#level2")).toBeTruthy();
       expect(cloned.querySelector("#level3")).toBeTruthy();
       expect(cloned.querySelector("#level4")).toBeTruthy();
@@ -340,22 +340,22 @@ describe("cloneNode functionality", () => {
       const doc = parseHTML(html);
       const container = doc.querySelector("#container")!;
 
-      // Acceder a innerHTML para asegurar que _internalInnerHTML esté establecido
+      
       const originalInnerHTML = container.innerHTML;
       expect(originalInnerHTML).toBeTruthy();
 
       const cloned = container.cloneNode(true);
 
-      // Verificar que innerHTML funciona en el clon
+      
       const clonedInnerHTML = cloned.innerHTML;
       expect(clonedInnerHTML).toBeTruthy();
       expect(clonedInnerHTML.length).toBeGreaterThan(0);
 
-      // Verificar que contiene el mismo contenido
+      
       expect(clonedInnerHTML).toContain("<p>Paragraph 1</p>");
       expect(clonedInnerHTML).toContain("<p>Paragraph 2</p>");
 
-      // Verificar que el accessor de innerHTML funciona correctamente
+      
       expect(typeof cloned.innerHTML).toBe("string");
     });
 
@@ -369,10 +369,10 @@ describe("cloneNode functionality", () => {
 
       const cloned = parent.cloneNode(true);
 
-      // Verificar que childNodes tiene la misma estructura
+      
       expect(cloned.childNodes.length).toBe(originalChildCount);
       
-      // Verificar que podemos acceder a cada hijo
+      
       for (let i = 0; i < cloned.childNodes.length; i++) {
         expect(cloned.childNodes[i]).toBeTruthy();
         expect(cloned.childNodes[i].nodeType).toBeDefined();
@@ -386,12 +386,12 @@ describe("cloneNode functionality", () => {
 
       const cloned = container.cloneNode(true);
 
-      // Verificar que el array children está correctamente poblado
+      
       expect(cloned.children).toBeTruthy();
       expect(Array.isArray(cloned.children)).toBe(true);
       expect(cloned.children.length).toBe(3);
 
-      // Verificar que todos son elementos
+      
       for (const child of cloned.children) {
         expect(child.nodeType).toBe(NodeType.ELEMENT_NODE);
       }
@@ -404,12 +404,12 @@ describe("cloneNode functionality", () => {
 
       const cloned = list.cloneNode(true);
 
-      // Verificar referencias firstChild y lastChild
+      
       expect(cloned.firstChild).toBeTruthy();
       expect(cloned.lastChild).toBeTruthy();
       
-      // En DOM real, firstChild puede ser un nodo de texto (whitespace)
-      // pero debemos asegurar que existen
+      
+      
       expect(cloned.firstElementChild).toBeTruthy();
       expect(cloned.lastElementChild).toBeTruthy();
       
@@ -427,12 +427,12 @@ describe("cloneNode functionality", () => {
       const doc = parseHTML(html);
       const dynamic = doc.querySelector("#dynamic")!;
 
-      // Modificar innerHTML antes de clonar
+      
       dynamic.innerHTML = "<p>Dynamic content</p><span>More content</span>";
 
       const cloned = dynamic.cloneNode(true);
 
-      // Verificar que el contenido modificado se clonó
+      
       expect(cloned.querySelector("p")).toBeTruthy();
       expect(cloned.querySelector("p")?.textContent).toBe("Dynamic content");
       expect(cloned.querySelector("span")).toBeTruthy();
@@ -446,17 +446,17 @@ describe("cloneNode functionality", () => {
 
       const cloned = original.cloneNode(true);
 
-      // Verificar contenido clonado
+      
       expect(cloned.querySelector("p")?.textContent).toBe("Original");
 
-      // Modificar innerHTML del clon
+      
       cloned.innerHTML = "<span>Modified</span>";
 
-      // Original no debe cambiar
+      
       expect(original.querySelector("p")?.textContent).toBe("Original");
       expect(original.querySelector("span")).toBeNull();
 
-      // Clon debe tener el nuevo contenido
+      
       expect(cloned.querySelector("span")?.textContent).toBe("Modified");
       expect(cloned.querySelector("p")).toBeNull();
     });
@@ -488,13 +488,13 @@ describe("cloneNode functionality", () => {
 
       const cloned = card.cloneNode(true);
 
-      // Verificar estructura completa
+      
       expect(cloned.getAttribute("data-id")).toBe("123");
       expect(cloned.querySelector(".card-header")).toBeTruthy();
       expect(cloned.querySelector(".card-body")).toBeTruthy();
       expect(cloned.querySelector(".card-footer")).toBeTruthy();
 
-      // Verificar contenido específico
+      
       expect(cloned.querySelector(".card-title")?.textContent).toBe("Card Title");
       expect(cloned.querySelector("strong")?.textContent).toBe("bold");
       
@@ -502,7 +502,7 @@ describe("cloneNode functionality", () => {
       expect(items.length).toBe(2);
       
       const buttons = cloned.querySelectorAll("button");
-      expect(buttons.length).toBe(3); // close, save, cancel
+      expect(buttons.length).toBe(3); 
     });
 
     it("should clone a form with various input types", () => {
@@ -522,7 +522,7 @@ describe("cloneNode functionality", () => {
 
       const cloned = form.cloneNode(true);
 
-      // Verificar que todos los inputs se clonaron
+      
       const textInput = cloned.querySelector('[name="username"]');
       expect(textInput).toBeTruthy();
       expect(textInput?.getAttribute("value")).toBe("john");

package/tests/custom-elements.test.ts

@@ -210,7 +210,7 @@ describe('Custom Elements Support', () => {
       const ast = parse(tokens);
 
       const element = ast.children![0]!;
-      // nodeName should also be uppercase
+      
       if (element.nodeName) {
         expect(element.nodeName.toUpperCase()).toBe('MY-COMP');
       }
@@ -382,11 +382,11 @@ describe('Custom Elements Support', () => {
       const tokens = tokenize(html);
       const ast = parse(tokens);
 
-      // Find first element (skip whitespace text nodes)
+      
       const userProfile = ast.children!.find(node => node.type === ASTNodeType.ELEMENT)!;
       expect(userProfile.tagName).toBe('user-profile');
       
-      // Should have proper nesting
+      
       expect(userProfile.children).toBeDefined();
       expect(userProfile.children!.length).toBeGreaterThan(0);
     });
@@ -412,7 +412,7 @@ describe('Custom Elements Support', () => {
       const tokens = tokenize(html);
       const ast = parse(tokens);
 
-      // Find first element (skip whitespace text nodes)
+      
       const appRoot = ast.children!.find(node => node.type === ASTNodeType.ELEMENT)!;
       expect(appRoot.tagName).toBe('app-root');
     });
@@ -471,12 +471,12 @@ describe('Custom Elements Support', () => {
     test('tokenizer should capture full custom element name', () => {
       const tokens = tokenize('<my-component-123></my-component-123>');
       
-      // Find the opening tag token
+      
       const openTag = tokens.find(t => t.type === 'TAG_OPEN');
       expect(openTag).toBeDefined();
       expect(openTag!.value).toBe('my-component-123');
       
-      // Find the closing tag token
+      
       const closeTag = tokens.find(t => t.type === 'TAG_CLOSE');
       expect(closeTag).toBeDefined();
       expect(closeTag!.value).toBe('my-component-123');
@@ -642,7 +642,7 @@ describe('Custom Elements Support', () => {
       const tokens = tokenize(html);
       const ast = parse(tokens);
 
-      // Should have comment, element, comment
+      
       const myComp = ast.children!.find(node => node.type === ASTNodeType.ELEMENT)!;
       expect(myComp.tagName).toBe('my-comp');
     });
@@ -700,7 +700,7 @@ describe('Custom Elements Support', () => {
       const tokens = tokenize('<table><tr><td><my-cell>content</my-cell></td></tr></table>');
       const ast = parse(tokens);
 
-      // Find the custom element
+      
       const table = ast.children![0]!;
       expect(table.tagName).toBe('table');
     });

package/tests/official/acid/acid-tests.test.ts

@@ -233,7 +233,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(10); // Should be very fast
+    expect(end - start).toBeLessThan(10); 
   });
   
   it('should handle medium-sized HTML', () => {
@@ -245,7 +245,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(100); // Should still be fast
+    expect(end - start).toBeLessThan(100); 
   });
   
   it('should handle large HTML documents', () => {
@@ -257,7 +257,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(1000); // Should complete within 1 second
+    expect(end - start).toBeLessThan(1000); 
   });
   
   it('should handle deeply nested HTML', () => {
@@ -276,7 +276,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(500); // Should handle deep nesting
+    expect(end - start).toBeLessThan(500); 
   });
 });
 
@@ -284,14 +284,14 @@ describe('Memory Usage Tests', () => {
   it('should not leak memory on repeated parsing', () => {
     const testHtml = '<div><p>Memory test</p></div>';
     
-    // Parse the same HTML multiple times
+    
     for (let i = 0; i < 1000; i++) {
       const tokens = tokenize(testHtml);
       const ast = parse(tokens);
       expect(ast).toBeDefined();
     }
     
-    // If we get here without crashing, memory is likely managed well
+    
     expect(true).toBe(true);
   });
   

package/tests/official/final-output/final-output.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'bun:test';
 import { parseHTML } from '../../../index';
 
-// Helper function to normalize text for comparison
+
 function normalizeText(text: string): string {
   return text
     .replace(/\s+/g, ' ')
@@ -16,7 +16,7 @@ describe('Final HTML Output Validation', () => {
       const document = parseHTML(html);
       
       expect(document).toBeDefined();
-      expect(document.nodeType).toBe(9); // DOCUMENT_NODE
+      expect(document.nodeType).toBe(9); 
       
       const div = document.querySelector('div');
       expect(div).toBeDefined();
@@ -101,9 +101,9 @@ describe('Final HTML Output Validation', () => {
       expect(p).toBeDefined();
       expect(p?.textContent).toBe('Content');
       
-      // Check for comment node
+      
       const commentNode = div?.childNodes[0];
-      expect(commentNode?.nodeType).toBe(8); // COMMENT_NODE
+      expect(commentNode?.nodeType).toBe(8); 
     });
   });
 
@@ -135,16 +135,16 @@ describe('Final HTML Output Validation', () => {
       expect(div).toBeDefined();
       expect(div?.childNodes.length).toBe(3);
       
-      // First text node
-      expect(div?.childNodes[0]?.nodeType).toBe(3); // TEXT_NODE
+      
+      expect(div?.childNodes[0]?.nodeType).toBe(3); 
       expect(div?.childNodes[0]?.textContent).toBe('Text before ');
       
-      // Span element
-      expect(div?.childNodes[1]?.nodeType).toBe(1); // ELEMENT_NODE
+      
+      expect(div?.childNodes[1]?.nodeType).toBe(1); 
       expect((div?.childNodes[1] as Element)?.tagName).toBe('SPAN');
       
-      // Last text node
-      expect(div?.childNodes[2]?.nodeType).toBe(3); // TEXT_NODE
+      
+      expect(div?.childNodes[2]?.nodeType).toBe(3); 
       expect(div?.childNodes[2]?.textContent).toBe(' text after');
     });
 
@@ -264,7 +264,7 @@ describe('Final HTML Output Validation', () => {
       const document = parseHTML(malformedHTML);
       
       expect(document).toBeDefined();
-      expect(document.nodeType).toBe(9); // DOCUMENT_NODE
+      expect(document.nodeType).toBe(9); 
       
       const divs = document.querySelectorAll('div');
       expect(divs.length).toBeGreaterThan(0);
@@ -296,7 +296,7 @@ describe('Final HTML Output Validation', () => {
       const p = document.querySelector('p');
       expect(p).toBeDefined();
       expect(p?.textContent).toContain('Special chars:');
-      // The exact entity handling depends on your implementation
+      
     });
 
     it('should handle multiple top-level elements', () => {
@@ -321,17 +321,17 @@ describe('Final HTML Output Validation', () => {
       
       const document = parseHTML(html);
       
-      // Test getElementById
+      
       const byId = document.getElementById('test');
       expect(byId).toBeDefined();
       expect(byId?.tagName).toBe('DIV');
       
-      // Test querySelector
+      
       const bySelector = document.querySelector('.container');
       expect(bySelector).toBeDefined();
       expect(bySelector?.id).toBe('test');
       
-      // Test querySelectorAll
+      
       const byClass = document.querySelectorAll('.text');
       expect(byClass.length).toBe(1);
       expect(byClass[0]?.textContent).toBe('Hello');

package/tests/official/html5lib/tokenizer-utils.ts

@@ -2,7 +2,7 @@ import { expect, describe, it } from 'bun:test';
 import { tokenize, TokenType } from '../../../src/tokenizer';
 import type { Token } from '../../../src/tokenizer';
 
-// HTML5lib tokenizer test format
+
 export interface HTML5libTokenizerTest {
   description: string;
   input: string;
@@ -18,12 +18,12 @@ export interface HTML5libTokenizerTestSuite {
 }
 
 export type HTML5libTokenOutput = 
-  | ['StartTag', string, Record<string, string>] // StartTag without self-closing
-  | ['StartTag', string, Record<string, string>, boolean] // StartTag with self-closing
-  | ['EndTag', string] // EndTag
-  | ['Comment', string] // Comment
-  | ['Character', string] // Character
-  | ['DOCTYPE', string, string | null, string | null, boolean]; // DOCTYPE
+  | ['StartTag', string, Record<string, string>] 
+  | ['StartTag', string, Record<string, string>, boolean] 
+  | ['EndTag', string] 
+  | ['Comment', string] 
+  | ['Character', string] 
+  | ['DOCTYPE', string, string | null, string | null, boolean]; 
 
 export interface HTML5libError {
   code: string;
@@ -31,9 +31,7 @@ export interface HTML5libError {
   col: number;
 }
 
-/**
- * Converts HTML5lib token format to our internal token format
- */
+
 export function convertHTML5libToken(html5libToken: HTML5libTokenOutput): Partial<Token> {
   const type = html5libToken[0];
   const nameOrData = html5libToken[1];
@@ -78,9 +76,7 @@ export function convertHTML5libToken(html5libToken: HTML5libTokenOutput): Partia
   }
 }
 
-/**
- * Converts our internal token format to HTML5lib format for comparison
- */
+
 export function convertToHTML5libToken(token: Token): HTML5libTokenOutput {
   switch (token.type) {
     case TokenType.DOCTYPE:
@@ -102,9 +98,7 @@ export function convertToHTML5libToken(token: Token): HTML5libTokenOutput {
   }
 }
 
-/**
- * Normalizes adjacent character tokens as per HTML5lib spec
- */
+
 export function normalizeCharacterTokens(tokens: Token[]): Token[] {
   const normalized: Token[] = [];
   let currentText = '';
@@ -140,13 +134,11 @@ export function normalizeCharacterTokens(tokens: Token[]): Token[] {
   return normalized;
 }
 
-/**
- * Runs a single HTML5lib tokenizer test
- */
+
 export function runHTML5libTokenizerTest(test: HTML5libTokenizerTest): void {
   const { description, input, output: expectedOutput, initialStates = ['Data state'] } = test;
   
-  // Process double-escaped input if needed
+  
   let processedInput = input;
   if (test.doubleEscaped) {
     processedInput = processedInput.replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => {
@@ -156,16 +148,16 @@ export function runHTML5libTokenizerTest(test: HTML5libTokenizerTest): void {
   
   for (const initialState of initialStates) {
     it(`${description} (${initialState})`, () => {
-      // Tokenize the input
+      
       const tokens = tokenize(processedInput);
       
-      // Normalize character tokens
+      
       const normalizedTokens = normalizeCharacterTokens(tokens);
       
-      // Convert to HTML5lib format for comparison
+      
       const actualOutput = normalizedTokens.map(convertToHTML5libToken);
       
-      // Process expected output if double-escaped
+      
       let processedExpectedOutput = expectedOutput;
       if (test.doubleEscaped) {
         processedExpectedOutput = expectedOutput.map(token => {
@@ -178,15 +170,13 @@ export function runHTML5libTokenizerTest(test: HTML5libTokenizerTest): void {
         });
       }
       
-      // Compare outputs
+      
       expect(actualOutput).toEqual(processedExpectedOutput);
     });
   }
 }
 
-/**
- * Runs all tests from an HTML5lib tokenizer test suite
- */
+
 export function runHTML5libTokenizerTestSuite(testSuite: HTML5libTokenizerTestSuite, suiteName: string): void {
   describe(`HTML5lib Tokenizer Tests: ${suiteName}`, () => {
     testSuite.tests.forEach(test => {
@@ -195,9 +185,7 @@ export function runHTML5libTokenizerTestSuite(testSuite: HTML5libTokenizerTestSu
   });
 }
 
-/**
- * Loads and runs HTML5lib tokenizer tests from JSON
- */
+
 export async function loadHTML5libTokenizerTests(testData: string, suiteName: string): Promise<void> {
   const testSuite: HTML5libTokenizerTestSuite = JSON.parse(testData);
   runHTML5libTokenizerTestSuite(testSuite, suiteName);