rusteerio 1.0.1 → 1.1.1

package/dist/{chunk-DMRD3FGC.mjs → chunk-FPRP6UIX.mjs}

@@ -52,17 +52,30 @@ function decodeString(value) {
   }
   return start === 0 ? value : parts.join("") + value.slice(start);
 }
-var stringToken = /"(?:[^"\\]|\\[\s\S])*"/g;
 var encodeJsonCandidate = /[\ud800-\ue800]|\\u(?:d[89a-f][\da-f]{2}|e[0-8][\da-f]{2})/i;
 var escapedJsonCandidate = /\\u(?:d[89a-f][\da-f]{2}|e[0-8][\da-f]{2})/i;
 var decodeJsonCandidate = /[\ue000-\ue800]|\\ue[0-8][\da-f]{2}/i;
 function encodeJson(value) {
   if (!encodeJsonCandidate.test(value)) return value;
   if (isWellFormed?.call(value) && !encoded.test(value) && !escapedJsonCandidate.test(value)) return value;
-  return value.replace(stringToken, (token) => JSON.stringify(encodeString(JSON.parse(token))));
+  return mapJsonStrings(value, encodeString);
 }
 function decodeJson(value) {
-  return decodeJsonCandidate.test(value) ? value.replace(stringToken, (token) => JSON.stringify(decodeString(JSON.parse(token)))) : value;
+  return decodeJsonCandidate.test(value) ? mapJsonStrings(value, decodeString) : value;
+}
+function mapJsonStrings(json, transform) {
+  const parts = [];
+  let copied = 0;
+  let quote = json.indexOf('"');
+  while (quote !== -1) {
+    let end = quote + 1;
+    while (end < json.length && json.charCodeAt(end) !== 34) end += json.charCodeAt(end) === 92 ? 2 : 1;
+    if (end >= json.length) break;
+    parts.push(json.slice(copied, quote), JSON.stringify(transform(JSON.parse(json.slice(quote, end + 1)))));
+    copied = end + 1;
+    quote = json.indexOf('"', copied);
+  }
+  return copied === 0 ? json : parts.join("") + json.slice(copied);
 }
 function encodeOptions(value) {
   if (value === void 0) return '{"__utf16Codec":true}';
@@ -74,12 +87,39 @@ function encodeOptions(value) {
 }
 
 // src/transport.ts
-var registryKey = /* @__PURE__ */ Symbol.for("rusteerio.native-transport.v1");
+var registryKey = /* @__PURE__ */ Symbol.for("rusteerio.native-transport.v2");
 var globals = globalThis;
-var registry = globals[registryKey] ??= { documents: /* @__PURE__ */ new WeakMap(), originals: /* @__PURE__ */ new WeakMap(), userErrors: /* @__PURE__ */ new WeakSet() };
+var registry = globals[registryKey] ??= { userErrors: /* @__PURE__ */ new WeakSet() };
+var transportedKey = /* @__PURE__ */ Symbol.for("rusteerio.native-transport.prototype");
+var jsonMethods = /* @__PURE__ */ new Set(["op", "node", "exportTree", "parserDiagnostics", "adopt"]);
+var argumentEncoders = {
+  op: (args) => {
+    args[1] = encodeJson(args[1]);
+  },
+  create: (args) => {
+    args[0] = encodeString(args[0]);
+    if (typeof args[2] === "string") args[2] = encodeOptions(args[2]);
+  },
+  select: (args) => {
+    args[0] = encodeString(args[0]);
+  },
+  matches: (args) => {
+    args[0] = encodeString(args[0]);
+  },
+  attr: (args) => {
+    args[1] = encodeString(args[1]);
+  },
+  setAttribute: (args) => {
+    args[1] = encodeString(args[1]);
+    if (typeof args[2] === "string") args[2] = encodeString(args[2]);
+  },
+  render: (args) => {
+    if (typeof args[1] === "string") args[1] = encodeJson(args[1]);
+  }
+};
 function wrapNativeBinding(binding) {
   const raw = binding;
-  const { documents, originals, userErrors } = registry;
+  const { userErrors } = registry;
   const restoreError = (error) => {
     if (error instanceof Error && !userErrors.has(error)) {
       const message = decodeString(error.message);
@@ -107,41 +147,33 @@ function wrapNativeBinding(binding) {
       throw error;
     }
   };
-  const jsonMethods = /* @__PURE__ */ new Set(["op", "node", "exportTree", "parserDiagnostics", "adopt"]);
-  const wrapDocument = (document) => {
-    const cached2 = documents.get(document);
-    if (cached2) return cached2;
-    const methods = /* @__PURE__ */ new Map();
-    const wrapped2 = new Proxy(document, {
-      get(target, property2) {
-        const value = Reflect.get(target, property2, target);
-        if (typeof value !== "function") return value;
-        if (property2 === "constructor") return value;
-        if (methods.has(property2)) return methods.get(property2);
-        const method = (...input) => invoke(() => {
-          const args = input.slice();
-          if (property2 === "op") args[1] = encodeJson(args[1]);
-          else if (property2 === "create") {
-            args[0] = encodeString(args[0]);
-            if (typeof args[2] === "string") args[2] = encodeOptions(args[2]);
-          } else if (property2 === "select" || property2 === "matches") args[0] = encodeString(args[0]);
-          else if (property2 === "attr") args[1] = encodeString(args[1]);
-          else if (property2 === "adopt") args[0] = originals.get(args[0]) ?? args[0];
-          const result = Reflect.apply(value, target, args);
-          if (property2 === "op" && args[0] === "serialize" && typeof result === "string" && result.startsWith("{")) {
-            const error = JSON.parse(result).__nativeError;
-            if (error?.name === "URIError") throw new URIError(error.message);
-          }
-          return typeof result === "string" ? jsonMethods.has(String(property2)) ? decodeJson(result) : decodeString(result) : result;
-        });
-        methods.set(property2, method);
-        return method;
+  const transportMethod = (name, method) => {
+    const encodeArguments = argumentEncoders[name];
+    const decode = jsonMethods.has(name) ? decodeJson : decodeString;
+    const isOperation = name === "op";
+    return function transported(...args) {
+      try {
+        if (encodeArguments) encodeArguments(args);
+        const result = method.apply(this, args);
+        if (typeof result !== "string") return result;
+        if (isOperation && args[0] === "serialize" && result.startsWith("{")) {
+          const error = JSON.parse(result).__nativeError;
+          if (error?.name === "URIError") throw new URIError(error.message);
+        }
+        return decode(result);
+      } catch (error) {
+        return restoreError(error);
       }
-    });
-    documents.set(document, wrapped2);
-    originals.set(wrapped2, document);
-    return wrapped2;
+    };
   };
+  const prototype = raw.NativeDocument.prototype;
+  if (!Object.hasOwn(prototype, transportedKey)) {
+    for (const name of Object.getOwnPropertyNames(prototype)) {
+      const method = prototype[name];
+      if (name !== "constructor" && typeof method === "function") prototype[name] = transportMethod(name, method);
+    }
+    Object.defineProperty(prototype, transportedKey, { value: true });
+  }
   const wrapStream = (stream) => {
     let carry = "";
     return {
@@ -161,7 +193,7 @@ function wrapNativeBinding(binding) {
           carry = "";
           await invoke(() => stream.write(encodeString(final)));
         }
-        return wrapDocument(await invoke(() => stream.finish()));
+        return invoke(() => stream.finish());
       },
       abort() {
         carry = "";
@@ -175,12 +207,19 @@ function wrapNativeBinding(binding) {
     }
   });
   const wrapped = { ...raw };
-  wrapped.NativeDocument = wrapConstructor(raw.NativeDocument, ([html, isDocument2, options]) => [encodeString(html), isDocument2, encodeOptions(options)], wrapDocument);
+  const Document2 = raw.NativeDocument;
+  wrapped.NativeDocument = function NativeDocument(html, isDocument2, options) {
+    try {
+      return new Document2(encodeString(html), isDocument2, encodeOptions(options));
+    } catch (error) {
+      return restoreError(error);
+    }
+  };
   if (raw.NativeStream) wrapped.NativeStream = wrapConstructor(raw.NativeStream, ([options, isDocument2, bridge]) => [encodeOptions(options), isDocument2, bridge && wrapBridge(bridge)], wrapStream);
   if (raw.NativeHookStream) wrapped.NativeHookStream = wrapConstructor(raw.NativeHookStream, ([isDocument2, options, bridge]) => [isDocument2, encodeOptions(options), wrapBridge(bridge)], wrapStream);
-  if (raw.parseWithTreeAdapter) wrapped.parseWithTreeAdapter = (source, isDocument2, options, bridge) => wrapDocument(invoke(() => raw.parseWithTreeAdapter(encodeString(source), isDocument2, encodeOptions(options), wrapBridge(bridge))));
-  if (raw.parseAsync) wrapped.parseAsync = async (source, isDocument2, options) => wrapDocument(await invoke(() => raw.parseAsync(encodeString(source), isDocument2, encodeOptions(options))));
-  if (raw.parseManyAsync) wrapped.parseManyAsync = async (sources, isDocument2, threads, options) => (await invoke(() => raw.parseManyAsync(sources.map(encodeString), isDocument2, threads, encodeOptions(options)))).map(wrapDocument);
+  if (raw.parseWithTreeAdapter) wrapped.parseWithTreeAdapter = (source, isDocument2, options, bridge) => invoke(() => raw.parseWithTreeAdapter(encodeString(source), isDocument2, encodeOptions(options), wrapBridge(bridge)));
+  if (raw.parseAsync) wrapped.parseAsync = (source, isDocument2, options) => invoke(() => raw.parseAsync(encodeString(source), isDocument2, encodeOptions(options)));
+  if (raw.parseManyAsync) wrapped.parseManyAsync = (sources, isDocument2, threads, options) => invoke(() => raw.parseManyAsync(sources.map(encodeString), isDocument2, threads, encodeOptions(options)));
   if (raw.extractPlanManyAsync) wrapped.extractPlanManyAsync = async (sources, plan, threads, options) => decodeJson(await invoke(() => raw.extractPlanManyAsync(sources.map(encodeString), encodeJson(plan), threads, encodeOptions(options))));
   if (raw.extractManyAsync) wrapped.extractManyAsync = async (sources, queries, threads, isDocument2, options) => decodeJson(await invoke(() => raw.extractManyAsync(sources.map(encodeString), queries.map((query) => ({ ...query, key: encodeString(query.key), selector: encodeString(query.selector), ...query.attr === void 0 ? {} : { attr: encodeString(query.attr) } })), threads, isDocument2, encodeOptions(options))));
   return wrapped;
@@ -190,10 +229,13 @@ function wrapNativeBinding(binding) {
 var cached;
 var attempted = false;
 var bindingError;
+function packageDirectory() {
+  return typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
+}
 function nativeBinding() {
   if (attempted) return cached;
   attempted = true;
-  const moduleDirectory = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
+  const moduleDirectory = packageDirectory();
   const require2 = createRequire(join(moduleDirectory, "rusteerio-loader.cjs"));
   const directories = [moduleDirectory, dirname(moduleDirectory)];
   const libc = process.platform === "linux" ? process.report?.getReport()?.header?.glibcVersionRuntime ? "gnu" : "musl" : void 0;
@@ -346,8 +388,8 @@ function treeAdapterBridge(adapter, options) {
       const doctype = invoke("isDocumentTypeNode", [node]);
       const name = element ? invoke("getTagName", [node]) : doctype ? "!doctype" : node.name;
       const type = element ? name === "script" || name === "style" ? name : "tag" : text ? "text" : comment ? "comment" : doctype ? "directive" : node.type ?? "root";
-      const children2 = element || type === "root" || type === "cdata" ? invoke("getChildNodes", [node]) ?? [] : [];
-      const record = { id, type, children: Array.from(children2, identify), parent: identify(invoke("getParentNode", [node])) };
+      const children = element || type === "root" || type === "cdata" ? invoke("getChildNodes", [node]) ?? [] : [];
+      const record = { id, type, children: Array.from(children, identify), parent: identify(invoke("getParentNode", [node])) };
       if (name !== void 0) record.name = name;
       if (element) {
         record.namespace = invoke("getNamespaceURI", [node]);
@@ -449,11 +491,19 @@ function createTreeAdapterSession(options, isDocument2) {
 function parseNativeDocument(source, options, isDocument2) {
   const binding = requireNative();
   const nativeOptions = parserOptions(source, options);
+  if (!options._useHtmlParser2 && options.treeAdapter && canReplay(options)) {
+    const document2 = routeDocument(new binding.NativeDocument(source, isDocument2, JSON.stringify(nativeOptions)), options);
+    const nodes = replayIntoAdapter(document2, options.treeAdapter, isDocument2);
+    if (nodes) {
+      attachParsedNodes(document2.state, nodes);
+      return document2;
+    }
+  }
   if (!options._useHtmlParser2 && options.treeAdapter) {
-    const parse2 = binding.parseWithTreeAdapter;
-    if (!parse2) throw new Error("This native addon does not support treeAdapter hooks; rebuild the Rust addon.");
+    const parse3 = binding.parseWithTreeAdapter;
+    if (!parse3) throw new Error("This native addon does not support treeAdapter hooks; rebuild the Rust addon.");
     const adapter = treeAdapterBridge(options.treeAdapter, options);
-    return bindAdapterDocument(parse2(source, isDocument2, JSON.stringify(nativeOptions), adapter.bridge), options, adapter);
+    return bindAdapterDocument(parse3(source, isDocument2, JSON.stringify(nativeOptions), adapter.bridge), options, adapter);
   }
   const document = new binding.NativeDocument(source, isDocument2, JSON.stringify(nativeOptions));
   deliverParseErrors(document, options);
@@ -506,205 +556,833 @@ function createDiagnosticSession(options, isDocument2 = true) {
     }
   };
 }
+function canReplay(options) {
+  const adapter = options.treeAdapter;
+  return !options.onParseError && !options.sourceCodeLocationInfo && adapter.onItemPush === void 0 && adapter.onItemPop === void 0;
+}
+function replayIntoAdapter(document, adapter, isDocument2) {
+  const state = document.state;
+  const root = document.rootId() - state.base;
+  const size = state.baseline;
+  const nodes = new Array(size);
+  for (let local = 0; local < Math.min(size, 65); local++) recordAt(state, local);
+  for (let local = 0; local < size; local++) {
+    const snapshot = plainSnapshot(state, local);
+    const record = snapshot ? void 0 : recordAt(state, local);
+    if (!snapshot && !record) continue;
+    const type = snapshot ? snapshot.typeOf(local) : record.type;
+    if (local === root) {
+      nodes[local] = isDocument2 ? adapter.createDocument() : adapter.createDocumentFragment();
+      const mode = record?.["x-mode"];
+      if (isDocument2 && mode !== void 0) adapter.setDocumentMode(nodes[local], mode);
+      continue;
+    }
+    const parentLocal = snapshot ? snapshot.linkOf(local, 1) : record.parent;
+    const parent = parentLocal == null ? void 0 : nodes[parentLocal];
+    if (parent === void 0) return void 0;
+    switch (type) {
+      case "tag":
+      case "script":
+      case "style": {
+        const element = snapshot ? adapter.createElement(snapshot.nameOf(local), snapshot.namespaceOf(local), snapshot.attributeObjects(local)) : adapter.createElement(record.name, record.namespace, attributeList(record));
+        adapter.appendChild(parent, element);
+        nodes[local] = element;
+        break;
+      }
+      case "root": {
+        const content = adapter.createDocumentFragment();
+        adapter.setTemplateContent(parent, content);
+        nodes[local] = content;
+        break;
+      }
+      case "text": {
+        adapter.insertText(parent, (snapshot ? snapshot.dataOf(local) : record.data) ?? "");
+        const children = adapter.getChildNodes(parent);
+        nodes[local] = children[children.length - 1];
+        break;
+      }
+      case "comment": {
+        const comment = adapter.createCommentNode((snapshot ? snapshot.dataOf(local) : record.data) ?? "");
+        adapter.appendChild(parent, comment);
+        nodes[local] = comment;
+        break;
+      }
+      case "directive": {
+        if (!record || record.name !== "!doctype" || !isDocument2) return void 0;
+        adapter.setDocumentType(parent, record["x-name"] ?? "", record["x-publicId"] ?? "", record["x-systemId"] ?? "");
+        nodes[local] = Array.from(adapter.getChildNodes(parent) ?? []).find((child) => adapter.isDocumentTypeNode(child));
+        break;
+      }
+      default:
+        return void 0;
+    }
+  }
+  const changes = differencesFromParse(adapter, nodes, state, root);
+  if (!changes) return void 0;
+  for (const change of changes) operation(document, "setNode", { id: state.base + change.local, field: change.field, value: change.value });
+  return nodes;
+}
+function attributeList(record) {
+  const attributes = record.attribs ?? {};
+  return Object.keys(attributes).map((name) => {
+    const namespace = record.attribsNamespace?.[name];
+    const prefix = record.attribsPrefix?.[name];
+    return { name, value: attributes[name], ...namespace === void 0 ? {} : { namespace }, ...prefix === void 0 ? {} : { prefix } };
+  });
+}
+function differencesFromParse(adapter, nodes, state, root) {
+  const changes = [];
+  for (let local = 0; local < nodes.length; local++) {
+    const node = nodes[local];
+    const snapshot = plainSnapshot(state, local);
+    const record = snapshot ? void 0 : recordAt(state, local);
+    if (!snapshot && !record) continue;
+    if (!node) return void 0;
+    const type = snapshot ? snapshot.typeOf(local) : record.type;
+    if (local !== root && adapter.getParentNode(node) !== nodes[snapshot ? snapshot.linkOf(local, 1) : record.parent]) return void 0;
+    if (type !== "text" && type !== "comment" && type !== "directive") {
+      const children = adapter.getChildNodes(node) ?? [];
+      const count = snapshot ? snapshot.childCount(local) : record.children.length;
+      if (children.length !== count) return void 0;
+      for (let index = 0; index < count; index++) if (children[index] !== nodes[snapshot ? snapshot.childAt(local, index) : record.children[index]]) return void 0;
+    }
+    if (type === "tag" || type === "script" || type === "style") {
+      const name = snapshot ? snapshot.nameOf(local) : record.name;
+      const namespace = snapshot ? snapshot.namespaceOf(local) : record.namespace;
+      if (!adapter.isElementNode(node) || adapter.getTagName(node) !== name || adapter.getNamespaceURI(node) !== namespace) return void 0;
+      const attributes = adapter.getAttrList(node) ?? [];
+      const expected = snapshot ? snapshot.attributeObjects(local) : attributeList(record);
+      const isSame = attributes.length === expected.length && attributes.every((attribute, index) => attribute.name === expected[index].name && attribute.value === expected[index].value);
+      if (!isSame) {
+        const values = /* @__PURE__ */ Object.create(null);
+        const namespaces = /* @__PURE__ */ Object.create(null);
+        const prefixes = /* @__PURE__ */ Object.create(null);
+        for (const attribute of attributes) {
+          values[attribute.name] = attribute.value;
+          if (attribute.namespace !== void 0) namespaces[attribute.name] = attribute.namespace;
+          if (attribute.prefix !== void 0) prefixes[attribute.name] = attribute.prefix;
+        }
+        changes.push({ local, field: "attribs", value: values }, { local, field: "attribsNamespace", value: namespaces }, { local, field: "attribsPrefix", value: prefixes });
+      }
+    } else if (type === "text" || type === "comment") {
+      if (type === "text" ? !adapter.isTextNode(node) : !adapter.isCommentNode(node)) return void 0;
+      const data2 = type === "text" ? adapter.getTextNodeContent(node) : adapter.getCommentNodeContent(node);
+      if (data2 !== (snapshot ? snapshot.dataOf(local) : record.data)) changes.push({ local, field: "data", value: data2 });
+    }
+  }
+  return changes;
+}
+
+// src/snapshot.ts
+var HEADER = 5;
+var STRIDE = 15;
+var ABSENT = 4294967295;
+var HAS_START_INDEX = 1;
+var HAS_END_INDEX = 2;
+var HAS_NAMESPACE = 4;
+var EMPTY_ATTRIBUTE_MAPS = 8;
+var OPAQUE = 16;
+var RELEASED = 32;
+var noChildren = Object.freeze([]);
+var noAttributes = Object.freeze({});
+var SnapshotRecord = class {
+  constructor(snapshot, id, base) {
+    this.snapshot = snapshot;
+    this.id = id;
+    this.base = base;
+    this.decodedData = void 0;
+    this.decodedAttributes = void 0;
+    this.decodedChildren = void 0;
+  }
+  snapshot;
+  id;
+  base;
+  decodedData;
+  decodedAttributes;
+  decodedChildren;
+  get type() {
+    return this.snapshot.name(this.snapshot.nodes[this.base]);
+  }
+  get name() {
+    const name = this.snapshot.nodes[this.base + 6];
+    return name ? this.snapshot.name(name - 1) : void 0;
+  }
+  get data() {
+    if (this.decodedData !== void 0) return this.decodedData;
+    const data2 = this.snapshot.nodes[this.base + 7];
+    return data2 ? this.decodedData = this.snapshot.string(data2 - 1) : void 0;
+  }
+  get parent() {
+    const parent = this.snapshot.nodes[this.base + 1];
+    return parent ? parent - 1 : null;
+  }
+  get prev() {
+    const prev = this.snapshot.nodes[this.base + 2];
+    return prev ? prev - 1 : null;
+  }
+  get next() {
+    const next = this.snapshot.nodes[this.base + 3];
+    return next ? next - 1 : null;
+  }
+  get startIndex() {
+    return this.index(HAS_START_INDEX, 11);
+  }
+  get endIndex() {
+    return this.index(HAS_END_INDEX, 12);
+  }
+  get namespace() {
+    const nodes = this.snapshot.nodes;
+    return nodes[this.base + 10] & HAS_NAMESPACE ? this.snapshot.name(nodes[this.base + 13]) : void 0;
+  }
+  get attribsNamespace() {
+    return this.snapshot.nodes[this.base + 10] & EMPTY_ATTRIBUTE_MAPS ? {} : void 0;
+  }
+  get attribsPrefix() {
+    return this.snapshot.nodes[this.base + 10] & EMPTY_ATTRIBUTE_MAPS ? {} : void 0;
+  }
+  get attribs() {
+    return this.decodedAttributes ??= this.snapshot.attributesOf(this.id);
+  }
+  get children() {
+    return this.decodedChildren ??= this.snapshot.childrenOf(this.id);
+  }
+  index(flag, offset) {
+    const nodes = this.snapshot.nodes;
+    if (!(nodes[this.base + 10] & flag)) return void 0;
+    const value = nodes[this.base + offset];
+    return value === ABSENT ? null : value;
+  }
+};
+var recordFields = ["type", "name", "data", "parent", "prev", "next", "startIndex", "endIndex", "namespace", "attribsNamespace", "attribsPrefix", "attribs", "children"];
+function plainRecord(record) {
+  if (!(record instanceof SnapshotRecord)) return record;
+  const copy = { id: record.id };
+  for (const field of recordFields) {
+    const value = record[field];
+    if (value !== void 0) copy[field] = value;
+  }
+  for (const key of Object.keys(record)) if (!key.startsWith("decoded") && key !== "snapshot" && key !== "base" && key !== "id") copy[key] = record[key];
+  return copy;
+}
+var NodeSnapshot = class {
+  size;
+  nodes;
+  children;
+  attributes;
+  strings;
+  text;
+  isEncoded;
+  names = [];
+  /** Node object constructors by interned type, resolved once per snapshot. */
+  viewConstructors = void 0;
+  constructor(raw) {
+    const { data: data2 } = raw;
+    const childrenStart = HEADER + data2[0];
+    const attributesStart = childrenStart + data2[1];
+    const stringsStart = attributesStart + data2[2];
+    this.text = raw.text;
+    this.isEncoded = data2[4] === 1;
+    this.nodes = data2.subarray(HEADER, childrenStart);
+    this.children = data2.subarray(childrenStart, attributesStart);
+    this.attributes = data2.subarray(attributesStart, stringsStart);
+    this.strings = data2.subarray(stringsStart, stringsStart + data2[3]);
+    this.size = this.nodes.length / STRIDE;
+  }
+  /** The record, `null` for a released node, or `undefined` when it must be read individually. */
+  record(local) {
+    if (local >= this.size) return void 0;
+    const base = local * STRIDE;
+    const flags = this.nodes[base + 10];
+    if (flags & RELEASED) return null;
+    if (flags & OPAQUE) return void 0;
+    const record = new SnapshotRecord(this, local, base);
+    const extras = this.nodes[base + 14];
+    if (extras) {
+      const fields = JSON.parse(this.string(extras - 1));
+      for (const key of Object.keys(fields)) Object.defineProperty(record, key, { value: fields[key], writable: true, enumerable: true, configurable: true });
+    }
+    return record;
+  }
+  /** Whether a node's fields all live in the arrays, so callers may read them without a record. */
+  isPlain(local) {
+    if (local >= this.size) return false;
+    const base = local * STRIDE;
+    return (this.nodes[base + 10] & (OPAQUE | RELEASED)) === 0 && this.nodes[base + 14] === 0;
+  }
+  typeOf(local) {
+    return this.name(this.nodes[local * STRIDE]);
+  }
+  nameOf(local) {
+    const name = this.nodes[local * STRIDE + 6];
+    return name ? this.name(name - 1) : void 0;
+  }
+  dataOf(local) {
+    const data2 = this.nodes[local * STRIDE + 7];
+    return data2 ? this.string(data2 - 1) : void 0;
+  }
+  /** The parent, previous or next sibling (`offset` 1, 2 or 3), or `null`. */
+  linkOf(local, offset) {
+    const link = this.nodes[local * STRIDE + offset];
+    return link ? link - 1 : null;
+  }
+  namespaceOf(local) {
+    const base = local * STRIDE;
+    return this.nodes[base + 10] & HAS_NAMESPACE ? this.name(this.nodes[base + 13]) : void 0;
+  }
+  /** A node's attributes as parse5 attribute objects; plain nodes have no namespaced ones. */
+  attributeObjects(local) {
+    const base = local * STRIDE;
+    const count = this.nodes[base + 9];
+    const first = this.nodes[base + 8];
+    const attributes = this.attributes;
+    const result = new Array(count);
+    for (let index = 0; index < count; index++) {
+      const pair = (first + index) * 2;
+      result[index] = { name: this.name(attributes[pair]), value: this.string(attributes[pair + 1]) };
+    }
+    return result;
+  }
+  /** Copies a node's attributes onto `target`, in order. */
+  copyAttributes(local, target) {
+    const base = local * STRIDE;
+    const count = this.nodes[base + 9];
+    const first = this.nodes[base + 8];
+    const attributes = this.attributes;
+    for (let index = 0; index < count; index++) {
+      const pair = (first + index) * 2;
+      const name = this.name(attributes[pair]);
+      const value = this.string(attributes[pair + 1]);
+      if (name === "__proto__") Object.defineProperty(target, name, { value, writable: true, enumerable: true, configurable: true });
+      else target[name] = value;
+    }
+  }
+  /** The flat child id list; a node's children start at `childStart(local)`. */
+  get childIds() {
+    return this.children;
+  }
+  childStart(local) {
+    return this.nodes[local * STRIDE + 4];
+  }
+  /** The interned reference of a node's type, comparable across nodes of this snapshot. */
+  typeReference(local) {
+    return this.nodes[local * STRIDE];
+  }
+  /** Child ids without materializing the record. */
+  childCount(local) {
+    return this.nodes[local * STRIDE + 5];
+  }
+  childAt(local, index) {
+    return this.children[this.nodes[local * STRIDE + 4] + index];
+  }
+  childrenOf(local) {
+    const base = local * STRIDE;
+    const count = this.nodes[base + 5];
+    if (count === 0) return noChildren;
+    const first = this.nodes[base + 4];
+    return Array.from(this.children.subarray(first, first + count));
+  }
+  attributesOf(local) {
+    const base = local * STRIDE;
+    const count = this.nodes[base + 9];
+    if (count === 0) return noAttributes;
+    const first = this.nodes[base + 8];
+    const attributes = this.attributes;
+    const result = {};
+    for (let index = 0; index < count; index++) {
+      const pair = (first + index) * 2;
+      const name = this.name(attributes[pair]);
+      const value = this.string(attributes[pair + 1]);
+      if (name === "__proto__") Object.defineProperty(result, name, { value, writable: true, enumerable: true, configurable: true });
+      else result[name] = value;
+    }
+    return result;
+  }
+  /** One attribute's value, without decoding the rest. */
+  attributeValue(local, name) {
+    const base = local * STRIDE;
+    const count = this.nodes[base + 9];
+    const first = this.nodes[base + 8];
+    const attributes = this.attributes;
+    for (let index = count - 1; index >= 0; index--) {
+      const pair = (first + index) * 2;
+      if (this.name(attributes[pair]) === name) return this.string(attributes[pair + 1]);
+    }
+    return void 0;
+  }
+  string(reference) {
+    const strings = this.strings;
+    const value = this.text.slice(strings[reference * 2], strings[reference * 2 + 1]);
+    return this.isEncoded ? decodeString(value) : value;
+  }
+  /** Names repeat across nodes, so each decodes once. */
+  name(reference) {
+    return this.names[reference] ??= this.string(reference);
+  }
+};
 
 // src/router.ts
-var registryKey2 = /* @__PURE__ */ Symbol.for("rusteerio.native-handles.v2");
+var STRIDE2 = 2 ** 32;
+var maximumDocuments = 2 ** 21;
+var rootSlots = 1;
+var VIEW_STATE = /* @__PURE__ */ Symbol.for("rusteerio.node.state");
+var VIEW_LOCAL = /* @__PURE__ */ Symbol.for("rusteerio.node.local");
+var VIEW_ATTRIBUTES = /* @__PURE__ */ Symbol.for("rusteerio.node.attributes");
+var VIEW_SELF = /* @__PURE__ */ Symbol.for("rusteerio.node.self");
+var DOCUMENT = /* @__PURE__ */ Symbol.for("rusteerio.selection.document");
+var API = /* @__PURE__ */ Symbol.for("rusteerio.selection.api");
+var IDS = /* @__PURE__ */ Symbol.for("rusteerio.selection.ids");
+var VALUES = /* @__PURE__ */ Symbol.for("rusteerio.selection.values");
+var LEASE = /* @__PURE__ */ Symbol.for("rusteerio.selection.lease");
+var IS_PLAIN = /* @__PURE__ */ Symbol.for("rusteerio.selection.is-plain");
+var VIEW_CHILD_TARGET = /* @__PURE__ */ Symbol.for("rusteerio.node.child-target");
+var registryKey2 = /* @__PURE__ */ Symbol.for(`rusteerio.native-documents.v5:${packageDirectory()}`);
+var stateKey = /* @__PURE__ */ Symbol.for("rusteerio.native-documents.state");
 var globals2 = globalThis;
 var registry2 = globals2[registryKey2] ??= (() => {
-  const handles = /* @__PURE__ */ new Map();
-  const byDocument = /* @__PURE__ */ new WeakMap();
-  const snapshots = /* @__PURE__ */ new WeakMap();
-  const pending = [];
-  let scheduled = false;
-  const flush = () => {
-    scheduled = false;
-    const batches = /* @__PURE__ */ new Map();
-    for (const pin of pending.splice(0)) {
-      const document = pin.document.deref();
-      if (!document) continue;
-      const entries = byDocument.get(document);
-      if (entries?.get(pin.local)?.pin === pin) entries.delete(pin.local);
-      const ids = batches.get(document) ?? [];
-      ids.push(pin.local);
-      batches.set(document, ids);
-    }
-    for (const [document, ids] of batches) {
-      snapshots.delete(document);
-      document.release?.(ids);
-      document.collectGarbage?.();
-    }
+  const created = {
+    space: {},
+    writes: 0,
+    states: [],
+    pending: /* @__PURE__ */ new Set(),
+    isScheduled: false,
+    leaseFinalizer: new FinalizationRegistry((token) => {
+      token.isReleased = true;
+    })
   };
-  return { next: 1, space: {}, handles, byDocument, snapshots, finalizer: new FinalizationRegistry((pin) => {
-    if (!handles.get(pin.global)?.deref()) handles.delete(pin.global);
-    pending.push(pin);
-    if (!scheduled) {
-      scheduled = true;
-      queueMicrotask(flush);
-    }
-  }) };
+  return created;
 })();
+function statesOf(document, ids) {
+  const states = [];
+  let previous;
+  for (const id of ids) {
+    if (id === void 0) continue;
+    if (previous && id >= previous.base && id < previous.base + STRIDE2) continue;
+    const state = stateIn(document, id);
+    if (!states.includes(state)) states.push(state);
+    previous = state;
+  }
+  return states;
+}
+function scheduleCollectionIfDue(state) {
+  if (state.raw.isCollectionDue?.()) scheduleCollection(state);
+}
+function scheduleCollection(state) {
+  registry2.pending.add(state);
+  if (registry2.pending.size > maximumPendingCollections) {
+    const evicted = registry2.pending.values().next().value;
+    registry2.pending.delete(evicted);
+    evicted.isCollectionEvicted = true;
+  }
+  if (registry2.isScheduled) return;
+  registry2.isScheduled = true;
+  setImmediate(() => {
+    registry2.isScheduled = false;
+    const states = [...registry2.pending];
+    registry2.pending.clear();
+    for (const pending of states) collectState(pending);
+  }).unref();
+}
+var maximumPendingCollections = 4;
+function writeCount() {
+  return registry2.writes;
+}
+function stateFor(raw, options = {}) {
+  const holder = raw;
+  const existing = holder[stateKey];
+  if (existing) return existing;
+  const index = raw.routingIndex();
+  if (index >= maximumDocuments) throw new RangeError("Too many documents are alive at once.");
+  const baseline = raw.slotCount?.() ?? 0;
+  const state = {
+    raw,
+    base: index * STRIDE2,
+    space: registry2.space,
+    options,
+    rootLocal: void 0,
+    routed: void 0,
+    // Sized up front: node objects are cached out of order, and regrowing a holey array is costly.
+    generation: 0,
+    records: [],
+    bulk: 0,
+    snapshotSize: 0,
+    stale: /* @__PURE__ */ new Set(),
+    views: new Array(baseline),
+    looseViews: /* @__PURE__ */ new Map(),
+    looseViewLimit: minimumLooseViewLimit,
+    weakViews: /* @__PURE__ */ new Map(),
+    baseline,
+    leases: /* @__PURE__ */ new Set(),
+    leaseSweepSize: 64,
+    data: /* @__PURE__ */ new Map(),
+    isExposed: false,
+    hasChildLists: false,
+    collectionRetries: 0,
+    isCollectionEvicted: false
+  };
+  holder[stateKey] = state;
+  return state;
+}
+function exposeState(state) {
+  if (state.isExposed) return;
+  state.isExposed = true;
+  registry2.states[state.base / STRIDE2] = new WeakRef(state);
+}
+function exposeTo(document, state) {
+  if (document.state === state) return;
+  exposeState(state);
+}
+function exposeDocumentTo(document, source) {
+  const state = source?.state;
+  if (state) exposeTo(document, state);
+}
+function cachedView(state, local) {
+  const view = local < state.baseline ? state.views[local] : state.looseViews.get(local);
+  return view ?? (state.weakViews.size ? state.weakViews.get(local)?.deref() : void 0);
+}
+var minimumLooseViewLimit = 1024;
+function cacheView(state, local, view) {
+  if (local < state.baseline) {
+    state.views[local] = view;
+    return;
+  }
+  state.looseViews.set(local, view);
+  if (state.looseViews.size >= state.looseViewLimit) {
+    state.looseViewLimit = state.looseViews.size * 2;
+    scheduleCollection(state);
+  }
+}
+function uncacheView(state, local) {
+  const view = cachedView(state, local);
+  if (local < state.baseline) state.views[local] = void 0;
+  state.looseViews.delete(local);
+  state.weakViews.delete(local);
+  return view;
+}
+function releaseSlotsFrom(state, end) {
+  for (const local of state.data.keys()) if (local >= end) releaseSlot(state, local);
+  for (const local of state.weakViews.keys()) if (local >= end) state.weakViews.delete(local);
+  if (state.adapterNodes && state.adapterNodes.length > end) {
+    for (let local = end; local < state.adapterNodes.length; local++) releaseAdapterNode(state, local);
+    state.adapterNodes.length = end;
+  }
+}
+function releaseSlot(state, local) {
+  uncacheView(state, local);
+  const entry = state.data.get(local);
+  if (entry) {
+    entry.isReleased = true;
+    state.data.delete(local);
+  }
+  releaseAdapterNode(state, local);
+}
+function releaseAdapterNode(state, local) {
+  const adapterNode = state.adapterNodes?.[local];
+  if (!adapterNode) return;
+  adapterNode[VIEW_SELF] = void 0;
+  state.adapterNodes[local] = void 0;
+}
+function hasViews(state) {
+  return state.views.length > 0 || state.looseViews.size > 0 || state.weakViews.size > 0;
+}
+function forEachView(state, visit) {
+  state.views.forEach((view, local) => {
+    if (view) visit(view, local);
+  });
+  for (const [local, view] of state.looseViews) visit(view, local);
+  for (const [local, reference] of state.weakViews) {
+    const view = reference.deref();
+    if (view) visit(view, local);
+  }
+}
+function weakenDetachedViews(state) {
+  if (!state.raw.detachedSlots) return false;
+  let isWeakened = false;
+  for (const local of state.raw.detachedSlots(state.rootLocal ??= state.raw.rootId())) {
+    const view = local < state.baseline ? state.views[local] : state.looseViews.get(local);
+    if (!view) continue;
+    if (local < state.baseline) state.views[local] = void 0;
+    else state.looseViews.delete(local);
+    state.weakViews.set(local, new WeakRef(view));
+    isWeakened = true;
+  }
+  return isWeakened;
+}
+function exposedStateOf(id) {
+  const state = registry2.states[Math.floor(id / STRIDE2)]?.deref();
+  if (!state || !(id >= 0)) throw new RangeError(`Unknown native node handle ${id}`);
+  return state;
+}
+function stateIn(document, id) {
+  const own = document.state;
+  if (own === void 0 || id < own.base || id >= own.base + STRIDE2) return exposedStateOf(id);
+  if (own.isCollectionEvicted) resumeCollection(document);
+  return own;
+}
+function resumeCollection(document) {
+  const state = document.state;
+  if (!state?.isCollectionEvicted) return;
+  state.isCollectionEvicted = false;
+  scheduleCollection(state);
+}
+function recordAt(state, local) {
+  const cached2 = state.records[local];
+  if (cached2 !== void 0) return cached2;
+  const record = readRecord(state, local);
+  state.records[local] = record;
+  return record;
+}
+var minimumReadsBeforeSnapshot = 64;
+function readRecord(state, local) {
+  const bulk = state.bulk;
+  if (bulk instanceof NodeSnapshot) {
+    const record = state.stale.size && state.stale.has(local) ? void 0 : bulk.record(local);
+    if (record !== void 0) return record;
+  } else if (state.raw.snapshot) {
+    const reads = bulk + 1;
+    const size = Math.max(state.snapshotSize, state.baseline);
+    const firstSnapshotRead = state.generation === 0 ? size / 100 : 1 + size / 100;
+    if (reads >= Math.min(minimumReadsBeforeSnapshot, firstSnapshotRead)) {
+      const snapshot = new NodeSnapshot(state.raw.snapshot());
+      state.snapshotSize = snapshot.size;
+      state.bulk = snapshot;
+      const record = snapshot.record(local);
+      if (record !== void 0) return record;
+    } else state.bulk = reads;
+  }
+  return rawOperation(state.raw, "node", { id: local });
+}
+function plainSnapshot(state, local) {
+  const bulk = state.bulk;
+  return bulk instanceof NodeSnapshot && !(state.stale.size && state.stale.has(local)) && bulk.isPlain(local) ? bulk : void 0;
+}
+function attributeAt(state, local, name) {
+  const snapshot = plainSnapshot(state, local);
+  if (snapshot) return snapshot.attributeValue(local, name);
+  const attributes = recordAt(state, local)?.attribs;
+  const value = attributes && Object.hasOwn(attributes, name) ? attributes[name] : void 0;
+  return typeof value === "string" ? value : void 0;
+}
+function invalidate(state) {
+  state.generation++;
+  state.records = [];
+  state.bulk = 0;
+  state.stale.clear();
+}
+function invalidateNodes(state, locals) {
+  const isSnapshot = state.bulk instanceof NodeSnapshot;
+  for (const local of locals) {
+    state.records[local] = void 0;
+    if (isSnapshot) state.stale.add(local);
+  }
+}
+function leaseNodes(document, owner, ids) {
+  const token = { isReleased: false };
+  const states = statesOf(document, ids);
+  const lease = { ids, token, states };
+  for (const state of states) addLease(state, lease);
+  registry2.leaseFinalizer.register(owner, token);
+  return lease;
+}
+function updateLease(document, lease, ids) {
+  lease.ids = ids;
+  lease.states = statesOf(document, ids);
+  for (const state of lease.states) addLease(state, lease);
+}
+function addLease(state, lease) {
+  state.leases.add(lease);
+  if (state.leases.size < state.leaseSweepSize) return;
+  for (const held of state.leases) if (held.token.isReleased) state.leases.delete(held);
+  state.leaseSweepSize = state.leases.size * 2 + 64;
+}
+var collectionRetries = 3;
+function collectState(state) {
+  registry2.pending.delete(state);
+  state.isCollectionEvicted = false;
+  if (!state.raw.collectPinned) return state.raw.collectGarbage?.();
+  if (weakenDetachedViews(state)) state.collectionRetries = collectionRetries;
+  const pins = [];
+  const { base } = state;
+  const end = base + STRIDE2;
+  for (const lease of state.leases) {
+    if (lease.token.isReleased) {
+      state.leases.delete(lease);
+      continue;
+    }
+    for (const id of lease.ids) if (id >= base && id < end) pins.push(id - base);
+  }
+  state.views.forEach((view, local) => {
+    if (view) pins.push(local);
+  });
+  for (const local of state.looseViews.keys()) pins.push(local);
+  for (const [local, reference] of state.weakViews) {
+    if (reference.deref()) pins.push(local);
+    else state.weakViews.delete(local);
+  }
+  const { free, ...stats } = state.raw.collectPinned(Uint32Array.from(pins), rootSlots);
+  invalidate(state);
+  for (const local of free) releaseSlot(state, local);
+  releaseSlotsFrom(state, stats.slots);
+  state.looseViewLimit = Math.max(minimumLooseViewLimit, state.looseViews.size * 2);
+  if (state.collectionRetries > 0 && state.weakViews.size > 0) {
+    state.collectionRetries--;
+    scheduleCollection(state);
+  }
+  return stats;
+}
 function rawOperation(document, command, args) {
   const result = document.op(command, JSON.stringify(args));
   return result === "" || result === void 0 ? void 0 : JSON.parse(result);
 }
-function localMap(document) {
-  let map = registry2.byDocument.get(document);
-  if (!map) registry2.byDocument.set(document, map = /* @__PURE__ */ new Map());
-  return map;
-}
-function handleFor(document, local) {
-  const map = localMap(document);
-  let handle = map.get(local)?.reference.deref();
-  if (!handle || handle.document !== document || handle.local !== local) {
-    const pin = { global: registry2.next++, document: new WeakRef(document), local };
-    handle = { global: pin.global, document, local, pin };
-    document.retain?.([local]);
-    const reference = new WeakRef(handle);
-    map.set(local, { reference, pin });
-    registry2.handles.set(handle.global, reference);
-    registry2.finalizer.register(handle, pin);
-  }
-  return handle;
-}
-function retainNodes(document, ids) {
-  return document.retainNodes?.(ids) ?? {};
-}
-var RoutedDocument = class _RoutedDocument {
+function globalRecord(state, record) {
+  if (!record) return null;
+  const { base } = state;
+  const link = (local) => local == null ? null : base + local;
+  return { ...plainRecord(record), id: base + record.id, children: (record.children ?? []).map((child) => base + child), parent: link(record.parent), prev: link(record.prev), next: link(record.next) };
+}
+var parentTypes = /* @__PURE__ */ new Set(["root", "tag", "script", "style", "cdata"]);
+var pointerFields = /* @__PURE__ */ new Set(["parent", "parentNode", "prev", "previousSibling", "next", "nextSibling"]);
+var idResultCommands = /* @__PURE__ */ new Set(["select", "matches", "uniqueSort", "traverse", "clone"]);
+var scratchCommands = /* @__PURE__ */ new Set(["select", "matches", "uniqueSort", "serializeArray", "serialize", "extractPlan"]);
+var writeCommands = /* @__PURE__ */ new Set(["create", "createNode", "setNode", "import", "insert", "clone", "remove", "removeAttr", "removeData", "addClass", "removeClass", "toggleClass"]);
+var attributeFields = /* @__PURE__ */ new Set(["attribs", "x-attribsNamespace", "x-attribsPrefix"]);
+var targetedAttributeWrites = /* @__PURE__ */ new Set(["attr", "removeAttr", "addClass", "removeClass", "toggleClass", "css"]);
+var recordOnlyWrites = /* @__PURE__ */ new Set([...targetedAttributeWrites, "data", "removeData"]);
+var structuralWrites = /* @__PURE__ */ new Set(["create", "createNode", "import", "insert", "clone", "remove", "html", "text", "data", "removeData"]);
+var RoutedDocument = class {
   nodeSpace = registry2.space;
   options;
-  anchor;
+  state;
   get raw() {
-    return this.anchor.document;
+    return this.state.raw;
   }
-  constructor(document, options = {}, anchor) {
+  constructor(document, options = {}) {
     this.options = options;
-    this.anchor = anchor ?? handleFor(document, document.rootId());
-  }
-  keep(handle) {
-    return handle.global;
-  }
-  lookup(id) {
-    const handle = registry2.handles.get(id)?.deref();
-    if (!handle) throw new RangeError(`Unknown native node handle ${id}`);
-    return handle;
-  }
-  global(document, local) {
-    return this.keep(handleFor(document, local));
-  }
-  globals(document, ids) {
-    return ids.map((id) => this.global(document, id));
+    this.state = stateFor(document, options);
+  }
+  /**
+   * Sets (or with `null` removes) an attribute, as the `attr` command does,
+   * through a typed native call. Attribute objects already handed out are
+   * updated in place instead of being read back.
+   */
+  setAttribute(ids, name, value) {
+    registry2.writes++;
+    for (const { state, locals } of this.groups(ids)) {
+      if (!state.raw.setAttribute) {
+        this.call(state, "attr", { ids: locals, name, value });
+        continue;
+      }
+      invalidateNodes(state, locals);
+      state.raw.setAttribute(locals, name, value);
+      for (const local of locals) {
+        const target = cachedView(state, local)?.[VIEW_ATTRIBUTES]?.target;
+        if (!target) continue;
+        if (value === null) delete target[name];
+        else if (name === "__proto__") Object.defineProperty(target, name, { value, writable: true, enumerable: true, configurable: true });
+        else target[name] = value;
+      }
+    }
   }
   retainNode(id) {
-    this.lookup(id);
-  }
-  retainNodes(ids) {
-    return ids.filter((id) => id !== void 0).map((id) => this.lookup(id));
-  }
-  nodeDocument(id) {
-    return new _RoutedDocument(this.raw, this.options, this.lookup(id));
+    this.owner(id);
   }
   collectGarbage() {
-    registry2.snapshots.delete(this.raw);
-    return this.raw.collectGarbage?.();
+    return collectState(this.state);
   }
   retainNodeData(id, data2) {
-    this.lookup(id).data = data2;
+    dataEntry(this.owner(id), id).data = data2;
   }
   nodeData(id) {
-    return this.lookup(id).data;
+    const state = this.owner(id);
+    return state.data.get(id - state.base)?.data;
   }
   nodeDataOperation(id) {
-    const handle = this.lookup(id);
+    const entry = dataEntry(this.owner(id), id);
     const options = this.options;
-    return (command, args) => rawOperation(handle.document, command, { ...args, ids: [handle.local], options });
+    return (command, args) => entry.isReleased ? void 0 : routedFor(entry.state).operate(command, { ...args, ids: [entry.state.base + entry.local], options });
   }
-  localNodeId(id) {
-    return this.global(this.raw, id);
+  localNodeId(local) {
+    return this.state.base + local;
   }
   rootId() {
-    return this.global(this.raw, this.raw.rootId());
+    return this.state.base + (this.state.rootLocal ??= this.raw.rootId());
+  }
+  isOwnNode(id) {
+    return id >= this.state.base && id < this.state.base + STRIDE2;
+  }
+  owner(id) {
+    return stateIn(this, id);
   }
-  record(document, record) {
-    if (!record) return null;
-    const view = { ...record, id: this.global(document, record.id) };
-    Object.defineProperty(view, "children", { enumerable: true, get: () => this.globals(document, record.children ?? []) });
-    for (const key of ["parent", "prev", "next"]) Object.defineProperty(view, key, { enumerable: true, get: () => record[key] == null ? null : this.global(document, record[key]) });
-    return view;
+  globals(state, locals) {
+    const { base } = state;
+    return locals.map((local) => base + local);
   }
   groups(ids) {
     const groups = [];
+    const own = this.state;
+    let last;
     for (const id of ids) {
-      const handle = this.lookup(id);
-      const last = groups[groups.length - 1];
-      if (last?.document === handle.document) {
-        last.ids.push(handle.local);
-        last.global.push(id);
-      } else groups.push({ document: handle.document, ids: [handle.local], global: [id] });
+      const state = id >= own.base && id < own.base + STRIDE2 ? own : exposedStateOf(id);
+      if (last?.state === state) last.locals.push(id - state.base);
+      else groups.push(last = { state, locals: [id - state.base] });
     }
     return groups;
   }
-  call(document, command, args) {
-    if (command === "extractPlan" && JSON.stringify(args.plan).includes("innerHTML")) registry2.snapshots.delete(document);
-    if (Object.hasOwn(args, "value") || ["create", "createNode", "setNode", "import", "insert", "clone", "remove", "removeAttr", "removeData", "addClass", "removeClass", "toggleClass"].includes(command)) registry2.snapshots.delete(document);
-    return rawOperation(document, command, { ...args, options: args.options ?? this.options });
-  }
-  move(target, ids, copy = false) {
-    if (!copy) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const id of ids) {
-        const handle = this.lookup(id);
-        const group = groups.get(handle.document) ?? [];
-        group.push(handle);
-        groups.set(handle.document, group);
-      }
-      for (const [source, handles] of groups) {
-        if (source === target) continue;
-        if (!target.adopt) throw new Error("The native addon does not support cross-document adoption. Rebuild the Rust addon.");
-        registry2.snapshots.delete(source);
-        registry2.snapshots.delete(target);
-        const adopted = JSON.parse(target.adopt(source, handles.map((handle) => handle.local), true));
-        for (const [oldLocal, newLocal] of adopted.mapping) {
-          const entry = localMap(source).get(oldLocal);
-          if (!entry) continue;
-          const handle = entry.reference.deref();
-          if (handle && (handle.document !== source || handle.local !== oldLocal)) continue;
-          localMap(source).delete(oldLocal);
-          entry.pin.document = new WeakRef(target);
-          entry.pin.local = newLocal;
-          if (handle) {
-            handle.document = target;
-            handle.local = newLocal;
-          }
-          localMap(target).set(newLocal, entry);
-        }
+  call(state, command, args) {
+    if (command === "extractPlan" && JSON.stringify(args.plan).includes("innerHTML")) invalidate(state);
+    const isWrite = Object.hasOwn(args, "value") || writeCommands.has(command);
+    if (isWrite) {
+      registry2.writes++;
+      const changed = recordOnlyWrites.has(command) ? args.ids ?? [] : command === "setNode" && attributeFields.has(args.field) ? [args.id] : void 0;
+      if (changed) invalidateNodes(state, changed);
+      else invalidate(state);
+    }
+    const result = rawOperation(state.raw, command, { ...args, options: args.options ?? this.options });
+    if (isWrite) {
+      refreshWrittenAttributes(state, command, args);
+      refreshChildLists(state);
+      scheduleCollectionIfDue(state);
+    }
+    return result;
+  }
+  /** Moves or copies nodes into `target`; returns their local ids there. */
+  moveInto(target, ids, isCopy = false) {
+    if (!isCopy) {
+      for (const group of this.groups(ids)) {
+        if (group.state === target) continue;
+        if (!target.raw.adopt) throw new Error("The native addon does not support cross-document adoption. Rebuild the Rust addon.");
+        const adopted = JSON.parse(target.raw.adopt(group.state.raw, group.locals, true));
+        rehome(group.state, target, adopted.mapping, ids);
+        refreshChildLists(group.state);
+        refreshChildLists(target);
+        scheduleCollectionIfDue(group.state);
       }
-      return ids.map((id) => this.lookup(id).local);
+      return ids.map((id) => id - target.base);
     }
     const result = [];
     for (const group of this.groups(ids)) {
-      if (copy && group.document === target) {
-        result.push(...this.call(target, "clone", { ids: group.ids, deep: true }));
+      if (group.state === target) {
+        result.push(...this.call(target, "clone", { ids: group.locals, deep: true }));
         continue;
       }
-      if (!target.adopt) throw new Error("The native addon does not support cross-document adoption. Rebuild the Rust addon.");
-      registry2.snapshots.delete(target);
-      const adopted = JSON.parse(target.adopt(group.document, group.ids, !copy));
+      if (!target.raw.adopt) throw new Error("The native addon does not support cross-document adoption. Rebuild the Rust addon.");
+      invalidate(target);
+      const adopted = JSON.parse(target.raw.adopt(group.state.raw, group.locals, false));
       result.push(...adopted.roots);
     }
     return result;
   }
   scratch(command, args, ids) {
-    const documents = [...new Set(ids.map((id) => this.lookup(id).document))];
+    const states = [...new Set(ids.map((id) => this.owner(id)))];
     const scratch = new (requireNative()).NativeDocument("", false, JSON.stringify(args.options ?? this.options));
     const toScratch = /* @__PURE__ */ new Map();
     const fromScratch = /* @__PURE__ */ new Map();
-    for (const document of documents) {
-      const records = JSON.parse(document.exportTree());
+    for (const state of states) {
+      const records = JSON.parse(state.raw.exportTree());
       const roots = records.filter((record) => record.parent == null).map((record) => record.id);
       if (!scratch.adopt) throw new Error("The native addon does not support native document copies.");
-      const copied = JSON.parse(scratch.adopt(document, roots, false));
+      const copied = JSON.parse(scratch.adopt(state.raw, roots, false));
       for (const [local, copy] of copied.mapping) {
-        const global = this.global(document, local);
+        const global = state.base + local;
         toScratch.set(global, copy);
         fromScratch.set(copy, global);
       }
@@ -712,177 +1390,308 @@ var RoutedDocument = class _RoutedDocument {
     const translated = { ...args };
     for (const key of ["ids", "contexts"]) if (Array.isArray(args[key])) translated[key] = args[key].map((id) => toScratch.get(id)).filter((id) => id !== void 0);
     if (args.pseudoMatches) translated.pseudoMatches = Object.fromEntries(Object.entries(args.pseudoMatches).map(([key, values]) => [key, values.map((id) => toScratch.get(id)).filter((id) => id !== void 0)]));
-    const result = this.call(scratch, command, translated);
+    const result = rawOperation(scratch, command, { ...translated, options: translated.options ?? this.options });
     return ["select", "matches", "uniqueSort"].includes(command) ? result.map((id) => fromScratch.get(id)).filter((id) => id !== void 0) : result;
   }
+  isMixed(groups) {
+    return groups.length > 1 && groups.some((group) => group.state !== groups[0].state);
+  }
   select(selector, contexts) {
     const ids = contexts ?? [this.rootId()];
-    if (!ids.length) return this.call(this.raw, "select", { selector, contexts: [] });
+    if (!ids.length) return this.call(this.state, "select", { selector, contexts: [] });
     const groups = this.groups(ids);
-    if (new Set(groups.map((group2) => group2.document)).size > 1) return this.scratch("select", { selector, contexts: ids }, ids);
+    if (this.isMixed(groups)) return this.scratch("select", { selector, contexts: ids }, ids);
     const group = groups[0];
-    const found = group.document === this.raw ? group.document.select(selector, group.ids) : this.call(group.document, "select", { selector, contexts: group.ids });
-    return this.globals(group.document, found);
+    const found = group.state === this.state ? group.state.raw.select(selector, group.locals) : this.call(group.state, "select", { selector, contexts: group.locals });
+    return this.globals(group.state, found);
   }
   text(ids) {
-    return this.groups(ids).map((group) => group.document.text(group.ids)).join("");
+    return this.groups(ids).map((group) => group.state.raw.text(group.locals)).join("");
   }
   innerHtml(id) {
-    const handle = this.lookup(id);
-    registry2.snapshots.delete(handle.document);
-    return handle.document === this.raw ? handle.document.innerHtml(handle.local) : this.call(handle.document, "html", { ids: [handle.local] });
+    const state = this.owner(id);
+    const local = id - state.base;
+    const isSplicing = recordAt(state, local)?.children?.some((child) => recordAt(state, child)?.type === "root") ?? false;
+    if (isSplicing) invalidate(state);
+    const html = state === this.state ? state.raw.innerHtml(local) : this.call(state, "html", { ids: [local] });
+    if (isSplicing && state.hasChildLists && childRefresher) forEachView(state, childRefresher);
+    return html;
   }
   outerHtml(ids) {
-    return this.groups(ids).map((group) => group.document === this.raw ? group.document.outerHtml(group.ids) : this.call(group.document, "render", { ids: group.ids })).join("");
+    return this.groups(ids).map((group) => group.state === this.state ? group.state.raw.outerHtml(group.locals) : this.call(group.state, "render", { ids: group.locals })).join("");
   }
   attr(id, name) {
-    const handle = this.lookup(id);
-    return this.call(handle.document, "attr", { ids: [handle.local], name }) ?? void 0;
+    const state = this.owner(id);
+    return this.call(state, "attr", { ids: [id - state.base], name }) ?? void 0;
   }
   tagName(id) {
-    const handle = this.lookup(id);
-    return rawOperation(handle.document, "node", { id: handle.local })?.name;
+    const state = this.owner(id);
+    return recordAt(state, id - state.base)?.name;
   }
   exportTree() {
-    return JSON.stringify(JSON.parse(this.raw.exportTree()).map((record) => this.record(this.raw, record)));
+    return JSON.stringify(JSON.parse(this.raw.exportTree()).map((record) => globalRecord(this.state, record)));
   }
   create(html, contextId) {
-    return JSON.parse(this.op("create", JSON.stringify({ html, contextId })));
+    return this.operate("create", { html, contextId });
   }
   op(command, json) {
     return JSON.stringify(this.operate(command, JSON.parse(json)) ?? null);
   }
   operate(command, args) {
     const options = args.options ?? this.options;
-    let result;
+    const hasValue = Object.hasOwn(args, "value");
     if (command === "node") {
-      const handle = this.lookup(args.id);
-      let snapshots = registry2.snapshots.get(handle.document);
-      if (!snapshots) registry2.snapshots.set(handle.document, snapshots = /* @__PURE__ */ new Map());
-      if (!snapshots.has(handle.local)) snapshots.set(handle.local, rawOperation(handle.document, "node", { id: handle.local }));
-      result = this.record(handle.document, snapshots.get(handle.local));
-    } else if (command === "createNode") result = this.global(this.raw, this.call(this.raw, command, args));
-    else if (command === "create") {
-      const context = args.contextId == null ? void 0 : this.lookup(args.contextId);
-      const document = context?.document ?? this.raw;
+      const state = this.owner(args.id);
+      return globalRecord(state, recordAt(state, args.id - state.base));
+    }
+    if (command === "createNode") return this.state.base + this.call(this.state, command, args);
+    if (command === "import") return this.globals(this.state, this.call(this.state, command, args));
+    if (command === "create") {
+      const context = args.contextId == null ? void 0 : this.owner(args.contextId);
+      const state = context ?? this.state;
+      const contextLocal = context ? args.contextId - context.base : void 0;
       if (hasParserHooks(options)) {
-        const contextRecord = context ? rawOperation(context.document, "node", { id: context.local }) : void 0;
-        const parsed = parseNativeDocument(args.html, { ...options, ...contextRecord ? { __contextName: contextRecord.name, __contextNamespace: contextRecord.namespace } : {} }, false);
-        const children2 = rawOperation(parsed, "node", { id: parsed.rootId() }).children;
-        this.move(document, children2);
-        result = children2;
-      } else result = this.globals(document, this.call(document, command, { ...args, contextId: context?.local }));
-    } else if (command === "import") result = this.globals(this.raw, this.call(this.raw, command, args));
-    else if (command === "setNode") {
-      let handle = this.lookup(args.id);
-      let value = args.value;
-      if (args.field === "children") value = this.move(handle.document, value ?? []);
-      else if (["parent", "parentNode", "prev", "previousSibling", "next", "nextSibling"].includes(args.field) && value != null) {
-        const pointer = this.lookup(value);
-        if (pointer.document !== handle.document) {
-          this.move(pointer.document, [args.id]);
-          handle = this.lookup(args.id);
+        const contextRecord = context ? recordAt(context, contextLocal) : void 0;
+        const children = parsedChildren(args.html, { ...options, ...contextRecord ? { __contextName: contextRecord.name, __contextNamespace: contextRecord.namespace } : {} });
+        return this.globals(state, this.moveInto(state, children));
+      }
+      return this.globals(state, this.call(state, command, { ...args, contextId: contextLocal }));
+    }
+    if (command === "setNode" || command === "prop" && hasValue && (args.name === "children" || args.name === "childNodes" || pointerFields.has(args.name))) {
+      const field = command === "setNode" ? args.field : args.name;
+      let result2 = null;
+      for (const id of command === "setNode" ? [args.id] : args.ids ?? []) {
+        let state = this.owner(id);
+        let nodeId2 = id;
+        let value = args.value;
+        if (field === "children" || field === "childNodes") value = this.moveInto(state, value ?? []);
+        else if (pointerFields.has(field) && value != null) {
+          const pointer = this.owner(value);
+          if (pointer !== state) {
+            const moved = [id];
+            this.moveInto(pointer, moved);
+            nodeId2 = moved[0];
+            state = pointer;
+          }
+          value = args.value - pointer.base;
         }
-        value = this.lookup(args.value).local;
+        const local = nodeId2 - state.base;
+        result2 = this.call(state, command, command === "setNode" ? { ...args, id: local, value } : { ...args, ids: [local], value });
       }
-      result = this.call(handle.document, command, { ...args, id: handle.local, value });
-    } else if (command === "insert") {
+      return result2;
+    }
+    if (command === "insert") {
       const targets = args.targetIds ?? [];
       const nodes = args.nodeIds ?? [];
-      result = [];
+      const sameDocument = targets.length > 0 && this.groups([...targets, ...nodes]);
+      if (sameDocument && sameDocument.length === 1) {
+        const { state } = sameDocument[0];
+        const inserted = this.call(state, command, { ...args, targetIds: targets.map((id) => id - state.base), nodeIds: nodes.map((id) => id - state.base) });
+        return this.globals(state, inserted);
+      }
+      const result2 = [];
       for (let index = 0; index < targets.length; index++) {
-        const target = this.lookup(targets[index]);
-        const local = this.move(target.document, nodes, index + 1 < targets.length);
-        const inserted = this.call(target.document, command, { ...args, targetIds: [target.local], nodeIds: local });
-        result.push(...this.globals(target.document, inserted));
+        const target = this.owner(targets[index]);
+        const targetLocal = targets[index] - target.base;
+        const local = this.moveInto(target, nodes, index + 1 < targets.length);
+        const inserted = this.call(target, command, { ...args, targetIds: [targetLocal], nodeIds: local });
+        result2.push(...this.globals(target, inserted));
       }
-    } else if (command === "html" && Object.hasOwn(args, "value") && hasParserHooks(options)) {
-      result = null;
-      for (const id of args.ids ?? []) {
-        const target = this.lookup(id);
-        const record = rawOperation(target.document, "node", { id: target.local });
-        if (!["root", "tag", "script", "style", "cdata"].includes(record.type)) continue;
-        const parsed = parseNativeDocument(String(args.value), { ...options, __contextName: record.name, __contextNamespace: record.namespace }, false);
-        const children2 = rawOperation(parsed, "node", { id: parsed.rootId() }).children;
-        const local = this.move(target.document, children2);
-        result = this.call(target.document, "setNode", { id: target.local, field: "children", value: local, options });
-      }
-    } else if (command === "contains") {
-      const parent = this.lookup(args.container ?? args.parent);
-      const child = this.lookup(args.contained ?? args.child);
-      result = parent.document === child.document && this.call(parent.document, command, { container: parent.local, contained: child.local });
-    } else if (command === "prop" && Object.hasOwn(args, "value") && ["children", "childNodes", "parent", "parentNode", "prev", "previousSibling", "next", "nextSibling"].includes(args.name)) {
-      result = null;
+      return result2;
+    }
+    if (command === "html" && hasValue && hasParserHooks(options)) {
+      let result2 = null;
       for (const id of args.ids ?? []) {
-        let handle = this.lookup(id);
-        let value = args.value;
-        if (args.name === "children" || args.name === "childNodes") value = this.move(handle.document, value ?? []);
-        else if (value != null) {
-          const pointer = this.lookup(value);
-          if (pointer.document !== handle.document) {
-            this.move(pointer.document, [id]);
-            handle = this.lookup(id);
-          }
-          value = this.lookup(args.value).local;
-        }
-        result = this.call(handle.document, command, { ...args, ids: [handle.local], value });
+        const state = this.owner(id);
+        const local = id - state.base;
+        const record = recordAt(state, local);
+        if (!record || !parentTypes.has(record.type)) continue;
+        const children = parsedChildren(String(args.value), { ...options, __contextName: record.name, __contextNamespace: record.namespace });
+        result2 = this.call(state, "setNode", { id: local, field: "children", value: this.moveInto(state, children), options });
       }
-    } else {
-      const ids = command === "select" ? args.contexts ?? [this.rootId()] : args.ids ?? [];
-      const groups = this.groups(ids);
-      const mixed = new Set(groups.map((group) => group.document)).size > 1;
-      if (mixed && ["select", "matches", "uniqueSort", "serializeArray", "serialize", "extractPlan"].includes(command)) result = this.scratch(command, { ...args, options }, ids);
-      else if (command === "extractPlan") {
-        const group = groups[0];
-        result = this.call(group?.document ?? this.raw, command, { ...args, options, ids: group?.ids ?? [] });
-      } else if (["select", "matches", "uniqueSort", "traverse", "clone"].includes(command)) {
-        result = [];
-        if (!groups.length && (command === "select" || command === "matches")) result = this.call(this.raw, command, { ...args, options, ids: [], ...command === "select" ? { contexts: [] } : {} });
-        for (const group of groups) {
-          const values = this.call(group.document, command, { ...args, options, ids: group.ids, ...command === "select" ? { contexts: group.ids } : {}, ...args.pseudoMatches ? { pseudoMatches: Object.fromEntries(Object.entries(args.pseudoMatches).map(([key, values2]) => [key, values2.map((id) => this.lookup(id)).filter((handle) => handle.document === group.document).map((handle) => handle.local)])) } : {} });
-          result.push(...this.globals(group.document, values));
-        }
-      } else if (["render", "outerHtml", "text"].includes(command) && !Object.hasOwn(args, "value")) result = groups.map((group) => this.call(group.document, command, { ...args, options, ids: group.ids })).join("");
-      else if (command === "hasClass") result = groups.some((group) => this.call(group.document, command, { ...args, options, ids: group.ids }));
-      else if (["serializeArray", "serialize"].includes(command)) result = groups.length ? this.call(groups[0].document, command, { ...args, options, ids: groups[0].ids }) : command === "serializeArray" ? [] : "";
-      else {
-        if (command === "html") for (const group of groups) registry2.snapshots.delete(group.document);
-        const writes = Object.hasOwn(args, "value") || ["remove", "removeAttr", "removeData", "addClass", "removeClass", "toggleClass"].includes(command);
-        const active = writes ? groups : groups.slice(0, 1);
-        result = null;
-        for (const group of active) result = this.call(group.document, command, { ...args, options, ids: group.ids });
+      return result2;
+    }
+    if (command === "contains") {
+      const container = args.container ?? args.parent;
+      const contained = args.contained ?? args.child;
+      const parent = this.owner(container);
+      const isSameDocument = contained >= parent.base && contained < parent.base + STRIDE2;
+      return isSameDocument && this.call(parent, command, { container: container - parent.base, contained: contained - parent.base });
+    }
+    const ids = command === "select" ? args.contexts ?? [this.rootId()] : args.ids ?? [];
+    const groups = this.groups(ids);
+    if (this.isMixed(groups) && scratchCommands.has(command)) return this.scratch(command, { ...args, options }, ids) ?? null;
+    if (command === "extractPlan") {
+      const group = groups[0];
+      return this.call(group?.state ?? this.state, command, { ...args, options, ids: group?.locals ?? [] }) ?? null;
+    }
+    if (idResultCommands.has(command)) {
+      const isSelect = command === "select";
+      if (!groups.length && (isSelect || command === "matches")) return this.call(this.state, command, { ...args, options, ids: [], ...isSelect ? { contexts: [] } : {} });
+      const result2 = [];
+      for (const group of groups) {
+        const pseudoMatches = args.pseudoMatches ? Object.fromEntries(Object.entries(args.pseudoMatches).map(([key, values2]) => [key, values2.filter((id) => id >= group.state.base && id < group.state.base + STRIDE2).map((id) => id - group.state.base)])) : void 0;
+        const values = this.call(group.state, command, { ...args, options, ids: group.locals, ...isSelect ? { contexts: group.locals } : {}, ...pseudoMatches ? { pseudoMatches } : {} });
+        result2.push(...this.globals(group.state, values));
       }
+      return result2;
+    }
+    if (command === "render" && !hasValue) {
+      const optionsJson = JSON.stringify(options);
+      return groups.map((group) => group.state.raw.render ? group.state.raw.render(group.locals, optionsJson) : this.call(group.state, command, { ...args, options, ids: group.locals })).join("");
     }
+    if ((command === "outerHtml" || command === "text") && !hasValue) return groups.map((group) => this.call(group.state, command, { ...args, options, ids: group.locals })).join("");
+    if (command === "hasClass") return groups.some((group) => this.call(group.state, command, { ...args, options, ids: group.locals }));
+    if (command === "serializeArray" || command === "serialize") return groups.length ? this.call(groups[0].state, command, { ...args, options, ids: groups[0].locals }) : command === "serializeArray" ? [] : "";
+    if (command === "html") for (const group of groups) invalidate(group.state);
+    const isWrite = hasValue || writeCommands.has(command);
+    let result = null;
+    for (const group of isWrite ? groups : groups.slice(0, 1)) result = this.call(group.state, command, { ...args, options, ids: group.locals });
     return result ?? null;
   }
 };
+function parsedChildren(html, options) {
+  const parsed = parseNativeDocument(html, options, false);
+  exposeState(parsed.state);
+  return parsed.operate("node", { id: parsed.rootId() }).children;
+}
+function dataEntry(state, id) {
+  const local = id - state.base;
+  let entry = state.data.get(local);
+  if (!entry) state.data.set(local, entry = { state, local });
+  return entry;
+}
+function rehome(source, target, mapping, ids) {
+  registry2.writes++;
+  invalidate(source);
+  invalidate(target);
+  exposeState(target);
+  const moved = /* @__PURE__ */ new Map();
+  for (const [oldLocal, newLocal] of mapping) {
+    moved.set(source.base + oldLocal, target.base + newLocal);
+    const node = uncacheView(source, oldLocal);
+    if (node) {
+      node[VIEW_STATE] = target;
+      node[VIEW_LOCAL] = newLocal;
+      cacheView(target, newLocal, node);
+      if (node[VIEW_CHILD_TARGET]) target.hasChildLists = true;
+    }
+    const entry = source.data.get(oldLocal);
+    if (entry) {
+      source.data.delete(oldLocal);
+      entry.state = target;
+      entry.local = newLocal;
+      target.data.set(newLocal, entry);
+    }
+    const adapterNode = source.adapterNodes?.[oldLocal];
+    if (adapterNode) {
+      source.adapterNodes[oldLocal] = void 0;
+      (target.adapterNodes ??= [])[newLocal] = adapterNode;
+      adapterNode[VIEW_STATE] = target;
+      adapterNode[VIEW_LOCAL] = newLocal;
+    }
+  }
+  const rewrite = (list) => {
+    let isTouched = false;
+    for (let index = 0; index < list.length; index++) {
+      const next = moved.get(list[index]);
+      if (next !== void 0) {
+        list[index] = next;
+        isTouched = true;
+      }
+    }
+    return isTouched;
+  };
+  for (const lease of [...source.leases]) {
+    if (!rewrite(lease.ids)) continue;
+    target.leases.add(lease);
+    if (!lease.states.includes(target)) lease.states.push(target);
+    if (!lease.ids.some((id) => id >= source.base && id < source.base + STRIDE2)) {
+      source.leases.delete(lease);
+      lease.states = lease.states.filter((state) => state !== source);
+    }
+  }
+  rewrite(ids);
+}
+function refreshWrittenAttributes(state, command, args) {
+  if (!hasViews(state)) return;
+  let locals;
+  if (targetedAttributeWrites.has(command)) locals = args.ids ?? [];
+  else if (command === "setNode") {
+    if (!attributeFields.has(args.field)) return;
+    locals = [args.id];
+  } else if (structuralWrites.has(command)) return;
+  const refresh = (view) => {
+    if (view && view[VIEW_ATTRIBUTES]) attributeRefresher?.(view);
+  };
+  if (locals) for (const local of locals) refresh(cachedView(state, local));
+  else forEachView(state, refresh);
+}
+var attributeRefresher;
+var childRefresher;
+function onViewRefresh(attributes, children) {
+  attributeRefresher = attributes;
+  childRefresher = children;
+}
+function refreshChildLists(state) {
+  if (!state.hasChildLists || !childRefresher) return;
+  const touched = state.raw.takeTouched?.();
+  if (touched === void 0) return;
+  if (touched === null) {
+    forEachView(state, childRefresher);
+    return;
+  }
+  for (const local of touched) {
+    const view = cachedView(state, local);
+    if (view) childRefresher(view);
+  }
+}
 function routeDocument(document, options = {}) {
   return document.nodeSpace === registry2.space ? document : new RoutedDocument(document, options);
 }
+function routedFor(state) {
+  return state.routed ??= new RoutedDocument(state.raw, state.options);
+}
 function sameNodeSpace(first, second) {
   return first === second || !!first.nodeSpace && first.nodeSpace === second.nodeSpace;
 }
+function isLocalState(state) {
+  return state.space === registry2.space;
+}
+function isRouted(document) {
+  return document.nodeSpace === registry2.space;
+}
 
 // src/nodes.ts
-var nodeStateKey = /* @__PURE__ */ Symbol.for("rusteerio.native-node-views.v2");
-var nodeGlobals = globalThis;
-var nodeState = nodeGlobals[nodeStateKey] ??= { views: /* @__PURE__ */ new WeakMap(), bindings: /* @__PURE__ */ new WeakMap(), caches: /* @__PURE__ */ new WeakMap(), finalizer: new FinalizationRegistry(({ cache, id }) => {
-  if (!cache.get(id)?.deref()) cache.delete(id);
-}) };
-var { bindings, caches } = nodeState;
-var arrayIndex = /^(?:0|[1-9]\d*)$/;
+var VIEW_CHILDREN = /* @__PURE__ */ Symbol.for("rusteerio.node.children");
+var emptyRecord = Object.freeze({ id: -1, type: "released", children: [] });
 function operation(document, command, args = {}) {
   const direct = document.operate;
   if (direct) return direct.call(document, command, args);
   const value = document.op(command, JSON.stringify(args));
   return value === void 0 || value === "" ? void 0 : JSON.parse(value);
 }
+function viewId(node) {
+  const view = node;
+  const state = view?.[VIEW_STATE];
+  return state !== void 0 && view[VIEW_SELF] === view && isLocalState(state) ? state.base + view[VIEW_LOCAL] : void 0;
+}
+function isNativeNode(node) {
+  const view = node;
+  return view?.[VIEW_STATE] !== void 0 && view[VIEW_SELF] === view;
+}
+function viewIdIn(document, node) {
+  const id = viewId(node);
+  if (id !== void 0) exposeTo(document, node[VIEW_STATE]);
+  return id;
+}
 function nodeBinding(node) {
-  return node && typeof node === "object" ? bindings.get(node) : void 0;
+  const id = node && typeof node === "object" ? viewId(node) : void 0;
+  return id === void 0 ? void 0 : { document: routedFor(node[VIEW_STATE]), id };
 }
 function nodeId(node, document) {
-  const binding = nodeBinding(node);
-  return binding && (!document || sameNodeSpace(document, binding.document)) ? binding.id : void 0;
+  const id = node && typeof node === "object" ? viewId(node) : void 0;
+  return id !== void 0 && (!document || isRouted(document)) ? id : void 0;
 }
 function hydrateLocation(location) {
   if (!location || typeof location !== "object") return location;
@@ -895,26 +1704,201 @@ function hydrateLocation(location) {
   return location;
 }
 function nodeRecord(document, id) {
-  return operation(document, "node", { id });
+  if (!isRouted(document)) return operation(document, "node", { id });
+  const state = stateIn(document, id);
+  return recordAt(state, id - state.base);
+}
+var isElementType = (type) => type === "tag" || type === "script" || type === "style";
+function traverseRecords(document, ids, kind) {
+  if (!isRouted(document)) return void 0;
+  const result = [];
+  for (const id of ids) {
+    const state = stateIn(document, id);
+    const { base } = state;
+    const node = recordAt(state, id - base);
+    if (!node) continue;
+    const isElement2 = (local) => isElementType(recordAt(state, local)?.type);
+    if (kind === "children") {
+      for (const child of node.children ?? []) if (isElement2(child)) result.push(base + child);
+    } else if (kind === "contents") {
+      for (const child of node.children ?? []) result.push(base + child);
+    } else if (kind === "parent") {
+      if (node.parent != null && isElement2(node.parent)) result.push(base + node.parent);
+    } else if (kind === "parents" || kind === "ancestors") {
+      const seen = /* @__PURE__ */ new Set();
+      for (let parent = node.parent; parent != null && !seen.has(parent); ) {
+        seen.add(parent);
+        const ancestor = recordAt(state, parent);
+        if (!ancestor || ancestor.type === "root") break;
+        if (isElementType(ancestor.type)) result.push(base + parent);
+        parent = ancestor.parent;
+      }
+    } else if (kind === "next" || kind === "prev" || kind === "nextAll" || kind === "prevAll") {
+      const isForward = kind === "next" || kind === "nextAll";
+      const isSingle = kind === "next" || kind === "prev";
+      const seen = /* @__PURE__ */ new Set();
+      for (let sibling = isForward ? node.next : node.prev; sibling != null && !seen.has(sibling); ) {
+        seen.add(sibling);
+        const record = recordAt(state, sibling);
+        if (!record) break;
+        if (isElementType(record.type)) {
+          result.push(base + sibling);
+          if (isSingle) break;
+        }
+        sibling = isForward ? record.next : record.prev;
+      }
+    } else if (kind === "siblings") {
+      const parent = node.parent == null ? null : recordAt(state, node.parent);
+      const local = id - base;
+      for (const other of parent?.children ?? []) if (other !== local && isElement2(other)) result.push(base + other);
+    } else return void 0;
+  }
+  return result;
+}
+function viewAt(state, local) {
+  const existing = state.views[local] ?? cachedView(state, local);
+  if (existing) return existing;
+  const parsed = state.adapterNodes?.[local];
+  if (parsed) {
+    state.adapterNodes[local] = void 0;
+    return adoptObject(state, local, parsed);
+  }
+  const snapshot = plainSnapshot(state, local);
+  let constructor;
+  if (snapshot) constructor = viewConstructor(snapshot.typeOf(local), false);
+  else {
+    const record = recordAt(state, local);
+    if (!record) return void 0;
+    constructor = viewConstructor(record.type, record.sourceCodeLocation !== void 0);
+  }
+  const view = new constructor(state, local);
+  cacheView(state, local, view);
+  return view;
+}
+function rootNode(document, id) {
+  if (!isRouted(document)) throw new TypeError("Native nodes require a routed document");
+  const state = stateIn(document, id);
+  const local = id - state.base;
+  const existing = cachedView(state, local);
+  if (existing) return existing;
+  if (state.adapterNodes?.[local] || state.options.sourceCodeLocationInfo) return viewAt(state, local);
+  const view = new (viewConstructor("root", false))(state, local);
+  cacheView(state, local, view);
+  return view;
+}
+function getNode(document, id, original) {
+  if (!isRouted(document)) throw new TypeError("Native nodes require a routed document");
+  const state = stateIn(document, id);
+  const local = id - state.base;
+  if (original === void 0) return viewAt(state, local);
+  return adoptObject(state, local, original);
+}
+function viewRecord(view) {
+  const state = view[VIEW_STATE];
+  const local = view[VIEW_LOCAL];
+  return state.records[local] ?? recordAt(state, local) ?? emptyRecord;
+}
+function linkedView(view, local) {
+  return local == null ? null : viewAt(view[VIEW_STATE], local) ?? null;
+}
+function setField(view, field, value) {
+  const state = view[VIEW_STATE];
+  operation(routedFor(state), "setNode", { id: state.base + view[VIEW_LOCAL], field, value });
 }
-function setField(document, id, field, value) {
-  operation(document, "setNode", { id, field, value });
+function setPointer(view, field, value) {
+  setField(view, field, value == null ? null : importNodes(routedFor(view[VIEW_STATE]), [value])[0]);
 }
-function attributes(document, id, field = "attribs", prototype = document.options?._useHtmlParser2 === false ? null : Object.prototype) {
-  const read = () => nodeRecord(document, id)?.[field] ?? {};
+function attributesOf(view) {
+  const state = view[VIEW_STATE];
+  let attributes = view[VIEW_ATTRIBUTES];
+  if (!attributes) view[VIEW_ATTRIBUTES] = attributes = createAttributes(view, state.options._useHtmlParser2 === false ? null : Object.prototype);
+  if (attributes.generation !== state.generation || attributes.state !== state) syncAttributes(view, attributes);
+  return attributes.proxy;
+}
+function createAttributes(view, prototype) {
   const target = Object.create(prototype);
+  const handler = Object.create(attributeWrites);
+  handler.view = view;
+  handler.target = target;
+  handler.generation = -1;
+  handler.state = view[VIEW_STATE];
+  handler.proxy = new Proxy(target, handler);
+  return handler;
+}
+function syncAttributes(view, attributes) {
+  const { target } = attributes;
+  const state = view[VIEW_STATE];
+  const local = view[VIEW_LOCAL];
+  if (attributes.generation === -1) {
+    const snapshot = plainSnapshot(state, local);
+    if (snapshot) {
+      snapshot.copyAttributes(local, target);
+      attributes.generation = state.generation;
+      return;
+    }
+  }
+  const values = viewRecord(view).attribs ?? {};
+  const keys = Object.keys(target);
+  const nextKeys = Object.keys(values);
+  let isSameOrder = keys.length === nextKeys.length;
+  for (let index = 0; isSameOrder && index < keys.length; index++) isSameOrder = keys[index] === nextKeys[index];
+  if (!isSameOrder) for (const key of keys) delete target[key];
+  for (const key of nextKeys) {
+    if (isSameOrder && target[key] === values[key]) continue;
+    if (key === "__proto__") Object.defineProperty(target, key, { value: values[key], writable: true, enumerable: true, configurable: true });
+    else target[key] = values[key];
+  }
+  attributes.generation = view[VIEW_STATE].generation;
+  attributes.state = view[VIEW_STATE];
+}
+function refreshAttributes(view) {
+  const attributes = view[VIEW_ATTRIBUTES];
+  if (attributes) syncAttributes(view, attributes);
+}
+onViewRefresh(refreshAttributes, fillChildren);
+var attributeWrites = {
+  set(target, key, value) {
+    if (typeof key === "symbol") return Reflect.set(target, key, value);
+    const view = this.view;
+    setField(view, "attribs", { ...viewRecord(view).attribs, [key]: String(value) });
+    syncAttributes(view, view[VIEW_ATTRIBUTES]);
+    return true;
+  },
+  deleteProperty(target, key) {
+    if (typeof key === "symbol") return Reflect.deleteProperty(target, key);
+    const view = this.view;
+    const values = { ...viewRecord(view).attribs };
+    delete values[key];
+    setField(view, "attribs", values);
+    syncAttributes(view, view[VIEW_ATTRIBUTES]);
+    return true;
+  },
+  defineProperty(target, key, descriptor) {
+    if (typeof key === "symbol") return Reflect.defineProperty(target, key, descriptor);
+    const view = this.view;
+    setField(view, "attribs", { ...viewRecord(view).attribs, [key]: String(descriptor.value) });
+    syncAttributes(view, view[VIEW_ATTRIBUTES]);
+    return true;
+  }
+};
+function attributeMap(view, field) {
+  const read = () => viewRecord(view)[field] ?? {};
+  const target = Object.create(view[VIEW_STATE].options._useHtmlParser2 === false ? null : Object.prototype);
+  const viewField = `x-${field}`;
   return new Proxy(target, {
     get(_target, key) {
-      return typeof key === "symbol" ? Reflect.get(target, key) : Object.hasOwn(read(), key) ? read()[key] : Reflect.get(target, key);
+      if (typeof key === "symbol") return Reflect.get(target, key);
+      const values = read();
+      return Object.hasOwn(values, key) ? values[key] : Reflect.get(target, key);
     },
     set(_target, key, value) {
-      setField(document, id, field, { ...read(), [key]: String(value) });
+      setField(view, viewField, { ...read(), [key]: String(value) });
       return true;
     },
     deleteProperty(_target, key) {
       const values = { ...read() };
       delete values[key];
-      setField(document, id, field, values);
+      setField(view, viewField, values);
       return true;
     },
     ownKeys() {
@@ -924,247 +1908,358 @@ function attributes(document, id, field = "attribs", prototype = document.option
       return Object.hasOwn(read(), key) || key in target;
     },
     getOwnPropertyDescriptor(_target, key) {
-      return Object.hasOwn(read(), key) ? { value: read()[key], writable: true, enumerable: true, configurable: true } : void 0;
+      const values = read();
+      return Object.hasOwn(values, key) ? { value: values[key], writable: true, enumerable: true, configurable: true } : void 0;
     },
     defineProperty(_target, key, descriptor) {
-      const values = { ...read(), [key]: String(descriptor.value) };
-      setField(document, id, field, values);
+      setField(view, viewField, { ...read(), [key]: String(descriptor.value) });
       return true;
     }
   });
 }
-function children(document, id) {
-  const read = () => nodeRecord(document, id)?.children ?? [];
-  const snapshot = () => read().map((child) => getNode(document, child));
-  const save = (nodes) => setField(document, id, "children", importNodes(document, nodes));
-  const mutating = /* @__PURE__ */ new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "copyWithin", "fill"]);
-  const target = [];
-  return new Proxy(target, {
-    get(_target, key, receiver) {
-      if (key === "length") return read().length;
-      if (typeof key === "string" && arrayIndex.test(key)) {
-        const child = read()[Number(key)];
-        return child === void 0 ? void 0 : getNode(document, child);
-      }
-      if (typeof key === "string" && mutating.has(key)) return (...args) => {
-        const values = snapshot();
-        const result = Reflect.apply(Array.prototype[key], values, args);
-        save(values);
-        return result === values ? receiver : result;
-      };
-      return Reflect.get(target, key, receiver);
-    },
-    set(_target, key, value) {
-      const values = snapshot();
-      if (key === "length") values.length = value;
-      else if (typeof key === "string" && arrayIndex.test(key)) values[Number(key)] = value;
-      else return Reflect.set(target, key, value);
-      save(values);
-      return true;
-    },
-    deleteProperty(_target, key) {
-      if (typeof key === "string" && arrayIndex.test(key)) {
-        const values = snapshot();
-        values.splice(Number(key), 1);
-        save(values);
-        return true;
-      }
-      return Reflect.deleteProperty(target, key);
-    },
-    has(_target, key) {
-      return typeof key === "string" && arrayIndex.test(key) ? Number(key) < read().length : Reflect.has(target, key);
-    },
-    ownKeys() {
-      return [...read().map((_child, i) => String(i)), "length"];
-    },
-    getOwnPropertyDescriptor(_target, key) {
-      if (key === "length") return { ...Reflect.getOwnPropertyDescriptor(target, "length"), value: read().length };
-      if (typeof key === "string" && arrayIndex.test(key) && Number(key) < read().length) return { value: getNode(document, read()[Number(key)]), writable: true, enumerable: true, configurable: true };
-      return Reflect.getOwnPropertyDescriptor(target, key);
+var ChildArray = class _ChildArray extends Array {
+  #view;
+  constructor(view) {
+    super();
+    this.#view = view;
+  }
+  static viewOf(list) {
+    return list instanceof _ChildArray ? list.#view : void 0;
+  }
+};
+Object.defineProperty(ChildArray.prototype, "constructor", { configurable: true, writable: true, value: Array });
+for (const method of ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "copyWithin", "fill"]) {
+  Object.defineProperty(ChildArray.prototype, method, {
+    configurable: true,
+    writable: true,
+    value(...args) {
+      const view = ChildArray.viewOf(this);
+      if (!view) return Reflect.apply(Array.prototype[method], this, args);
+      const values = Array.from(this);
+      const result = Reflect.apply(Array.prototype[method], values, args);
+      saveChildren(view, values);
+      return result === values ? this : result;
     }
   });
 }
-var parentAliases = { parentNode: "parent", previousSibling: "prev", nextSibling: "next" };
-var sourceFields = /* @__PURE__ */ new Set(["type", "name", "data", "namespace", "prefix", "startIndex", "endIndex", "sourceCodeLocation", "x-name", "x-publicId", "x-systemId", "x-mode"]);
-var tagTypes = /* @__PURE__ */ new Set(["tag", "script", "style"]);
-var parentTypes = /* @__PURE__ */ new Set(["root", "tag", "script", "style", "cdata"]);
-var dataTypes = /* @__PURE__ */ new Set(["text", "comment", "directive"]);
-function viewKeys(record) {
-  const keys = ["parent", "prev", "next", "startIndex", "endIndex"];
-  if (parentTypes.has(record.type)) keys.push("children");
-  if (record.data !== void 0) keys.push("data");
-  if (record.name !== void 0) keys.push("name");
-  if (tagTypes.has(record.type)) keys.push("attribs");
-  keys.push("type");
-  for (const field of sourceFields) if (!keys.includes(field) && field in record) keys.push(field);
-  if (tagTypes.has(record.type)) {
-    if ("attribsNamespace" in record) keys.push("x-attribsNamespace");
-    if ("attribsPrefix" in record) keys.push("x-attribsPrefix");
-  }
-  return keys;
-}
-function viewValue(state, key, receiver) {
-  const { document, id } = state;
-  const record = nodeRecord(document, id);
-  if (key === "cloneNode") return cloneNode;
-  if (key === "nodeType") return { root: 9, text: 3, comment: 8, cdata: 4 }[record.type] ?? 1;
-  if (key === "tagName" && tagTypes.has(record.type)) return record.name;
-  if (key === "nodeValue" && dataTypes.has(record.type)) return record.data;
-  const pointer = parentAliases[key] ?? key;
-  if (["parent", "prev", "next"].includes(pointer)) return record[pointer] == null ? null : getNode(document, record[pointer]);
-  if (["children", "childNodes", "firstChild", "lastChild"].includes(key) && parentTypes.has(record.type)) {
-    const list = state.children ??= children(document, id);
-    return key === "firstChild" ? list[0] ?? null : key === "lastChild" ? list[list.length - 1] ?? null : list;
-  }
-  if (key === "attribs" && tagTypes.has(record.type)) return state.attributes ??= attributes(document, id);
-  if ((key === "x-attribsNamespace" && "attribsNamespace" in record || key === "x-attribsPrefix" && "attribsPrefix" in record) && tagTypes.has(record.type)) {
-    state.maps ??= {};
-    return state.maps[key] ??= attributes(document, id, key === "x-attribsNamespace" ? "attribsNamespace" : "attribsPrefix");
-  }
-  if (key === "attributes" && tagTypes.has(record.type)) {
-    const attrs = state.attributes ??= attributes(document, id);
-    return Object.keys(attrs).map((name) => ({ name, value: attrs[name], namespace: record.attribsNamespace?.[name], prefix: record.attribsPrefix?.[name] }));
-  }
-  if (key === "sourceCodeLocation") return hydrateLocation(record[key]);
-  if (sourceFields.has(key)) return record[key] ?? (key === "startIndex" || key === "endIndex" ? null : void 0);
-  return void 0;
+function saveChildren(view, values) {
+  setField(view, "children", importNodes(routedFor(view[VIEW_STATE]), values));
 }
-function writeView(state, key, value) {
-  const { document, id } = state;
-  const record = nodeRecord(document, id);
-  if (key === "tagName" && tagTypes.has(record.type)) key = "name";
-  else if (key === "nodeValue" && dataTypes.has(record.type)) key = "data";
-  else if (key === "childNodes") key = "children";
-  else key = parentAliases[key] ?? key;
-  if (sourceFields.has(key) || ["attribs", "x-attribsNamespace", "x-attribsPrefix"].includes(key)) {
-    setField(document, id, key, value);
-    return true;
-  }
-  if (key === "children" && parentTypes.has(record.type)) {
-    setField(document, id, key, importNodes(document, value));
-    return true;
-  }
-  if (["parent", "prev", "next"].includes(key)) {
-    setField(document, id, key, value == null ? null : importNodes(document, [value])[0]);
-    return true;
-  }
-  return false;
+function childList(view) {
+  const existing = view[VIEW_CHILDREN];
+  if (existing) return existing;
+  const state = view[VIEW_STATE];
+  if (!state.hasChildLists) {
+    state.hasChildLists = true;
+    state.raw.takeTouched?.();
+  }
+  const list = new ChildArray(view);
+  view[VIEW_CHILD_TARGET] = list;
+  view[VIEW_CHILDREN] = list;
+  fillChildren(view);
+  return list;
+}
+function fillChildren(view) {
+  const target = view[VIEW_CHILD_TARGET];
+  if (!target) return;
+  const state = view[VIEW_STATE];
+  const local = view[VIEW_LOCAL];
+  const snapshot = plainSnapshot(state, local);
+  if (snapshot && state.stale.size === 0) {
+    fillFromSnapshot(state, snapshot, local, target);
+    return;
+  }
+  const locals = viewRecord(view).children ?? [];
+  target.length = locals.length;
+  for (let index = 0; index < locals.length; index++) target[index] = viewAt(state, locals[index]);
 }
-var nodeHandler = {
-  get(target, key, receiver) {
-    if (Reflect.getOwnPropertyDescriptor(target, key)) return Reflect.get(target, key, receiver);
-    if (typeof key === "string") {
-      const state = nodeState.views.get(target);
-      if (key === "cloneNode" || key === "nodeType" || sourceFields.has(key) || ["tagName", "nodeValue", "parent", "prev", "next", "parentNode", "previousSibling", "nextSibling", "children", "childNodes", "firstChild", "lastChild", "attribs", "attributes", "x-attribsNamespace", "x-attribsPrefix"].includes(key)) return viewValue(state, key, receiver);
+function fillFromSnapshot(state, snapshot, local, target) {
+  const count = snapshot.childCount(local);
+  const first = snapshot.childStart(local);
+  const childIds2 = snapshot.childIds;
+  const views = state.views;
+  const isStrong = !state.adapterNodes;
+  const constructors = snapshotConstructors(snapshot);
+  target.length = count;
+  for (let index = 0; index < count; index++) {
+    const child = childIds2[first + index];
+    let node = views[child] ?? (state.weakViews.size ? cachedView(state, child) : void 0);
+    if (node === void 0) {
+      const constructor = isStrong && child < state.baseline && snapshot.isPlain(child) ? constructors(snapshot.typeReference(child)) : void 0;
+      if (constructor) views[child] = node = new constructor(state, child);
+      else node = viewAt(state, child);
     }
-    return Reflect.get(target, key, receiver);
-  },
-  set(target, key, value, receiver) {
-    if (Reflect.getOwnPropertyDescriptor(target, key)) return Reflect.set(target, key, value, receiver);
-    if (typeof key === "string" && writeView(nodeState.views.get(target), key, value)) return true;
-    return Reflect.set(target, key, value, receiver);
+    target[index] = node;
+  }
+}
+function snapshotConstructors(snapshot) {
+  let lookup = snapshot.viewConstructors;
+  if (!lookup) {
+    const byReference = [];
+    lookup = (reference) => byReference[reference] ??= viewConstructor(snapshot.name(reference), false);
+    snapshot.viewConstructors = lookup;
+  }
+  return lookup;
+}
+var recordField = (field, fallback) => ({
+  get() {
+    return viewRecord(this)[field] ?? fallback;
   },
-  has(target, key) {
-    return Reflect.has(target, key) || typeof key === "string" && (viewKeys(nodeRecord(nodeState.views.get(target).document, nodeState.views.get(target).id)).includes(key) || ["cloneNode", "nodeType", "parentNode", "previousSibling", "nextSibling"].includes(key));
+  set(value) {
+    setField(this, field, value);
+  }
+});
+var snapshotField = (field) => ({
+  get() {
+    const state = this[VIEW_STATE];
+    const local = this[VIEW_LOCAL];
+    const snapshot = plainSnapshot(state, local);
+    if (snapshot) return field === "type" ? snapshot.typeOf(local) : field === "name" ? snapshot.nameOf(local) : snapshot.dataOf(local);
+    return viewRecord(this)[field];
   },
-  ownKeys(target) {
-    const state = nodeState.views.get(target);
-    return [.../* @__PURE__ */ new Set([...viewKeys(nodeRecord(state.document, state.id)), ...Reflect.ownKeys(target)])];
+  set(value) {
+    setField(this, field, value);
+  }
+});
+var linkOffsets = { parent: 1, prev: 2, next: 3 };
+var pointerField = (field) => ({
+  get() {
+    const state = this[VIEW_STATE];
+    const local = this[VIEW_LOCAL];
+    const snapshot = plainSnapshot(state, local);
+    return linkedView(this, snapshot ? snapshot.linkOf(local, linkOffsets[field]) : viewRecord(this)[field]);
   },
-  getOwnPropertyDescriptor(target, key) {
-    const existing = Reflect.getOwnPropertyDescriptor(target, key);
-    if (existing) return existing;
-    const state = nodeState.views.get(target);
-    if (typeof key === "string" && viewKeys(nodeRecord(state.document, state.id)).includes(key)) return { value: viewValue(state, key, void 0), configurable: true, enumerable: true, writable: true };
-    return void 0;
+  set(value) {
+    setPointer(this, field, value);
   }
+});
+var nodeAccessors = {
+  type: snapshotField("type"),
+  parent: pointerField("parent"),
+  prev: pointerField("prev"),
+  next: pointerField("next"),
+  startIndex: recordField("startIndex", null),
+  endIndex: recordField("endIndex", null)
 };
-function getNode(document, id, original) {
-  const cacheKey = document.nodeSpace ?? document;
-  let cache = caches.get(cacheKey);
-  if (!cache) caches.set(cacheKey, cache = /* @__PURE__ */ new Map());
-  const existing = cache.get(id)?.deref();
-  if (existing) return existing;
-  document = document.nodeDocument?.(id) ?? document;
-  const lease = document.retainNodes?.([id]);
-  const record = nodeRecord(document, id);
-  if (!record) return void 0;
-  if (original === void 0) {
-    const target = Object.create(nodePrototype(record.type));
-    const node2 = new Proxy(target, nodeHandler);
-    nodeState.views.set(target, { document, id, lease });
-    cache.set(id, new WeakRef(node2));
-    nodeState.finalizer.register(node2, { cache, id });
-    bindings.set(node2, { document, id });
-    return node2;
-  }
-  const node = original;
-  cache.set(id, new WeakRef(node));
-  nodeState.finalizer.register(node, { cache, id });
-  bindings.set(node, { document, id });
-  const read = () => {
-    void lease;
-    return nodeRecord(document, id);
+var locationAccessor = { get() {
+  return hydrateLocation(viewRecord(this).sourceCodeLocation);
+}, set(value) {
+  setField(this, "sourceCodeLocation", value);
+} };
+var childAccessors = {
+  children: { get() {
+    return childList(this);
+  }, set(value) {
+    setField(this, "children", importNodes(routedFor(this[VIEW_STATE]), value));
+  } }
+};
+var elementAccessors = {
+  name: snapshotField("name"),
+  attribs: { get() {
+    return attributesOf(this);
+  }, set(value) {
+    setField(this, "attribs", value);
+  } },
+  namespace: recordField("namespace"),
+  prefix: recordField("prefix"),
+  "x-attribsNamespace": { get() {
+    return viewRecord(this).attribsNamespace !== void 0 ? attributeMap(this, "attribsNamespace") : void 0;
+  }, set(value) {
+    setField(this, "x-attribsNamespace", value);
+  } },
+  "x-attribsPrefix": { get() {
+    return viewRecord(this).attribsPrefix !== void 0 ? attributeMap(this, "attribsPrefix") : void 0;
+  }, set(value) {
+    setField(this, "x-attribsPrefix", value);
+  } }
+};
+var dataAccessors = { data: snapshotField("data") };
+var directiveAccessors = { name: recordField("name"), "x-name": recordField("x-name"), "x-publicId": recordField("x-publicId"), "x-systemId": recordField("x-systemId") };
+var documentAccessors = { "x-mode": recordField("x-mode") };
+function accessorsFor(type) {
+  switch (type) {
+    case "tag":
+    case "script":
+    case "style":
+      return { ...nodeAccessors, ...childAccessors, ...elementAccessors };
+    case "root":
+      return { ...nodeAccessors, ...childAccessors, ...documentAccessors };
+    case "cdata":
+      return { ...nodeAccessors, ...childAccessors };
+    case "directive":
+      return { ...nodeAccessors, ...dataAccessors, ...directiveAccessors };
+    case "text":
+    case "comment":
+      return { ...nodeAccessors, ...dataAccessors };
+    default:
+      return { ...nodeAccessors, ...childAccessors, ...dataAccessors, name: recordField("name") };
+  }
+}
+var viewConstructors = /* @__PURE__ */ new Map();
+var plainConstructors = /* @__PURE__ */ Object.create(null);
+function viewConstructor(type, hasLocation) {
+  if (!hasLocation) {
+    const plain = plainConstructors[type];
+    if (plain) return plain;
+  }
+  const key = hasLocation ? `${type}:location` : type;
+  let constructor = viewConstructors.get(key);
+  if (constructor) return constructor;
+  const prototype = Object.create(nodePrototype(type));
+  const accessors = hasLocation ? { ...accessorsFor(type), sourceCodeLocation: locationAccessor } : accessorsFor(type);
+  for (const [field, accessor] of Object.entries(accessors)) Object.defineProperty(prototype, field, { ...accessor, configurable: true, enumerable: false });
+  constructor = function(state, local) {
+    this[VIEW_STATE] = state;
+    this[VIEW_LOCAL] = local;
+    this[VIEW_SELF] = this;
+    this[VIEW_ATTRIBUTES] = void 0;
+    this[VIEW_CHILDREN] = void 0;
+    this[VIEW_CHILD_TARGET] = void 0;
   };
-  const define = (key, get, set, enumerable = true) => {
-    try {
-      Object.defineProperty(node, key, { configurable: true, enumerable, get, ...set ? { set } : {} });
-    } catch {
+  Object.defineProperty(prototype, inspectSymbol, { configurable: true, writable: true, value: inspectNode });
+  constructor.prototype = prototype;
+  viewConstructors.set(key, constructor);
+  if (!hasLocation) plainConstructors[type] = constructor;
+  return constructor;
+}
+var inspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var inspectedFields = ["type", "name", "data", "attribs", "namespace", "startIndex", "endIndex"];
+function inspectNode(depth, options, inspect) {
+  const fields = {};
+  for (const field of inspectedFields) if (field in this && this[field] != null) fields[field] = field === "attribs" ? { ...this.attribs } : this[field];
+  if ("children" in this) fields.children = `[${this.children.length} nodes]`;
+  const name = Object.getPrototypeOf(Object.getPrototypeOf(this))?.constructor?.name ?? "Node";
+  return depth < 0 ? `[${name}]` : `${name} ${inspect(fields, { ...options, depth: 1 })}`;
+}
+var adoptedAliases = {
+  parentNode: { configurable: true, enumerable: false, get() {
+    return this.parent;
+  }, set(value) {
+    this.parent = value;
+  } },
+  previousSibling: { configurable: true, enumerable: false, get() {
+    return this.prev;
+  }, set(value) {
+    this.prev = value;
+  } },
+  nextSibling: { configurable: true, enumerable: false, get() {
+    return this.next;
+  }, set(value) {
+    this.next = value;
+  } },
+  nodeType: { configurable: true, enumerable: false, get() {
+    return { root: 9, text: 3, comment: 8, cdata: 4 }[viewRecord(this).type] ?? 1;
+  } },
+  cloneNode: { configurable: true, enumerable: false, writable: true, value: cloneNode }
+};
+var adoptedChildAliases = {
+  childNodes: { configurable: true, enumerable: false, get() {
+    return this.children;
+  }, set(value) {
+    this.children = value;
+  } },
+  firstChild: { configurable: true, enumerable: false, get() {
+    return this.children[0] ?? null;
+  } },
+  lastChild: { configurable: true, enumerable: false, get() {
+    return this.children[this.children.length - 1] ?? null;
+  } }
+};
+var adoptedElementAliases = {
+  tagName: { configurable: true, enumerable: false, get() {
+    return this.name;
+  }, set(value) {
+    this.name = value;
+  } },
+  attributes: { configurable: true, enumerable: false, get() {
+    const attributes = this.attribs;
+    const record = viewRecord(this);
+    return Object.keys(attributes).map((name) => ({ name, value: attributes[name], namespace: record.attribsNamespace?.[name], prefix: record.attribsPrefix?.[name] }));
+  } }
+};
+var adoptedDataAliases = {
+  nodeValue: { configurable: true, enumerable: false, get() {
+    return this.data;
+  }, set(value) {
+    this.data = value;
+  } }
+};
+var adoptedFields = /* @__PURE__ */ new Map();
+var optionalAdoptedKeys = ["name", "data", "namespace", "prefix", "sourceCodeLocation", "x-name", "x-publicId", "x-systemId", "x-mode", "x-attribsNamespace", "x-attribsPrefix"];
+var optionalAdoptedFields = new Set(optionalAdoptedKeys);
+var adoptedShapes = /* @__PURE__ */ new Map();
+function adoptObject(state, local, original) {
+  const record = recordAt(state, local);
+  if (!record) return void 0;
+  const view = original;
+  const attributesPrototype = original.attribs && typeof original.attribs === "object" ? Object.getPrototypeOf(original.attribs) : void 0;
+  view[VIEW_STATE] = state;
+  view[VIEW_LOCAL] = local;
+  view[VIEW_SELF] = view;
+  view[VIEW_ATTRIBUTES] = void 0;
+  view[VIEW_CHILDREN] = void 0;
+  view[VIEW_CHILD_TARGET] = void 0;
+  let fields = adoptedFields.get(record.type);
+  if (!fields) {
+    fields = {};
+    for (const [key, accessor] of Object.entries({ ...accessorsFor(record.type), sourceCodeLocation: locationAccessor })) fields[key] = { ...accessor, configurable: true, enumerable: true };
+    adoptedFields.set(record.type, fields);
+  }
+  let shape = record.type;
+  for (const key of optionalAdoptedKeys) {
+    if (!(key in fields)) continue;
+    const field = key === "x-attribsNamespace" ? "attribsNamespace" : key === "x-attribsPrefix" ? "attribsPrefix" : key;
+    shape += record[field] !== void 0 || Object.hasOwn(original, key) ? "1" : "0";
+  }
+  let descriptors = adoptedShapes.get(shape);
+  if (!descriptors) {
+    const present = {};
+    for (const key in fields) {
+      const field = key === "x-attribsNamespace" ? "attribsNamespace" : key === "x-attribsPrefix" ? "attribsPrefix" : key;
+      if (optionalAdoptedFields.has(key) && record[field] === void 0 && !Object.hasOwn(original, key)) continue;
+      present[key] = fields[key];
     }
-  };
-  for (const field of ["type", "name", "data", "namespace", "prefix", "startIndex", "endIndex", "sourceCodeLocation", "x-name", "x-publicId", "x-systemId", "x-mode"]) {
-    if (field in record || ["type", "startIndex", "endIndex"].includes(field)) define(field, () => (field === "sourceCodeLocation" ? hydrateLocation(read()[field]) : read()[field]) ?? (field === "startIndex" || field === "endIndex" ? null : void 0), (value) => setField(document, id, field, value));
-  }
-  for (const field of ["parent", "prev", "next"]) define(field, () => {
-    const value = read()[field];
-    return value === null || value === void 0 ? null : getNode(document, value);
-  }, (value) => setField(document, id, field, value == null ? null : importNodes(document, [value])[0]));
-  for (const [alias, field] of [["parentNode", "parent"], ["previousSibling", "prev"], ["nextSibling", "next"]]) define(alias, () => node[field], (value) => {
-    node[field] = value;
-  }, false);
-  if ("children" in record && ["root", "tag", "script", "style", "cdata"].includes(record.type)) {
-    const list = children(document, id);
-    define("children", () => list, (value) => setField(document, id, "children", importNodes(document, value)));
-    define("childNodes", () => list, (value) => {
-      node.children = value;
-    }, false);
-    define("firstChild", () => list[0] ?? null, void 0, false);
-    define("lastChild", () => list[list.length - 1] ?? null, void 0, false);
-  }
-  if (["tag", "script", "style"].includes(record.type)) {
-    const attrs = attributes(document, id, "attribs", Object.getPrototypeOf(original.attribs ?? {}));
-    define("attribs", () => attrs, (value) => setField(document, id, "attribs", value));
-    define("tagName", () => node.name, (value) => {
-      node.name = value;
-    }, false);
-    for (const field of ["x-attribsNamespace", "x-attribsPrefix"]) {
-      if (!((field === "x-attribsNamespace" ? "attribsNamespace" : "attribsPrefix") in record) && !Object.hasOwn(original, field)) continue;
-      const values = attributes(document, id, field === "x-attribsNamespace" ? "attribsNamespace" : "attribsPrefix");
-      define(field, () => values, (value) => setField(document, id, field, value));
-    }
-    define("attributes", () => Object.keys(attrs).map((name) => ({ name, value: attrs[name], namespace: read().attribsNamespace?.[name], prefix: read().attribsPrefix?.[name] })), void 0, false);
-  }
-  if (["text", "comment", "directive"].includes(record.type)) define("nodeValue", () => node.data, (value) => {
-    node.data = value;
-  }, false);
-  define("nodeType", () => ({ root: 9, text: 3, comment: 8, cdata: 4 })[read().type] ?? 1, void 0, false);
-  Object.defineProperty(node, "cloneNode", { configurable: true, enumerable: false, writable: true, value: cloneNode });
-  return node;
+    const isParent = "children" in present;
+    const isData = record.type === "text" || record.type === "comment" || record.type === "directive";
+    descriptors = { ...present, ...adoptedAliases, ...isParent ? adoptedChildAliases : {}, ...isElementType(record.type) ? adoptedElementAliases : {}, ...isData ? adoptedDataAliases : {} };
+    adoptedShapes.set(shape, descriptors);
+  }
+  const isElement2 = isElementType(record.type);
+  try {
+    Object.defineProperties(view, descriptors);
+  } catch {
+  }
+  if (isElement2 && attributesPrototype !== void 0) view[VIEW_ATTRIBUTES] = createAttributes(view, attributesPrototype);
+  cacheView(state, local, view);
+  return view;
+}
+function attachParsedNodes(state, nodes) {
+  state.adapterNodes = nodes;
+  for (let local = 0; local < nodes.length; local++) {
+    const node = nodes[local];
+    if (!node) continue;
+    node[VIEW_STATE] = state;
+    node[VIEW_LOCAL] = local;
+    node[VIEW_SELF] = node;
+  }
 }
 function cloneNode(recursive = false) {
   const binding = nodeBinding(this);
   if (!binding) throw new TypeError("cloneNode requires a native DOM node receiver");
   return getNode(binding.document, operation(binding.document, "clone", { ids: [binding.id], deep: recursive })[0]);
 }
+function childIds(document, id) {
+  const state = stateIn(document, id);
+  return (recordAt(state, id - state.base)?.children ?? []).map((child) => state.base + child);
+}
 function importNodes(document, input) {
   if (input == null || input === false) return [];
   const values = Array.isArray(input) || typeof input === "object" && "length" in input && !("type" in input) ? Array.from(input) : [input];
   const result = [];
   for (const node of values) {
     if (node == null) continue;
-    const existing = nodeId(node, document);
+    const existing = node && typeof node === "object" ? viewIdIn(document, node) : void 0;
     if (existing !== void 0) {
-      document.retainNode?.(existing);
       result.push(existing);
       continue;
     }
@@ -1189,8 +2284,8 @@ function importNodes(document, input) {
     const adopt = (oldId, newId) => {
       const source = originals.get(oldId);
       const oldChildren = records[oldId].children;
-      const newChildren = nodeRecord(document, newId).children ?? [];
-      getNode(document, newId, nodeBinding(source) ? void 0 : source);
+      const newChildren = childIds(document, newId);
+      getNode(document, newId, isNativeNode(source) ? void 0 : source);
       for (let i = 0; i < oldChildren.length; i++) if (newChildren[i] !== void 0) adopt(oldChildren[i], newChildren[i]);
     };
     adopt(root, imported[0]);
@@ -1201,10 +2296,10 @@ function importNodes(document, input) {
 
 // src/dom.ts
 var ElementType = Object.freeze({ Root: "root", Text: "text", Directive: "directive", Comment: "comment", Script: "script", Style: "style", Tag: "tag", CDATA: "cdata", Doctype: "doctype" });
-function initialize(node, type, fields, children2 = []) {
+function initialize(node, type, fields, children = []) {
   const document = routeDocument(new (requireNative()).NativeDocument("", false));
   const id = operation(document, "createNode", { type, ...fields });
-  if (children2.length) operation(document, "setNode", { id, field: "children", value: importNodes(document, children2) });
+  if (children.length) operation(document, "setNode", { id, field: "children", value: importNodes(document, children) });
   return getNode(document, id, node);
 }
 var Node = class {
@@ -1259,21 +2354,21 @@ var ProcessingInstruction = class extends DataNode {
   }
 };
 var Document = class extends NodeWithChildren {
-  constructor(children2) {
+  constructor(children) {
     super();
-    return initialize(this, "root", {}, children2);
+    return initialize(this, "root", {}, children);
   }
 };
 var CDATA = class extends NodeWithChildren {
-  constructor(children2) {
+  constructor(children) {
     super();
-    return initialize(this, "cdata", {}, children2);
+    return initialize(this, "cdata", {}, children);
   }
 };
 var Element = class extends NodeWithChildren {
-  constructor(name, attribs, children2 = [], type) {
+  constructor(name, attribs, children = [], type) {
     super();
-    return initialize(this, type ?? (name === "script" || name === "style" ? name : "tag"), { name, attribs }, children2);
+    return initialize(this, type ?? (name === "script" || name === "style" ? name : "tag"), { name, attribs }, children);
   }
 };
 function nodePrototype(type) {
@@ -1380,7 +2475,7 @@ function dataValue(object, key) {
 function compileExtractPlan(map, options) {
   if (options.pseudos || options.treeAdapter || options.Tokenizer || options.xml && typeof options.xml === "object" && options.xml.Tokenizer) return void 0;
   const ancestors = /* @__PURE__ */ new Set();
-  const compile = (input) => {
+  const compile2 = (input) => {
     if (!input || typeof input !== "object" || types.isProxy(input) || ancestors.has(input) || ancestors.size >= 64) return void 0;
     for (let current = Object.getPrototypeOf(input); current; current = Object.getPrototypeOf(current)) {
       if (types.isProxy(current)) return void 0;
@@ -1417,7 +2512,7 @@ function compileExtractPlan(map, options) {
           if (!scalarProperties.has(value) && !/^(?:data-|aria-).+/.test(value)) return void 0;
           entries2.push({ key, selector, all, value: { kind: "property", name: value } });
         } else {
-          const nested = compile(value);
+          const nested = compile2(value);
           if (!nested) return void 0;
           entries2.push({ key, selector, all, value: { kind: "map", entries: nested } });
         }
@@ -1427,7 +2522,7 @@ function compileExtractPlan(map, options) {
       ancestors.delete(input);
     }
   };
-  const entries = compile(map);
+  const entries = compile2(map);
   return entries && { version: 1, entries };
 }
 function hydrateExtractResult(result, entries) {
@@ -1445,13 +2540,37 @@ function hydrateExtractResult(result, entries) {
 }
 
 // src/attributes.ts
-var dataObjects = /* @__PURE__ */ new WeakMap();
-var dataFinalizer = new FinalizationRegistry(({ cache, id, reference }) => {
-  const records = cache.deref();
-  if (records?.get(id) === reference) records.delete(id);
-});
+var elementTypes = /* @__PURE__ */ new Set(["tag", "script", "style"]);
+var booleanAttribute = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i;
+var absent = /* @__PURE__ */ Symbol("absent");
+var deferred = /* @__PURE__ */ Symbol("deferred");
+function readAttribute(selection, name) {
+  const node = selection[0];
+  if (typeof node !== "object" || node === null) return absent;
+  const state = node[VIEW_STATE];
+  if (state === void 0 || node[VIEW_SELF] !== node) return typeof node.type === "string" ? deferred : absent;
+  const local = node[VIEW_LOCAL];
+  const snapshot = plainSnapshot(state, local);
+  const record = snapshot ? void 0 : recordAt(state, local);
+  const type = snapshot ? snapshot.typeOf(local) : record?.type;
+  if (type === void 0 || !elementTypes.has(type)) return absent;
+  const value = attributeAt(state, local, name);
+  if (value === void 0) {
+    const attributes = record?.attribs;
+    if (attributes && Object.hasOwn(attributes, name)) return deferred;
+    return name === "value" ? deferred : absent;
+  }
+  const options = selection.options ?? {};
+  const isXml = options.xmlMode ?? (options.xml === true || typeof options.xml === "object" && options.xml !== null);
+  return !isXml && booleanAttribute.test(name) ? name : value;
+}
+function setAttribute(selection, ids, name, value) {
+  const document = selection[DOCUMENT];
+  if (document.setAttribute) document.setAttribute(ids, name, value);
+  else selection.op("attr", { ids, name, value });
+}
 function isElement(selection, id) {
-  return ["tag", "script", "style"].includes(nodeRecord(selection._document, id)?.type);
+  return ["tag", "script", "style"].includes(nodeRecord(selection[DOCUMENT], id)?.type);
 }
 function nativeValue(value) {
   const seen = /* @__PURE__ */ new WeakSet();
@@ -1474,18 +2593,10 @@ function hydrateValue(value) {
   return value;
 }
 function dataObject(selection, id) {
-  const document = selection._document;
-  const cacheKey = document.nodeSpace ?? document;
-  let documents = dataObjects.get(cacheKey);
-  if (!documents) dataObjects.set(cacheKey, documents = /* @__PURE__ */ new Map());
-  const existingReference = documents.get(id);
-  let data2 = existingReference?.deref() ?? document.nodeData?.(id);
+  const document = selection[DOCUMENT];
+  let data2 = document.nodeData?.(id);
   if (!data2) {
-    const documentReference = new WeakRef(document);
-    const dispatch = document.nodeDataOperation?.(id) ?? ((command, args) => {
-      const document2 = documentReference.deref();
-      return document2 ? JSON.parse(document2.op(command, JSON.stringify(args))) : void 0;
-    });
+    const dispatch = document.nodeDataOperation?.(id) ?? ((command, args) => JSON.parse(document.op(command, JSON.stringify(args))));
     const target = {};
     data2 = new Proxy(target, {
       set(object, name, value) {
@@ -1504,28 +2615,26 @@ function dataObject(selection, id) {
         return true;
       }
     });
-    const node = getNode(selection._document, id);
-    Object.defineProperty(node, "data", { configurable: true, enumerable: true, get: () => data2, set: (value) => {
-      for (const key of Object.keys(data2)) delete data2[key];
-      for (const key of Object.keys(value ?? {})) data2[key] = value[key];
+    document.retainNodeData?.(id, data2);
+  }
+  const node = getNode(selection[DOCUMENT], id);
+  if (!Object.hasOwn(node, "data")) {
+    const values = data2;
+    Object.defineProperty(node, "data", { configurable: true, enumerable: true, get: () => values, set: (value) => {
+      for (const key of Object.keys(values)) delete values[key];
+      for (const key of Object.keys(value ?? {})) values[key] = value[key];
     } });
   }
-  if (existingReference?.deref() !== data2) {
-    const reference = new WeakRef(data2);
-    documents.set(id, reference);
-    dataFinalizer.register(data2, { cache: new WeakRef(documents), id, reference });
-  }
-  document.retainNodeData?.(id, data2);
   return data2;
 }
 function property(selection, id, name, raw = false) {
   const result = selection.op("prop", { ids: [id], name, ...raw ? { raw: true } : {} });
   if (name === "sourceCodeLocation") return hydrateLocation(result);
-  return result?.__nativeNodeProperty ? getNode(selection._document, id)[result.__nativeNodeProperty] : result === null ? void 0 : result;
+  return result?.__nativeNodeProperty ? getNode(selection[DOCUMENT], id)[result.__nativeNodeProperty] : result === null ? void 0 : result;
 }
 function propertyValue(selection, name, value) {
-  if (name === "children" || name === "childNodes") return importNodes(selection._document, value);
-  if (["parent", "parentNode", "prev", "previousSibling", "next", "nextSibling"].includes(name)) return value == null ? null : importNodes(selection._document, [value])[0] ?? null;
+  if (name === "children" || name === "childNodes") return importNodes(selection[DOCUMENT], value);
+  if (["parent", "parentNode", "prev", "previousSibling", "next", "nextSibling"].includes(name)) return value == null ? null : importNodes(selection[DOCUMENT], [value])[0] ?? null;
   return value;
 }
 function attr(name, value) {
@@ -1534,22 +2643,27 @@ function attr(name, value) {
       if (typeof name !== "string") throw new Error("Bad combination of arguments.");
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const node = getNode(this._document, id);
+        const node = getNode(this[DOCUMENT], id);
         const current = node.attribs[name];
         const next = value.call(node, index, current);
-        this.op("attr", { ids: [id], name, value: next === null ? null : String(next) });
+        setAttribute(this, [id], name, next === null ? null : String(next));
       });
     } else if (typeof name === "object") {
-      for (const key of Object.keys(name)) this.op("attr", { ids: this.ids, name: key, value: name[key] === null ? null : String(name[key]) });
+      for (const key of Object.keys(name)) setAttribute(this, this.ids, key, name[key] === null ? null : String(name[key]));
     } else {
-      this.op("attr", { ids: this.ids, name, value: value === null ? null : String(value) });
+      setAttribute(this, this.ids, name, value === null ? null : String(value));
     }
     return this;
   }
   if (arguments.length > 1) return this;
+  if (typeof name === "string") {
+    const cached2 = readAttribute(this, name);
+    if (cached2 === absent) return void 0;
+    if (cached2 !== deferred) return cached2;
+  }
   const result = this.op("attr", { ids: this.ids, ...typeof name === "string" ? { name } : {} });
   if (result === null) return void 0;
-  return !name && this.ids.length ? getNode(this._document, this.ids[0]).attribs : result;
+  return !name && this.ids.length ? getNode(this[DOCUMENT], this.ids[0]).attribs : result;
 }
 function prop(name, value) {
   if (typeof name === "string" && value === void 0) return this.ids.length ? property(this, this.ids[0], name) : void 0;
@@ -1558,7 +2672,7 @@ function prop(name, value) {
       if (typeof name === "object") throw new TypeError("Bad combination of arguments.");
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const next = value.call(getNode(this._document, id), index, property(this, id, name, true));
+        const next = value.call(getNode(this[DOCUMENT], id), index, property(this, id, name, true));
         this.op("prop", { ids: [id], name, value: propertyValue(this, name, next) });
       });
     } else if (typeof name === "object") {
@@ -1601,7 +2715,7 @@ function css(name, value) {
           for (const id of this.ids) {
             if (!isElement(this, id)) continue;
             const current = this.op("css", { ids: [id], name: key }) ?? void 0;
-            const next = name[key].call(getNode(this._document, id), propertyIndex, current);
+            const next = name[key].call(getNode(this[DOCUMENT], id), propertyIndex, current);
             this.op("css", { ids: [id], name: key, value: next == null ? null : String(next) });
           }
         } else this.op("css", { ids: this.ids, name: key, value: name[key] == null ? null : String(name[key]) });
@@ -1610,7 +2724,7 @@ function css(name, value) {
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
         const current = this.op("css", { ids: [id], name }) ?? void 0;
-        const next = value.call(getNode(this._document, id), index, current);
+        const next = value.call(getNode(this[DOCUMENT], id), index, current);
         this.op("css", { ids: [id], name, value: next == null ? null : String(next) });
       });
     } else if (typeof name === "string") this.op("css", { ids: this.ids, name, value: value == null ? null : String(value) });
@@ -1623,7 +2737,7 @@ function classMethod(command) {
     if (typeof name === "function") {
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const node = getNode(this._document, id);
+        const node = getNode(this[DOCUMENT], id);
         const next = command === "toggleClass" ? name.call(node, index, node.attribs.class ?? "", state) : name.call(node, index, node.attribs.class ?? "");
         if (typeof next === "string") this.op(command, { ids: [id], name: next, ...typeof state === "boolean" ? { state } : {} });
       });
@@ -1640,7 +2754,8 @@ function installAttributes(CheerioClass) {
     data,
     css,
     removeAttr(name) {
-      this.op("removeAttr", { ids: this.ids, name });
+      const ids = this.ids;
+      for (const single of String(name).split(/\s+/)) if (single) setAttribute(this, ids, single, null);
       return this;
     },
     hasClass(name) {
@@ -1668,9 +2783,9 @@ function parseWithNative(content, options, isDocument2, context) {
   if (!isDocument2 && context) {
     const document2 = nodeBinding(context)?.document ?? routeDocument(new (requireNative()).NativeDocument("", false, JSON.stringify(cleanParserOptions(options))), options);
     const contextId = importNodes(document2, [context])[0];
-    const children2 = operation(document2, "create", { html: content, contextId, options });
+    const children = operation(document2, "create", { html: content, contextId, options });
     const root = operation(document2, "createNode", { type: "root", options });
-    operation(document2, "setNode", { id: root, field: "children", value: children2, options });
+    operation(document2, "setNode", { id: root, field: "children", value: children, options });
     return getNode(document2, root);
   }
   const document = parseNativeDocument(content, options, isDocument2);
@@ -1683,7 +2798,7 @@ function parseWithHtmlparser2(content, options) {
   return parseWithNative(content, { ...options, _useHtmlParser2: true }, false, null);
 }
 function getParse(parser) {
-  return function parse2(content, options, isDocument2, context) {
+  return function parse3(content, options, isDocument2, context) {
     if (Buffer.isBuffer(content)) content = content.toString();
     if (typeof content === "string") return parser(content, options, isDocument2, context);
     if (!Array.isArray(content) && content.type === "root" && nodeBinding(content)) return content;
@@ -1696,6 +2811,183 @@ function getParse(parser) {
 }
 var parse = getParse((content, options, isDocument2, context) => options._useHtmlParser2 ? parseWithHtmlparser2(content, options) : parseWithParse5(content, options, isDocument2, context));
 
+// src/match.ts
+var compiled = /* @__PURE__ */ new Map();
+var compiledLimit = 512;
+function matchSimpleSelector(document, ids, selector, options) {
+  if (!isRouted(document)) return void 0;
+  const compounds = compile(selector);
+  if (!compounds) return void 0;
+  const isXml = isXmlMode(options);
+  const isLowerCaseTags = options.lowerCaseTags ?? !isXml;
+  const isLowerCaseAttributes = options.lowerCaseAttributeNames ?? !isXml;
+  const result = [];
+  for (const id of ids) {
+    const state = stateIn(document, id);
+    if (!sameMatchOptions(state.options, isXml, isLowerCaseTags, isLowerCaseAttributes)) return void 0;
+    const local = id - state.base;
+    for (const compound of compounds) {
+      if (matchesCompound(state, local, compound, isLowerCaseTags, isLowerCaseAttributes)) {
+        result.push(id);
+        break;
+      }
+    }
+  }
+  return result;
+}
+var walkBudget = 4096;
+var smallDocumentNodes = 512;
+var tinyDocumentNodes = 64;
+function selectSimpleWithin(document, contexts, selector, options) {
+  if (contexts.length !== 1 || !isRouted(document)) return void 0;
+  const compounds = compile(selector);
+  if (!compounds) return void 0;
+  const isXml = isXmlMode(options);
+  const isLowerCaseTags = options.lowerCaseTags ?? !isXml;
+  const isLowerCaseAttributes = options.lowerCaseAttributeNames ?? !isXml;
+  const state = stateIn(document, contexts[0]);
+  if (!sameMatchOptions(state.options, isXml, isLowerCaseTags, isLowerCaseAttributes)) return void 0;
+  const context = contexts[0] - state.base;
+  const size = Math.max(state.baseline, state.snapshotSize);
+  const isDocumentRoot = context === (state.rootLocal ??= state.raw.rootId());
+  const contextType = isDocumentRoot ? "root" : typeAt(state, context);
+  const isReadable = state.bulk instanceof NodeSnapshot ? size <= smallDocumentNodes : state.generation === 0 && size <= tinyDocumentNodes;
+  const isSmallRoot = contextType === "root" && isReadable;
+  if (!isElementType2(contextType) && !isSmallRoot) return void 0;
+  const result = [];
+  const stack = [];
+  pushChildren(state, context, stack);
+  for (let visited = 0; stack.length; visited++) {
+    if (visited === walkBudget) return void 0;
+    const local = stack.pop();
+    const type = typeAt(state, local);
+    if (type === "root") {
+      if (isSmallRoot) return void 0;
+      continue;
+    }
+    if (isElementType2(type)) {
+      for (const compound of compounds) {
+        if (matchesCompound(state, local, compound, isLowerCaseTags, isLowerCaseAttributes)) {
+          result.push(state.base + local);
+          break;
+        }
+      }
+    }
+    pushChildren(state, local, stack);
+  }
+  return result;
+}
+var isElementType2 = (type) => type === "tag" || type === "script" || type === "style";
+function typeAt(state, local) {
+  const snapshot = plainSnapshot(state, local);
+  return snapshot ? snapshot.typeOf(local) : recordAt(state, local)?.type;
+}
+function pushChildren(state, local, stack) {
+  const snapshot = plainSnapshot(state, local);
+  if (snapshot) {
+    for (let index = snapshot.childCount(local) - 1; index >= 0; index--) stack.push(snapshot.childAt(local, index));
+    return;
+  }
+  const children = recordAt(state, local)?.children ?? [];
+  for (let index = children.length - 1; index >= 0; index--) stack.push(children[index]);
+}
+function isXmlMode(options) {
+  return options.xmlMode ?? (options.xml === true || typeof options.xml === "object" && options.xml !== null);
+}
+function sameMatchOptions(documentOptions, isXml, isLowerCaseTags, isLowerCaseAttributes) {
+  const isDocumentXml = isXmlMode(documentOptions);
+  return isDocumentXml === isXml && (documentOptions.lowerCaseTags ?? !isDocumentXml) === isLowerCaseTags && (documentOptions.lowerCaseAttributeNames ?? !isDocumentXml) === isLowerCaseAttributes;
+}
+function matchesCompound(state, local, compound, isLowerCaseTags, isLowerCaseAttributes) {
+  const snapshot = plainSnapshot(state, local);
+  const record = snapshot ? void 0 : recordAt(state, local);
+  if (!snapshot && !record) return false;
+  if (!isElementType2(snapshot ? snapshot.typeOf(local) : record.type)) return false;
+  if (compound.tag !== void 0 && (snapshot ? snapshot.nameOf(local) : record.name) !== (isLowerCaseTags ? compound.lowerTag : compound.tag)) return false;
+  for (const id of compound.ids) if (attributeAt(state, local, "id") !== id) return false;
+  if (compound.classes.length) {
+    const classes = attributeAt(state, local, "class");
+    if (classes === void 0) return false;
+    for (const name of compound.classes) if (!hasClass(classes, name)) return false;
+  }
+  for (const name of isLowerCaseAttributes ? compound.lowerAttributes : compound.attributes) if (attributeAt(state, local, name) === void 0) return false;
+  return true;
+}
+var isAsciiWhitespace = (code) => code === 32 || code === 9 || code === 10 || code === 12 || code === 13;
+function hasClass(classes, name) {
+  for (let start = classes.indexOf(name); start !== -1; start = classes.indexOf(name, start + 1)) {
+    const end = start + name.length;
+    if ((start === 0 || isAsciiWhitespace(classes.charCodeAt(start - 1))) && (end === classes.length || isAsciiWhitespace(classes.charCodeAt(end)))) return true;
+  }
+  return false;
+}
+function asciiLowerCase(value) {
+  return /[A-Z]/.test(value) ? value.replace(/[A-Z]/g, (letter) => letter.toLowerCase()) : value;
+}
+function compile(selector) {
+  const cached2 = compiled.get(selector);
+  if (cached2 !== void 0) return cached2;
+  const result = parse2(selector);
+  if (compiled.size >= compiledLimit) compiled.clear();
+  compiled.set(selector, result);
+  return result;
+}
+var identifierStart = /[A-Za-z_]/;
+var identifierPart = /[A-Za-z0-9_-]/;
+function parse2(selector) {
+  const compounds = [];
+  let index = 0;
+  const skipSpace = () => {
+    while (index < selector.length && isAsciiWhitespace(selector.charCodeAt(index))) index++;
+  };
+  const identifier = () => {
+    const start = index;
+    if (selector[index] === "-") index++;
+    if (!identifierStart.test(selector[index] ?? "")) return null;
+    while (index < selector.length && identifierPart.test(selector[index])) index++;
+    return selector.slice(start, index);
+  };
+  for (; ; ) {
+    skipSpace();
+    const compound = { tag: void 0, lowerTag: void 0, ids: [], classes: [], attributes: [], lowerAttributes: [] };
+    let hasPart = false;
+    if (selector[index] === "*") {
+      index++;
+      hasPart = true;
+    } else if (/[A-Za-z]/.test(selector[index] ?? "")) {
+      compound.tag = identifier();
+      hasPart = true;
+    }
+    for (; ; ) {
+      const character = selector[index];
+      if (character === "#" || character === ".") {
+        index++;
+        const name = identifier();
+        if (name === null) return null;
+        (character === "#" ? compound.ids : compound.classes).push(name);
+      } else if (character === "[") {
+        index++;
+        skipSpace();
+        const name = identifier();
+        if (name === null) return null;
+        skipSpace();
+        if (selector[index] !== "]") return null;
+        index++;
+        compound.attributes.push(name);
+      } else break;
+      hasPart = true;
+    }
+    if (!hasPart) return null;
+    compound.lowerTag = compound.tag === void 0 ? void 0 : asciiLowerCase(compound.tag);
+    compound.lowerAttributes = compound.attributes.map(asciiLowerCase);
+    compounds.push(compound);
+    skipSpace();
+    if (index === selector.length) return compounds;
+    if (selector[index] !== ",") return null;
+    index++;
+  }
+}
+
 // src/selection.ts
 var numeric = /^(?:0|[1-9]\d*)$/;
 var isMarkup = (value) => /<[a-zA-Z!/?]/.test(value);
@@ -1767,103 +3059,166 @@ function* customPseudoArguments(selector, name) {
     index = end;
   }
 }
+var isIndex = (property2) => {
+  if (typeof property2 !== "string") return false;
+  const first = property2.charCodeAt(0);
+  return first >= 48 && first <= 57 && numeric.test(property2);
+};
+var plainSelectionLimit = 16;
+var lengthOf = (target) => target[VALUES]?.length ?? target[IDS].length;
+function nodeAt(target, index) {
+  if (target[VALUES]) return target[VALUES][index];
+  const id = target[IDS][index];
+  return id === void 0 ? void 0 : getNode(target[DOCUMENT], id);
+}
+function releaseIds(target) {
+  if (target[LEASE]) updateLease(target[DOCUMENT], target[LEASE], target[VALUES] ? [] : target[IDS]);
+}
+function writeIndex(target, index, value) {
+  if (target[VALUES]) target[VALUES][index] = value;
+  else {
+    const id = importNodes(target[DOCUMENT], [value])[0];
+    if (id === void 0) {
+      target[VALUES] = target[IDS].map((existing) => getNode(target[DOCUMENT], existing));
+      target[VALUES][index] = value;
+    } else target[IDS][index] = id;
+  }
+  releaseIds(target);
+}
+var selectionHandler = {
+  get: (target, property2) => isIndex(property2) ? nodeAt(target, Number(property2)) : property2 === "length" ? lengthOf(target) : Reflect.get(target, property2),
+  set: (target, property2, value) => {
+    if (isIndex(property2)) {
+      writeIndex(target, Number(property2), value);
+      return true;
+    }
+    if (property2 === "length") {
+      if (target[VALUES]) target[VALUES].length = value;
+      else target[IDS].length = value;
+      releaseIds(target);
+      return true;
+    }
+    return Reflect.set(target, property2, value);
+  },
+  has: (target, property2) => isIndex(property2) ? Number(property2) < lengthOf(target) : property2 === "length" || Reflect.has(target, property2),
+  ownKeys: (target) => [...Array.from({ length: lengthOf(target) }, (_, i) => String(i)), "length", ...Reflect.ownKeys(target)],
+  getOwnPropertyDescriptor: (target, property2) => {
+    if (isIndex(property2) && Number(property2) < lengthOf(target))
+      return { value: nodeAt(target, Number(property2)), writable: true, configurable: true, enumerable: true };
+    if (property2 === "length") return { value: lengthOf(target), writable: true, configurable: true, enumerable: true };
+    return Reflect.getOwnPropertyDescriptor(target, property2);
+  },
+  deleteProperty: (target, property2) => {
+    if (isIndex(property2)) {
+      if (target[VALUES])
+        delete target[VALUES][Number(property2)];
+      else
+        delete target[IDS][Number(property2)];
+      releaseIds(target);
+      return true;
+    }
+    return Reflect.deleteProperty(target, property2);
+  }
+};
 var Cheerio = class {
-  cheerio = "[cheerio object]";
+  /** @internal */
+  get _document() {
+    return this[DOCUMENT];
+  }
+  /** @internal */
+  get _api() {
+    return this[API];
+  }
+  /** @internal */
+  get _ids() {
+    return this[IDS];
+  }
   constructor(api, document, ids = [], root = null, options = {}, values) {
-    Object.defineProperties(this, {
-      _document: { value: document, writable: true, configurable: true },
-      _api: { value: api, writable: true, configurable: true },
-      _ids: { value: ids, writable: true, configurable: true },
-      _values: { value: values, writable: true, configurable: true },
-      _lease: { value: retainNodes(document, ids), writable: true, configurable: true },
-      options: { value: options, writable: true, configurable: true, enumerable: true },
-      _root: { value: root, writable: true, configurable: true, enumerable: true },
-      length: { configurable: true, enumerable: true, get: () => this._values?.length ?? this._ids.length, set: (value) => {
-        if (this._values)
-          this._values.length = value;
-        else
-          this._ids.length = value;
-        this._lease = retainNodes(document, this._values ? [] : this._ids);
-      } }
-    });
-    delete this.cheerio;
-    return new Proxy(this, {
-      get: (target, property2, receiver) => typeof property2 === "string" && numeric.test(property2) ? target._values ? target._values[Number(property2)] : target._ids[Number(property2)] === void 0 ? void 0 : getNode(document, target._ids[Number(property2)]) : Reflect.get(target, property2, receiver),
-      set: (target, property2, value, receiver) => {
-        if (typeof property2 === "string" && numeric.test(property2)) {
-          if (target._values)
-            target._values[Number(property2)] = value;
-          else {
-            const id = importNodes(document, [value])[0];
-            if (id === void 0) {
-              target._values = target._ids.map((existing) => getNode(document, existing));
-              target._values[Number(property2)] = value;
-            } else
-              target._ids[Number(property2)] = id;
-          }
-          target._lease = retainNodes(document, target._values ? [] : target._ids);
-          return true;
-        }
-        return Reflect.set(target, property2, value, receiver);
-      },
-      has: (target, property2) => typeof property2 === "string" && numeric.test(property2) ? Number(property2) < target.length : Reflect.has(target, property2),
-      ownKeys: (target) => [...Array.from({ length: target.length }, (_, i) => String(i)), ...Reflect.ownKeys(target)],
-      getOwnPropertyDescriptor: (target, property2) => typeof property2 === "string" && numeric.test(property2) && Number(property2) < target.length ? { value: target._values ? target._values[Number(property2)] : getNode(document, target._ids[Number(property2)]), writable: true, configurable: true, enumerable: true } : Reflect.getOwnPropertyDescriptor(target, property2),
-      deleteProperty: (target, property2) => {
-        if (typeof property2 === "string" && numeric.test(property2)) {
-          if (target._values)
-            delete target._values[Number(property2)];
-          else
-            delete target._ids[Number(property2)];
-          target._lease = retainNodes(document, target._values ? [] : target._ids);
-          return true;
-        }
-        return Reflect.deleteProperty(target, property2);
-      }
-    });
+    this[DOCUMENT] = document;
+    this[API] = api;
+    this[IDS] = ids;
+    this[VALUES] = values;
+    this[LEASE] = void 0;
+    const count = values ? values.length : ids.length;
+    const isPlain = count <= plainSelectionLimit;
+    this[IS_PLAIN] = isPlain;
+    if (isPlain) this.length = count;
+    this.options = options;
+    this._root = root;
+    if (isPlain) {
+      if (values) for (let index = 0; index < count; index++) this[index] = values[index];
+      else for (let index = 0; index < count; index++) this[index] = getNode(document, ids[index]);
+      return;
+    }
+    if (!values) this[LEASE] = leaseNodes(document, this, ids);
+    return new Proxy(this, selectionHandler);
+  }
+  /** @internal Re-reads a plain selection after direct index writes or after its nodes moved documents. */
+  _syncIndices() {
+    const length = this.length;
+    const values = this[VALUES];
+    const ids = this[IDS];
+    let isChanged = (values ?? ids).length !== length;
+    for (let index = 0; !isChanged && index < length; index++) isChanged = values ? this[index] !== values[index] : viewId(this[index]) !== ids[index];
+    if (!isChanged) return;
+    const items = Array.from({ length }, (_unused, index) => this[index]);
+    const isAllNodes = items.every((value) => value && typeof value === "object" && typeof value.type === "string");
+    this[VALUES] = isAllNodes ? void 0 : items;
+    this[IDS] = isAllNodes ? importNodes(this[DOCUMENT], items) : [];
   }
   /** @internal */
   get ids() {
-    return this._values ? importNodes(this._document, this._values) : this._ids;
+    if (this[IS_PLAIN]) this._syncIndices();
+    return this[VALUES] ? importNodes(this[DOCUMENT], this[VALUES]) : this[IDS];
   }
   /** @internal */
   op(command, args = {}) {
     const values = args;
-    return operation(this._document, command, { ...values, options: values.options ?? this.options });
+    return operation(this[DOCUMENT], command, { ...values, options: values.options ?? this.options });
   }
   /** @internal */
   _query(command, args) {
-    const callbacks = Object.entries(this.options.pseudos ?? {}).filter((entry) => typeof entry[1] === "function");
-    if (!callbacks.length)
-      return command === "select" && !args.options ? this._document.select(args.selector, args.contexts) : this.op(command, args);
+    const pseudos = this.options.pseudos;
+    const callbacks = pseudos ? Object.entries(pseudos).filter((entry) => typeof entry[1] === "function") : [];
+    if (!callbacks.length) {
+      if (command === "matches" && args.ids) {
+        const matched = matchSimpleSelector(this[DOCUMENT], args.ids, args.selector, args.options ?? this.options);
+        if (matched) return matched;
+      }
+      if (command === "select" && args.contexts) {
+        const found = selectSimpleWithin(this[DOCUMENT], args.contexts, args.selector, args.options ?? this.options);
+        if (found) return found;
+      }
+      return command === "select" && !args.options ? this[DOCUMENT].select(args.selector, args.contexts) : this.op(command, args);
+    }
     const pseudoMatches = {};
-    const candidates = [.../* @__PURE__ */ new Set([...this._document.select("*"), ...args.ids ?? [], ...args.contexts ? this._document.select("*", args.contexts) : []])];
+    const candidates = [.../* @__PURE__ */ new Set([...this[DOCUMENT].select("*"), ...args.ids ?? [], ...args.contexts ? this[DOCUMENT].select("*", args.contexts) : []])];
     for (const [name, callback] of callbacks) {
       for (const argument of customPseudoArguments(args.selector, name)) {
         if (argument !== void 0 && callback.length < 2)
           throw new Error(`Pseudo-class :${name} doesn't have any arguments`);
         if (argument === void 0 && callback.length >= 2)
           throw new Error(`Pseudo-class :${name} requires an argument`);
-        pseudoMatches[`${name}(${argument ?? ""})`] = candidates.filter((id) => callback(getNode(this._document, id), argument ?? null));
+        pseudoMatches[`${name}(${argument ?? ""})`] = candidates.filter((id) => callback(getNode(this[DOCUMENT], id), argument ?? null));
       }
     }
     return this.op(command, { ...args, pseudoMatches });
   }
   /** @internal */
   _fromIds(ids) {
-    const result = new this._api.fn.constructor(this._api, this._document, ids, this._root, this.options);
+    const result = new this[API].fn.constructor(this[API], this[DOCUMENT], ids, this._root, this.options);
     result.prevObject = this;
     return result;
   }
   /** @internal */
   _fromValues(values) {
     const allNodes = values.every((value) => value && typeof value === "object" && typeof value.type === "string");
-    const result = new this._api.fn.constructor(this._api, this._document, allNodes ? importNodes(this._document, values) : [], this._root, this.options, allNodes ? void 0 : values);
+    const result = new this[API].fn.constructor(this[API], this[DOCUMENT], allNodes ? importNodes(this[DOCUMENT], values) : [], this._root, this.options, allNodes ? void 0 : values);
     result.prevObject = this;
     return result;
   }
   _make(value, context) {
-    const result = typeof value === "string" || value?.cheerio ? this._api(value, context) : this._fromValues(value == null ? [] : typeof value === "object" && "length" in value && !value.type ? Array.from(value) : [value]);
+    const result = typeof value === "string" || value?.cheerio ? this[API](value, context) : this._fromValues(value == null ? [] : typeof value === "object" && "length" in value && !value.type ? Array.from(value) : [value]);
     result.prevObject = this;
     return result;
   }
@@ -1871,7 +3226,7 @@ var Cheerio = class {
     return parse(content, options, isDocument2, context);
   }
   _render(content) {
-    return this._document.outerHtml(importNodes(this._document, content));
+    return this[DOCUMENT].outerHtml(importNodes(this[DOCUMENT], content));
   }
   /** @internal */
   _domIds(content, contextId) {
@@ -1879,22 +3234,26 @@ var Cheerio = class {
       return [];
     if (typeof content === "string")
       return this.op("create", { html: content, contextId, options: this.options });
-    if (content?.cheerio)
-      return content._document && sameNodeSpace(this._document, content._document) ? content.ids : importNodes(this._document, content.toArray());
+    if (content?.cheerio) {
+      if (!content[DOCUMENT] || !sameNodeSpace(this[DOCUMENT], content[DOCUMENT]))
+        return importNodes(this[DOCUMENT], content.toArray());
+      exposeDocumentTo(this[DOCUMENT], content[DOCUMENT]);
+      return content.ids;
+    }
     if (typeof content === "object" && "length" in content && !content.type)
       return Array.from(content).flatMap((item) => this._domIds(item, contextId));
-    return importNodes(this._document, [content]);
+    return importNodes(this[DOCUMENT], [content]);
   }
   _makeDomArray(content, clone = false) {
     const ids = this._domIds(content);
-    return (clone ? this.op("clone", { ids, deep: true }) : ids).map((id) => getNode(this._document, id));
+    return (clone ? this.op("clone", { ids, deep: true }) : ids).map((id) => getNode(this[DOCUMENT], id));
   }
   find(selector) {
     if (!selector)
       return this._fromIds([]);
     if (typeof selector === "string")
       return this._findBySelector(selector, Infinity);
-    const ids = importNodes(this._document, selector);
+    const ids = importNodes(this[DOCUMENT], selector);
     return this._fromIds(ids.filter((id) => this.ids.some((container) => this.op("contains", { container, contained: id }))));
   }
   _findBySelector(selector, limit) {
@@ -1907,21 +3266,21 @@ var Cheerio = class {
       return ids;
     if (typeof selector === "string")
       return this._query("matches", { ids, selector, options: this.options });
-    return ids.filter((id, index) => this._predicate(selector, getNode(this._document, id), index));
+    return ids.filter((id, index) => this._predicate(selector, getNode(this[DOCUMENT], id), index));
   }
   /** @internal */
   _predicate(selector, node, index) {
     if (typeof selector === "function")
       return !!selector.call(node, index, node);
     if (typeof selector === "string")
-      return this._query("matches", { ids: importNodes(this._document, [node]), selector, options: this.options }).length > 0;
+      return this._query("matches", { ids: importNodes(this[DOCUMENT], [node]), selector, options: this.options }).length > 0;
     if (selector?.cheerio)
       return selector.toArray().includes(node);
     return node === selector;
   }
   /** @internal */
   _traverse(kind, selector) {
-    let ids = this.op("traverse", { ids: this.ids, kind });
+    let ids = traverseRecords(this[DOCUMENT], this.ids, kind) ?? this.op("traverse", { ids: this.ids, kind });
     ids = this._filterIds(ids, selector);
     if (this.length > 1 && ids.length > 1) {
       if (kind === "parents" || kind === "siblings")
@@ -1964,8 +3323,8 @@ var Cheerio = class {
   _until(kind, until, filter) {
     let ids = [];
     for (const id of this.ids)
-      for (const candidate of this.op("traverse", { ids: [id], kind })) {
-        if (until && this._predicate(until, getNode(this._document, candidate), ids.length))
+      for (const candidate of traverseRecords(this[DOCUMENT], [id], kind) ?? this.op("traverse", { ids: [id], kind })) {
+        if (until && this._predicate(until, getNode(this[DOCUMENT], candidate), ids.length))
           break;
         ids.push(candidate);
       }
@@ -1988,25 +3347,37 @@ var Cheerio = class {
       return this._fromIds([]);
     const result = [];
     for (const id of this.ids) {
-      const record = nodeRecord(this._document, id);
-      const candidates = [...["tag", "script", "style"].includes(record.type) ? [id] : [], ...this.op("traverse", { ids: [id], kind: "parents" })];
-      const match = candidates.find((candidate) => this._predicate(selector, getNode(this._document, candidate), 0));
+      const record = nodeRecord(this[DOCUMENT], id);
+      const candidates = [...["tag", "script", "style"].includes(record.type) ? [id] : [], ...traverseRecords(this[DOCUMENT], [id], "parents") ?? this.op("traverse", { ids: [id], kind: "parents" })];
+      const matched = typeof selector === "string" ? new Set(this._filterIds(candidates, selector)) : void 0;
+      const match = matched ? candidates.find((candidate) => matched.has(candidate)) : candidates.find((candidate) => this._predicate(selector, getNode(this[DOCUMENT], candidate), 0));
       if (match !== void 0 && !result.includes(match))
         result.push(match);
     }
     return this._fromIds(result);
   }
   each(callback) {
-    const length = this.length;
-    for (let i = 0; i < length; i++)
-      if (callback.call(this[i], i, this[i]) === false)
+    if (this[IS_PLAIN]) {
+      const length2 = this.length;
+      for (let i = 0; i < length2; i++)
+        if (callback.call(this[i], i, this[i]) === false)
+          break;
+      return this;
+    }
+    const values = this[VALUES], ids = this[IDS], document = this[DOCUMENT];
+    const length = values ? values.length : ids.length;
+    for (let i = 0; i < length; i++) {
+      const node = values ? values[i] : getNode(document, ids[i]);
+      if (callback.call(node, i, node) === false)
         break;
+    }
     return this;
   }
   map(callback) {
     const result = [];
-    for (let i = 0; i < this.length; i++) {
-      const value = callback.call(this[i], i, this[i]);
+    const items = this._items();
+    for (let i = 0; i < items.length; i++) {
+      const value = callback.call(items[i], i, items[i]);
       if (value != null)
         result.push(...Array.isArray(value) ? value : [value]);
     }
@@ -2019,7 +3390,7 @@ var Cheerio = class {
     const matcher = match;
     if (typeof match !== "string")
       return nodes.filter((node, index) => typeof matcher === "function" ? matcher.call(node, index, node) : matcher?.cheerio ? matcher.toArray().includes(node) : matcher === node);
-    const document = this?._document ?? nodeBinding(root)?.document ?? nodeBinding(nodes[0])?.document ?? new (requireNative()).NativeDocument("", false);
+    const document = this?.[DOCUMENT] ?? nodeBinding(root)?.document ?? nodeBinding(nodes[0])?.document ?? routeDocument(new (requireNative()).NativeDocument("", false));
     const ids = importNodes(document, nodes);
     const selected = new Set(operation(document, "matches", { ids, selector: match, options: { xmlMode } }));
     return nodes.filter((node) => {
@@ -2052,50 +3423,72 @@ var Cheerio = class {
       return this;
     if (index < 0)
       index += this.length;
-    return this._fromValues(this[index] === void 0 ? [] : [this[index]]);
+    const item = this._itemAt(index);
+    return this._fromValues(item === void 0 ? [] : [item]);
   }
   get(index) {
-    return index == null ? this.toArray() : this[index < 0 ? this.length + index : index];
+    return index == null ? this.toArray() : this._itemAt(index < 0 ? this.length + index : index);
   }
   toArray() {
-    return Array.from({ length: this.length }, (_unused, i) => this[i]);
+    return this._items();
+  }
+  /** @internal Every item, read without a proxy trap per index. */
+  _items() {
+    if (this[IS_PLAIN]) {
+      const length = this.length;
+      const items = new Array(length);
+      for (let i = 0; i < length; i++) items[i] = this[i];
+      return items;
+    }
+    const values = this[VALUES], ids = this[IDS], document = this[DOCUMENT];
+    return values ? values.slice() : ids.map((id) => getNode(document, id));
+  }
+  /** @internal */
+  _itemAt(index) {
+    if (this[IS_PLAIN]) return this[index];
+    const values = this[VALUES];
+    if (values) return values[index];
+    const id = this[IDS][index];
+    return id === void 0 ? void 0 : getNode(this[DOCUMENT], id);
   }
   slice(start, end) {
-    return this._values ? this._fromValues(this._values.slice(start, end)) : this._fromIds(this._ids.slice(start, end));
+    const ids = this.ids;
+    return this[VALUES] ? this._fromValues(this[VALUES].slice(start, end)) : this._fromIds(ids.slice(start, end));
   }
   end() {
     return this.prevObject ?? this._make([]);
   }
   add(other, context) {
-    return this._fromIds(this.op("uniqueSort", { ids: [...this.ids, ...this._api(other, context).ids] }));
+    const added = this[API](other, context);
+    const addedIds = added[DOCUMENT] && sameNodeSpace(this[DOCUMENT], added[DOCUMENT]) ? added.ids : importNodes(this[DOCUMENT], added.toArray());
+    return this._fromIds(this.op("uniqueSort", { ids: [...this.ids, ...addedIds] }));
   }
   addBack(selector) {
     return this.prevObject ? this.add(selector ? this.prevObject.filter(selector) : this.prevObject) : this;
   }
   index(selector) {
-    const haystack = selector == null ? this.parent().children() : typeof selector === "string" ? this._api(selector) : this;
+    const haystack = selector == null ? this.parent().children() : typeof selector === "string" ? this[API](selector) : this;
     const needle = selector == null || typeof selector === "string" ? this[0] : selector?.cheerio ? selector[0] : selector;
     return haystack.toArray().indexOf(needle);
   }
   splice(...args) {
     return Reflect.apply(Array.prototype.splice, this, args);
   }
-  *[Symbol.iterator]() {
-    for (let i = 0; i < this.length; i++)
-      yield this[i];
+  [Symbol.iterator]() {
+    return this._items()[Symbol.iterator]();
   }
   /** @internal */
   _insert(position, content) {
-    const targets = this.ids.filter((id) => ["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this._document, id).type));
+    const targets = this.ids.filter((id) => ["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this[DOCUMENT], id).type));
     if (!targets.length)
       return this;
     if (typeof content[0] === "function")
       return this.each((index, node) => {
         if (!targets.includes(this.ids[index]))
           return;
-        if ((position === "before" || position === "after") && nodeRecord(this._document, this.ids[index]).parent == null)
+        if ((position === "before" || position === "after") && nodeRecord(this[DOCUMENT], this.ids[index]).parent == null)
           return;
-        const value = content[0].call(node, index, this._document.innerHtml(this.ids[index]));
+        const value = content[0].call(node, index, this[DOCUMENT].innerHtml(this.ids[index]));
         let nodes2 = this._domIds(value);
         if (index < this.length - 1)
           nodes2 = this.op("clone", { ids: nodes2, deep: true });
@@ -2120,20 +3513,20 @@ var Cheerio = class {
     return this._insert("after", content);
   }
   appendTo(target) {
-    this._api(target).append(this);
+    this[API](target).append(this);
     return this;
   }
   prependTo(target) {
-    this._api(target).prepend(this);
+    this[API](target).prepend(this);
     return this;
   }
   /** @internal */
   _insertRelative(target, position) {
-    const targets = this._api(target).ids;
+    const targets = this[API](target).ids;
     this.remove();
     const inserted = [];
     for (const id of targets) {
-      if (nodeRecord(this._document, id).parent == null)
+      if (nodeRecord(this[DOCUMENT], id).parent == null)
         continue;
       const clones = this.op("clone", { ids: this.ids, deep: true });
       this.op("insert", { targetIds: [id], nodeIds: clones, position });
@@ -2153,7 +3546,7 @@ var Cheerio = class {
   }
   replaceWith(content) {
     return this.each((index, node) => {
-      if (nodeRecord(this._document, this.ids[index]).parent == null)
+      if (nodeRecord(this[DOCUMENT], this.ids[index]).parent == null)
         return;
       const value = typeof content === "function" ? content.call(node, index, node) : content;
       this.op("insert", { targetIds: [this.ids[index]], nodeIds: this._domIds(value), position: "replace" });
@@ -2166,33 +3559,33 @@ var Cheerio = class {
   }
   html(content) {
     if (content === void 0)
-      return this.length && ["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this._document, this.ids[0]).type) ? this._document.innerHtml(this.ids[0]) : null;
+      return this.length && ["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this[DOCUMENT], this.ids[0]).type) ? this[DOCUMENT].innerHtml(this.ids[0]) : null;
     if (!content?.cheerio) {
       this.op("html", { ids: this.ids, value: String(content) });
       return this;
     }
     for (const id of this.ids) {
-      const nodes = content?.cheerio ? importNodes(this._document, content.toArray()) : this._domIds(String(content), id);
+      const nodes = content?.cheerio ? importNodes(this[DOCUMENT], content.toArray()) : this._domIds(String(content), id);
       this.op("setNode", { id, field: "children", value: nodes });
     }
     return this;
   }
   text(content) {
     if (content === void 0)
-      return this._document.text(this.ids);
+      return this[DOCUMENT].text(this.ids);
     if (typeof content !== "function") {
       this.op("text", { ids: this.ids, value: String(content) });
       return this;
     }
     for (let i = 0; i < this.ids.length; i++) {
       const id = this.ids[i];
-      const value = typeof content === "function" ? content.call(getNode(this._document, id), i, this._document.text([id])) : content;
+      const value = typeof content === "function" ? content.call(getNode(this[DOCUMENT], id), i, this[DOCUMENT].text([id])) : content;
       this.op("text", { ids: [id], value: String(value) });
     }
     return this;
   }
   toString() {
-    return this._document.outerHtml(this.ids);
+    return this[DOCUMENT].outerHtml(this.ids);
   }
   clone() {
     return this._fromIds(this.op("clone", { ids: this.ids, deep: true }));
@@ -2200,8 +3593,8 @@ var Cheerio = class {
   /** @internal */
   _deepest(id, tagsOnly = false) {
     for (; ; ) {
-      const children2 = this.op("traverse", { ids: [id], kind: "children" });
-      const child = tagsOnly ? children2.find((candidate) => nodeRecord(this._document, candidate).type === "tag") : children2[0];
+      const children = this.op("traverse", { ids: [id], kind: "children" });
+      const child = tagsOnly ? children.find((candidate) => nodeRecord(this[DOCUMENT], candidate).type === "tag") : children[0];
       if (child === void 0)
         return id;
       id = child;
@@ -2212,24 +3605,23 @@ var Cheerio = class {
     const lastParent = this.parents().last();
     for (let i = 0; i < this.length; i++) {
       const id = this.ids[i];
-      const node = getNode(this._document, id);
+      const node = getNode(this[DOCUMENT], id);
       const value = typeof content === "function" ? content.call(node, i, node) : typeof content === "string" && !isMarkup(content) ? lastParent.find(content).clone() : content;
       let wrappers = this._domIds(value);
       if (i < this.length - 1)
         wrappers = this.op("clone", { ids: wrappers, deep: true });
       const wrapper = wrappers[0];
-      if (wrapper === void 0 || !["root", "tag", "script", "style"].includes(nodeRecord(this._document, wrapper).type))
+      if (wrapper === void 0 || !["root", "tag", "script", "style"].includes(nodeRecord(this[DOCUMENT], wrapper).type))
         continue;
-      const deepest = this._deepest(wrapper);
       if (inner) {
-        if (!["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this._document, id).type))
+        if (!["root", "tag", "script", "style", "cdata"].includes(nodeRecord(this[DOCUMENT], id).type))
           continue;
         const contents = this.op("traverse", { ids: [id], kind: "contents" });
-        this.op("setNode", { id: deepest, field: "children", value: contents });
+        this.op("setNode", { id: this._deepest(wrapper), field: "children", value: contents });
         this.op("setNode", { id, field: "children", value: [wrapper] });
-      } else if (nodeRecord(this._document, id).parent != null) {
-        this.op("insert", { targetIds: [id], nodeIds: [wrapper], position: "before" });
-        this.op("setNode", { id: deepest, field: "children", value: [id] });
+      } else if (nodeRecord(this[DOCUMENT], id).parent != null) {
+        const [inserted = wrapper] = this.op("insert", { targetIds: [id], nodeIds: [wrapper], position: "before" });
+        this.op("setNode", { id: this._deepest(inserted), field: "children", value: [id] });
       }
     }
     return this;
@@ -2249,7 +3641,7 @@ var Cheerio = class {
       return this;
     const first = this[0];
     const wrappers = this._make(typeof content === "function" ? content.call(first, 0, first) : content).insertBefore(first);
-    const root = [...wrappers.ids].reverse().find((id) => nodeRecord(this._document, id).type === "tag");
+    const root = [...wrappers.ids].reverse().find((id) => nodeRecord(this[DOCUMENT], id).type === "tag");
     if (root !== void 0)
       this.op("insert", { targetIds: [this._deepest(root, true)], nodeIds: this.ids, position: "append" });
     return this;
@@ -2259,6 +3651,19 @@ var Cheerio = class {
   }
 };
 Object.defineProperty(Cheerio.prototype, "cheerio", { value: "[cheerio object]", writable: true, configurable: true });
+var inspectCustom = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+Object.defineProperty(Cheerio.prototype, inspectCustom, {
+  configurable: true,
+  writable: true,
+  value(depth, options, inspect) {
+    const prototype = Object.getPrototypeOf(this);
+    if (depth < 0) return options.stylize(`[${prototype.constructor.name}]`, "special");
+    const shown = Object.create(prototype);
+    Object.defineProperty(shown, inspectCustom, { value: void 0 });
+    for (const key of Object.keys(this)) shown[key] = this[key];
+    return inspect(shown, { ...options, depth });
+  }
+});
 installAttributes(Cheerio);
 var nativeExtractionMethods = Object.freeze({
   make: Cheerio.prototype._make,
@@ -2283,12 +3688,12 @@ function nativePrefix(scope, map, keys, key) {
     const slot = Object.getOwnPropertyDescriptor(map, name);
     if (!slot || !slot.enumerable || !("value" in slot)) break;
     Object.defineProperty(prefix, name, { value: slot.value, enumerable: true, configurable: true });
-    const compiled = compileExtractPlan(prefix, scope.options);
-    if (!compiled) {
+    const compiled2 = compileExtractPlan(prefix, scope.options);
+    if (!compiled2) {
       delete prefix[name];
       break;
     }
-    plan = compiled;
+    plan = compiled2;
     count++;
   }
   if (!plan || !count) return void 0;
@@ -2316,10 +3721,12 @@ function extract(map) {
     const selector = typeof descriptor === "string" ? descriptor : descriptor.selector;
     const value = typeof descriptor === "string" ? "textContent" : descriptor.value ?? "textContent";
     const selection = this._findBySelector(selector, all ? Infinity : 1);
+    const rows = typeof value === "object" ? nativeRows(this, key, all, selector, value) : void 0;
     const read = (index) => {
       if (typeof value === "function") return value(selection[index], key, result);
       const scope = this._make === nativeExtractionMethods.make ? this._fromIds([selection.ids[index]]) : this._make(selection[index]);
-      return typeof value === "string" ? scope.prop(value) : scope.extract(value);
+      if (typeof value === "string") return scope.prop(value);
+      return rows ? completeRow(scope, value, rows, index) : scope.extract(value);
     };
     let extracted;
     if (all) {
@@ -2336,6 +3743,69 @@ function extract(map) {
   }
   return result;
 }
+function nativeRows(scope, key, all, selector, map) {
+  const keys = plainKeys(map);
+  if (!keys || scope._make !== nativeExtractionMethods.make || scope._findBySelector !== nativeExtractionMethods.find || scope.prop !== nativeExtractionMethods.prop || scope.extract !== nativeExtractionMethods.extract) return void 0;
+  const subset = /* @__PURE__ */ Object.create(null);
+  const nativeKeys = /* @__PURE__ */ new Set();
+  for (const name of keys) {
+    const slot = Object.getOwnPropertyDescriptor(map, name);
+    if (!slot || !slot.enumerable || !("value" in slot)) continue;
+    const single = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(single, name, { value: slot.value, enumerable: true, configurable: true });
+    if (!compileExtractPlan(single, scope.options)) continue;
+    Object.defineProperty(subset, name, { value: slot.value, enumerable: true, configurable: true });
+    nativeKeys.add(name);
+  }
+  if (!nativeKeys.size || nativeKeys.size === keys.length) return void 0;
+  const outer = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(outer, key, { value: all ? [{ selector, value: subset }] : { selector, value: subset }, enumerable: true, configurable: true });
+  const plan = compileExtractPlan(outer, scope.options);
+  if (!plan) return void 0;
+  const writes = writeCount();
+  const values = scope.op("extractPlan", { ids: scope.ids, plan });
+  hydrateExtractResult(values, plan.entries);
+  const extracted = values[key];
+  const rows = all ? extracted : extracted === void 0 ? [] : [extracted];
+  return Array.isArray(rows) ? { keys: nativeKeys, rows, writes } : void 0;
+}
+function completeRow(scope, map, rows, index) {
+  const row = {};
+  const native = rows.rows[index] ?? {};
+  for (const name in map) {
+    if (rows.keys.has(name) && writeCount() === rows.writes) {
+      row[name] = native[name];
+      continue;
+    }
+    const entry = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(entry, name, { value: map[name], enumerable: true, configurable: true });
+    fillEntries(scope, entry, row);
+  }
+  return row;
+}
+function fillEntries(scope, map, result) {
+  for (const key in map) {
+    const entry = map[key];
+    const all = Array.isArray(entry);
+    const descriptor = all ? entry[0] : entry;
+    const selector = typeof descriptor === "string" ? descriptor : descriptor.selector;
+    const value = typeof descriptor === "string" ? "textContent" : descriptor.value ?? "textContent";
+    const selection = scope._findBySelector(selector, all ? Infinity : 1);
+    const read = (index) => {
+      if (typeof value === "function") return value(selection[index], key, result);
+      const child = scope._make === nativeExtractionMethods.make ? scope._fromIds([selection.ids[index]]) : scope._make(selection[index]);
+      return typeof value === "string" ? child.prop(value) : child.extract(value);
+    };
+    if (all) {
+      const values = [];
+      for (let index = 0; index < selection.length; index += 1) {
+        const extracted = read(index);
+        if (extracted != null) values.push(...Array.isArray(extracted) ? extracted : [extracted]);
+      }
+      result[key] = values;
+    } else result[key] = selection.length ? read(0) : void 0;
+  }
+}
 async function extractCooperatively(selection, map) {
   let deadline = performance.now() + 4;
   let visits = 0;
@@ -2364,6 +3834,7 @@ async function extractCooperatively(selection, map) {
       const selector = typeof descriptor === "string" ? descriptor : descriptor.selector;
       const value = typeof descriptor === "string" ? "textContent" : descriptor.value ?? "textContent";
       const found = scope._findBySelector(selector, all ? Infinity : 1);
+      const rows = typeof value === "object" ? nativeRows(scope, key, all, selector, value) : void 0;
       const output = [];
       let single;
       const count = all ? found.length : Math.min(found.length, 1);
@@ -2373,7 +3844,7 @@ async function extractCooperatively(selection, map) {
         if (typeof value === "function") extracted = value(found[index], key, result);
         else {
           const child = scope._make === nativeExtractionMethods.make ? scope._fromIds([found.ids[index]]) : scope._make(found[index]);
-          extracted = typeof value === "string" ? child.prop(value) : child.extract === nativeExtractionMethods.extract ? (await walk(child, value)).value : child.extract(value);
+          extracted = typeof value === "string" ? child.prop(value) : rows ? completeRow(child, value, rows, index) : child.extract === nativeExtractionMethods.extract ? (await walk(child, value)).value : child.extract(value);
         }
         if (all) {
           if (extracted != null) output.push(...Array.isArray(extracted) ? extracted : [extracted]);
@@ -2432,12 +3903,12 @@ function sniffEncoding(buffer, options = {}) {
   if (!label) {
     const prefix = Buffer.from(buffer.subarray(0, options.maxBytes ?? 1024)).toString("latin1").replace(/<!--[\s\S]*?(?:-->|$)/g, "");
     for (const token of prefix.matchAll(/<meta\b([^>]*)>/gi)) {
-      const attributes2 = {};
+      const attributes = {};
       for (const attribute of token[1].matchAll(/([^\s=/'">]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g)) {
         const key = attribute[1].toLowerCase();
-        if (!(key in attributes2)) attributes2[key] = attribute[2] ?? attribute[3] ?? attribute[4] ?? "";
+        if (!(key in attributes)) attributes[key] = attribute[2] ?? attribute[3] ?? attribute[4] ?? "";
       }
-      const declared = attributes2.charset ?? (attributes2["http-equiv"]?.toLowerCase() === "content-type" ? /\bcharset\s*=\s*["']?([^\s;"']+)/i.exec(attributes2.content ?? "")?.[1] : void 0);
+      const declared = attributes.charset ?? (attributes["http-equiv"]?.toLowerCase() === "content-type" ? /\bcharset\s*=\s*["']?([^\s;"']+)/i.exec(attributes.content ?? "")?.[1] : void 0);
       label = encodingLabel(declared);
       if (label) {
         if (label === "utf-16le" || label === "utf-16be") label = "utf-8";
@@ -2974,13 +4445,22 @@ function createAPI(document, options, initialRoot = document.rootId()) {
   class LoadedCheerio extends Cheerio {
   }
   let api;
-  const initialize2 = function(selector, context, root, override) {
-    if (selector?.cheerio) return selector;
-    const opts = flattenOptions(override, internal);
-    const rootIds = root === void 0 ? [initialRoot] : typeof root === "string" ? [makeRoot(document, operation(document, "create", { html: root, options: opts }))] : root?.cheerio ? importNodes(document, root.toArray()) : importNodes(document, root);
+  const createRoot = (rootIds, opts) => {
     const rootInstance = new LoadedCheerio(api, document, rootIds, null, opts);
     rootInstance._root = rootInstance;
+    return rootInstance;
+  };
+  const initialize2 = function(selector, context, root, override) {
+    resumeCollection(document);
+    if (selector?.cheerio) {
+      exposeDocumentTo(document, selector[DOCUMENT]);
+      return selector;
+    }
+    const opts = flattenOptions(override, internal);
+    const rootInstance = createRoot(root === void 0 ? [initialRoot] : typeof root === "string" ? [makeRoot(document, operation(document, "create", { html: root, options: opts }))] : root?.cheerio ? importNodes(document, root.toArray()) : importNodes(document, root), opts);
     if (!selector) return new LoadedCheerio(api, document, [], rootInstance, opts);
+    const id = viewIdIn(document, selector);
+    if (id !== void 0) return new LoadedCheerio(api, document, [id], rootInstance, opts);
     if (typeof selector === "string" && isHtml(selector)) return new LoadedCheerio(api, document, operation(document, "create", { html: selector, options: opts }), rootInstance, opts);
     if (typeof selector === "object") {
       const values = "length" in selector && !selector.type ? Array.from(selector) : [selector];
@@ -2999,55 +4479,57 @@ function createAPI(document, options, initialRoot = document.rootId()) {
     }
     return searchContext.find(search);
   };
-  api = Object.assign(initialize2, {
+  api = Object.assign(initialize2, staticMethods, {
     load,
-    _root: getNode(document, initialRoot),
+    _root: rootNode(document, initialRoot),
     _options: internal,
     fn: LoadedCheerio.prototype,
-    prototype: LoadedCheerio.prototype,
-    root() {
-      return this(this._root);
-    },
-    html(dom2, renderOptions) {
-      if (!this) return "";
-      if (dom2 && typeof dom2 === "object" && !("length" in dom2) && !("type" in dom2)) {
-        renderOptions = dom2;
-        dom2 = void 0;
-      }
-      const nodes = dom2 === void 0 ? [this._root] : this(dom2).toArray();
-      const binding = nodeBinding(this._root);
-      return operation(binding.document, "render", { ids: importNodes(binding.document, nodes), options: flattenOptions(renderOptions, this._options) });
-    },
-    xml(dom2) {
-      const binding = nodeBinding(this._root);
-      return operation(binding.document, "render", { ids: importNodes(binding.document, dom2 === void 0 ? [this._root] : this(dom2).toArray()), options: { ...this._options, xmlMode: true, _useHtmlParser2: true } });
-    },
-    text(elements) {
-      if (!elements && !this) return "";
-      const nodes = elements ?? [this._root];
-      const binding = this ? nodeBinding(this._root) : nodeBinding(nodes[0]);
-      if (binding) return binding.document.text(importNodes(binding.document, nodes));
-      const doc = routeDocument(new (requireNative()).NativeDocument("", false));
-      return doc.text(importNodes(doc, nodes));
-    },
-    parseHTML(data2, context, keepScripts = typeof context === "boolean" ? context : false) {
-      if (!data2 || typeof data2 !== "string") return null;
-      if (typeof context === "boolean") keepScripts = context;
-      const parsed = this.load(data2, this._options, false);
-      if (!keepScripts) parsed("script").remove();
-      return parsed._root.children.slice();
-    },
-    extract(map) {
-      return this.root().extract(map);
-    },
-    contains,
-    merge
+    prototype: LoadedCheerio.prototype
   });
   return api;
 }
-function makeRoot(document, children2) {
+var staticMethods = {
+  root() {
+    return this(this._root);
+  },
+  html(dom2, renderOptions) {
+    if (!this) return "";
+    if (dom2 && typeof dom2 === "object" && !("length" in dom2) && !("type" in dom2)) {
+      renderOptions = dom2;
+      dom2 = void 0;
+    }
+    const nodes = dom2 === void 0 ? [this._root] : this(dom2).toArray();
+    const binding = nodeBinding(this._root);
+    return operation(binding.document, "render", { ids: importNodes(binding.document, nodes), options: flattenOptions(renderOptions, this._options) });
+  },
+  xml(dom2) {
+    const binding = nodeBinding(this._root);
+    return operation(binding.document, "render", { ids: importNodes(binding.document, dom2 === void 0 ? [this._root] : this(dom2).toArray()), options: { ...this._options, xmlMode: true, _useHtmlParser2: true } });
+  },
+  text(elements) {
+    if (!elements && !this) return "";
+    const nodes = elements ?? [this._root];
+    const binding = this ? nodeBinding(this._root) : nodeBinding(nodes[0]);
+    if (binding) return binding.document.text(importNodes(binding.document, nodes));
+    const doc = routeDocument(new (requireNative()).NativeDocument("", false));
+    return doc.text(importNodes(doc, nodes));
+  },
+  parseHTML(data2, context, keepScripts = typeof context === "boolean" ? context : false) {
+    if (!data2 || typeof data2 !== "string") return null;
+    if (typeof context === "boolean") keepScripts = context;
+    const parsed = this.load(data2, this._options, false);
+    if (!keepScripts) parsed("script").remove();
+    return parsed._root.children.slice();
+  },
+  extract(map) {
+    return this.root().extract(map);
+  },
+  contains,
+  merge
+};
+function makeRoot(document, children) {
   const id = operation(document, "createNode", { type: "root" });
-  operation(document, "setNode", { id, field: "children", value: children2 });
+  operation(document, "setNode", { id, field: "children", value: children });
   return id;
 }
 function load(content, options, isDocument2 = true) {
@@ -3182,4 +4664,4 @@ export {
   loadAll,
   extractAll
 };
-//# sourceMappingURL=chunk-DMRD3FGC.mjs.map
+//# sourceMappingURL=chunk-FPRP6UIX.mjs.map