@hireobi/cli 0.1.7 → 0.1.8

package/dist/obi.js

@@ -17692,7 +17692,7 @@ async function send(context, request) {
     headers2.authorization = `Bearer ${request.bearer}`;
   }
   if (context.evaluationCaseId && /^\/api\/v1\/(?:status|business(?:\/.*)?|questions(?:\/.*)?|readiness|strategies|work\/[0-9a-fA-F-]+\/artifact(?:\/revisions(?:\/[1-9][0-9]*)?)?|harness(?:\/(?:evidence|outcomes))?|memory)(?:\?.*)?$/.test(request.path)) {
-    headers2["x-heysurface-evaluation-case"] = context.evaluationCaseId;
+    headers2["x-obi-evaluation-case"] = context.evaluationCaseId;
   }
   if (request.idempotencyKey !== void 0) {
     headers2[IDEMPOTENCY_KEY_HEADER] = request.idempotencyKey;
@@ -18063,37 +18063,114 @@ async function readReadiness(context, accessToken) {
 
 // src/refresh.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { open as open2, readFile, stat, unlink as unlink2 } from "node:fs/promises";
+import { open as open2, readFile, stat, unlink as unlink3 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
 import { join as join3 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // src/file-backend.ts
 import { randomBytes } from "node:crypto";
-import { constants } from "node:fs";
-import { lstat as lstat2, open, readdir, rename, unlink } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { lstat as lstat2, open, readdir as readdir2, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/state-directory.ts
 import { createHash } from "node:crypto";
-import { chmod, lstat, mkdir } from "node:fs/promises";
+import { constants } from "node:fs";
+import { chmod, copyFile, cp, link, lstat, mkdir, readdir, rename, rm, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { basename, dirname, isAbsolute, join } from "node:path";
 var posixModes = process.platform !== "win32";
-function resolveStateDirectory(environment) {
+function stateBase(environment) {
   const stateHome = environment.XDG_STATE_HOME;
   if (stateHome !== void 0 && isAbsolute(stateHome)) {
-    return join(stateHome, "heysurface");
+    return stateHome;
   }
   if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Application Support", "heysurface");
+    return join(homedir(), "Library", "Application Support");
   }
   if (process.platform === "win32") {
     const localAppData = environment.LOCALAPPDATA;
-    const base = localAppData !== void 0 && isAbsolute(localAppData) ? localAppData : join(homedir(), "AppData", "Local");
-    return join(base, "heysurface");
+    return localAppData !== void 0 && isAbsolute(localAppData) ? localAppData : join(homedir(), "AppData", "Local");
+  }
+  return join(homedir(), ".local", "state");
+}
+var currentName = "obi-cli";
+function resolveStateDirectory(environment) {
+  return join(stateBase(environment), currentName);
+}
+var legacyName = "heysurface";
+function legacyStateDirectory(environment) {
+  return join(stateBase(environment), legacyName);
+}
+function legacySibling(stateDirectory) {
+  return basename(stateDirectory) === currentName ? join(dirname(stateDirectory), legacyName) : null;
+}
+async function present(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error51) {
+    if (error51.code === "ENOENT") return false;
+    throw error51;
   }
-  return join(homedir(), ".local", "state", "heysurface");
+}
+async function prepareStateDirectory(environment) {
+  const current = resolveStateDirectory(environment);
+  const legacy = legacyStateDirectory(environment);
+  try {
+    if (!await present(legacy)) return current;
+    if (await present(current)) {
+      await adoptConnection(legacy, current).catch(() => void 0);
+      return current;
+    }
+    try {
+      await rename(legacy, current);
+      return current;
+    } catch (error51) {
+      const code = error51.code;
+      if (code === "EXDEV") {
+        await copyThenRemove(legacy, current);
+        return current;
+      }
+      if ((code === "ENOENT" || code === "EEXIST" || code === "ENOTEMPTY") && await present(current)) return current;
+      return legacy;
+    }
+  } catch {
+    return await present(current).catch(() => false) ? current : legacy;
+  }
+}
+var connectionFile = /^(credentials|pending)-[0-9a-f]{24}\.json$/;
+async function adoptConnection(legacy, current) {
+  if ((await readdir(current)).some((name) => connectionFile.test(name))) return;
+  for (const name of (await readdir(legacy)).filter((entry) => connectionFile.test(entry))) {
+    const source = join(legacy, name);
+    const target = join(current, name);
+    if (!(await lstat(source)).isFile() || await present(target)) continue;
+    try {
+      await link(source, target);
+    } catch (error51) {
+      if (error51.code !== "EXDEV") throw error51;
+      await copyFile(source, target, constants.COPYFILE_EXCL);
+      if (posixModes) await chmod(target, 384);
+    }
+    await unlink(source);
+  }
+}
+async function copyThenRemove(legacy, current) {
+  const stats = await lstat(legacy);
+  if (!stats.isDirectory()) throw new Error("not a directory");
+  const staging = `${current}.${process.pid}.moving`;
+  await mkdir(staging, { mode: 448 });
+  try {
+    await cp(legacy, staging, { recursive: true, preserveTimestamps: true, verbatimSymlinks: true, errorOnExist: true, force: false });
+    if (posixModes) await chmod(staging, stats.mode & 511);
+    await rename(staging, current);
+  } catch (error51) {
+    await rm(staging, { recursive: true, force: true });
+    throw error51;
+  }
+  await rm(legacy, { recursive: true, force: true });
 }
 function originKey(origin) {
   return createHash("sha256").update(origin).digest("hex").slice(0, 24);
@@ -18148,7 +18225,7 @@ async function ensureStateDirectory(directory) {
 
 // src/file-backend.ts
 var maxItemBytes = 64 * 1024;
-var noFollow = constants.O_NOFOLLOW ?? 0;
+var noFollow = constants2.O_NOFOLLOW ?? 0;
 function isMissing(error51) {
   return error51.code === "ENOENT";
 }
@@ -18190,7 +18267,7 @@ var FileBackend = class {
     }
     let handle;
     try {
-      handle = await open(path, constants.O_RDONLY | noFollow);
+      handle = await open(path, constants2.O_RDONLY | noFollow);
     } catch (error51) {
       if (error51.code === "ELOOP") {
         throw insecureStorage();
@@ -18220,7 +18297,7 @@ var FileBackend = class {
       }
     }
     const temporary = join2(this.directory, `.${item}-${originKey(origin)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
-    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow, 384);
+    const handle = await open(temporary, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | noFollow, 384);
     try {
       if (posixModes) {
         await handle.chmod(384);
@@ -18229,14 +18306,14 @@ var FileBackend = class {
       await handle.sync();
     } catch (error51) {
       await handle.close();
-      await unlink(temporary);
+      await unlink2(temporary);
       throw error51;
     }
     await handle.close();
     try {
-      await rename(temporary, path);
+      await rename2(temporary, path);
     } catch (error51) {
-      await unlink(temporary);
+      await unlink2(temporary);
       throw error51;
     }
   }
@@ -18244,7 +18321,7 @@ var FileBackend = class {
   async remove(item, origin) {
     let names;
     try {
-      names = await readdir(this.directory);
+      names = await readdir2(this.directory);
     } catch (error51) {
       if (isMissing(error51)) {
         return;
@@ -18255,7 +18332,7 @@ var FileBackend = class {
     const paths = names.filter((name) => name.startsWith(leftover) && name.endsWith(".tmp")).map((name) => join2(this.directory, name));
     for (const path of [this.path(item, origin), ...paths]) {
       try {
-        await unlink(path);
+        await unlink2(path);
       } catch (error51) {
         if (!isMissing(error51)) {
           throw error51;
@@ -18266,8 +18343,9 @@ var FileBackend = class {
 };
 
 // src/os-backends.ts
-import { accessSync, constants as constants2, existsSync as existsSync2, statSync } from "node:fs";
-var service = "heysurface-cli";
+import { accessSync, constants as constants3, existsSync as existsSync2, statSync } from "node:fs";
+var currentService = "obi-cli";
+var legacyService = "heysurface-cli";
 var plainToken = /^[A-Za-z0-9:/.[\]_-]+$/;
 var keychainNotFound = 44;
 var maxCommandLength = 4e3;
@@ -18305,14 +18383,16 @@ async function run(executable, args, stdin) {
 var KeychainBackend = class {
   kind = "keychain";
   executable;
-  constructor(executable) {
+  service;
+  constructor(executable, service = currentService) {
     this.executable = executable;
+    this.service = service;
   }
   async exists(item, origin) {
     return await this.read(item, origin) !== null;
   }
   async read(item, origin) {
-    const result = await run(this.executable, ["find-generic-password", "-s", service, "-a", account(item, origin), "-w"]);
+    const result = await run(this.executable, ["find-generic-password", "-s", this.service, "-a", account(item, origin), "-w"]);
     if (result.exitCode === keychainNotFound) {
       return null;
     }
@@ -18323,7 +18403,7 @@ var KeychainBackend = class {
   }
   async write(item, origin, value) {
     const hex3 = Buffer.from(encode3(value), "utf8").toString("hex");
-    const command = `add-generic-password -U -s ${service} -a ${account(item, origin)} -X ${hex3}
+    const command = `add-generic-password -U -s ${this.service} -a ${account(item, origin)} -X ${hex3}
 `;
     if (command.length > maxCommandLength) {
       throw refused();
@@ -18334,7 +18414,7 @@ var KeychainBackend = class {
     }
   }
   async remove(item, origin) {
-    const result = await run(this.executable, ["delete-generic-password", "-s", service, "-a", account(item, origin)]);
+    const result = await run(this.executable, ["delete-generic-password", "-s", this.service, "-a", account(item, origin)]);
     if (result.exitCode !== 0 && result.exitCode !== keychainNotFound) {
       throw refused();
     }
@@ -18343,11 +18423,13 @@ var KeychainBackend = class {
 var SecretServiceBackend = class {
   kind = "secret-service";
   executable;
-  constructor(executable) {
+  service;
+  constructor(executable, service = currentService) {
     this.executable = executable;
+    this.service = service;
   }
   attributes(item, origin) {
-    return ["service", service, "account", account(item, origin)];
+    return ["service", this.service, "account", account(item, origin)];
   }
   async exists(item, origin) {
     return await this.read(item, origin) !== null;
@@ -18363,7 +18445,7 @@ var SecretServiceBackend = class {
     return decode3(result.stdout);
   }
   async write(item, origin, value) {
-    const result = await run(this.executable, ["store", "--label=Heysurface CLI", ...this.attributes(item, origin)], encode3(value));
+    const result = await run(this.executable, ["store", "--label=Obi CLI", ...this.attributes(item, origin)], encode3(value));
     if (result.exitCode !== 0) {
       throw refused();
     }
@@ -18379,7 +18461,7 @@ var secretToolLocations = ["/usr/bin/secret-tool", "/usr/local/bin/secret-tool",
 function installedSecretTool() {
   for (const candidate of secretToolLocations) {
     try {
-      accessSync(candidate, constants2.X_OK);
+      accessSync(candidate, constants3.X_OK);
       if (statSync(candidate).isFile()) {
         return candidate;
       }
@@ -18388,15 +18470,58 @@ function installedSecretTool() {
   }
   return null;
 }
+var MigratingBackend = class {
+  kind;
+  current;
+  legacy;
+  constructor(current, legacy) {
+    this.kind = current.kind;
+    this.current = current;
+    this.legacy = legacy;
+  }
+  async exists(item, origin) {
+    return await this.read(item, origin) !== null;
+  }
+  async read(item, origin) {
+    const value = await this.current.read(item, origin);
+    if (value !== null) return value;
+    const old = await this.legacy.read(item, origin);
+    if (old === null) return null;
+    const moved = await this.current.read(item, origin);
+    if (moved !== null) {
+      await this.legacy.remove(item, origin).catch(() => void 0);
+      return moved;
+    }
+    try {
+      await this.current.write(item, origin, old);
+    } catch {
+      return old;
+    }
+    await this.legacy.remove(item, origin).catch(() => void 0);
+    return old;
+  }
+  async write(item, origin, value) {
+    await this.current.write(item, origin, value);
+  }
+  async remove(item, origin) {
+    await this.current.remove(item, origin);
+    try {
+      await this.legacy.remove(item, origin);
+    } catch {
+      process.stderr.write("Warning: a copy of this connection under the former store name could not be removed.\n");
+    }
+  }
+};
 function systemBackend() {
   if (process.platform === "darwin") {
-    return existsSync2("/usr/bin/security") ? new KeychainBackend("/usr/bin/security") : null;
+    const security = "/usr/bin/security";
+    return existsSync2(security) ? new MigratingBackend(new KeychainBackend(security), new KeychainBackend(security, legacyService)) : null;
   }
   if (process.platform === "win32") {
     return null;
   }
   const secretTool = installedSecretTool();
-  return secretTool === null ? null : new SecretServiceBackend(secretTool);
+  return secretTool === null ? null : new MigratingBackend(new SecretServiceBackend(secretTool), new SecretServiceBackend(secretTool, legacyService));
 }
 
 // src/retired-origin.ts
@@ -18634,7 +18759,7 @@ async function acquireLock(path) {
     if (holder !== null && isStale(holder)) {
       const current = await readHolder(path);
       if (current !== null && current.raw === holder.raw && current.identity === holder.identity) {
-        await unlink2(path).catch((error51) => {
+        await unlink3(path).catch((error51) => {
           if (error51.code !== "ENOENT") throw error51;
         });
       }
@@ -18653,7 +18778,7 @@ async function withCredentialLock(context, action) {
   try {
     return await action();
   } finally {
-    await unlink2(path).catch((error51) => {
+    await unlink3(path).catch((error51) => {
       if (error51.code !== "ENOENT") throw error51;
     });
   }
@@ -19708,7 +19833,7 @@ import { resolve } from "node:path";
 
 // src/local-json.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { rename as rename2, unlink as unlink3, writeFile as writeFile2 } from "node:fs/promises";
+import { rename as rename3, unlink as unlink4, writeFile as writeFile2 } from "node:fs/promises";
 function localFileError(message, nextAction) {
   return new CliError({
     code: "RESEARCH_FILE_ERROR",
@@ -19726,9 +19851,9 @@ async function writeJsonAtomic(path, value, options) {
   if (bytes > options.maxBytes) throw localFileError(options.tooLarge, options.nextAction);
   try {
     await writeFile2(temporary, content, { mode: 384, flag: "wx" });
-    await rename2(temporary, path);
+    await rename3(temporary, path);
   } catch {
-    await unlink3(temporary).catch(() => void 0);
+    await unlink4(temporary).catch(() => void 0);
     throw localFileError("The output could not be written atomically.", options.nextAction);
   }
   return bytes;
@@ -20020,7 +20145,7 @@ import { setTimeout as sleep2 } from "node:timers/promises";
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { hostname as hostname4 } from "node:os";
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 var maxLabelLength = 64;
 function parentProcessName() {
   try {
@@ -20033,7 +20158,7 @@ function parentProcessName() {
         stdio: ["ignore", "pipe", "ignore"],
         timeout: 2e3
       });
-      return basename(command.trim());
+      return basename2(command.trim());
     }
   } catch {
   }
@@ -20056,17 +20181,30 @@ function deviceLabel() {
 // src/origin.ts
 var productionOrigin = "https://agent.hireobi.com";
 var developmentOrigin = /^http:\/\/(localhost|127\.0\.0\.1|\[::1\]):([1-9][0-9]{0,4})$/;
+var retiredVariable = "HEYSURFACE_ORIGIN";
 function invalidOrigin() {
   return new CliError({
     code: "INVALID_ORIGIN",
-    message: "HEYSURFACE_ORIGIN must be a loopback development origin with an explicit port.",
+    message: "OBI_ORIGIN must be a loopback development origin with an explicit port.",
+    exitCode: 2,
+    retryable: false,
+    nextAction: "Unset OBI_ORIGIN, or set it to http://localhost:<port>, http://127.0.0.1:<port> or http://[::1]:<port>."
+  });
+}
+function retiredOrigin() {
+  return new CliError({
+    code: "INVALID_ORIGIN",
+    message: `${retiredVariable} is no longer read; the development origin is OBI_ORIGIN.`,
     exitCode: 2,
     retryable: false,
-    nextAction: "Unset HEYSURFACE_ORIGIN, or set it to http://localhost:<port>, http://127.0.0.1:<port> or http://[::1]:<port>."
+    nextAction: `Unset ${retiredVariable}, and set OBI_ORIGIN instead if you meant a development server.`
   });
 }
 function resolveOrigin(environment) {
-  const override = environment.HEYSURFACE_ORIGIN;
+  if (environment[retiredVariable] !== void 0) {
+    throw retiredOrigin();
+  }
+  const override = environment.OBI_ORIGIN;
   if (override === void 0) {
     return { origin: productionOrigin, development: false };
   }
@@ -20294,14 +20432,12 @@ var storageLabels = {
   "secret-service": "the system Secret Service",
   file: "a file readable only by your user"
 };
-function toHumanOutput(result, identity = "heysurface") {
+function toHumanOutput(result) {
   if (!result.ok) {
     return failureText(result);
   }
   if (result.command === "help") {
-    if (identity === "heysurface") return `Usage: ${result.data.usage}
-`;
-    const usage2 = result.data.usage.split("\n").map((line) => `  ${line.trimStart().replace(/^heysurface /, "obi ")}`).join("\n");
+    const usage2 = result.data.usage.split("\n").map((line) => `  ${line.trimStart()}`).join("\n");
     return `Obi \xB7 AI Search Employee
 
 Get started
@@ -20321,8 +20457,8 @@ ${usage2}
   }
   if (result.command === "skill") {
     return result.data.action === "path" ? `${sanitizeHumanText(result.data.path)}
-` : identity === "obi" ? `Obi Skill registered locally. In a new Claude Code or Cursor chat, type /obi. In Codex CLI, type $obi or choose Obi from /skills. In the desktop app, select Obi from the skills picker.
-${result.data.removed.length > 0 ? "The earlier /heysurface Skill links of this package were removed; use /obi instead.\n" : ""}` : "Heysurface Skill registered locally. Open a new Claude Code or Cursor agent chat and type /heysurface.\n";
+` : `Obi Skill registered locally. In a new Claude Code or Cursor chat, type /obi. In Codex CLI, type $obi or choose Obi from /skills. In the desktop app, select Obi from the skills picker.
+${result.data.removed.length > 0 ? "Earlier Skill links of this package under another name were removed; use /obi.\n" : ""}`;
   }
   if (result.command === "capabilities") {
     return "Available: business, capabilities, credentials, doctor, eval, harness, login, logout, memory, questions, readiness, research, skill, status, strategies. Scan execution requires server authorization and a separate customer decision.\n";
@@ -20538,11 +20674,11 @@ ${sanitizeHumanText(data.revision.content)}
     ];
     if (review.identity === null) lines.push("  pending");
     else {
-      const { identity: identity2 } = review;
-      lines.push(`  Current company name [${identity2.origin}${identity2.latestReview === null ? "" : `, ${identity2.latestReview}`}]: ${sanitizeHumanText(identity2.value.companyName ?? "unresolved")} (company only).`);
-      lines.push(`  Site proposal [${identity2.proposal.status}]: ${sanitizeHumanText(identity2.proposal.name ?? "unresolved")} on ${sanitizeHumanText(identity2.proposal.domain)} (${sanitizeHumanText(identity2.proposal.reason)}).`);
-      if (identity2.conflict !== null) lines.push(`  Name conflict: customer says ${sanitizeHumanText(identity2.conflict.customerName)}; site proposes ${sanitizeHumanText(identity2.conflict.siteProposedName)}. Keep the customer name and review the discrepancy.`);
-      for (const evidence2 of identity2.proposal.evidence) lines.push(`    Proposal evidence: ${sanitizeHumanText(evidence2.quote)} \u2014 ${sanitizeHumanText(evidence2.url)}`);
+      const { identity } = review;
+      lines.push(`  Current company name [${identity.origin}${identity.latestReview === null ? "" : `, ${identity.latestReview}`}]: ${sanitizeHumanText(identity.value.companyName ?? "unresolved")} (company only).`);
+      lines.push(`  Site proposal [${identity.proposal.status}]: ${sanitizeHumanText(identity.proposal.name ?? "unresolved")} on ${sanitizeHumanText(identity.proposal.domain)} (${sanitizeHumanText(identity.proposal.reason)}).`);
+      if (identity.conflict !== null) lines.push(`  Name conflict: customer says ${sanitizeHumanText(identity.conflict.customerName)}; site proposes ${sanitizeHumanText(identity.conflict.siteProposedName)}. Keep the customer name and review the discrepancy.`);
+      for (const evidence2 of identity.proposal.evidence) lines.push(`    Proposal evidence: ${sanitizeHumanText(evidence2.quote)} \u2014 ${sanitizeHumanText(evidence2.url)}`);
     }
     lines.push("Summary:");
     if (review.summary === null) lines.push("  pending");
@@ -20649,13 +20785,13 @@ function humanWarnings(result) {
   }
   return "";
 }
-function writeResult(result, json2, identity = "heysurface") {
+function writeResult(result, json2) {
   if (json2) {
     process.stdout.write(toJsonLine(result));
     return;
   }
-  const human = toHumanOutput(result, identity);
-  const heading2 = identity === "obi" && (!result.ok || result.command !== "version" && result.command !== "skill" && result.command !== "help") ? "Obi\n\n" : "";
+  const human = toHumanOutput(result);
+  const heading2 = !result.ok || result.command !== "version" && result.command !== "skill" && result.command !== "help" ? "Obi\n\n" : "";
   const output = `${heading2}${result.evaluationCaseId ? `Evaluation case ${result.evaluationCaseId}
 ${human}` : human}`;
   if (result.ok) {
@@ -20684,7 +20820,7 @@ async function confirmAccount(account2) {
 }
 
 // src/version.ts
-var cliVersion = "0.1.7";
+var cliVersion = "0.1.8";
 
 // src/login.ts
 var loginRequestTimeoutMs = 1e4;
@@ -20704,10 +20840,10 @@ function connectionLink(pending) {
   return pending.verificationUriComplete ?? pending.verificationUri;
 }
 function announcementLines(pending, opening) {
-  const link = sanitizeHumanText(connectionLink(pending));
+  const link2 = sanitizeHumanText(connectionLink(pending));
   const code = sanitizeHumanText(pending.userCode);
   return [
-    opening ? `Opening ${link} in your browser: sign in there, or create your Obi account.` : `Open ${link} to sign in or create your Obi account.`,
+    opening ? `Opening ${link2} in your browser: sign in there, or create your Obi account.` : `Open ${link2} to sign in or create your Obi account.`,
     `Check that the page shows the code ${code}, and approve the connection only if it does.`
   ];
 }
@@ -21140,12 +21276,12 @@ import { urlToHttpOptions } from "node:url";
 
 // ../geo-engine/src/safe-fetch-decoding.ts
 import { Duplex, pipeline } from "node:stream";
-import { constants as constants3, createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from "node:zlib";
+import { constants as constants4, createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from "node:zlib";
 var MAX_CODINGS = 5;
 var ZLIB_DEFLATE_METHOD = 8;
 var BODILESS_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
-var ZLIB_LENIENCY = { flush: constants3.Z_SYNC_FLUSH, finishFlush: constants3.Z_SYNC_FLUSH };
-var BROTLI_LENIENCY = { flush: constants3.BROTLI_OPERATION_FLUSH, finishFlush: constants3.BROTLI_OPERATION_FLUSH };
+var ZLIB_LENIENCY = { flush: constants4.Z_SYNC_FLUSH, finishFlush: constants4.Z_SYNC_FLUSH };
+var BROTLI_LENIENCY = { flush: constants4.BROTLI_OPERATION_FLUSH, finishFlush: constants4.BROTLI_OPERATION_FLUSH };
 function createDeflateDecoder() {
   let inflater;
   const start = (format) => {
@@ -21523,20 +21659,20 @@ var SEQUENCES = {
   PUBLIC: "public",
   SYSTEM: "system"
 };
-function isSurrogate(cp) {
-  return cp >= 55296 && cp <= 57343;
+function isSurrogate(cp2) {
+  return cp2 >= 55296 && cp2 <= 57343;
 }
-function isSurrogatePair(cp) {
-  return cp >= 56320 && cp <= 57343;
+function isSurrogatePair(cp2) {
+  return cp2 >= 56320 && cp2 <= 57343;
 }
 function getSurrogatePairCodePoint(cp1, cp2) {
   return (cp1 - 55296) * 1024 + 9216 + cp2;
 }
-function isControlCodePoint(cp) {
-  return cp !== 32 && cp !== 10 && cp !== 13 && cp !== 9 && cp !== 12 && cp >= 1 && cp <= 31 || cp >= 127 && cp <= 159;
+function isControlCodePoint(cp2) {
+  return cp2 !== 32 && cp2 !== 10 && cp2 !== 13 && cp2 !== 9 && cp2 !== 12 && cp2 >= 1 && cp2 <= 31 || cp2 >= 127 && cp2 <= 159;
 }
-function isUndefinedCodePoint(cp) {
-  return cp >= 64976 && cp <= 65007 || UNDEFINED_CODE_POINTS.has(cp);
+function isUndefinedCodePoint(cp2) {
+  return cp2 >= 64976 && cp2 <= 65007 || UNDEFINED_CODE_POINTS.has(cp2);
 }
 
 // ../node_modules/parse5/dist/common/error-codes.js
@@ -21654,20 +21790,20 @@ var Preprocessor = class {
     this.gapStack.push(this.lastGapPos);
     this.lastGapPos = this.pos;
   }
-  _processSurrogate(cp) {
+  _processSurrogate(cp2) {
     if (this.pos !== this.html.length - 1) {
       const nextCp = this.html.charCodeAt(this.pos + 1);
       if (isSurrogatePair(nextCp)) {
         this.pos++;
         this._addGap();
-        return getSurrogatePairCodePoint(cp, nextCp);
+        return getSurrogatePairCodePoint(cp2, nextCp);
       }
     } else if (!this.lastChunkWritten) {
       this.endOfChunkHit = true;
       return CODE_POINTS.EOF;
     }
     this._err(ERR.surrogateInInputStream);
-    return cp;
+    return cp2;
   }
   willDropParsedChunk() {
     return this.pos > this.bufferWaterline;
@@ -21704,8 +21840,8 @@ var Preprocessor = class {
       return this.html.startsWith(pattern, this.pos);
     }
     for (let i = 0; i < pattern.length; i++) {
-      const cp = this.html.charCodeAt(this.pos + i) | 32;
-      if (cp !== pattern.charCodeAt(i)) {
+      const cp2 = this.html.charCodeAt(this.pos + i) | 32;
+      if (cp2 !== pattern.charCodeAt(i)) {
         return false;
       }
     }
@@ -21731,13 +21867,13 @@ var Preprocessor = class {
       this.endOfChunkHit = !this.lastChunkWritten;
       return CODE_POINTS.EOF;
     }
-    let cp = this.html.charCodeAt(this.pos);
-    if (cp === CODE_POINTS.CARRIAGE_RETURN) {
+    let cp2 = this.html.charCodeAt(this.pos);
+    if (cp2 === CODE_POINTS.CARRIAGE_RETURN) {
       this.isEol = true;
       this.skipNextNewLine = true;
       return CODE_POINTS.LINE_FEED;
     }
-    if (cp === CODE_POINTS.LINE_FEED) {
+    if (cp2 === CODE_POINTS.LINE_FEED) {
       this.isEol = true;
       if (this.skipNextNewLine) {
         this.line--;
@@ -21747,19 +21883,19 @@ var Preprocessor = class {
       }
     }
     this.skipNextNewLine = false;
-    if (isSurrogate(cp)) {
-      cp = this._processSurrogate(cp);
+    if (isSurrogate(cp2)) {
+      cp2 = this._processSurrogate(cp2);
     }
-    const isCommonValidRange = this.handler.onParseError === null || cp > 31 && cp < 127 || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.CARRIAGE_RETURN || cp > 159 && cp < 64976;
+    const isCommonValidRange = this.handler.onParseError === null || cp2 > 31 && cp2 < 127 || cp2 === CODE_POINTS.LINE_FEED || cp2 === CODE_POINTS.CARRIAGE_RETURN || cp2 > 159 && cp2 < 64976;
     if (!isCommonValidRange) {
-      this._checkForProblematicCharacters(cp);
+      this._checkForProblematicCharacters(cp2);
     }
-    return cp;
+    return cp2;
   }
-  _checkForProblematicCharacters(cp) {
-    if (isControlCodePoint(cp)) {
+  _checkForProblematicCharacters(cp2) {
+    if (isControlCodePoint(cp2)) {
       this._err(ERR.controlCharacterInInputStream);
-    } else if (isUndefinedCodePoint(cp)) {
+    } else if (isUndefinedCodePoint(cp2)) {
       this._err(ERR.noncharacterInInputStream);
     }
   }
@@ -22825,29 +22961,29 @@ var TokenizerMode = {
   PLAINTEXT: State.PLAINTEXT,
   CDATA_SECTION: State.CDATA_SECTION
 };
-function isAsciiDigit(cp) {
-  return cp >= CODE_POINTS.DIGIT_0 && cp <= CODE_POINTS.DIGIT_9;
+function isAsciiDigit(cp2) {
+  return cp2 >= CODE_POINTS.DIGIT_0 && cp2 <= CODE_POINTS.DIGIT_9;
 }
-function isAsciiUpper(cp) {
-  return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_Z;
+function isAsciiUpper(cp2) {
+  return cp2 >= CODE_POINTS.LATIN_CAPITAL_A && cp2 <= CODE_POINTS.LATIN_CAPITAL_Z;
 }
-function isAsciiLower(cp) {
-  return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_Z;
+function isAsciiLower(cp2) {
+  return cp2 >= CODE_POINTS.LATIN_SMALL_A && cp2 <= CODE_POINTS.LATIN_SMALL_Z;
 }
-function isAsciiLetter(cp) {
-  return isAsciiLower(cp) || isAsciiUpper(cp);
+function isAsciiLetter(cp2) {
+  return isAsciiLower(cp2) || isAsciiUpper(cp2);
 }
-function isAsciiAlphaNumeric2(cp) {
-  return isAsciiLetter(cp) || isAsciiDigit(cp);
+function isAsciiAlphaNumeric2(cp2) {
+  return isAsciiLetter(cp2) || isAsciiDigit(cp2);
 }
-function toAsciiLower(cp) {
-  return cp + 32;
+function toAsciiLower(cp2) {
+  return cp2 + 32;
 }
-function isWhitespace(cp) {
-  return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED;
+function isWhitespace(cp2) {
+  return cp2 === CODE_POINTS.SPACE || cp2 === CODE_POINTS.LINE_FEED || cp2 === CODE_POINTS.TABULATION || cp2 === CODE_POINTS.FORM_FEED;
 }
-function isScriptDataDoubleEscapeSequenceEnd(cp) {
-  return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
+function isScriptDataDoubleEscapeSequenceEnd(cp2) {
+  return isWhitespace(cp2) || cp2 === CODE_POINTS.SOLIDUS || cp2 === CODE_POINTS.GREATER_THAN_SIGN;
 }
 function getErrorForNumericCharacterReference(code) {
   if (code === CODE_POINTS.NULL) {
@@ -22881,9 +23017,9 @@ var Tokenizer = class {
     this.currentAttr = { name: "", value: "" };
     this.preprocessor = new Preprocessor(handler);
     this.currentLocation = this.getCurrentLocation(-1);
-    this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => {
+    this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp2, consumed) => {
       this.preprocessor.pos = this.entityStartPos + consumed - 1;
-      this._flushCodePointConsumedAsCharacterReference(cp);
+      this._flushCodePointConsumedAsCharacterReference(cp2);
     }, handler.onParseError ? {
       missingSemicolonAfterCharacterReference: () => {
         this._err(ERR.missingSemicolonAfterCharacterReference, 1);
@@ -22923,9 +23059,9 @@ var Tokenizer = class {
     this.inLoop = true;
     while (this.active && !this.paused) {
       this.consumedAfterSnapshot = 0;
-      const cp = this._consume();
+      const cp2 = this._consume();
       if (!this._ensureHibernation()) {
-        this._callState(cp);
+        this._callState(cp2);
       }
     }
     this.inLoop = false;
@@ -23160,9 +23296,9 @@ var Tokenizer = class {
     }
     this._createCharacterToken(type, ch);
   }
-  _emitCodePoint(cp) {
-    const type = isWhitespace(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
-    this._appendCharToCurrentCharacterToken(type, cp < 65536 ? String.fromCharCode(cp) : String.fromCodePoint(cp));
+  _emitCodePoint(cp2) {
+    const type = isWhitespace(cp2) ? TokenType.WHITESPACE_CHARACTER : cp2 === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
+    this._appendCharToCurrentCharacterToken(type, cp2 < 65536 ? String.fromCharCode(cp2) : String.fromCodePoint(cp2));
   }
   //NOTE: used when we emit characters explicitly.
   //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.
@@ -23179,298 +23315,298 @@ var Tokenizer = class {
   _isCharacterReferenceInAttribute() {
     return this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED;
   }
-  _flushCodePointConsumedAsCharacterReference(cp) {
+  _flushCodePointConsumedAsCharacterReference(cp2) {
     if (this._isCharacterReferenceInAttribute()) {
-      this.currentAttr.value += String.fromCodePoint(cp);
+      this.currentAttr.value += String.fromCodePoint(cp2);
     } else {
-      this._emitCodePoint(cp);
+      this._emitCodePoint(cp2);
     }
   }
   // Calling states this way turns out to be much faster than any other approach.
-  _callState(cp) {
+  _callState(cp2) {
     switch (this.state) {
       case State.DATA: {
-        this._stateData(cp);
+        this._stateData(cp2);
         break;
       }
       case State.RCDATA: {
-        this._stateRcdata(cp);
+        this._stateRcdata(cp2);
         break;
       }
       case State.RAWTEXT: {
-        this._stateRawtext(cp);
+        this._stateRawtext(cp2);
         break;
       }
       case State.SCRIPT_DATA: {
-        this._stateScriptData(cp);
+        this._stateScriptData(cp2);
         break;
       }
       case State.PLAINTEXT: {
-        this._statePlaintext(cp);
+        this._statePlaintext(cp2);
         break;
       }
       case State.TAG_OPEN: {
-        this._stateTagOpen(cp);
+        this._stateTagOpen(cp2);
         break;
       }
       case State.END_TAG_OPEN: {
-        this._stateEndTagOpen(cp);
+        this._stateEndTagOpen(cp2);
         break;
       }
       case State.TAG_NAME: {
-        this._stateTagName(cp);
+        this._stateTagName(cp2);
         break;
       }
       case State.RCDATA_LESS_THAN_SIGN: {
-        this._stateRcdataLessThanSign(cp);
+        this._stateRcdataLessThanSign(cp2);
         break;
       }
       case State.RCDATA_END_TAG_OPEN: {
-        this._stateRcdataEndTagOpen(cp);
+        this._stateRcdataEndTagOpen(cp2);
         break;
       }
       case State.RCDATA_END_TAG_NAME: {
-        this._stateRcdataEndTagName(cp);
+        this._stateRcdataEndTagName(cp2);
         break;
       }
       case State.RAWTEXT_LESS_THAN_SIGN: {
-        this._stateRawtextLessThanSign(cp);
+        this._stateRawtextLessThanSign(cp2);
         break;
       }
       case State.RAWTEXT_END_TAG_OPEN: {
-        this._stateRawtextEndTagOpen(cp);
+        this._stateRawtextEndTagOpen(cp2);
         break;
       }
       case State.RAWTEXT_END_TAG_NAME: {
-        this._stateRawtextEndTagName(cp);
+        this._stateRawtextEndTagName(cp2);
         break;
       }
       case State.SCRIPT_DATA_LESS_THAN_SIGN: {
-        this._stateScriptDataLessThanSign(cp);
+        this._stateScriptDataLessThanSign(cp2);
         break;
       }
       case State.SCRIPT_DATA_END_TAG_OPEN: {
-        this._stateScriptDataEndTagOpen(cp);
+        this._stateScriptDataEndTagOpen(cp2);
         break;
       }
       case State.SCRIPT_DATA_END_TAG_NAME: {
-        this._stateScriptDataEndTagName(cp);
+        this._stateScriptDataEndTagName(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPE_START: {
-        this._stateScriptDataEscapeStart(cp);
+        this._stateScriptDataEscapeStart(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPE_START_DASH: {
-        this._stateScriptDataEscapeStartDash(cp);
+        this._stateScriptDataEscapeStartDash(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED: {
-        this._stateScriptDataEscaped(cp);
+        this._stateScriptDataEscaped(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED_DASH: {
-        this._stateScriptDataEscapedDash(cp);
+        this._stateScriptDataEscapedDash(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED_DASH_DASH: {
-        this._stateScriptDataEscapedDashDash(cp);
+        this._stateScriptDataEscapedDashDash(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
-        this._stateScriptDataEscapedLessThanSign(cp);
+        this._stateScriptDataEscapedLessThanSign(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: {
-        this._stateScriptDataEscapedEndTagOpen(cp);
+        this._stateScriptDataEscapedEndTagOpen(cp2);
         break;
       }
       case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: {
-        this._stateScriptDataEscapedEndTagName(cp);
+        this._stateScriptDataEscapedEndTagName(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: {
-        this._stateScriptDataDoubleEscapeStart(cp);
+        this._stateScriptDataDoubleEscapeStart(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPED: {
-        this._stateScriptDataDoubleEscaped(cp);
+        this._stateScriptDataDoubleEscaped(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
-        this._stateScriptDataDoubleEscapedDash(cp);
+        this._stateScriptDataDoubleEscapedDash(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
-        this._stateScriptDataDoubleEscapedDashDash(cp);
+        this._stateScriptDataDoubleEscapedDashDash(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
-        this._stateScriptDataDoubleEscapedLessThanSign(cp);
+        this._stateScriptDataDoubleEscapedLessThanSign(cp2);
         break;
       }
       case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: {
-        this._stateScriptDataDoubleEscapeEnd(cp);
+        this._stateScriptDataDoubleEscapeEnd(cp2);
         break;
       }
       case State.BEFORE_ATTRIBUTE_NAME: {
-        this._stateBeforeAttributeName(cp);
+        this._stateBeforeAttributeName(cp2);
         break;
       }
       case State.ATTRIBUTE_NAME: {
-        this._stateAttributeName(cp);
+        this._stateAttributeName(cp2);
         break;
       }
       case State.AFTER_ATTRIBUTE_NAME: {
-        this._stateAfterAttributeName(cp);
+        this._stateAfterAttributeName(cp2);
         break;
       }
       case State.BEFORE_ATTRIBUTE_VALUE: {
-        this._stateBeforeAttributeValue(cp);
+        this._stateBeforeAttributeValue(cp2);
         break;
       }
       case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
-        this._stateAttributeValueDoubleQuoted(cp);
+        this._stateAttributeValueDoubleQuoted(cp2);
         break;
       }
       case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: {
-        this._stateAttributeValueSingleQuoted(cp);
+        this._stateAttributeValueSingleQuoted(cp2);
         break;
       }
       case State.ATTRIBUTE_VALUE_UNQUOTED: {
-        this._stateAttributeValueUnquoted(cp);
+        this._stateAttributeValueUnquoted(cp2);
         break;
       }
       case State.AFTER_ATTRIBUTE_VALUE_QUOTED: {
-        this._stateAfterAttributeValueQuoted(cp);
+        this._stateAfterAttributeValueQuoted(cp2);
         break;
       }
       case State.SELF_CLOSING_START_TAG: {
-        this._stateSelfClosingStartTag(cp);
+        this._stateSelfClosingStartTag(cp2);
         break;
       }
       case State.BOGUS_COMMENT: {
-        this._stateBogusComment(cp);
+        this._stateBogusComment(cp2);
         break;
       }
       case State.MARKUP_DECLARATION_OPEN: {
-        this._stateMarkupDeclarationOpen(cp);
+        this._stateMarkupDeclarationOpen(cp2);
         break;
       }
       case State.COMMENT_START: {
-        this._stateCommentStart(cp);
+        this._stateCommentStart(cp2);
         break;
       }
       case State.COMMENT_START_DASH: {
-        this._stateCommentStartDash(cp);
+        this._stateCommentStartDash(cp2);
         break;
       }
       case State.COMMENT: {
-        this._stateComment(cp);
+        this._stateComment(cp2);
         break;
       }
       case State.COMMENT_LESS_THAN_SIGN: {
-        this._stateCommentLessThanSign(cp);
+        this._stateCommentLessThanSign(cp2);
         break;
       }
       case State.COMMENT_LESS_THAN_SIGN_BANG: {
-        this._stateCommentLessThanSignBang(cp);
+        this._stateCommentLessThanSignBang(cp2);
         break;
       }
       case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: {
-        this._stateCommentLessThanSignBangDash(cp);
+        this._stateCommentLessThanSignBangDash(cp2);
         break;
       }
       case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: {
-        this._stateCommentLessThanSignBangDashDash(cp);
+        this._stateCommentLessThanSignBangDashDash(cp2);
         break;
       }
       case State.COMMENT_END_DASH: {
-        this._stateCommentEndDash(cp);
+        this._stateCommentEndDash(cp2);
         break;
       }
       case State.COMMENT_END: {
-        this._stateCommentEnd(cp);
+        this._stateCommentEnd(cp2);
         break;
       }
       case State.COMMENT_END_BANG: {
-        this._stateCommentEndBang(cp);
+        this._stateCommentEndBang(cp2);
         break;
       }
       case State.DOCTYPE: {
-        this._stateDoctype(cp);
+        this._stateDoctype(cp2);
         break;
       }
       case State.BEFORE_DOCTYPE_NAME: {
-        this._stateBeforeDoctypeName(cp);
+        this._stateBeforeDoctypeName(cp2);
         break;
       }
       case State.DOCTYPE_NAME: {
-        this._stateDoctypeName(cp);
+        this._stateDoctypeName(cp2);
         break;
       }
       case State.AFTER_DOCTYPE_NAME: {
-        this._stateAfterDoctypeName(cp);
+        this._stateAfterDoctypeName(cp2);
         break;
       }
       case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: {
-        this._stateAfterDoctypePublicKeyword(cp);
+        this._stateAfterDoctypePublicKeyword(cp2);
         break;
       }
       case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
-        this._stateBeforeDoctypePublicIdentifier(cp);
+        this._stateBeforeDoctypePublicIdentifier(cp2);
         break;
       }
       case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
-        this._stateDoctypePublicIdentifierDoubleQuoted(cp);
+        this._stateDoctypePublicIdentifierDoubleQuoted(cp2);
         break;
       }
       case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
-        this._stateDoctypePublicIdentifierSingleQuoted(cp);
+        this._stateDoctypePublicIdentifierSingleQuoted(cp2);
         break;
       }
       case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
-        this._stateAfterDoctypePublicIdentifier(cp);
+        this._stateAfterDoctypePublicIdentifier(cp2);
         break;
       }
       case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
-        this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);
+        this._stateBetweenDoctypePublicAndSystemIdentifiers(cp2);
         break;
       }
       case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: {
-        this._stateAfterDoctypeSystemKeyword(cp);
+        this._stateAfterDoctypeSystemKeyword(cp2);
         break;
       }
       case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
-        this._stateBeforeDoctypeSystemIdentifier(cp);
+        this._stateBeforeDoctypeSystemIdentifier(cp2);
         break;
       }
       case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
-        this._stateDoctypeSystemIdentifierDoubleQuoted(cp);
+        this._stateDoctypeSystemIdentifierDoubleQuoted(cp2);
         break;
       }
       case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
-        this._stateDoctypeSystemIdentifierSingleQuoted(cp);
+        this._stateDoctypeSystemIdentifierSingleQuoted(cp2);
         break;
       }
       case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
-        this._stateAfterDoctypeSystemIdentifier(cp);
+        this._stateAfterDoctypeSystemIdentifier(cp2);
         break;
       }
       case State.BOGUS_DOCTYPE: {
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
         break;
       }
       case State.CDATA_SECTION: {
-        this._stateCdataSection(cp);
+        this._stateCdataSection(cp2);
         break;
       }
       case State.CDATA_SECTION_BRACKET: {
-        this._stateCdataSectionBracket(cp);
+        this._stateCdataSectionBracket(cp2);
         break;
       }
       case State.CDATA_SECTION_END: {
-        this._stateCdataSectionEnd(cp);
+        this._stateCdataSectionEnd(cp2);
         break;
       }
       case State.CHARACTER_REFERENCE: {
@@ -23478,7 +23614,7 @@ var Tokenizer = class {
         break;
       }
       case State.AMBIGUOUS_AMPERSAND: {
-        this._stateAmbiguousAmpersand(cp);
+        this._stateAmbiguousAmpersand(cp2);
         break;
       }
       default: {
@@ -23489,8 +23625,8 @@ var Tokenizer = class {
   // State machine
   // Data state
   //------------------------------------------------------------------
-  _stateData(cp) {
-    switch (cp) {
+  _stateData(cp2) {
+    switch (cp2) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State.TAG_OPEN;
         break;
@@ -23501,7 +23637,7 @@ var Tokenizer = class {
       }
       case CODE_POINTS.NULL: {
         this._err(ERR.unexpectedNullCharacter);
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -23509,14 +23645,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   //  RCDATA state
   //------------------------------------------------------------------
-  _stateRcdata(cp) {
-    switch (cp) {
+  _stateRcdata(cp2) {
+    switch (cp2) {
       case CODE_POINTS.AMPERSAND: {
         this._startCharacterReference();
         break;
@@ -23535,14 +23671,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // RAWTEXT state
   //------------------------------------------------------------------
-  _stateRawtext(cp) {
-    switch (cp) {
+  _stateRawtext(cp2) {
+    switch (cp2) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State.RAWTEXT_LESS_THAN_SIGN;
         break;
@@ -23557,14 +23693,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data state
   //------------------------------------------------------------------
-  _stateScriptData(cp) {
-    switch (cp) {
+  _stateScriptData(cp2) {
+    switch (cp2) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;
         break;
@@ -23579,14 +23715,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // PLAINTEXT state
   //------------------------------------------------------------------
-  _statePlaintext(cp) {
-    switch (cp) {
+  _statePlaintext(cp2) {
+    switch (cp2) {
       case CODE_POINTS.NULL: {
         this._err(ERR.unexpectedNullCharacter);
         this._emitChars(REPLACEMENT_CHARACTER);
@@ -23597,19 +23733,19 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Tag open state
   //------------------------------------------------------------------
-  _stateTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this._createStartTagToken();
       this.state = State.TAG_NAME;
-      this._stateTagName(cp);
+      this._stateTagName(cp2);
     } else
-      switch (cp) {
+      switch (cp2) {
         case CODE_POINTS.EXCLAMATION_MARK: {
           this.state = State.MARKUP_DECLARATION_OPEN;
           break;
@@ -23622,7 +23758,7 @@ var Tokenizer = class {
           this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
           this._createCommentToken(1);
           this.state = State.BOGUS_COMMENT;
-          this._stateBogusComment(cp);
+          this._stateBogusComment(cp2);
           break;
         }
         case CODE_POINTS.EOF: {
@@ -23635,19 +23771,19 @@ var Tokenizer = class {
           this._err(ERR.invalidFirstCharacterOfTagName);
           this._emitChars("<");
           this.state = State.DATA;
-          this._stateData(cp);
+          this._stateData(cp2);
         }
       }
   }
   // End tag open state
   //------------------------------------------------------------------
-  _stateEndTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateEndTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this._createEndTagToken();
       this.state = State.TAG_NAME;
-      this._stateTagName(cp);
+      this._stateTagName(cp2);
     } else
-      switch (cp) {
+      switch (cp2) {
         case CODE_POINTS.GREATER_THAN_SIGN: {
           this._err(ERR.missingEndTagName);
           this.state = State.DATA;
@@ -23663,15 +23799,15 @@ var Tokenizer = class {
           this._err(ERR.invalidFirstCharacterOfTagName);
           this._createCommentToken(2);
           this.state = State.BOGUS_COMMENT;
-          this._stateBogusComment(cp);
+          this._stateBogusComment(cp2);
         }
       }
   }
   // Tag name state
   //------------------------------------------------------------------
-  _stateTagName(cp) {
+  _stateTagName(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -23699,31 +23835,31 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+        token.tagName += String.fromCodePoint(isAsciiUpper(cp2) ? toAsciiLower(cp2) : cp2);
       }
     }
   }
   // RCDATA less-than sign state
   //------------------------------------------------------------------
-  _stateRcdataLessThanSign(cp) {
-    if (cp === CODE_POINTS.SOLIDUS) {
+  _stateRcdataLessThanSign(cp2) {
+    if (cp2 === CODE_POINTS.SOLIDUS) {
       this.state = State.RCDATA_END_TAG_OPEN;
     } else {
       this._emitChars("<");
       this.state = State.RCDATA;
-      this._stateRcdata(cp);
+      this._stateRcdata(cp2);
     }
   }
   // RCDATA end tag open state
   //------------------------------------------------------------------
-  _stateRcdataEndTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateRcdataEndTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this.state = State.RCDATA_END_TAG_NAME;
-      this._stateRcdataEndTagName(cp);
+      this._stateRcdataEndTagName(cp2);
     } else {
       this._emitChars("</");
       this.state = State.RCDATA;
-      this._stateRcdata(cp);
+      this._stateRcdata(cp2);
     }
   }
   handleSpecialEndTag(_cp) {
@@ -23733,8 +23869,8 @@ var Tokenizer = class {
     this._createEndTagToken();
     const token = this.currentToken;
     token.tagName = this.lastStartTagName;
-    const cp = this.preprocessor.peek(this.lastStartTagName.length);
-    switch (cp) {
+    const cp2 = this.preprocessor.peek(this.lastStartTagName.length);
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -23761,49 +23897,49 @@ var Tokenizer = class {
   }
   // RCDATA end tag name state
   //------------------------------------------------------------------
-  _stateRcdataEndTagName(cp) {
-    if (this.handleSpecialEndTag(cp)) {
+  _stateRcdataEndTagName(cp2) {
+    if (this.handleSpecialEndTag(cp2)) {
       this._emitChars("</");
       this.state = State.RCDATA;
-      this._stateRcdata(cp);
+      this._stateRcdata(cp2);
     }
   }
   // RAWTEXT less-than sign state
   //------------------------------------------------------------------
-  _stateRawtextLessThanSign(cp) {
-    if (cp === CODE_POINTS.SOLIDUS) {
+  _stateRawtextLessThanSign(cp2) {
+    if (cp2 === CODE_POINTS.SOLIDUS) {
       this.state = State.RAWTEXT_END_TAG_OPEN;
     } else {
       this._emitChars("<");
       this.state = State.RAWTEXT;
-      this._stateRawtext(cp);
+      this._stateRawtext(cp2);
     }
   }
   // RAWTEXT end tag open state
   //------------------------------------------------------------------
-  _stateRawtextEndTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateRawtextEndTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this.state = State.RAWTEXT_END_TAG_NAME;
-      this._stateRawtextEndTagName(cp);
+      this._stateRawtextEndTagName(cp2);
     } else {
       this._emitChars("</");
       this.state = State.RAWTEXT;
-      this._stateRawtext(cp);
+      this._stateRawtext(cp2);
     }
   }
   // RAWTEXT end tag name state
   //------------------------------------------------------------------
-  _stateRawtextEndTagName(cp) {
-    if (this.handleSpecialEndTag(cp)) {
+  _stateRawtextEndTagName(cp2) {
+    if (this.handleSpecialEndTag(cp2)) {
       this._emitChars("</");
       this.state = State.RAWTEXT;
-      this._stateRawtext(cp);
+      this._stateRawtext(cp2);
     }
   }
   // Script data less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataLessThanSign(cp) {
-    switch (cp) {
+  _stateScriptDataLessThanSign(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SOLIDUS: {
         this.state = State.SCRIPT_DATA_END_TAG_OPEN;
         break;
@@ -23816,57 +23952,57 @@ var Tokenizer = class {
       default: {
         this._emitChars("<");
         this.state = State.SCRIPT_DATA;
-        this._stateScriptData(cp);
+        this._stateScriptData(cp2);
       }
     }
   }
   // Script data end tag open state
   //------------------------------------------------------------------
-  _stateScriptDataEndTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateScriptDataEndTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this.state = State.SCRIPT_DATA_END_TAG_NAME;
-      this._stateScriptDataEndTagName(cp);
+      this._stateScriptDataEndTagName(cp2);
     } else {
       this._emitChars("</");
       this.state = State.SCRIPT_DATA;
-      this._stateScriptData(cp);
+      this._stateScriptData(cp2);
     }
   }
   // Script data end tag name state
   //------------------------------------------------------------------
-  _stateScriptDataEndTagName(cp) {
-    if (this.handleSpecialEndTag(cp)) {
+  _stateScriptDataEndTagName(cp2) {
+    if (this.handleSpecialEndTag(cp2)) {
       this._emitChars("</");
       this.state = State.SCRIPT_DATA;
-      this._stateScriptData(cp);
+      this._stateScriptData(cp2);
     }
   }
   // Script data escape start state
   //------------------------------------------------------------------
-  _stateScriptDataEscapeStart(cp) {
-    if (cp === CODE_POINTS.HYPHEN_MINUS) {
+  _stateScriptDataEscapeStart(cp2) {
+    if (cp2 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State.SCRIPT_DATA_ESCAPE_START_DASH;
       this._emitChars("-");
     } else {
       this.state = State.SCRIPT_DATA;
-      this._stateScriptData(cp);
+      this._stateScriptData(cp2);
     }
   }
   // Script data escape start dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapeStartDash(cp) {
-    if (cp === CODE_POINTS.HYPHEN_MINUS) {
+  _stateScriptDataEscapeStartDash(cp2) {
+    if (cp2 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
       this._emitChars("-");
     } else {
       this.state = State.SCRIPT_DATA;
-      this._stateScriptData(cp);
+      this._stateScriptData(cp2);
     }
   }
   // Script data escaped state
   //------------------------------------------------------------------
-  _stateScriptDataEscaped(cp) {
-    switch (cp) {
+  _stateScriptDataEscaped(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.SCRIPT_DATA_ESCAPED_DASH;
         this._emitChars("-");
@@ -23887,14 +24023,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data escaped dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedDash(cp) {
-    switch (cp) {
+  _stateScriptDataEscapedDash(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
         this._emitChars("-");
@@ -23917,14 +24053,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.SCRIPT_DATA_ESCAPED;
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data escaped dash dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedDashDash(cp) {
-    switch (cp) {
+  _stateScriptDataEscapedDashDash(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this._emitChars("-");
         break;
@@ -23951,64 +24087,64 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.SCRIPT_DATA_ESCAPED;
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data escaped less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedLessThanSign(cp) {
-    if (cp === CODE_POINTS.SOLIDUS) {
+  _stateScriptDataEscapedLessThanSign(cp2) {
+    if (cp2 === CODE_POINTS.SOLIDUS) {
       this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
-    } else if (isAsciiLetter(cp)) {
+    } else if (isAsciiLetter(cp2)) {
       this._emitChars("<");
       this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;
-      this._stateScriptDataDoubleEscapeStart(cp);
+      this._stateScriptDataDoubleEscapeStart(cp2);
     } else {
       this._emitChars("<");
       this.state = State.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp);
+      this._stateScriptDataEscaped(cp2);
     }
   }
   // Script data escaped end tag open state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedEndTagOpen(cp) {
-    if (isAsciiLetter(cp)) {
+  _stateScriptDataEscapedEndTagOpen(cp2) {
+    if (isAsciiLetter(cp2)) {
       this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME;
-      this._stateScriptDataEscapedEndTagName(cp);
+      this._stateScriptDataEscapedEndTagName(cp2);
     } else {
       this._emitChars("</");
       this.state = State.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp);
+      this._stateScriptDataEscaped(cp2);
     }
   }
   // Script data escaped end tag name state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedEndTagName(cp) {
-    if (this.handleSpecialEndTag(cp)) {
+  _stateScriptDataEscapedEndTagName(cp2) {
+    if (this.handleSpecialEndTag(cp2)) {
       this._emitChars("</");
       this.state = State.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp);
+      this._stateScriptDataEscaped(cp2);
     }
   }
   // Script data double escape start state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapeStart(cp) {
+  _stateScriptDataDoubleEscapeStart(cp2) {
     if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
-      this._emitCodePoint(cp);
+      this._emitCodePoint(cp2);
       for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) {
         this._emitCodePoint(this._consume());
       }
       this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
     } else if (!this._ensureHibernation()) {
       this.state = State.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp);
+      this._stateScriptDataEscaped(cp2);
     }
   }
   // Script data double escaped state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscaped(cp) {
-    switch (cp) {
+  _stateScriptDataDoubleEscaped(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
         this._emitChars("-");
@@ -24030,14 +24166,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data double escaped dash state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedDash(cp) {
-    switch (cp) {
+  _stateScriptDataDoubleEscapedDash(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
         this._emitChars("-");
@@ -24061,14 +24197,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data double escaped dash dash state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedDashDash(cp) {
-    switch (cp) {
+  _stateScriptDataDoubleEscapedDashDash(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this._emitChars("-");
         break;
@@ -24096,39 +24232,39 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // Script data double escaped less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedLessThanSign(cp) {
-    if (cp === CODE_POINTS.SOLIDUS) {
+  _stateScriptDataDoubleEscapedLessThanSign(cp2) {
+    if (cp2 === CODE_POINTS.SOLIDUS) {
       this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END;
       this._emitChars("/");
     } else {
       this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
-      this._stateScriptDataDoubleEscaped(cp);
+      this._stateScriptDataDoubleEscaped(cp2);
     }
   }
   // Script data double escape end state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapeEnd(cp) {
+  _stateScriptDataDoubleEscapeEnd(cp2) {
     if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
-      this._emitCodePoint(cp);
+      this._emitCodePoint(cp2);
       for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) {
         this._emitCodePoint(this._consume());
       }
       this.state = State.SCRIPT_DATA_ESCAPED;
     } else if (!this._ensureHibernation()) {
       this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
-      this._stateScriptDataDoubleEscaped(cp);
+      this._stateScriptDataDoubleEscaped(cp2);
     }
   }
   // Before attribute name state
   //------------------------------------------------------------------
-  _stateBeforeAttributeName(cp) {
-    switch (cp) {
+  _stateBeforeAttributeName(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24139,7 +24275,7 @@ var Tokenizer = class {
       case CODE_POINTS.GREATER_THAN_SIGN:
       case CODE_POINTS.EOF: {
         this.state = State.AFTER_ATTRIBUTE_NAME;
-        this._stateAfterAttributeName(cp);
+        this._stateAfterAttributeName(cp2);
         break;
       }
       case CODE_POINTS.EQUALS_SIGN: {
@@ -24151,14 +24287,14 @@ var Tokenizer = class {
       default: {
         this._createAttr("");
         this.state = State.ATTRIBUTE_NAME;
-        this._stateAttributeName(cp);
+        this._stateAttributeName(cp2);
       }
     }
   }
   // Attribute name state
   //------------------------------------------------------------------
-  _stateAttributeName(cp) {
-    switch (cp) {
+  _stateAttributeName(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24168,7 +24304,7 @@ var Tokenizer = class {
       case CODE_POINTS.EOF: {
         this._leaveAttrName();
         this.state = State.AFTER_ATTRIBUTE_NAME;
-        this._stateAfterAttributeName(cp);
+        this._stateAfterAttributeName(cp2);
         break;
       }
       case CODE_POINTS.EQUALS_SIGN: {
@@ -24180,7 +24316,7 @@ var Tokenizer = class {
       case CODE_POINTS.APOSTROPHE:
       case CODE_POINTS.LESS_THAN_SIGN: {
         this._err(ERR.unexpectedCharacterInAttributeName);
-        this.currentAttr.name += String.fromCodePoint(cp);
+        this.currentAttr.name += String.fromCodePoint(cp2);
         break;
       }
       case CODE_POINTS.NULL: {
@@ -24189,14 +24325,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+        this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp2) ? toAsciiLower(cp2) : cp2);
       }
     }
   }
   // After attribute name state
   //------------------------------------------------------------------
-  _stateAfterAttributeName(cp) {
-    switch (cp) {
+  _stateAfterAttributeName(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24224,14 +24360,14 @@ var Tokenizer = class {
       default: {
         this._createAttr("");
         this.state = State.ATTRIBUTE_NAME;
-        this._stateAttributeName(cp);
+        this._stateAttributeName(cp2);
       }
     }
   }
   // Before attribute value state
   //------------------------------------------------------------------
-  _stateBeforeAttributeValue(cp) {
-    switch (cp) {
+  _stateBeforeAttributeValue(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24254,14 +24390,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.ATTRIBUTE_VALUE_UNQUOTED;
-        this._stateAttributeValueUnquoted(cp);
+        this._stateAttributeValueUnquoted(cp2);
       }
     }
   }
   // Attribute value (double-quoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueDoubleQuoted(cp) {
-    switch (cp) {
+  _stateAttributeValueDoubleQuoted(cp2) {
+    switch (cp2) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
         break;
@@ -24281,14 +24417,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp);
+        this.currentAttr.value += String.fromCodePoint(cp2);
       }
     }
   }
   // Attribute value (single-quoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueSingleQuoted(cp) {
-    switch (cp) {
+  _stateAttributeValueSingleQuoted(cp2) {
+    switch (cp2) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
         break;
@@ -24308,14 +24444,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp);
+        this.currentAttr.value += String.fromCodePoint(cp2);
       }
     }
   }
   // Attribute value (unquoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueUnquoted(cp) {
-    switch (cp) {
+  _stateAttributeValueUnquoted(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24345,7 +24481,7 @@ var Tokenizer = class {
       case CODE_POINTS.EQUALS_SIGN:
       case CODE_POINTS.GRAVE_ACCENT: {
         this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
-        this.currentAttr.value += String.fromCodePoint(cp);
+        this.currentAttr.value += String.fromCodePoint(cp2);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -24354,14 +24490,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp);
+        this.currentAttr.value += String.fromCodePoint(cp2);
       }
     }
   }
   // After attribute value (quoted) state
   //------------------------------------------------------------------
-  _stateAfterAttributeValueQuoted(cp) {
-    switch (cp) {
+  _stateAfterAttributeValueQuoted(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24389,14 +24525,14 @@ var Tokenizer = class {
       default: {
         this._err(ERR.missingWhitespaceBetweenAttributes);
         this.state = State.BEFORE_ATTRIBUTE_NAME;
-        this._stateBeforeAttributeName(cp);
+        this._stateBeforeAttributeName(cp2);
       }
     }
   }
   // Self-closing start tag state
   //------------------------------------------------------------------
-  _stateSelfClosingStartTag(cp) {
-    switch (cp) {
+  _stateSelfClosingStartTag(cp2) {
+    switch (cp2) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         const token = this.currentToken;
         token.selfClosing = true;
@@ -24412,15 +24548,15 @@ var Tokenizer = class {
       default: {
         this._err(ERR.unexpectedSolidusInTag);
         this.state = State.BEFORE_ATTRIBUTE_NAME;
-        this._stateBeforeAttributeName(cp);
+        this._stateBeforeAttributeName(cp2);
       }
     }
   }
   // Bogus comment state
   //------------------------------------------------------------------
-  _stateBogusComment(cp) {
+  _stateBogusComment(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State.DATA;
         this.emitCurrentComment(token);
@@ -24437,13 +24573,13 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.data += String.fromCodePoint(cp);
+        token.data += String.fromCodePoint(cp2);
       }
     }
   }
   // Markup declaration open state
   //------------------------------------------------------------------
-  _stateMarkupDeclarationOpen(cp) {
+  _stateMarkupDeclarationOpen(cp2) {
     if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) {
       this._createCommentToken(SEQUENCES.DASH_DASH.length + 1);
       this.state = State.COMMENT_START;
@@ -24463,13 +24599,13 @@ var Tokenizer = class {
       this._err(ERR.incorrectlyOpenedComment);
       this._createCommentToken(2);
       this.state = State.BOGUS_COMMENT;
-      this._stateBogusComment(cp);
+      this._stateBogusComment(cp2);
     }
   }
   // Comment start state
   //------------------------------------------------------------------
-  _stateCommentStart(cp) {
-    switch (cp) {
+  _stateCommentStart(cp2) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.COMMENT_START_DASH;
         break;
@@ -24483,15 +24619,15 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // Comment start dash state
   //------------------------------------------------------------------
-  _stateCommentStartDash(cp) {
+  _stateCommentStartDash(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.COMMENT_END;
         break;
@@ -24511,15 +24647,15 @@ var Tokenizer = class {
       default: {
         token.data += "-";
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // Comment state
   //------------------------------------------------------------------
-  _stateComment(cp) {
+  _stateComment(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.COMMENT_END_DASH;
         break;
@@ -24541,15 +24677,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.data += String.fromCodePoint(cp);
+        token.data += String.fromCodePoint(cp2);
       }
     }
   }
   // Comment less-than sign state
   //------------------------------------------------------------------
-  _stateCommentLessThanSign(cp) {
+  _stateCommentLessThanSign(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.EXCLAMATION_MARK: {
         token.data += "!";
         this.state = State.COMMENT_LESS_THAN_SIGN_BANG;
@@ -24561,44 +24697,44 @@ var Tokenizer = class {
       }
       default: {
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // Comment less-than sign bang state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBang(cp) {
-    if (cp === CODE_POINTS.HYPHEN_MINUS) {
+  _stateCommentLessThanSignBang(cp2) {
+    if (cp2 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH;
     } else {
       this.state = State.COMMENT;
-      this._stateComment(cp);
+      this._stateComment(cp2);
     }
   }
   // Comment less-than sign bang dash state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBangDash(cp) {
-    if (cp === CODE_POINTS.HYPHEN_MINUS) {
+  _stateCommentLessThanSignBangDash(cp2) {
+    if (cp2 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;
     } else {
       this.state = State.COMMENT_END_DASH;
-      this._stateCommentEndDash(cp);
+      this._stateCommentEndDash(cp2);
     }
   }
   // Comment less-than sign bang dash dash state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBangDashDash(cp) {
-    if (cp !== CODE_POINTS.GREATER_THAN_SIGN && cp !== CODE_POINTS.EOF) {
+  _stateCommentLessThanSignBangDashDash(cp2) {
+    if (cp2 !== CODE_POINTS.GREATER_THAN_SIGN && cp2 !== CODE_POINTS.EOF) {
       this._err(ERR.nestedComment);
     }
     this.state = State.COMMENT_END;
-    this._stateCommentEnd(cp);
+    this._stateCommentEnd(cp2);
   }
   // Comment end dash state
   //------------------------------------------------------------------
-  _stateCommentEndDash(cp) {
+  _stateCommentEndDash(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State.COMMENT_END;
         break;
@@ -24612,15 +24748,15 @@ var Tokenizer = class {
       default: {
         token.data += "-";
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // Comment end state
   //------------------------------------------------------------------
-  _stateCommentEnd(cp) {
+  _stateCommentEnd(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State.DATA;
         this.emitCurrentComment(token);
@@ -24643,15 +24779,15 @@ var Tokenizer = class {
       default: {
         token.data += "--";
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // Comment end bang state
   //------------------------------------------------------------------
-  _stateCommentEndBang(cp) {
+  _stateCommentEndBang(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.HYPHEN_MINUS: {
         token.data += "--!";
         this.state = State.COMMENT_END_DASH;
@@ -24672,14 +24808,14 @@ var Tokenizer = class {
       default: {
         token.data += "--!";
         this.state = State.COMMENT;
-        this._stateComment(cp);
+        this._stateComment(cp2);
       }
     }
   }
   // DOCTYPE state
   //------------------------------------------------------------------
-  _stateDoctype(cp) {
-    switch (cp) {
+  _stateDoctype(cp2) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24689,7 +24825,7 @@ var Tokenizer = class {
       }
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State.BEFORE_DOCTYPE_NAME;
-        this._stateBeforeDoctypeName(cp);
+        this._stateBeforeDoctypeName(cp2);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -24704,18 +24840,18 @@ var Tokenizer = class {
       default: {
         this._err(ERR.missingWhitespaceBeforeDoctypeName);
         this.state = State.BEFORE_DOCTYPE_NAME;
-        this._stateBeforeDoctypeName(cp);
+        this._stateBeforeDoctypeName(cp2);
       }
     }
   }
   // Before DOCTYPE name state
   //------------------------------------------------------------------
-  _stateBeforeDoctypeName(cp) {
-    if (isAsciiUpper(cp)) {
-      this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp)));
+  _stateBeforeDoctypeName(cp2) {
+    if (isAsciiUpper(cp2)) {
+      this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp2)));
       this.state = State.DOCTYPE_NAME;
     } else
-      switch (cp) {
+      switch (cp2) {
         case CODE_POINTS.SPACE:
         case CODE_POINTS.LINE_FEED:
         case CODE_POINTS.TABULATION:
@@ -24747,16 +24883,16 @@ var Tokenizer = class {
           break;
         }
         default: {
-          this._createDoctypeToken(String.fromCodePoint(cp));
+          this._createDoctypeToken(String.fromCodePoint(cp2));
           this.state = State.DOCTYPE_NAME;
         }
       }
   }
   // DOCTYPE name state
   //------------------------------------------------------------------
-  _stateDoctypeName(cp) {
+  _stateDoctypeName(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24782,15 +24918,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+        token.name += String.fromCodePoint(isAsciiUpper(cp2) ? toAsciiLower(cp2) : cp2);
       }
     }
   }
   // After DOCTYPE name state
   //------------------------------------------------------------------
-  _stateAfterDoctypeName(cp) {
+  _stateAfterDoctypeName(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24818,16 +24954,16 @@ var Tokenizer = class {
           this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
           token.forceQuirks = true;
           this.state = State.BOGUS_DOCTYPE;
-          this._stateBogusDoctype(cp);
+          this._stateBogusDoctype(cp2);
         }
       }
     }
   }
   // After DOCTYPE public keyword state
   //------------------------------------------------------------------
-  _stateAfterDoctypePublicKeyword(cp) {
+  _stateAfterDoctypePublicKeyword(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24865,15 +25001,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // Before DOCTYPE public identifier state
   //------------------------------------------------------------------
-  _stateBeforeDoctypePublicIdentifier(cp) {
+  _stateBeforeDoctypePublicIdentifier(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -24908,15 +25044,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // DOCTYPE public identifier (double-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypePublicIdentifierDoubleQuoted(cp) {
+  _stateDoctypePublicIdentifierDoubleQuoted(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
         break;
@@ -24941,15 +25077,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.publicId += String.fromCodePoint(cp);
+        token.publicId += String.fromCodePoint(cp2);
       }
     }
   }
   // DOCTYPE public identifier (single-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypePublicIdentifierSingleQuoted(cp) {
+  _stateDoctypePublicIdentifierSingleQuoted(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
         break;
@@ -24974,15 +25110,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.publicId += String.fromCodePoint(cp);
+        token.publicId += String.fromCodePoint(cp2);
       }
     }
   }
   // After DOCTYPE public identifier state
   //------------------------------------------------------------------
-  _stateAfterDoctypePublicIdentifier(cp) {
+  _stateAfterDoctypePublicIdentifier(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -25018,15 +25154,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // Between DOCTYPE public and system identifiers state
   //------------------------------------------------------------------
-  _stateBetweenDoctypePublicAndSystemIdentifiers(cp) {
+  _stateBetweenDoctypePublicAndSystemIdentifiers(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -25059,15 +25195,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // After DOCTYPE system keyword state
   //------------------------------------------------------------------
-  _stateAfterDoctypeSystemKeyword(cp) {
+  _stateAfterDoctypeSystemKeyword(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -25105,15 +25241,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // Before DOCTYPE system identifier state
   //------------------------------------------------------------------
-  _stateBeforeDoctypeSystemIdentifier(cp) {
+  _stateBeforeDoctypeSystemIdentifier(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -25148,15 +25284,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // DOCTYPE system identifier (double-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypeSystemIdentifierDoubleQuoted(cp) {
+  _stateDoctypeSystemIdentifierDoubleQuoted(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
         break;
@@ -25181,15 +25317,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.systemId += String.fromCodePoint(cp);
+        token.systemId += String.fromCodePoint(cp2);
       }
     }
   }
   // DOCTYPE system identifier (single-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypeSystemIdentifierSingleQuoted(cp) {
+  _stateDoctypeSystemIdentifierSingleQuoted(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
         break;
@@ -25214,15 +25350,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.systemId += String.fromCodePoint(cp);
+        token.systemId += String.fromCodePoint(cp2);
       }
     }
   }
   // After DOCTYPE system identifier state
   //------------------------------------------------------------------
-  _stateAfterDoctypeSystemIdentifier(cp) {
+  _stateAfterDoctypeSystemIdentifier(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -25244,15 +25380,15 @@ var Tokenizer = class {
       default: {
         this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
         this.state = State.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp);
+        this._stateBogusDoctype(cp2);
       }
     }
   }
   // Bogus DOCTYPE state
   //------------------------------------------------------------------
-  _stateBogusDoctype(cp) {
+  _stateBogusDoctype(cp2) {
     const token = this.currentToken;
-    switch (cp) {
+    switch (cp2) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.emitCurrentDoctype(token);
         this.state = State.DATA;
@@ -25272,8 +25408,8 @@ var Tokenizer = class {
   }
   // CDATA section state
   //------------------------------------------------------------------
-  _stateCdataSection(cp) {
-    switch (cp) {
+  _stateCdataSection(cp2) {
+    switch (cp2) {
       case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
         this.state = State.CDATA_SECTION_BRACKET;
         break;
@@ -25284,25 +25420,25 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp);
+        this._emitCodePoint(cp2);
       }
     }
   }
   // CDATA section bracket state
   //------------------------------------------------------------------
-  _stateCdataSectionBracket(cp) {
-    if (cp === CODE_POINTS.RIGHT_SQUARE_BRACKET) {
+  _stateCdataSectionBracket(cp2) {
+    if (cp2 === CODE_POINTS.RIGHT_SQUARE_BRACKET) {
       this.state = State.CDATA_SECTION_END;
     } else {
       this._emitChars("]");
       this.state = State.CDATA_SECTION;
-      this._stateCdataSection(cp);
+      this._stateCdataSection(cp2);
     }
   }
   // CDATA section end state
   //------------------------------------------------------------------
-  _stateCdataSectionEnd(cp) {
-    switch (cp) {
+  _stateCdataSectionEnd(cp2) {
+    switch (cp2) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State.DATA;
         break;
@@ -25314,7 +25450,7 @@ var Tokenizer = class {
       default: {
         this._emitChars("]]");
         this.state = State.CDATA_SECTION;
-        this._stateCdataSection(cp);
+        this._stateCdataSection(cp2);
       }
     }
   }
@@ -25343,15 +25479,15 @@ var Tokenizer = class {
   }
   // Ambiguos ampersand state
   //------------------------------------------------------------------
-  _stateAmbiguousAmpersand(cp) {
-    if (isAsciiAlphaNumeric2(cp)) {
-      this._flushCodePointConsumedAsCharacterReference(cp);
+  _stateAmbiguousAmpersand(cp2) {
+    if (isAsciiAlphaNumeric2(cp2)) {
+      this._flushCodePointConsumedAsCharacterReference(cp2);
     } else {
-      if (cp === CODE_POINTS.SEMICOLON) {
+      if (cp2 === CODE_POINTS.SEMICOLON) {
         this._err(ERR.unknownNamedCharacterReference);
       }
       this.state = this.returnState;
-      this._callState(cp);
+      this._callState(cp2);
     }
   }
 };
@@ -30516,7 +30652,7 @@ function searchCrawlers() {
   return CRAWLER_REGISTRY.filter((entry) => entry.purpose === "search_index").map((entry) => entry.token);
 }
 function probeUserAgent(token) {
-  return `Mozilla/5.0 (compatible; ${token}; Heysurface readiness check)`;
+  return `Mozilla/5.0 (compatible; ${token}; Obi readiness check)`;
 }
 function firewallProbePlan(origin) {
   const base = new URL(origin).origin;
@@ -30622,6 +30758,7 @@ function auditFirewall(probes, origin) {
 }
 
 // ../geo-engine/src/geo/host-acquisition.ts
+var ROBOTS_TOKENS = ["Obi", "Heysurface"];
 var INVENTORY_SAFETY_LIMIT = 1e5;
 var priority = { robots: 0, sitemap: 1, page: 2, llms: 3 };
 var pagePriority = {
@@ -30697,9 +30834,9 @@ function discoverHostPageLinks(state, body, pageUrl, known = new Set(state.resou
   const alias = new URL(pageUrl);
   alias.hostname = alias.hostname.startsWith("www.") ? alias.hostname.slice(4) : `www.${alias.hostname}`;
   const links = [pageUrl, alias.href].flatMap((base) => extractSameOriginLinks(body, base, INVENTORY_SAFETY_LIMIT));
-  for (const link of links) {
-    if (/\.(?:xml|pdf|png|jpe?g|gif|svg|webp|ico|css|js|zip|mp4|woff2?)$/i.test(new URL(link).pathname)) continue;
-    const resource = appendResource(state, link, "page", known);
+  for (const link2 of links) {
+    if (/\.(?:xml|pdf|png|jpe?g|gif|svg|webp|ico|css|js|zip|mp4|woff2?)$/i.test(new URL(link2).pathname)) continue;
+    const resource = appendResource(state, link2, "page", known);
     if (resource) added.push(resource);
   }
   return added;
@@ -30794,6 +30931,7 @@ async function crawlHostBatch(raw, options = {}) {
   const pages = [];
   const fetcher = options.fetcher ?? observeSelectedHttp;
   const probePlan = options.probeBots ? firewallProbePlan(state.origin) : [];
+  const parsedRobots = /* @__PURE__ */ new Map();
   for (let attempt = 0; attempt < batchSize; attempt++) {
     if (pendingChanged) {
       pending.sort((a, b) => order.get(a.url) - order.get(b.url));
@@ -30829,7 +30967,12 @@ async function crawlHostBatch(raw, options = {}) {
     if (next.kind !== "robots" && state.robots) {
       const robots = state.robots;
       const unavailable2 = robots.errorKind || robots.truncated || robots.status === null || robots.status === 429 || robots.status >= 500;
-      const blocked = robots.status === 200 && robots.body !== null && !evaluateAccess(parseRobots(robots.body), "Heysurface", next.url).allowed;
+      let rules = null;
+      if (robots.status === 200 && robots.body !== null) {
+        rules = parsedRobots.get(robots.body) ?? parseRobots(robots.body);
+        parsedRobots.set(robots.body, rules);
+      }
+      const blocked = rules !== null && ROBOTS_TOKENS.some((token) => !evaluateAccess(rules, token, next.url).allowed);
       if (unavailable2 || blocked) {
         next.status = "blocked";
         next.error = unavailable2 ? "robots_unavailable" : "robots_disallow";
@@ -31147,7 +31290,7 @@ function auditLlms(obs, ctx) {
   }
   const valid = links.filter((l) => l.resolved !== null);
   const seen = /* @__PURE__ */ new Map();
-  for (const link of valid) seen.set(normalize(link.resolved), [...seen.get(normalize(link.resolved)) ?? [], link]);
+  for (const link2 of valid) seen.set(normalize(link2.resolved), [...seen.get(normalize(link2.resolved)) ?? [], link2]);
   const duplicates = [...seen.entries()].filter(([, list]) => list.length > 1).slice(0, MAX_LISTED);
   if (duplicates.length > 0) {
     fail("llms.duplicate-links", duplicates.map(([u]) => u).join("\n"), duplicates.flatMap(([, list]) => list.map((l) => l.line)), { links: duplicates.map(([u]) => u) }, "info");
@@ -32680,7 +32823,7 @@ async function captureResearch(input, checkpoint, output) {
 
 // src/research-video.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile7, rm } from "node:fs/promises";
+import { mkdir as mkdir2, readdir as readdir3, readFile as readFile7, rm as rm2 } from "node:fs/promises";
 import { join as join4, resolve as resolve3 } from "node:path";
 var maxToolOutputBytes = 256 * 1024;
 var runTool = (executable, args, timeoutMs) => new Promise((done, fail) => {
@@ -32708,7 +32851,7 @@ var runTool = (executable, args, timeoutMs) => new Promise((done, fail) => {
   });
 });
 var presenceTimeoutMs = 6e4;
-async function present(runner, executable, flag) {
+async function present2(runner, executable, flag) {
   try {
     return (await runner(executable, [flag], presenceTimeoutMs)).exitCode === 0;
   } catch {
@@ -32716,7 +32859,7 @@ async function present(runner, executable, flag) {
   }
 }
 async function videoTools(runner = runTool) {
-  const [ytDlp, ffmpeg] = await Promise.all([present(runner, "yt-dlp", "--version"), present(runner, "ffmpeg", "-version")]);
+  const [ytDlp, ffmpeg] = await Promise.all([present2(runner, "yt-dlp", "--version"), present2(runner, "ffmpeg", "-version")]);
   return { ytDlp, ffmpeg };
 }
 var missingTool = (frames) => videoError(
@@ -32776,7 +32919,7 @@ function publicVideoUrl(raw) {
 }
 async function readVideo(rawUrl, outputDir, frames, runner = runTool) {
   const url3 = publicVideoUrl(rawUrl);
-  if (frames > 0 && !await present(runner, "ffmpeg", "-version")) throw missingTool(frames);
+  if (frames > 0 && !await present2(runner, "ffmpeg", "-version")) throw missingTool(frames);
   const directory = resolve3(outputDir);
   await mkdir2(directory, { recursive: true });
   const base = ["--ignore-config", "--no-playlist", "--quiet", "--no-warnings"];
@@ -32803,7 +32946,7 @@ async function readVideo(rawUrl, outputDir, frames, runner = runTool) {
       ...target,
       url3.href
     ], 18e4).catch(() => null);
-    const file2 = (await readdir2(directory)).find((name) => name === `video.${chosen.language}.vtt`);
+    const file2 = (await readdir3(directory)).find((name) => name === `video.${chosen.language}.vtt`);
     if (subtitles?.exitCode !== 0 || !file2) {
       throw failed("The video has captions but their download failed.", "Retry in a minute; the platform may be rate-limiting.");
     }
@@ -32831,7 +32974,7 @@ async function readVideo(rawUrl, outputDir, frames, runner = runTool) {
     throw failed("The video's length is unknown, so frames cannot be spaced.", "Retry with --frames 0 to keep the captions only.");
   }
   if (frames > 0 && duration3) {
-    const removeMedia = async () => Promise.all((await readdir2(directory)).filter((file2) => file2.startsWith("media.")).map((file2) => rm(join4(directory, file2), { force: true })));
+    const removeMedia = async () => Promise.all((await readdir3(directory)).filter((file2) => file2.startsWith("media.")).map((file2) => rm2(join4(directory, file2), { force: true })));
     await removeMedia();
     try {
       const download = await runner("yt-dlp", [
@@ -32844,7 +32987,7 @@ async function readVideo(rawUrl, outputDir, frames, runner = runTool) {
       ], 6e5).catch(() => {
         throw failed("The video download did not finish.", "Retry with --frames 0 to keep the captions only.");
       });
-      const media = (await readdir2(directory)).find((file2) => file2.startsWith("media.") && !file2.endsWith(".part"));
+      const media = (await readdir3(directory)).find((file2) => file2.startsWith("media.") && !file2.endsWith(".part"));
       if (download.exitCode !== 0 || !media) {
         throw failed("The video could not be downloaded for frames.", "Retry with --frames 0 to keep the captions only.");
       }
@@ -32925,7 +33068,20 @@ async function removeEverywhere(context) {
     await new CredentialStore(backend, context.origin.origin).removeCredential();
   }
 }
+async function forgetLegacyFolder(context) {
+  const legacy = legacySibling(context.stateDirectory);
+  if (legacy === null) return;
+  const backend = new FileBackend(legacy);
+  for (const item of ["credentials", "pending"]) {
+    await backend.remove(item, context.origin.origin).catch(() => void 0);
+  }
+}
 async function logout(context) {
+  const data = await logoutHere(context);
+  await forgetLegacyFolder(context);
+  return data;
+}
+async function logoutHere(context) {
   const origin = context.origin.origin;
   let located;
   try {
@@ -32970,27 +33126,28 @@ async function showAlphaStrategies(context) {
 }
 
 // src/skill-install.ts
-import { lstat as lstat3, mkdir as mkdir3, realpath, symlink, unlink as unlink4 } from "node:fs/promises";
+import { lstat as lstat3, mkdir as mkdir3, readlink, realpath, symlink, unlink as unlink5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { join as join5, sep } from "node:path";
 var skillDirectories = [".agents/skills", ".claude/skills"];
-function installError(message, identity) {
+var alphaSkillName = "heysurface";
+function installError(message) {
   return new CliError({
     code: "SKILL_INSTALL_FAILED",
     message,
     exitCode: 4,
     retryable: false,
-    nextAction: `Check the personal Skill directories and run ${identity} skill install again. Existing files are never replaced.`,
+    nextAction: "Check the personal Skill directories and run obi skill install again. Existing files are never replaced.",
     mode: "local"
   });
 }
-async function existingPath(path, identity) {
+async function existingPath(path) {
   try {
     await lstat3(path);
     return true;
   } catch (error51) {
     if (error51.code === "ENOENT") return false;
-    throw installError(`Cannot inspect ${path}.`, identity);
+    throw installError(`Cannot inspect ${path}.`);
   }
 }
 async function linksIntoPackage(path, packageRoot) {
@@ -32999,50 +33156,51 @@ async function linksIntoPackage(path, packageRoot) {
     entry = await lstat3(path);
   } catch (error51) {
     if (error51.code === "ENOENT") return false;
-    throw installError(`Cannot inspect ${path}.`, "obi");
+    throw installError(`Cannot inspect ${path}.`);
   }
   if (!entry.isSymbolicLink()) return false;
-  let target;
   try {
-    target = await realpath(path);
+    const target = await realpath(path);
+    return target === packageRoot || target.startsWith(`${packageRoot}${sep}`);
   } catch {
-    return false;
+    try {
+      return await readlink(path) === join5(packageRoot, "skills", alphaSkillName);
+    } catch {
+      return false;
+    }
   }
-  return target === packageRoot || target.startsWith(`${packageRoot}${sep}`);
 }
-async function installSkill(sourceDirectory, identity) {
+async function installSkill(sourceDirectory) {
   const source = await realpath(sourceDirectory);
   const home = homedir2();
-  const destinations = skillDirectories.map((directory) => join5(home, directory, identity));
+  const destinations = skillDirectories.map((directory) => join5(home, directory, "obi"));
   for (const destination of destinations) {
-    if (!await existingPath(destination, identity)) continue;
+    if (!await existingPath(destination)) continue;
     try {
       if (await realpath(destination) === source) continue;
     } catch {
     }
-    throw installError(`A Skill entry already exists at ${destination}.`, identity);
+    throw installError(`A Skill entry already exists at ${destination}.`);
   }
   for (const destination of destinations) {
-    if (await existingPath(destination, identity)) continue;
+    if (await existingPath(destination)) continue;
     try {
       await mkdir3(join5(destination, ".."), { recursive: true });
       await symlink(source, destination, process.platform === "win32" ? "junction" : "dir");
     } catch {
-      throw installError(`Could not register the ${identity === "heysurface" ? "Heysurface" : "Obi"} Skill at ${destination}.`, identity);
+      throw installError(`Could not register the Obi Skill at ${destination}.`);
     }
   }
   const removed = [];
-  if (identity === "obi") {
-    const packageRoot = await realpath(join5(source, "..", ".."));
-    for (const alpha of skillDirectories.map((directory) => join5(home, directory, "heysurface"))) {
-      if (!await linksIntoPackage(alpha, packageRoot)) continue;
-      try {
-        await unlink4(alpha);
-      } catch {
-        throw installError(`Could not retire the alpha /heysurface Skill link at ${alpha}.`, identity);
-      }
-      removed.push(alpha);
+  const packageRoot = await realpath(join5(source, "..", ".."));
+  for (const alpha of skillDirectories.map((directory) => join5(home, directory, alphaSkillName))) {
+    if (!await linksIntoPackage(alpha, packageRoot)) continue;
+    try {
+      await unlink5(alpha);
+    } catch {
+      throw installError(`Could not retire the earlier Skill link at ${alpha}.`);
     }
+    removed.push(alpha);
   }
   return { paths: destinations, removed };
 }
@@ -33260,7 +33418,7 @@ async function executeCommand(args, runtime) {
     });
   }
   if (args.command === "skill") {
-    const path = fileURLToPath(new URL(`../skills/${runtime.identity}/SKILL.md`, import.meta.url));
+    const path = fileURLToPath(new URL("../skills/obi/SKILL.md", import.meta.url));
     try {
       await access(path);
     } catch {
@@ -33273,7 +33431,7 @@ async function executeCommand(args, runtime) {
         mode: "local"
       });
     }
-    return success2("skill", "local", args.skillAction === "install" ? { action: "install", ...await installSkill(fileURLToPath(new URL(`../skills/${runtime.identity}`, import.meta.url)), runtime.identity) } : { action: "path", path });
+    return success2("skill", "local", args.skillAction === "install" ? { action: "install", ...await installSkill(fileURLToPath(new URL("../skills/obi", import.meta.url))) } : { action: "path", path });
   }
   if (args.command === "login") {
     return success2("login", "product", await login(session, {
@@ -33496,7 +33654,7 @@ function failureResult(error51, command, mode) {
 function markOrigin(result, origin) {
   return origin?.development === true ? cliResultSchema.parse({ ...result, origin: origin.origin, development: true }) : result;
 }
-async function runCli(identity) {
+async function runCli() {
   const argv = process.argv.slice(2);
   const json2 = wantsJson(argv);
   const welcome = argv.length === 0 && process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -33511,7 +33669,7 @@ async function runCli(identity) {
     const resolved = resolveOrigin(process.env);
     if (resolved.development && !json2 && !warned) {
       warned = true;
-      process.stderr.write(`Warning: HEYSURFACE_ORIGIN points this CLI at the development server ${sanitizeHumanText(resolved.origin)}, not at Obi.
+      process.stderr.write(`Warning: OBI_ORIGIN points this CLI at the development server ${sanitizeHumanText(resolved.origin)}, not at Obi.
 `);
     }
     return resolved;
@@ -33523,8 +33681,7 @@ async function runCli(identity) {
     origin = activeOrigin();
     const result = await executeCommand(args, {
       origin,
-      stateDirectory: resolveStateDirectory(process.env),
-      identity
+      stateDirectory: await prepareStateDirectory(process.env)
     });
     const evaluationCaseId = args.evaluationCaseId;
     const scopeNext = (data) => ({
@@ -33539,7 +33696,7 @@ async function runCli(identity) {
     if (scoped.ok && welcome) {
       process.stdout.write(renderWelcome(process.env, process.stdout.columns, process.stdout.getColorDepth()));
     } else {
-      writeResult(markOrigin(scoped, origin), args.json, identity);
+      writeResult(markOrigin(scoped, origin), args.json);
     }
   } catch (error51) {
     if (origin === void 0) {
@@ -33555,7 +33712,7 @@ async function runCli(identity) {
       retryable: false,
       nextAction: "Run the command again or inspect the local CLI installation."
     });
-    writeResult(markOrigin(failureResult(knownError, knownError.command ?? command, mode), origin), json2, identity);
+    writeResult(markOrigin(failureResult(knownError, knownError.command ?? command, mode), origin), json2);
     process.exitCode = knownError.exitCode;
   } finally {
     closeIdleConnections();
@@ -33563,4 +33720,4 @@ async function runCli(identity) {
 }
 
 // src/obi.ts
-void runCli("obi");
+void runCli();