@poe-platform/safe-bash 0.1.815 → 0.1.816

package/dist/safe-bash-command-htmlq/index.js

@@ -402,16 +402,23 @@ var HtmlTokenizer = class {
   }
 };
 
-// packages/safe-bash-command-htmlq/src/streaming-tokenizer.ts
-var StreamingHtmlTokenizer = class {
-  constructor(source, budget) {
+// packages/safe-bash-command-htmlq/src/token-framer.ts
+var HtmlTokenFramer = class {
+  constructor(source, budget, createFrame, decode2) {
     this.budget = budget;
+    this.createFrame = createFrame;
+    this.decode = decode2;
     this.input = source[Symbol.asyncIterator]();
   }
   budget;
+  createFrame;
+  decode;
   buffer = "";
   ended = false;
   input;
+  get residentInputUnits() {
+    return this.buffer.length;
+  }
   async peek(length = 1) {
     while (!this.ended && this.buffer.length < length) {
       const next = await this.input.next();
@@ -426,20 +433,23 @@ var StreamingHtmlTokenizer = class {
   }
   async next(raw, foreign = false) {
     if (!await this.peek()) return void 0;
-    let frame = "";
+    const frame = this.createFrame();
+    let size = 0;
     const take = async (length = 1) => {
       const value = await this.peek(length);
-      this.budget.bound("tokenBytes", (frame.length + value.length) * 2);
-      frame += value;
+      this.budget.bound("tokenBytes", (size + value.length) * 2);
+      await frame.write(value);
+      size += value.length;
       this.buffer = this.buffer.slice(value.length);
     };
     const until = async (delimiter2) => {
-      while (await this.peek()) {
-        if (await this.peek(delimiter2.length) === delimiter2) {
-          await take(delimiter2.length);
+      while (await this.peek(delimiter2.length)) {
+        const at = this.buffer.indexOf(delimiter2);
+        if (at >= 0) {
+          await take(at + delimiter2.length);
           break;
         }
-        await take();
+        await take(Math.max(1, this.buffer.length - delimiter2.length + 1));
       }
     };
     if (raw) {
@@ -487,7 +497,7 @@ var StreamingHtmlTokenizer = class {
         }
         await take();
       }
-      if (frame) return new HtmlTokenizer(frame, this.budget).next(raw, foreign);
+      if (size) return this.decode(await frame.finish(), raw, foreign);
     }
     if (await this.peek() !== "<") {
       while (await this.peek() && this.buffer[0] !== "<") {
@@ -501,6 +511,13 @@ var StreamingHtmlTokenizer = class {
       await take(4);
       let state = "start";
       while (await this.peek()) {
+        if (state === "data") {
+          const end = this.buffer.indexOf("-");
+          if (end !== 0) {
+            await take(end < 0 ? this.buffer.length : end);
+            continue;
+          }
+        }
         const c = await this.peek();
         await take();
         if (state === "start" || state === "startDash") {
@@ -528,14 +545,32 @@ var StreamingHtmlTokenizer = class {
       if (!asciiLetter(first)) {
         if (closing || first === "!" || first === "?") await until(">");
       } else {
-        while (await this.peek() && !delimiter(await this.peek())) await take();
+        while (await this.peek() && !delimiter(await this.peek())) {
+          let end = 0;
+          while (end < this.buffer.length && !delimiter(this.buffer[end])) end++;
+          await take(end);
+        }
         let state = "before";
         let quote = "";
         while (await this.peek()) {
           const c = await this.peek();
           if (state === "quoted") {
-            await take();
-            if (c === quote) state = "before";
+            const end = this.buffer.indexOf(quote);
+            await take(end < 0 ? this.buffer.length : end + 1);
+            if (end >= 0) state = "before";
+            continue;
+          }
+          if (state === "name" || state === "unquoted") {
+            let end = 0;
+            while (end < this.buffer.length && !(0, entities_exports.htmlSpace)(this.buffer[end]) && this.buffer[end] !== ">" && (state === "unquoted" || this.buffer[end] !== "=" && this.buffer[end] !== "/")) end++;
+            if (end) {
+              await take(end);
+              continue;
+            }
+          } else if ((0, entities_exports.htmlSpace)(c) || state === "before" && c === "/") {
+            let end = 0;
+            while (end < this.buffer.length && ((0, entities_exports.htmlSpace)(this.buffer[end]) || state === "before" && this.buffer[end] === "/")) end++;
+            await take(end);
             continue;
           }
           if (c === ">") {
@@ -572,7 +607,7 @@ var StreamingHtmlTokenizer = class {
         }
       }
     }
-    return new HtmlTokenizer(frame, this.budget).next(void 0, foreign);
+    return this.decode(await frame.finish(), void 0, foreign);
   }
 };
 function delimiter(c) {
@@ -582,6 +617,20 @@ function asciiLetter(c) {
   return c >= "A" && c <= "Z" || c >= "a" && c <= "z";
 }
 
+// packages/safe-bash-command-htmlq/src/streaming-tokenizer.ts
+var StreamingHtmlTokenizer = class extends HtmlTokenFramer {
+  constructor(source, budget) {
+    super(source, budget, () => {
+      let value = "";
+      return { write(chunk) {
+        value += chunk;
+      }, finish() {
+        return value;
+      } };
+    }, (frame, raw, foreign) => new HtmlTokenizer(frame, budget).next(raw, foreign));
+  }
+};
+
 // packages/safe-bash-command-htmlq/src/tree-rules.ts
 var formatting = /* @__PURE__ */ new Set([
   "a",
@@ -2718,6 +2767,10 @@ var DocumentStore = class {
   }
   storage;
   cooperate;
+  mutations = 0;
+  get revision() {
+    return this.mutations;
+  }
   nodes = /* @__PURE__ */ new Map();
   get residentNodes() {
     return this.nodes.size;
@@ -2756,6 +2809,7 @@ var DocumentStore = class {
     view.setFloat64(8, namespaces.indexOf(node.namespace), true);
     for (const [index, field] of fields.entries()) view.setFloat64(16 + index * 8, node[field], true);
     this.nodes.delete(id);
+    this.mutations++;
     await this.storage.write(id, bytes);
     this.retain(node);
   }
@@ -2818,6 +2872,13 @@ var DocumentStore = class {
       id = next;
     }
   }
+  async patchAttribute(id, name, namespace) {
+    const bytes = new Uint8Array(8), view = new DataView(bytes.buffer);
+    view.setFloat64(0, name, true);
+    await this.storage.write(id + 8, bytes);
+    view.setFloat64(0, attributeNamespaces.indexOf(namespace), true);
+    await this.storage.write(id + 24, bytes);
+  }
   async replaceAttribute(id, value) {
     const bytes = new Uint8Array(8);
     new DataView(bytes.buffer).setFloat64(0, value, true);
@@ -2916,132 +2977,808 @@ var StoredSequence = class {
   }
 };
 
-// packages/safe-bash-command-htmlq/src/stored-parser.ts
-function allSpace2(value) {
-  for (const c of value)
-    if (!(0, entities_exports.htmlSpace)(c))
-      return false;
-  return true;
+// packages/safe-bash-command-htmlq/src/stored-tokenizer.ts
+import { IntegerTable as IntegerTable2 } from "@poe-platform/safe-fs/storage";
+
+// packages/safe-bash-command-htmlq/src/entity-data.ts
+var entity_data_exports = {};
+__reExport(entity_data_exports, entity_data_star);
+import * as entity_data_star from "../safe-bash-markdown-engine/entity-data.js";
+
+// packages/safe-bash-command-htmlq/src/stored-selectors.ts
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+function lower(value) {
+  let result = "";
+  for (const c of value) result += c >= "A" && c <= "Z" ? String.fromCharCode(c.charCodeAt(0) + 32) : c;
+  return result;
 }
-async function parseStoredHtml(source, tree, strings, storage, options) {
-  const budget = new HtmlBudget(options);
-  async function* normalized() {
-    let first = true, carriage = false;
-    for await (const original of decodedHtml(source, options)) {
-      let result2 = "";
-      for (const c of original) {
-        budget.charge("work", 1);
-        if (first) {
-          first = false;
-          if (c === "\uFEFF")
-            continue;
+var StoredQueries = class {
+  constructor(tree, text, storage, budget) {
+    this.tree = tree;
+    this.text = text;
+    this.storage = storage;
+    this.budget = budget;
+    this.pending = new StoredSequence(storage);
+    this.ranks = new IntegerTable(storage, 64);
+    this.rankParents = new IntegerTable(storage, 64);
+  }
+  tree;
+  text;
+  storage;
+  budget;
+  pending;
+  revision = -1;
+  ranks;
+  rankParents;
+  async literal(root, expected, insensitive = false, prefix = false) {
+    const length = (await this.text.info(root)).length;
+    this.budget.charge("work", length + expected.length);
+    if (prefix ? length < expected.length : length !== expected.length) return false;
+    let at = 0;
+    if (insensitive) expected = lower(expected);
+    for await (const original of this.text.chunks(root)) {
+      const chunk = insensitive ? lower(original) : original;
+      for (let i = 0; i < chunk.length && at < expected.length; i++, at++) if (chunk[i] !== expected[at]) return false;
+      if (at === expected.length) return true;
+    }
+    return at === expected.length;
+  }
+  async equal(left, right) {
+    if (left === right) return true;
+    if ((await this.text.info(left)).length !== (await this.text.info(right)).length) return false;
+    const a = this.text.chunks(left), b = this.text.chunks(right);
+    let x = "", y = "", ax = 0, by = 0;
+    try {
+      for (; ; ) {
+        if (ax === x.length) {
+          x = (await a.next()).value ?? "";
+          ax = 0;
         }
-        if (carriage && c === "\n") {
-          carriage = false;
-          continue;
+        if (by === y.length) {
+          y = (await b.next()).value ?? "";
+          by = 0;
         }
-        carriage = c === "\r";
-        result2 += carriage ? "\n" : c;
+        if (!x || !y) return x === y;
+        const length = Math.min(x.length - ax, y.length - by);
+        this.budget.charge("work", length);
+        if (x.slice(ax, ax + length) !== y.slice(by, by + length)) return false;
+        ax += length;
+        by += length;
       }
-      yield result2;
+    } finally {
+      await a.return(void 0);
+      await b.return(void 0);
     }
   }
-  const tokenizer = new StreamingHtmlTokenizer(normalized(), budget);
-  let result = 0, failure;
-  try {
-    result = await buildStoredTree(tree, strings, storage, tokenizer, budget);
-  } catch (error) {
-    failure = { error };
+  async attribute(node, name) {
+    this.budget.charge("work", name.length);
+    this.budget.charge("retainedBytes", name.length * 2);
+    const expected = node.namespace === "html" ? lower(name) : name;
+    for await (const a of this.tree.attributes(node.id)) {
+      this.budget.charge("work", 1);
+      if (a.namespace === "none" && await this.literal(a.name, expected)) return a.value;
+    }
+    return void 0;
   }
-  try {
-    await tokenizer.close();
-  } catch (error) {
-    if (failure)
-      throw new AggregateError([failure.error, error], "HTML parsing and input cleanup failed");
-    throw error;
+  async word(root, expected, insensitive = false) {
+    if (!expected) return false;
+    for (const c of expected) if (cssSpace(c)) return false;
+    if (insensitive) expected = lower(expected);
+    let at = 0, matching = true;
+    for await (const original of this.text.chunks(root)) {
+      const chunk = insensitive ? lower(original) : original;
+      this.budget.charge("work", chunk.length);
+      for (let i = 0; i < chunk.length; i++) {
+        const c = chunk[i];
+        if (cssSpace(c)) {
+          if (matching && at === expected.length) return true;
+          at = 0;
+          matching = true;
+        } else {
+          if (c !== expected[at]) matching = false;
+          at++;
+        }
+      }
+    }
+    return matching && at === expected.length;
   }
-  if (failure)
-    throw failure.error;
-  return result;
-}
-async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
-  const labels = /* @__PURE__ */ new Map();
-  const names = /* @__PURE__ */ new Map();
-  const value = async (id) => {
-    const cached = labels.get(id);
-    if (cached !== void 0) return cached;
-    let value2 = "";
-    for await (const chunk of strings.chunks(id)) value2 += chunk;
-    if (value2.length <= 64) {
-      if (labels.size === 256) labels.delete(labels.keys().next().value);
-      labels.set(id, value2);
+  async contains(root, expected, insensitive) {
+    if (!expected) return false;
+    if (insensitive) expected = lower(expected);
+    let tail = "";
+    for await (const original of this.text.chunks(root)) {
+      const chunk = tail + (insensitive ? lower(original) : original);
+      this.budget.charge("work", chunk.length);
+      if (chunk.includes(expected)) return true;
+      tail = expected.length === 1 ? "" : chunk.slice(-(expected.length - 1));
     }
-    return value2;
-  };
-  const nameRef = async (name) => {
-    const cached = names.get(name);
-    if (cached !== void 0) return cached;
-    const id = await strings.from(name);
-    if (name.length <= 64) {
-      if (names.size === 256) names.delete(names.keys().next().value);
-      names.set(name, id);
-      if (labels.size === 256) labels.delete(labels.keys().next().value);
-      labels.set(id, name);
+    return false;
+  }
+  /** Build sibling ordinals once per parent; type totals are shared stored
+   * counters. Mutation invalidates indexes, while both resident caches stay fixed. */
+  async rank(node, typed) {
+    if (!node.parent) return [0, 0];
+    if (this.revision !== this.tree.revision) {
+      this.ranks = new IntegerTable(this.storage, 64);
+      this.rankParents = new IntegerTable(this.storage, 64);
+      this.revision = this.tree.revision;
+    }
+    const flag = BigInt(Number(typed)), parentKey = BigInt(node.parent) * 2n + flag;
+    let total = await this.rankParents.get(parentKey);
+    if (total === void 0) {
+      let count2 = 0;
+      const families = new IntegerTable(this.storage, 64);
+      for await (const id of this.tree.children(node.parent)) {
+        this.budget.charge("work", 1);
+        const child = await this.tree.read(id);
+        if (child.kind !== "element") continue;
+        count2++;
+        let position2 = count2;
+        if (typed) {
+          let hash = 2166136261;
+          for await (const chunk of this.text.chunks(child.name)) {
+            this.budget.charge("work", chunk.length);
+            for (let i = 0; i < chunk.length; i++) hash = Math.imul(hash ^ chunk.charCodeAt(i), 16777619) >>> 0;
+          }
+          const key = BigInt(hash) * 4n + BigInt(child.namespace === "html" ? 0 : child.namespace === "svg" ? 1 : 2);
+          const first = Number(await families.get(key) ?? 0n);
+          let counter = first, ordinal = 1;
+          while (counter) {
+            const bytes3 = await this.storage.read(counter, 24), view3 = new DataView(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength);
+            if (await this.equal(child.name, view3.getFloat64(8, true))) {
+              ordinal = view3.getFloat64(16, true) + 1;
+              break;
+            }
+            counter = view3.getFloat64(0, true);
+          }
+          if (!counter) {
+            const bytes3 = new Uint8Array(24), view3 = new DataView(bytes3.buffer);
+            view3.setFloat64(0, first, true);
+            view3.setFloat64(8, child.name, true);
+            view3.setFloat64(16, 1, true);
+            counter = await this.storage.append(bytes3);
+            await families.set(key, BigInt(counter));
+          } else {
+            const bytes3 = new Uint8Array(8);
+            new DataView(bytes3.buffer).setFloat64(0, ordinal, true);
+            await this.storage.write(counter + 16, bytes3);
+          }
+          const bytes2 = new Uint8Array(16), view2 = new DataView(bytes2.buffer);
+          view2.setFloat64(0, ordinal, true);
+          view2.setFloat64(8, counter + 16, true);
+          position2 = await this.storage.append(bytes2);
+        }
+        this.budget.charge("retainedBytes", typed ? 48 : 16);
+        await this.ranks.set(BigInt(id) * 2n + flag, BigInt(position2));
+      }
+      total = BigInt(count2);
+      await this.rankParents.set(parentKey, total);
+    }
+    const position = await this.ranks.get(BigInt(node.id) * 2n + flag);
+    if (position === void 0) return [0, 0];
+    if (!typed) return [Number(position), Number(total)];
+    const bytes = await this.storage.read(Number(position), 16), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const count = await this.storage.read(view.getFloat64(8, true), 8);
+    return [view.getFloat64(0, true), new DataView(count.buffer, count.byteOffset, count.byteLength).getFloat64(0, true)];
+  }
+  async previous(id) {
+    let n = (await this.tree.read(id)).previous;
+    while (n) {
+      const node = await this.tree.read(n);
+      if (node.kind === "element") return n;
+      this.budget.charge("work", 1);
+      n = node.previous;
     }
-    return id;
-  };
-  const meta = async (id) => {
-    const node = await tree.read(id);
-    return { ...node, name: await value(node.name) };
-  };
-  const make = async (kind, name = "", data = "", namespace = "html") => {
-    budget.charge("nodes", 1);
-    budget.charge("retainedBytes", 128 + (name.length + data.length) * 2);
-    return tree.create(kind, { name: await nameRef(name), data: await strings.from(data), namespace });
-  };
-  const append = async (parent, node, before = 0) => {
-    const previous2 = (await tree.read(node)).parent;
-    budget.charge("work", (previous2 ? (await tree.read(previous2)).childCount : 0) + (before ? (await tree.read(parent)).childCount : 1));
-    await tree.attach(parent, node, before);
-  };
-  const document = await make("document"), html = await make("element", "html"), head = await make("element", "head"), body = await make("element", "body");
-  await append(document, html);
-  await append(html, head);
-  await append(html, body);
-  const stack = new StoredSequence(storage), active = new StoredSequence(storage);
-  await stack.push(html);
-  let form = 0;
-  let mode = "beforeHead";
-  const current = async () => await stack.get(stack.length - 1);
-  const target = async (node) => {
-    node ??= await current();
-    return (await tree.read(node)).templateContents || node;
-  };
-  const push = async (node) => {
-    budget.bound("depth", stack.length + 1);
-    await stack.push(node);
-  };
-  const find = async (name) => {
-    for (let i = stack.length - 1; i >= 0; i--) {
-      budget.charge("work", 1);
-      if ((await meta(await stack.get(i))).name.toLowerCase() === name)
-        return i;
+    return 0;
+  }
+  async test(node, test) {
+    const budget = this.budget;
+    budget.charge("work", 1);
+    if (test.kind === "type") {
+      budget.charge("retainedBytes", test.value.length * 2);
+      return test.namespace !== "none" && (test.value === "*" || await this.literal(node.name, node.namespace === "html" ? lower(test.value) : test.value));
     }
-    return -1;
-  };
-  const pop = async (name) => {
-    const i = await find(name);
-    if (i > 0)
-      await stack.truncate(i);
-  };
-  const inScope = async (names2, extra = []) => {
-    for (let i = stack.length - 1; i >= 0; i--) {
-      budget.charge("work", 1);
-      const node = await meta(await stack.get(i));
-      if (node.namespace === "html" && names2.includes(node.name))
-        return i;
-      if (node.namespace === "html" && (htmlScopeBarriers.has(node.name) || extra.includes(node.name)) || node.namespace === "mathml" && mathmlScopeBarriers.has(node.name) || node.namespace === "svg" && svgScopeBarriers.has(node.name))
-        return -1;
+    if (test.kind === "id") {
+      const value = await this.attribute(node, "id");
+      return value !== void 0 && this.literal(value, test.value);
+    }
+    if (test.kind === "class") return this.word(await this.attribute(node, "class") ?? 0, test.value);
+    if (test.kind === "attribute") {
+      const value = await this.attribute(node, test.value), expected = test.expected;
+      if (value === void 0) return false;
+      switch (test.operator) {
+        case "":
+          return true;
+        case "=":
+          return this.literal(value, expected, test.insensitive);
+        case "^=":
+          return !!expected && this.literal(value, expected, test.insensitive, true);
+        case "$=": {
+          const length = (await this.text.info(value)).length;
+          return !!expected && length >= expected.length && this.literal(await this.text.slice(value, length - expected.length), expected, test.insensitive);
+        }
+        case "*=":
+          return this.contains(value, expected, test.insensitive);
+        case "|=":
+          return await this.literal(value, expected, test.insensitive) || this.literal(value, expected + "-", test.insensitive, true);
+        case "~=":
+          return this.word(value, expected, test.insensitive);
+        default:
+          return false;
+      }
+    }
+    if (test.kind !== "pseudo") return false;
+    const p = test.value;
+    if (p === "not") return !await this.matches(node.id, test.negated);
+    if (p === "root" || p === "scope") return !!node.parent && (await this.tree.read(node.parent)).kind === "document";
+    if (p === "any-link" || p === "link") return node.namespace === "html" && (await this.literal(node.name, "a") || await this.literal(node.name, "area") || await this.literal(node.name, "link")) && await this.attribute(node, "href") !== void 0;
+    if (p === "empty") {
+      for await (const child of this.tree.children(node.id)) {
+        budget.charge("work", 1);
+        const n = await this.tree.read(child);
+        if (n.kind === "element" || n.kind === "text" && (await this.text.info(n.data)).length > 0) return false;
+      }
+      return true;
+    }
+    if (["visited", "active", "focus", "hover", "enabled", "disabled", "checked", "indeterminate"].includes(p)) return false;
+    if (!p.includes("of-type") && (p.startsWith("first-") || p.startsWith("last-") || p.startsWith("only-"))) {
+      if (!node.parent) return false;
+      const sibling = async (direction) => {
+        for (let id = node[direction]; id; ) {
+          budget.charge("work", 1);
+          const other = await this.tree.read(id);
+          if (other.kind === "element") return true;
+          id = other[direction];
+        }
+        return false;
+      };
+      if (p.startsWith("first-")) return !await sibling("previous");
+      if (p.startsWith("last-")) return !await sibling("next");
+      return !await sibling("previous") && !await sibling("next");
+    }
+    const [ordinal, count] = await this.rank(node, p.includes("of-type"));
+    let index = ordinal;
+    if (!index) return false;
+    if (p.startsWith("first-")) return index === 1;
+    if (p.startsWith("last-")) return index === count;
+    if (p.startsWith("only-")) return count === 1;
+    if (p.includes("last")) index = count - index + 1;
+    const delta = index - test.b;
+    return test.a === 0 ? delta === 0 : delta / test.a >= 0 && delta % test.a === 0;
+  }
+  async matches(id, program) {
+    const marker = this.pending.length;
+    const push = async (node, at, depth, axis) => {
+      await this.pending.push(node);
+      await this.pending.push(at);
+      await this.pending.push(depth);
+      await this.pending.push(axis);
+    };
+    try {
+      for (const parts of program) {
+        await push(id, parts.length - 1, 0, 0);
+        while (this.pending.length > marker) {
+          const axis = await this.pending.pop(), depth = await this.pending.pop(), at = await this.pending.pop();
+          const node = await this.tree.read(await this.pending.pop());
+          if (axis < 0) {
+            const next2 = axis === -2 ? await this.previous(node.id) : node.parent;
+            if (next2) await push(next2, at, depth, -axis);
+            continue;
+          }
+          if (axis > 0) await push(node.id, at, depth, -axis);
+          if (axis === 1) this.budget.charge("work", 1);
+          this.budget.bound("depth", depth);
+          this.budget.charge("work", 1);
+          if (node.kind !== "element") continue;
+          let matches = true;
+          for (const test of parts[at].tests) if (!await this.test(node, test)) {
+            matches = false;
+            break;
+          }
+          if (!matches) continue;
+          if (!at) return true;
+          const relation = parts[at].relation;
+          const next = relation === "+" || relation === "~" ? await this.previous(node.id) : node.parent;
+          if (next) await push(next, at - 1, depth + 1, relation === "~" ? 2 : relation === ">" || relation === "+" ? 0 : 1);
+        }
+      }
+      return false;
+    } finally {
+      await this.pending.truncate(marker);
+    }
+  }
+};
+function selectStoredHtml(root, selector, tree, text, storage, options) {
+  const budget = new HtmlBudget(options), program = new SelectorParser(selector, budget).list();
+  const query = new StoredQueries(tree, text, storage, budget);
+  return (async function* () {
+    let id = root, start = true, depth = 0;
+    while (id) {
+      budget.charge("work", 1);
+      budget.bound("depth", depth);
+      const node = await tree.read(id), entering = start;
+      if (start) {
+        if (node.first) {
+          id = node.first;
+          depth++;
+        } else start = false;
+      } else {
+        if (id === root) return;
+        if (node.next) {
+          id = node.next;
+          start = true;
+        } else {
+          id = node.parent;
+          depth = Math.max(0, depth - 1);
+        }
+      }
+      if (entering) {
+        budget.charge("work", 1);
+        if (node.kind === "element" && await query.matches(node.id, program)) yield node.id;
+      }
+    }
+  })();
+}
+
+// packages/safe-bash-command-htmlq/src/stored-tokenizer.ts
+var Cursor = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  buffer = "";
+  ended = false;
+  position = 0;
+  async peek(count = 1) {
+    while (!this.ended && this.buffer.length < count) {
+      const next = await this.source.next();
+      if (next.done) this.ended = true;
+      else this.buffer += next.value;
+    }
+    return this.buffer.slice(0, count);
+  }
+  async window() {
+    await this.peek();
+    return this.buffer;
+  }
+  advance(count) {
+    this.buffer = this.buffer.slice(count);
+    this.position += count;
+  }
+  async skip(test) {
+    for (; ; ) {
+      const window = await this.window();
+      let end = 0;
+      while (end < window.length && test(window[end])) end++;
+      this.advance(end);
+      if (end < window.length || !window) return;
+    }
+  }
+};
+var StoredNames = class {
+  constructor(storage, text, queries) {
+    this.storage = storage;
+    this.text = text;
+    this.queries = queries;
+    this.table = new IntegerTable2(storage, 64);
+  }
+  storage;
+  text;
+  queries;
+  table;
+  async add(name) {
+    let hash = 2166136261;
+    for await (const chunk of this.text.chunks(name)) {
+      this.queries.budget.charge("work", chunk.length);
+      for (let i = 0; i < chunk.length; i++) hash = Math.imul(hash ^ chunk.charCodeAt(i), 16777619) >>> 0;
+    }
+    const key = BigInt(hash), first = Number(await this.table.get(key) ?? 0n);
+    for (let id = first; id; ) {
+      const bytes2 = await this.storage.read(id, 16), view2 = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+      if (await this.queries.equal(name, view2.getFloat64(8, true))) return false;
+      id = view2.getFloat64(0, true);
+    }
+    const bytes = new Uint8Array(16), view = new DataView(bytes.buffer);
+    view.setFloat64(0, first, true);
+    view.setFloat64(8, name, true);
+    await this.table.set(key, BigInt(await this.storage.append(bytes)));
+    return true;
+  }
+};
+var StoredHtmlTokenizer = class extends HtmlTokenFramer {
+  constructor(source, budget, tree, text, storage) {
+    super(source, budget, () => text.builder(), (root, raw, foreign) => decode(root, raw, foreign, budget, tree, text, storage));
+  }
+};
+async function decode(root, raw, foreign, budget, tree, text, storage) {
+  const length = (await text.info(root)).length;
+  budget.charge("work", length * 2);
+  const cursor = new Cursor(text.chunks(root));
+  const queries = new StoredQueries(tree, text, storage, budget);
+  const finish = (token) => {
+    budget.bound("tokenBytes", length * 2);
+    budget.charge("work", length + 1);
+    return token;
+  };
+  const transformed = async (start2, end, replacement, lower2 = false, entities = false, attribute2 = false) => {
+    budget.charge("work", (end - start2) * 33);
+    async function* chunks() {
+      for await (const chunk of text.chunks(await text.slice(root, start2, end))) {
+        const clean = chunk.replaceAll("\0", replacement);
+        yield lower2 ? (0, entities_exports.asciiLower)(clean) : clean;
+      }
+    }
+    const builder = text.builder();
+    if (!entities) {
+      for await (const chunk of chunks()) await builder.write(chunk);
+    } else {
+      const input = new Cursor(chunks());
+      while (await input.peek()) {
+        const window = await input.window(), amp = window.indexOf("&");
+        if (amp !== 0) {
+          const count = amp < 0 ? window.length : amp;
+          await builder.write(window.slice(0, count));
+          input.advance(count);
+          continue;
+        }
+        const look = await input.peek(34);
+        if (look[1] === "#") {
+          const hex = (0, entities_exports.asciiLower)(look[2] ?? "") === "x", prefix2 = hex ? 3 : 2;
+          const digit2 = (c) => {
+            const n = c.charCodeAt(0);
+            return n >= 48 && n <= 57 ? n - 48 : hex && n >= 65 && n <= 70 ? n - 55 : hex && n >= 97 && n <= 102 ? n - 87 : -1;
+          };
+          if (digit2(look[prefix2] ?? "") >= 0) {
+            input.advance(prefix2);
+            let n = 0;
+            for (; ; ) {
+              const part = await input.window();
+              let at = 0;
+              while (at < part.length && digit2(part[at]) >= 0) {
+                n = Math.min(1114112, n * (hex ? 16 : 10) + digit2(part[at]));
+                at++;
+              }
+              input.advance(at);
+              if (!part || at < part.length) break;
+            }
+            if (await input.peek() === ";") input.advance(1);
+            await builder.write((0, entities_exports.decodeEntities)(`&#${n};`, false));
+            continue;
+          }
+        } else {
+          let found = "";
+          for (let end2 = 2; end2 <= Math.min(33, look.length); end2++) {
+            const key = look.slice(1, end2);
+            if (Object.hasOwn(entity_data_exports.namedEntities, key)) found = key;
+          }
+          const next = look[found.length + 1] ?? "", code2 = next.charCodeAt(0);
+          if (found && !(attribute2 && !found.endsWith(";") && (next === "=" || code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 90 || code2 >= 97 && code2 <= 122))) {
+            await builder.write(entity_data_exports.namedEntities[found]);
+            input.advance(found.length + 1);
+            continue;
+          }
+        }
+        await builder.write("&");
+        input.advance(1);
+      }
+    }
+    return builder.finish();
+  };
+  const prefix = await cursor.peek(10);
+  if (raw)
+    return finish({ kind: "text", data: await transformed(0, length, "\uFFFD", false, raw === "title" || raw === "textarea") });
+  if (!prefix.startsWith("<")) return finish({ kind: "text", data: await transformed(0, length, foreign ? "\uFFFD" : "", false, true) });
+  if (foreign && prefix.startsWith("<![CDATA[")) {
+    let suffix = "";
+    for await (const part of text.chunks(await text.slice(root, Math.max(0, length - 3)))) suffix += part;
+    return finish({ kind: "text", data: await transformed(9, suffix === "]]>" ? length - 3 : length, "\uFFFD") });
+  }
+  if (prefix.startsWith("<!--")) {
+    cursor.advance(4);
+    const builder = text.builder();
+    let state = "start";
+    while (await cursor.peek()) {
+      if (state === "data") {
+        const window = await cursor.window(), dash = window.indexOf("-");
+        if (dash !== 0) {
+          const count = dash < 0 ? window.length : dash;
+          budget.charge("work", count);
+          await builder.write(window.slice(0, count).replaceAll("\0", "\uFFFD"));
+          cursor.advance(count);
+          continue;
+        }
+      }
+      const c = await cursor.peek();
+      cursor.advance(1);
+      budget.charge("work", 1);
+      const clean = c === "\0" ? "\uFFFD" : c;
+      if (state === "start") {
+        if (c === "-") state = "startDash";
+        else if (c === ">") break;
+        else {
+          await builder.write(clean);
+          state = "data";
+        }
+      } else if (state === "startDash" || state === "dash") {
+        if (c === "-") state = "end";
+        else if (c === ">" && state === "startDash") break;
+        else {
+          await builder.write("-" + clean);
+          state = "data";
+        }
+      } else if (state === "data") state = "dash";
+      else if (state === "end") {
+        if (c === ">") break;
+        else if (c === "!") state = "bang";
+        else if (c === "-") await builder.write("-");
+        else {
+          await builder.write("--" + clean);
+          state = "data";
+        }
+      } else {
+        if (c === ">") break;
+        if (c === "-") {
+          await builder.write("--!");
+          state = "dash";
+        } else {
+          await builder.write("--!" + clean);
+          state = "data";
+        }
+      }
+    }
+    return finish({ kind: "comment", data: await builder.finish() });
+  }
+  if ((0, entities_exports.asciiLower)(prefix.slice(0, 9)) === "<!doctype") {
+    cursor.advance(9);
+    await cursor.skip((c) => c.trim() === "");
+    const start2 = cursor.position;
+    let nameEnd = length, trimmedEnd = start2;
+    while (await cursor.peek() && await cursor.peek() !== ">") {
+      const window = await cursor.window();
+      let at = 0;
+      while (at < window.length && window[at] !== ">") {
+        const c = window[at];
+        if ((0, entities_exports.htmlSpace)(c) && nameEnd === length) nameEnd = cursor.position + at;
+        if (c.trim() !== "") trimmedEnd = cursor.position + at + 1;
+        at++;
+      }
+      budget.charge("work", at);
+      cursor.advance(at);
+    }
+    return finish({ kind: "doctype", data: await transformed(start2, Math.min(nameEnd, trimmedEnd), "\0", true) });
+  }
+  cursor.advance(1);
+  const closing = await cursor.peek() === "/";
+  if (closing) cursor.advance(1);
+  const initial = await cursor.peek(), code = initial.charCodeAt(0);
+  if (closing && !initial) return finish({ kind: "text", data: await text.from("</") });
+  if (closing && initial === ">") return finish({ kind: "text", data: 0 });
+  if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122)) {
+    if (initial === "!" || initial === "?" || closing) {
+      await cursor.skip((c) => c !== ">");
+      return finish({ kind: "comment", data: await transformed(initial === "?" ? 1 : 2, cursor.position, "\uFFFD") });
+    }
+    return finish({ kind: "text", data: await text.from("<") });
+  }
+  const start = cursor.position;
+  await cursor.skip((c) => !(0, entities_exports.htmlSpace)(c) && c !== "/" && c !== ">");
+  const name = await transformed(start, cursor.position, "\uFFFD", true);
+  const attributes = await tree.create("fragment"), names = new StoredNames(storage, text, queries);
+  let selfClosing = false, terminated = false;
+  while (await cursor.peek()) {
+    await cursor.skip(entities_exports.htmlSpace);
+    const look = await cursor.peek(2);
+    if (look.startsWith(">")) {
+      terminated = true;
+      cursor.advance(1);
+      break;
+    }
+    if (look === "/>") {
+      selfClosing = true;
+      terminated = true;
+      cursor.advance(2);
+      break;
+    }
+    if (look.startsWith("/")) {
+      cursor.advance(1);
+      continue;
+    }
+    const start2 = cursor.position;
+    if (look.startsWith("=")) cursor.advance(1);
+    await cursor.skip((c) => !(0, entities_exports.htmlSpace)(c) && c !== "=" && c !== ">" && c !== "/");
+    const attr = await transformed(start2, cursor.position, "\uFFFD", true);
+    await cursor.skip(entities_exports.htmlSpace);
+    let value = 0;
+    if (await cursor.peek() === "=") {
+      cursor.advance(1);
+      await cursor.skip(entities_exports.htmlSpace);
+      const quote = await cursor.peek();
+      if (quote === '"' || quote === "'") {
+        cursor.advance(1);
+        const start3 = cursor.position;
+        await cursor.skip((c) => c !== quote);
+        value = await transformed(start3, cursor.position, "\uFFFD", false, true, true);
+        if (await cursor.peek()) cursor.advance(1);
+      } else {
+        const start3 = cursor.position;
+        await cursor.skip((c) => !(0, entities_exports.htmlSpace)(c) && c !== ">");
+        value = await transformed(start3, cursor.position, "\uFFFD", false, true, true);
+      }
+    }
+    if (attr && !closing && await names.add(attr)) {
+      budget.charge("attributes", 1);
+      await tree.attribute(attributes, attr, value, "none");
+    }
+    if (cursor.position === start2 && await cursor.peek()) cursor.advance(1);
+  }
+  if (!terminated) return void 0;
+  return finish({ kind: closing ? "end" : "start", name, attributes, selfClosing });
+}
+
+// packages/safe-bash-command-htmlq/src/stored-name.ts
+async function lowerStoredName(text, root, budget) {
+  const builder = text.builder();
+  let precedingCased = false, offset = 0;
+  for await (const chunk of text.chunks(root)) {
+    let result = "";
+    for (const c of chunk) {
+      offset += c.length;
+      budget.charge("work", c.length);
+      let lowered = c.toLowerCase();
+      if (c === "\u03A3" && precedingCased) {
+        let followingCased = false;
+        for await (const next of text.characters(await text.slice(root, offset))) {
+          budget.charge("work", next.length);
+          if (/\p{Case_Ignorable}/u.test(next)) continue;
+          followingCased = /\p{Cased}/u.test(next);
+          break;
+        }
+        if (!followingCased) lowered = "\u03C2";
+      }
+      result += lowered;
+      if (!/\p{Case_Ignorable}/u.test(c)) precedingCased = /\p{Cased}/u.test(c);
+    }
+    await builder.write(result);
+  }
+  return builder.finish();
+}
+
+// packages/safe-bash-command-htmlq/src/stored-parser.ts
+async function parseStoredHtml(source, tree, strings, storage, options) {
+  const budget = new HtmlBudget(options);
+  async function* normalized() {
+    let first = true, carriage = false;
+    for await (const original of decodedHtml(source, options)) {
+      let result2 = "";
+      for (const c of original) {
+        budget.charge("work", 1);
+        if (first) {
+          first = false;
+          if (c === "\uFEFF")
+            continue;
+        }
+        if (carriage && c === "\n") {
+          carriage = false;
+          continue;
+        }
+        carriage = c === "\r";
+        result2 += carriage ? "\n" : c;
+      }
+      yield result2;
+    }
+  }
+  const tokenizer = new StoredHtmlTokenizer(normalized(), budget, tree, strings, storage);
+  let result = 0, failure;
+  try {
+    result = await buildStoredTree(tree, strings, storage, tokenizer, budget);
+  } catch (error) {
+    failure = { error };
+  }
+  try {
+    await tokenizer.close();
+  } catch (error) {
+    if (failure)
+      throw new AggregateError([failure.error, error], "HTML parsing and input cleanup failed");
+    throw error;
+  }
+  if (failure)
+    throw failure.error;
+  return result;
+}
+async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
+  const queries = new StoredQueries(tree, strings, storage, budget);
+  const whitespacePrefix = async (root) => {
+    let offset = 0;
+    for await (const chunk of strings.chunks(root)) {
+      budget.charge("work", chunk.length);
+      for (const c of chunk) {
+        if (!(0, entities_exports.htmlSpace)(c)) return offset;
+        offset++;
+      }
+    }
+    return offset;
+  };
+  const allSpace2 = async (root) => await whitespacePrefix(root) === (await strings.info(root)).length;
+  const labels = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Map();
+  const value = async (id) => {
+    const cached = labels.get(id);
+    if (cached !== void 0) return cached;
+    if ((await strings.info(id)).length > 64) return "";
+    let value2 = "";
+    for await (const chunk of strings.chunks(id)) value2 += chunk;
+    if (value2.length <= 64) {
+      if (labels.size === 256) labels.delete(labels.keys().next().value);
+      labels.set(id, value2);
+    }
+    return value2;
+  };
+  const nameRef = async (name) => {
+    const cached = names.get(name);
+    if (cached !== void 0) return cached;
+    const id = await strings.from(name);
+    if (name.length <= 64) {
+      if (names.size === 256) names.delete(names.keys().next().value);
+      names.set(name, id);
+      if (labels.size === 256) labels.delete(labels.keys().next().value);
+      labels.set(id, name);
+    }
+    return id;
+  };
+  const meta = async (id) => {
+    const node = await tree.read(id);
+    return { ...node, name: await value(node.name) };
+  };
+  const make = async (kind, name = "", data = "", namespace = "html") => {
+    budget.charge("nodes", 1);
+    const nameId = typeof name === "string" ? await nameRef(name) : name;
+    const dataId = typeof data === "string" ? await strings.from(data) : data;
+    budget.charge("retainedBytes", 128 + ((await strings.info(nameId)).length + (await strings.info(dataId)).length) * 2);
+    return tree.create(kind, { name: nameId, data: dataId, namespace });
+  };
+  const append = async (parent, node, before = 0) => {
+    const previous2 = (await tree.read(node)).parent;
+    budget.charge("work", (previous2 ? (await tree.read(previous2)).childCount : 0) + (before ? (await tree.read(parent)).childCount : 1));
+    await tree.attach(parent, node, before);
+  };
+  const document = await make("document"), html = await make("element", "html"), head = await make("element", "head"), body = await make("element", "body");
+  await append(document, html);
+  await append(html, head);
+  await append(html, body);
+  const stack = new StoredSequence(storage), active = new StoredSequence(storage);
+  await stack.push(html);
+  let form = 0;
+  let mode = "beforeHead";
+  const current = async () => await stack.get(stack.length - 1);
+  const target = async (node) => {
+    node ??= await current();
+    return (await tree.read(node)).templateContents || node;
+  };
+  const push = async (node) => {
+    budget.bound("depth", stack.length + 1);
+    await stack.push(node);
+  };
+  const find = async (name) => {
+    for (let i = stack.length - 1; i >= 0; i--) {
+      budget.charge("work", 1);
+      if ((await meta(await stack.get(i))).name.toLowerCase() === name)
+        return i;
+    }
+    return -1;
+  };
+  const pop = async (name) => {
+    const i = await find(name);
+    if (i > 0)
+      await stack.truncate(i);
+  };
+  const inScope = async (names2, extra = []) => {
+    for (let i = stack.length - 1; i >= 0; i--) {
+      budget.charge("work", 1);
+      const node = await meta(await stack.get(i));
+      if (node.namespace === "html" && names2.includes(node.name))
+        return i;
+      if (node.namespace === "html" && (htmlScopeBarriers.has(node.name) || extra.includes(node.name)) || node.namespace === "mathml" && mathmlScopeBarriers.has(node.name) || node.namespace === "svg" && svgScopeBarriers.has(node.name))
+        return -1;
     }
     return -1;
   };
@@ -3061,21 +3798,16 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
     }
   };
   const setAttributes = async (node, attributes) => {
-    for (const a of attributes)
-      await tree.attribute(node, await strings.from(a.name), await strings.from(a.value), a.namespace);
+    const source = await tree.read(attributes);
+    await tree.patch(node, { firstAttribute: source.firstAttribute, lastAttribute: source.lastAttribute, attributeCount: source.attributeCount });
   };
   const mergeAttributes = async (node, attributes) => {
-    budget.charge("work", (await tree.read(node)).attributeCount + attributes.length);
-    for (const a of attributes) {
-      let exists = false;
-      for await (const old of tree.attributes(node))
-        if (await value(old.name) === a.name) {
-          exists = true;
-          break;
-        }
-      if (!exists) {
-        budget.charge("retainedBytes", 64 + (a.name.length + a.value.length) * 2);
-        await setAttributes(node, [a]);
+    const names2 = new StoredNames(storage, strings, queries);
+    for await (const old of tree.attributes(node)) await names2.add(old.name);
+    for await (const a of tree.attributes(attributes)) {
+      if (await names2.add(a.name)) {
+        budget.charge("retainedBytes", 64 + ((await strings.info(a.name)).length + (await strings.info(a.value)).length) * 2);
+        await tree.attribute(node, a.name, a.value, a.namespace);
       }
     }
   };
@@ -3201,11 +3933,11 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
     if (!data)
       return;
     await reconstruct();
-    const [parent, before] = allSpace2(data) ? [await target(), void 0] : await location();
+    const [parent, before] = await allSpace2(data) ? [await target(), void 0] : await location();
     const last = before ? (await tree.read(before)).previous : (await tree.read(parent)).last;
     if (last && (await tree.read(last)).kind === "text") {
-      budget.charge("retainedBytes", data.length * 2);
-      await tree.patch(last, { data: await strings.concat((await tree.read(last)).data, await strings.from(data)) });
+      budget.charge("retainedBytes", (await strings.info(data)).length * 2);
+      await tree.patch(last, { data: await strings.concat((await tree.read(last)).data, data) });
     } else
       await append(parent, await make("text", "", data), before);
   };
@@ -3239,37 +3971,30 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
     }
     if (token.kind === "text") {
       if (mode === "beforeHead") {
-        if (allSpace2(token.data))
+        if (await allSpace2(token.data))
           continue;
         mode = "body";
         await stack.push(body);
       }
-      if (mode === "head" && await current() === head && !allSpace2(token.data)) {
+      if (mode === "head" && await current() === head && !await allSpace2(token.data)) {
         mode = "body";
         await stack.truncate(1);
         await stack.push(body);
       }
       let data = token.data;
-      if ((await meta(await current())).name === "colgroup" && !allSpace2(data)) {
-        let prefix = 0;
-        while ((0, entities_exports.htmlSpace)(data[prefix] ?? "")) {
-          budget.charge("work", 1);
-          prefix++;
-        }
-        if (prefix)
-          await text(data.slice(0, prefix));
-        data = data.slice(prefix);
+      if ((await meta(await current())).name === "colgroup" && !await allSpace2(data)) {
+        const prefix = await whitespacePrefix(data);
+        if (prefix) await text(await strings.slice(data, 0, prefix));
+        data = await strings.slice(data, prefix);
         await stack.pop();
       }
-      if (((await meta(await current())).name === "pre" || (await meta(await current())).name === "textarea" || (await meta(await current())).name === "listing") && (await tree.read(await current())).childCount === 0 && data.startsWith("\n"))
-        data = data.slice(1);
-      if ((await meta(await current())).namespace === "html" && !rawElements.has((await meta(await current())).name))
-        data = data.includes("\0") ? data.replaceAll("\0", "") : data;
+      if (((await meta(await current())).name === "pre" || (await meta(await current())).name === "textarea" || (await meta(await current())).name === "listing") && (await tree.read(await current())).childCount === 0 && await strings.at(data, 0) === "\n")
+        data = await strings.slice(data, 1);
       await text(data);
       continue;
     }
     let t = token;
-    const name = t.name;
+    const name = await value(t.name);
     if ((await meta(await current())).namespace === "html" && (await meta(await current())).name === "colgroup" && name !== "col" && name !== "template" && name !== "colgroup")
       await stack.pop();
     if (t.kind === "start" && captionBreakingElements.has(name)) {
@@ -3381,7 +4106,7 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
       } else {
         for (let i = stack.length - 1; i > 0; i--) {
           budget.charge("work", 1);
-          if ((await meta(await stack.get(i))).name.toLowerCase() === name) {
+          if (await queries.equal(await lowerStoredName(strings, (await tree.read(await stack.get(i))).name, budget), t.name)) {
             await stack.truncate(i);
             break;
           }
@@ -3521,22 +4246,20 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
       if (formatting.has(name))
         await reconstruct();
     }
-    const node = await make("element", ns === "svg" ? svgNames[name] ?? name : name, "", ns);
+    const node = await make("element", ns === "svg" ? svgNames[name] ?? t.name : t.name, "", ns);
     const attributes = t.attributes;
-    budget.charge("retainedBytes", attributes.reduce((sum, a) => sum + 64 + (a.name.length + a.value.length) * 2, 0));
-    if (ns !== "html")
-      for (const a of attributes) {
-        if (ns === "svg")
-          a.name = svgAttributes[a.name] ?? a.name;
-        if (ns === "mathml" && a.name === "definitionurl")
-          a.name = "definitionURL";
-        const colon = a.name.indexOf(":");
-        const prefix = a.name.slice(0, colon);
-        if (colon > 0 && ["xml", "xmlns", "xlink"].includes(prefix))
-          a.namespace = prefix;
-        else if (a.name === "xmlns")
-          a.namespace = "xmlns";
+    for await (const a of tree.attributes(attributes)) {
+      budget.charge("retainedBytes", 64 + ((await strings.info(a.name)).length + (await strings.info(a.value)).length) * 2);
+      if (ns !== "html") {
+        const label = await value(a.name);
+        const adjusted = ns === "svg" ? svgAttributes[label] : label === "definitionurl" ? "definitionURL" : void 0;
+        let namespace = a.namespace;
+        for (const prefix of ["xml", "xmlns", "xlink"])
+          if (await queries.literal(a.name, prefix + ":", false, true)) namespace = prefix;
+        if (label === "xmlns") namespace = "xmlns";
+        await tree.patchAttribute(a.id, adjusted ? await nameRef(adjusted) : a.name, namespace);
       }
+    }
     await setAttributes(node, attributes);
     const [parent, before] = ns === "html" && !tableAllowedElements.has(name) ? await location() : [await target(), void 0];
     await append(parent, node, before);
@@ -3557,256 +4280,402 @@ async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
   return document;
 }
 
-// packages/safe-bash-command-htmlq/src/stored-selectors.ts
-function lower(value) {
-  let result = "";
-  for (const c of value) result += c >= "A" && c <= "Z" ? String.fromCharCode(c.charCodeAt(0) + 32) : c;
-  return result;
-}
-var StoredQueries = class {
-  constructor(tree, text, storage, budget) {
-    this.tree = tree;
+// packages/safe-bash-command-htmlq/src/stored-url.ts
+import { normalizeStoredHostname } from "../safe-bash-command-html-to-markdown/stored-destination.js";
+var ports = { ftp: "21", file: "", http: "80", https: "443", ws: "80", wss: "443" };
+var alpha = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+var digit = (c) => c >= "0" && c <= "9";
+var StoredUrls = class {
+  constructor(text, storage, budget) {
     this.text = text;
+    this.storage = storage;
     this.budget = budget;
-    this.pending = new StoredSequence(storage);
   }
-  tree;
-  text;
-  budget;
-  pending;
-  async literal(root, expected, insensitive = false, prefix = false) {
-    const length = (await this.text.info(root)).length;
-    this.budget.charge("work", length + expected.length);
-    if (prefix ? length < expected.length : length !== expected.length) return false;
-    let at = 0;
-    if (insensitive) expected = lower(expected);
-    for await (const original of this.text.chunks(root)) {
-      const chunk = insensitive ? lower(original) : original;
-      for (let i = 0; i < chunk.length && at < expected.length; i++, at++) if (chunk[i] !== expected[at]) return false;
-      if (at === expected.length) return true;
-    }
-    return at === expected.length;
-  }
-  async equal(left, right) {
-    if (left === right) return true;
-    if ((await this.text.info(left)).length !== (await this.text.info(right)).length) return false;
-    const a = this.text.chunks(left), b = this.text.chunks(right);
-    let x = "", y = "", ax = 0, by = 0;
+  text;
+  storage;
+  budget;
+  legacyOpaqueRelative = (() => {
     try {
-      for (; ; ) {
-        if (ax === x.length) {
-          x = (await a.next()).value ?? "";
-          ax = 0;
-        }
-        if (by === y.length) {
-          y = (await b.next()).value ?? "";
-          by = 0;
-        }
-        if (!x || !y) return x === y;
-        const length = Math.min(x.length - ax, y.length - by);
-        this.budget.charge("work", length);
-        if (x.slice(ax, ax + length) !== y.slice(by, by + length)) return false;
-        ax += length;
-        by += length;
+      new URL("a#f", "z:b");
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  emptyParentKeepsSlash = new URL("z:/..").pathname === "/";
+  async *characters(root, start = 0, end) {
+    let offset = start;
+    for await (const chunk of this.text.chunks(await this.text.slice(root, start, end))) {
+      this.budget.charge("work", chunk.length);
+      for (const c of chunk) {
+        yield [c, offset];
+        offset += c.length;
       }
-    } finally {
-      await a.return(void 0);
-      await b.return(void 0);
     }
   }
-  async attribute(node, name) {
-    this.budget.charge("work", name.length);
-    this.budget.charge("retainedBytes", name.length * 2);
-    const expected = node.namespace === "html" ? lower(name) : name;
-    for await (const a of this.tree.attributes(node.id)) {
-      this.budget.charge("work", 1);
-      if (a.namespace === "none" && await this.literal(a.name, expected)) return a.value;
+  async small(root, maximum = 16) {
+    if ((await this.text.info(root)).length > maximum) return void 0;
+    let value = "";
+    for await (const chunk of this.text.chunks(root)) value += chunk;
+    return value;
+  }
+  async equal(a, b) {
+    if ((await this.text.info(a)).length !== (await this.text.info(b)).length) return false;
+    const right = this.text.characters(b);
+    try {
+      for await (const [c] of this.characters(a)) if (c !== (await right.next()).value) return false;
+      return true;
+    } finally {
+      await right.return(void 0);
     }
-    return void 0;
   }
-  async word(root, expected, insensitive = false) {
-    if (!expected) return false;
-    for (const c of expected) if (cssSpace(c)) return false;
-    if (insensitive) expected = lower(expected);
-    let at = 0, matching = true;
-    for await (const original of this.text.chunks(root)) {
-      const chunk = insensitive ? lower(original) : original;
-      this.budget.charge("work", chunk.length);
-      for (let i = 0; i < chunk.length; i++) {
-        const c = chunk[i];
-        if (cssSpace(c)) {
-          if (matching && at === expected.length) return true;
-          at = 0;
-          matching = true;
-        } else {
-          if (c !== expected[at]) matching = false;
-          at++;
+  async clean(root) {
+    const builder = this.text.builder();
+    let start = -1, end = 0, offset = 0;
+    for await (const chunk of this.text.chunks(root)) {
+      let clean = "";
+      for (const c of chunk) {
+        this.budget.charge("work", c.length);
+        if (c === "	" || c === "\n" || c === "\r") continue;
+        if (c.codePointAt(0) > 32) {
+          if (start < 0) start = offset;
+          end = offset + c.length;
         }
+        clean += c;
+        offset += c.length;
       }
+      await builder.write(clean);
     }
-    return matching && at === expected.length;
+    const result = await builder.finish();
+    return start < 0 ? 0 : this.text.slice(result, start, end);
   }
-  async contains(root, expected, insensitive) {
-    if (!expected) return false;
-    if (insensitive) expected = lower(expected);
-    let tail = "";
-    for await (const original of this.text.chunks(root)) {
-      const chunk = tail + (insensitive ? lower(original) : original);
+  async encode(root, kind, special = false) {
+    const result = this.text.builder();
+    for await (const chunk of this.text.chunks(root)) {
       this.budget.charge("work", chunk.length);
-      if (chunk.includes(expected)) return true;
-      tail = expected.length === 1 ? "" : chunk.slice(-(expected.length - 1));
-    }
-    return false;
+      const probe = new URL(special ? "http://x/" : "z://x/");
+      let value;
+      if (kind === "query") {
+        probe.search = "?x" + chunk;
+        value = probe.search.slice(2);
+      } else if (kind === "fragment") {
+        probe.hash = "#x" + chunk;
+        value = probe.hash.slice(2);
+      } else if (kind === "user") {
+        probe.username = chunk;
+        value = probe.username;
+      } else if (kind === "password") {
+        probe.password = chunk;
+        value = probe.password;
+      } else if (kind === "path") {
+        probe.pathname = "/x" + chunk + "x";
+        value = probe.pathname.slice(2, -1);
+      } else if (kind === "host") value = new URL("z://x" + chunk + "x/").hostname.slice(1, -1);
+      else value = new URL("z:x" + chunk + "x").pathname.slice(1, -1);
+      await result.write(value);
+    }
+    return result.finish();
   }
-  async previous(id) {
-    let n = (await this.tree.read(id)).previous;
-    while (n) {
-      const node = await this.tree.read(n);
-      if (node.kind === "element") return n;
-      this.budget.charge("work", 1);
-      n = node.previous;
+  async pathNode(id) {
+    if (!id) return [0, 0];
+    const bytes = await this.storage.read(id, 16), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return [view.getFloat64(0, true), view.getFloat64(8, true)];
+  }
+  async push(url, segment) {
+    const bytes = new Uint8Array(16), view = new DataView(bytes.buffer);
+    view.setFloat64(0, url.path, true);
+    view.setFloat64(8, segment, true);
+    url.path = await this.storage.append(bytes);
+  }
+  async drive(root) {
+    const value = await this.small(root, 2);
+    return value !== void 0 && value.length === 2 && alpha(value[0]) && (value[1] === ":" || value[1] === "|");
+  }
+  async shorten(url) {
+    const [parent, segment] = await this.pathNode(url.path);
+    if (url.special === "file" && !parent && await this.drive(segment)) return;
+    url.path = parent;
+  }
+  async firstDrive(url) {
+    let id = url.path;
+    while (id) {
+      const [parent, segment] = await this.pathNode(id);
+      if (!parent) return await this.drive(segment) ? segment : 0;
+      id = parent;
     }
     return 0;
   }
-  async test(node, test) {
-    const budget = this.budget;
-    budget.charge("work", 1);
-    if (test.kind === "type") {
-      budget.charge("retainedBytes", test.value.length * 2);
-      return test.namespace !== "none" && (test.value === "*" || await this.literal(node.name, node.namespace === "html" ? lower(test.value) : test.value));
+  async beginsDrive(root, start, end) {
+    if (end - start < 2 || !await this.drive(await this.text.slice(root, start, start + 2))) return false;
+    const next = await this.text.at(root, start + 2);
+    return start + 2 === end || next === "/" || next === "\\";
+  }
+  async path(url, root, start, end) {
+    let first = start;
+    const segment = async (last, final) => {
+      let part = await this.text.slice(root, first, last);
+      const small = (await this.small(part, 6))?.toLowerCase();
+      if (small === ".." || small === ".%2e" || small === "%2e." || small === "%2e%2e") {
+        const hadPath = Boolean(url.path);
+        await this.shorten(url);
+        if (final && (url.special !== void 0 || hadPath || this.emptyParentKeepsSlash)) await this.push(url, 0);
+      } else if (small === "." || small === "%2e") {
+        if (final) await this.push(url, 0);
+      } else {
+        if (url.special === "file" && !url.path && await this.drive(part)) {
+          part = await this.text.from((await this.small(part, 2))[0] + ":");
+        }
+        await this.push(url, await this.encode(part, "path"));
+      }
+    };
+    for await (const [c, offset] of this.characters(root, start, end)) {
+      if (c === "/" || url.special !== void 0 && c === "\\") {
+        await segment(offset, false);
+        first = offset + 1;
+      }
     }
-    if (test.kind === "id") {
-      const value = await this.attribute(node, "id");
-      return value !== void 0 && this.literal(value, test.value);
+    await segment(end, true);
+  }
+  async authority(url, root) {
+    const length = (await this.text.info(root)).length;
+    let at = -1;
+    for await (const [c, offset] of this.characters(root)) if (c === "@") at = offset;
+    if (at >= 0) {
+      if (url.special === "file") return false;
+      let colon = at;
+      for await (const [c, offset] of this.characters(root, 0, at)) if (c === ":") {
+        colon = offset;
+        break;
+      }
+      url.user = await this.encode(await this.text.slice(root, 0, colon), "user");
+      if (colon < at) url.password = await this.encode(await this.text.slice(root, colon + 1, at), "password");
     }
-    if (test.kind === "class") return this.word(await this.attribute(node, "class") ?? 0, test.value);
-    if (test.kind === "attribute") {
-      const value = await this.attribute(node, test.value), expected = test.expected;
-      if (value === void 0) return false;
-      switch (test.operator) {
-        case "":
-          return true;
-        case "=":
-          return this.literal(value, expected, test.insensitive);
-        case "^=":
-          return !!expected && this.literal(value, expected, test.insensitive, true);
-        case "$=": {
-          const length = (await this.text.info(value)).length;
-          return !!expected && length >= expected.length && this.literal(await this.text.slice(value, length - expected.length), expected, test.insensitive);
-        }
-        case "*=":
-          return this.contains(value, expected, test.insensitive);
-        case "|=":
-          return await this.literal(value, expected, test.insensitive) || this.literal(value, expected + "-", test.insensitive, true);
-        case "~=":
-          return this.word(value, expected, test.insensitive);
-        default:
-          return false;
+    const start = at + 1;
+    let end = length, bracket = false;
+    for await (const [c, offset] of this.characters(root, start)) {
+      if (c === "[") bracket = true;
+      if (c === "]") bracket = false;
+      if (c === ":" && !bracket) {
+        end = offset;
+        break;
       }
     }
-    if (test.kind !== "pseudo") return false;
-    const p = test.value;
-    if (p === "not") return !await this.matches(node.id, test.negated);
-    if (p === "root" || p === "scope") return !!node.parent && (await this.tree.read(node.parent)).kind === "document";
-    if (p === "any-link" || p === "link") return node.namespace === "html" && (await this.literal(node.name, "a") || await this.literal(node.name, "area") || await this.literal(node.name, "link")) && await this.attribute(node, "href") !== void 0;
-    if (p === "empty") {
-      for await (const child of this.tree.children(node.id)) {
-        budget.charge("work", 1);
-        const n = await this.tree.read(child);
-        if (n.kind === "element" || n.kind === "text" && (await this.text.info(n.data)).length > 0) return false;
+    if (end < length) {
+      if (url.special === "file") return false;
+      let port = 0;
+      for await (const [c] of this.characters(root, end + 1)) {
+        if (!digit(c)) return false;
+        port = port * 10 + Number(c);
+        if (port > 65535) return false;
       }
+      if (end + 1 < length && String(port) !== ports[url.special ?? ""]) url.port = String(port);
+    }
+    const host = await this.text.slice(root, start, end);
+    if (!host) {
+      if (at >= 0 || end < length || url.special !== void 0 && url.special !== "file") return false;
+      url.host = 0;
       return true;
     }
-    if (["visited", "active", "focus", "hover", "enabled", "disabled", "checked", "indeterminate"].includes(p)) return false;
-    let index = 0, count = 0;
-    if (node.parent) for await (const child of this.tree.children(node.parent)) {
-      budget.charge("work", 1);
-      const n = await this.tree.read(child);
-      if (n.kind !== "element" || p.includes("of-type") && (n.namespace !== node.namespace || !await this.equal(n.name, node.name))) continue;
-      count++;
-      if (child === node.id) index = count;
+    if (url.special !== void 0 || await this.text.at(host, 0) === "[") {
+      url.host = await normalizeStoredHostname(this.text, host, { work: (n) => this.budget.charge("work", n), checkpoint: () => this.budget.check() });
+      if (url.host === void 0) return false;
+      if (url.special === "file" && await this.small(url.host) === "localhost") url.host = 0;
+    } else {
+      for await (const [c] of this.characters(host)) if (c === "\0" || " #/:<>?@[\\]^|".includes(c)) return false;
+      url.host = await this.encode(host, "host");
     }
-    if (!index) return false;
-    if (p.startsWith("first-")) return index === 1;
-    if (p.startsWith("last-")) return index === count;
-    if (p.startsWith("only-")) return count === 1;
-    if (p.includes("last")) index = count - index + 1;
-    const delta = index - test.b;
-    return test.a === 0 ? delta === 0 : delta / test.a >= 0 && delta % test.a === 0;
+    return true;
   }
-  async matches(id, program) {
-    const marker = this.pending.length;
-    const push = async (node, at, depth, axis) => {
-      await this.pending.push(node);
-      await this.pending.push(at);
-      await this.pending.push(depth);
-      await this.pending.push(axis);
-    };
-    try {
-      for (const parts of program) {
-        await push(id, parts.length - 1, 0, 0);
-        while (this.pending.length > marker) {
-          const axis = await this.pending.pop(), depth = await this.pending.pop(), at = await this.pending.pop();
-          const node = await this.tree.read(await this.pending.pop());
-          if (axis < 0) {
-            const next2 = axis === -2 ? await this.previous(node.id) : node.parent;
-            if (next2) await push(next2, at, depth, -axis);
-            continue;
-          }
-          if (axis > 0) await push(node.id, at, depth, -axis);
-          if (axis === 1) this.budget.charge("work", 1);
-          this.budget.bound("depth", depth);
-          this.budget.charge("work", 1);
-          if (node.kind !== "element") continue;
-          let matches = true;
-          for (const test of parts[at].tests) if (!await this.test(node, test)) {
-            matches = false;
-            break;
+  async parse(original, base) {
+    const root = await this.clean(original), length = (await this.text.info(root)).length;
+    let fragmentAt = length, queryAt = length;
+    for await (const [c, offset] of this.characters(root)) {
+      if (c === "#") {
+        fragmentAt = offset;
+        break;
+      }
+      if (c === "?" && queryAt === length) queryAt = offset;
+    }
+    const end = Math.min(queryAt, fragmentAt);
+    let schemeEnd = -1;
+    for await (const [c, offset] of this.characters(root, 0, end)) {
+      if (offset > 0 && c === ":") {
+        schemeEnd = offset;
+        break;
+      }
+      if (!(alpha(c) || offset > 0 && (digit(c) || c === "+" || c === "-" || c === "."))) break;
+    }
+    let scheme = 0, special;
+    if (schemeEnd >= 0) {
+      const builder = this.text.builder();
+      for await (const chunk of this.text.chunks(await this.text.slice(root, 0, schemeEnd))) await builder.write(chunk.toLowerCase());
+      scheme = await builder.finish();
+      const name = await this.small(scheme);
+      if (name !== void 0 && Object.hasOwn(ports, name)) special = name;
+    } else {
+      if (!base) return void 0;
+      scheme = base.scheme;
+      special = base.special;
+    }
+    let url = { scheme, special, host: void 0, user: 0, password: 0, port: "", path: 0, opaque: false, opaqueRoot: void 0, query: void 0, fragment: void 0 };
+    let start = schemeEnd < 0 ? 0 : schemeEnd + 1;
+    const slash = (c) => c === "/" || special !== void 0 && c === "\\";
+    const first = await this.text.at(root, start), second = await this.text.at(root, start + 1);
+    const sameSpecial = schemeEnd >= 0 && special !== void 0 && base && await this.equal(scheme, base.scheme);
+    let relative = schemeEnd < 0 || Boolean(sameSpecial && special !== "file" && !(first === "/" && second === "/"));
+    let authority = false, fileDriveAuthority = false, pathStarted = false;
+    if (special === "file") {
+      url.host = 0;
+      if (slash(first) && slash(second)) {
+        authority = true;
+        start += 2;
+      } else {
+        if (base?.special === "file") {
+          url.host = base.host;
+          url.path = base.path;
+          url.query = base.query;
+        }
+        if (slash(first)) {
+          start++;
+          pathStarted = true;
+          const drive = base?.special === "file" ? await this.firstDrive(base) : 0;
+          url.path = 0;
+          if (drive && !await this.beginsDrive(root, start, end)) await this.push(url, drive);
+        } else if (start < end) {
+          if (await this.beginsDrive(root, start, end)) url.path = 0;
+          else await this.shorten(url);
+        }
+      }
+      relative = false;
+    } else if (relative) {
+      if (!base) return void 0;
+      url = { ...base, fragment: void 0 };
+      if (base.opaque && await this.text.at(root, 0) !== "#") {
+        if (!this.legacyOpaqueRelative || fragmentAt === length || schemeEnd >= 0) return void 0;
+        if (start < end) {
+          url.opaque = false;
+          url.path = 0;
+          let part = 0;
+          for await (const [c, offset] of this.characters(base.path)) if (c === "/") {
+            const segment = await this.text.slice(base.path, part, offset);
+            if (url.opaqueRoot === void 0) url.opaqueRoot = segment;
+            else await this.push(url, segment);
+            part = offset + 1;
           }
-          if (!matches) continue;
-          if (!at) return true;
-          const relation = parts[at].relation;
-          const next = relation === "+" || relation === "~" ? await this.previous(node.id) : node.parent;
-          if (next) await push(next, at - 1, depth + 1, relation === "~" ? 2 : relation === ">" || relation === "+" ? 0 : 1);
+          const last = await this.text.slice(base.path, part);
+          if (url.opaqueRoot === void 0) url.opaqueRoot = last;
+          else await this.push(url, last);
+        }
+      }
+      if (!url.opaque) {
+        if (slash(first) && slash(second)) {
+          authority = true;
+          start += 2;
+          url = { ...url, host: void 0, user: 0, password: 0, port: "", path: 0, opaqueRoot: void 0, query: void 0 };
+        } else if (slash(first)) {
+          url.path = 0;
+          url.opaqueRoot = void 0;
+          url.query = void 0;
+          start++;
+          pathStarted = true;
+        } else if (start < end) {
+          await this.shorten(url);
+          url.query = void 0;
+        }
+      }
+    } else if (special !== void 0) {
+      authority = true;
+    } else if (first === "/" && second === "/") {
+      authority = true;
+      start += 2;
+    } else if (first === "/") {
+      start++;
+      pathStarted = true;
+    } else url.opaque = true;
+    if (authority) {
+      if (special !== void 0 && special !== "file") {
+        for await (const [c, offset] of this.characters(root, start, end)) {
+          if (!slash(c)) break;
+          start = offset + 1;
+        }
+      }
+      let stop = end;
+      for await (const [c, offset] of this.characters(root, start, end)) if (slash(c)) {
+        stop = offset;
+        break;
+      }
+      const host = await this.text.slice(root, start, stop);
+      if (special === "file" && await this.drive(host)) {
+        fileDriveAuthority = true;
+        url.host = 0;
+      } else {
+        if (!await this.authority(url, host)) return void 0;
+        start = stop;
+        if (start < end && slash(await this.text.at(root, start))) {
+          start++;
+          pathStarted = true;
         }
       }
-      return false;
-    } finally {
-      await this.pending.truncate(marker);
     }
+    if (url.opaque) {
+      if (!relative) {
+        const trailingSpace = end < length && await this.text.at(root, end - 1) === " ";
+        url.path = await this.encode(await this.text.slice(root, start, trailingSpace ? end - 1 : end), "opaque");
+        if (trailingSpace) url.path = await this.text.concat(url.path, await this.text.from(new URL("z:x " + (queryAt < fragmentAt ? "?q" : "#f")).pathname.slice(1)));
+      }
+    } else if (start < end || pathStarted || authority || !url.path && special !== void 0) {
+      if (!(authority && special === void 0 && start === end && !pathStarted))
+        await this.path(url, root, start, end);
+      if (fileDriveAuthority) url.host = 0;
+      url.query = void 0;
+    }
+    if (queryAt < fragmentAt) url.query = await this.encode(await this.text.slice(root, queryAt + 1, fragmentAt), "query", special !== void 0);
+    if (fragmentAt < length) url.fragment = await this.encode(await this.text.slice(root, fragmentAt + 1), "fragment");
+    return url;
   }
-};
-function selectStoredHtml(root, selector, tree, text, storage, options) {
-  const budget = new HtmlBudget(options), program = new SelectorParser(selector, budget).list();
-  const query = new StoredQueries(tree, text, storage, budget);
-  return (async function* () {
-    let id = root, start = true, depth = 0;
-    while (id) {
-      budget.charge("work", 1);
-      budget.bound("depth", depth);
-      const node = await tree.read(id), entering = start;
-      if (start) {
-        if (node.first) {
-          id = node.first;
-          depth++;
-        } else start = false;
-      } else {
-        if (id === root) return;
-        if (node.next) {
-          id = node.next;
-          start = true;
-        } else {
-          id = node.parent;
-          depth = Math.max(0, depth - 1);
+  async serialize(url) {
+    const result = this.text.builder();
+    await result.append(url.scheme);
+    await result.write(":");
+    if (url.host !== void 0) {
+      await result.write("//");
+      if (url.user || url.password) {
+        await result.append(url.user);
+        if (url.password) {
+          await result.write(":");
+          await result.append(url.password);
         }
+        await result.write("@");
       }
-      if (entering) {
-        budget.charge("work", 1);
-        if (node.kind === "element" && await query.matches(node.id, program)) yield node.id;
+      await result.append(url.host);
+      if (url.port) await result.write(":" + url.port);
+    }
+    if (url.opaque) await result.append(url.path);
+    else {
+      const segments = new StoredSequence(this.storage);
+      for (let id = url.path; id; ) {
+        const [parent, segment] = await this.pathNode(id);
+        await segments.push(segment);
+        id = parent;
+      }
+      if (url.opaqueRoot !== void 0) await result.append(url.opaqueRoot);
+      if (url.opaqueRoot === void 0 && url.host === void 0 && segments.length > 1 && await segments.get(segments.length - 1) === 0) await result.write("/.");
+      while (segments.length) {
+        await result.write("/");
+        await result.append(await segments.pop());
       }
     }
-  })();
-}
+    if (url.query !== void 0) {
+      await result.write("?");
+      await result.append(url.query);
+    }
+    if (url.fragment !== void 0) {
+      await result.write("#");
+      await result.append(url.fragment);
+    }
+    return result.finish();
+  }
+};
 
 // packages/safe-bash-command-htmlq/src/stored-serializer.ts
 async function knownName(text, name) {
@@ -3919,13 +4788,6 @@ async function* serializeStoredHtml(root, tree, text, options, mode = "normalize
 }
 
 // packages/safe-bash-command-htmlq/src/stored-project.ts
-function baseUrl2(value) {
-  try {
-    return new URL(value);
-  } catch {
-    return void 0;
-  }
-}
 async function* projectStoredHtmlq(source, args, options, storage) {
   const budget = new HtmlBudget(options);
   let operations = 0, characters = 0;
@@ -3943,18 +4805,15 @@ async function* projectStoredHtmlq(source, args, options, storage) {
   });
   const document = await parseStoredHtml(source, tree, text, storage, options);
   const query = new StoredQueries(tree, text, storage, budget);
-  const string = async (id) => {
-    let result = "";
-    for await (const chunk of text.chunks(id)) result += chunk;
-    return result;
-  };
-  let base = baseUrl2(args.base);
+  const urls = new StoredUrls(text, storage, budget);
+  let base = await urls.parse(await text.from(args.base));
   if (args.detectBase) {
     for await (const first of selectStoredHtml(document, "base", tree, text, storage, options)) {
-      base = baseUrl2(await string(await query.attribute(await tree.read(first), "href") ?? 0)) ?? base;
+      base = await urls.parse(await query.attribute(await tree.read(first), "href") ?? 0) ?? base;
       break;
     }
   }
+  const baseHref = base ? await urls.serialize(base) : 0;
   const selected = selectStoredHtml(document, args.selector, tree, text, storage, options);
   let removal = "";
   if (args.removeNodes.length) {
@@ -4058,23 +4917,25 @@ async function* projectStoredHtmlq(source, args, options, storage) {
     if (base && node.namespace === "html" && ["a", "area", "link"].includes(await knownName(text, node.name))) {
       for await (const a of tree.attributes(id)) {
         if (a.namespace !== "none" || !await query.literal(a.name, "href")) continue;
-        const href = await string(a.value);
-        budget.charge("work", href.length + base.href.length);
+        const hrefLength = (await text.info(a.value)).length;
+        budget.charge("work", hrefLength + (await text.info(baseHref)).length);
         let value;
-        if (href.startsWith("////")) {
-          let i = 0;
-          while (href[i] === "/") i++;
-          value = href.slice(i);
-        } else {
-          try {
-            value = new URL(href, base).href;
-          } catch {
-            value = base.href;
+        if (await query.literal(a.value, "////", false, true)) {
+          let offset = 0;
+          for await (const c of text.characters(a.value)) {
+            budget.charge("work", 1);
+            if (c !== "/") break;
+            offset++;
           }
+          value = await text.slice(a.value, offset);
+        } else {
+          const resolved = await urls.parse(a.value, base);
+          value = resolved ? await urls.serialize(resolved) : baseHref;
         }
-        budget.charge("work", node.attributeCount + value.length);
-        budget.charge("retainedBytes", node.attributeCount * 64 + value.length * 2);
-        await tree.replaceAttribute(a.id, await text.from(value));
+        const valueLength = (await text.info(value)).length;
+        budget.charge("work", node.attributeCount + valueLength);
+        budget.charge("retainedBytes", node.attributeCount * 64 + valueLength * 2);
+        await tree.replaceAttribute(a.id, value);
         break;
       }
     }