rusteerio 1.1.0 → 1.1.2

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

@@ -219,7 +219,7 @@ function wrapNativeBinding(binding) {
   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) => 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.parseManyAsync) wrapped.parseManyAsync = (sources, isDocument2, threads, options, plans) => invoke(() => raw.parseManyAsync(sources.map(encodeString), isDocument2, threads, encodeOptions(options), plans === void 0 ? void 0 : encodeJson(plans)));
   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;
@@ -266,6 +266,284 @@ function nativeStatus() {
   return available ? { available } : { available, error: String(bindingError ?? "Native binding not found") };
 }
 
+// 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 = [];
+  /** Per interned type: 1 for element types, 2 for root, 3 for text, 0 otherwise. */
+  typeKinds = [];
+  /** Node object constructors by interned type, resolved once per snapshot. */
+  viewConstructors = void 0;
+  /** Text nodes too large for the arrays, read individually while this snapshot is current. */
+  largeTexts = /* @__PURE__ */ new Map();
+  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];
+  }
+  /** Whether a node is an element: a tag, script or style. */
+  isElementAt(local) {
+    return this.typeKind(local) === 1;
+  }
+  isRootAt(local) {
+    return this.typeKind(local) === 2;
+  }
+  isTextAt(local) {
+    return this.typeKind(local) === 3;
+  }
+  /** Whether a node's record adds fields stored as JSON, such as source locations. */
+  hasExtraFields(local) {
+    return this.nodes[local * STRIDE + 14] !== 0;
+  }
+  /** Whether the slot holds a node, rather than one a collection released. */
+  isPresent(local) {
+    return local < this.size && (this.nodes[local * STRIDE + 10] & RELEASED) === 0;
+  }
+  typeKind(local) {
+    const reference = this.nodes[local * STRIDE];
+    let kind = this.typeKinds[reference];
+    if (kind === void 0) {
+      const type = this.name(reference);
+      kind = this.typeKinds[reference] = type === "tag" || type === "script" || type === "style" ? 1 : type === "root" ? 2 : type === "text" ? 3 : 0;
+    }
+    return kind;
+  }
+  /** 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/hooks.ts
 var tokenCallbacks = ["onattribdata", "onattribentity", "onattribend", "onattribname", "oncdata", "onclosetag", "oncomment", "ondeclaration", "onend", "onopentagend", "onopentagname", "onprocessinginstruction", "onselfclosingtag", "ontext", "ontextentity"];
 function createTokenizerSession(options) {
@@ -568,357 +846,110 @@ function replayIntoAdapter(document, adapter, isDocument2) {
   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]) };
+    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;
     }
-    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;
+    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;
     }
   }
-  /** 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;
+  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;
     }
-    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]);
+    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 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);
-  }
-};
+  return changes;
+}
 
 // src/router.ts
 var STRIDE2 = 2 ** 32;
@@ -1017,7 +1048,8 @@ function stateFor(raw, options = {}) {
     isExposed: false,
     hasChildLists: false,
     collectionRetries: 0,
-    isCollectionEvicted: false
+    isCollectionEvicted: false,
+    hasPreparedSnapshot: false
   };
   holder[stateKey] = state;
   return state;
@@ -1142,7 +1174,7 @@ function readRecord(state, local) {
     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());
+      const snapshot = new NodeSnapshot(takePreparedSnapshot(state, true) ?? state.raw.snapshot());
       state.snapshotSize = snapshot.size;
       state.bulk = snapshot;
       const record = snapshot.record(local);
@@ -1151,10 +1183,45 @@ function readRecord(state, local) {
   }
   return rawOperation(state.raw, "node", { id: local });
 }
+function usePreparedSnapshot(document) {
+  if (!(document instanceof RoutedDocument)) return;
+  const state = document.state;
+  state.hasPreparedSnapshot = state.generation === 0 && state.bulk === 0;
+}
+function takePreparedSnapshot(state, isWanted) {
+  if (!state.hasPreparedSnapshot) return void 0;
+  state.hasPreparedSnapshot = false;
+  return state.raw.takePreparedSnapshot?.(isWanted) ?? void 0;
+}
 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 structureSnapshot(state, local) {
+  const bulk = state.bulk;
+  return bulk instanceof NodeSnapshot && !(state.stale.size && state.stale.has(local)) && bulk.isPresent(local) ? bulk : void 0;
+}
+var snapshotTextBudget = 256;
+function textFromSnapshot(state, local) {
+  let text = "";
+  const stack = [local];
+  for (let visited = 0; stack.length; visited++) {
+    const node = stack.pop();
+    const snapshot = structureSnapshot(state, node);
+    if (!snapshot || visited === snapshotTextBudget) return void 0;
+    if (snapshot.isTextAt(node)) {
+      text += snapshot.dataOf(node) ?? largeText(state, snapshot, node);
+      continue;
+    }
+    for (let index = snapshot.childCount(node) - 1; index >= 0; index--) stack.push(snapshot.childAt(node, index));
+  }
+  return text;
+}
+function largeText(state, snapshot, local) {
+  let text = snapshot.largeTexts.get(local);
+  if (text === void 0) snapshot.largeTexts.set(local, text = state.raw.text([local]));
+  return text;
+}
 function attributeAt(state, local, name) {
   const snapshot = plainSnapshot(state, local);
   if (snapshot) return snapshot.attributeValue(local, name);
@@ -1163,15 +1230,18 @@ function attributeAt(state, local, name) {
   return typeof value === "string" ? value : void 0;
 }
 function invalidate(state) {
+  takePreparedSnapshot(state, false);
   state.generation++;
   state.records = [];
   state.bulk = 0;
   state.stale.clear();
 }
 function invalidateNodes(state, locals) {
+  takePreparedSnapshot(state, false);
   const isSnapshot = state.bulk instanceof NodeSnapshot;
+  const { records } = state;
   for (const local of locals) {
-    state.records[local] = void 0;
+    if (records[local] !== void 0) records[local] = void 0;
     if (isSnapshot) state.stale.add(local);
   }
 }
@@ -1406,6 +1476,11 @@ var RoutedDocument = class {
     return this.globals(group.state, found);
   }
   text(ids) {
+    if (ids.length === 1) {
+      const state = this.owner(ids[0]);
+      const text = textFromSnapshot(state, ids[0] - state.base);
+      if (text !== void 0) return text;
+    }
     return this.groups(ids).map((group) => group.state.raw.text(group.locals)).join("");
   }
   innerHtml(id) {
@@ -1490,9 +1565,12 @@ var RoutedDocument = class {
         return this.globals(state, inserted);
       }
       const result2 = [];
+      const isBesideTarget = args.position === "before" || args.position === "after";
       for (let index = 0; index < targets.length; index++) {
         const target = this.owner(targets[index]);
         const targetLocal = targets[index] - target.base;
+        const record = recordAt(target, targetLocal);
+        if (!record || !parentTypes.has(record.type) || isBesideTarget && record.parent == null) continue;
         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));
@@ -1715,6 +1793,8 @@ function traverseRecords(document, ids, kind) {
   for (const id of ids) {
     const state = stateIn(document, id);
     const { base } = state;
+    const snapshot = state.bulk instanceof NodeSnapshot ? state.bulk : void 0;
+    if (snapshot?.isPresent(id - base) && traverseSnapshot(snapshot, base, id - base, kind, result)) continue;
     const node = recordAt(state, id - base);
     if (!node) continue;
     const isElement2 = (local) => isElementType(recordAt(state, local)?.type);
@@ -1755,6 +1835,60 @@ function traverseRecords(document, ids, kind) {
   }
   return result;
 }
+function traverseSnapshot(snapshot, base, local, kind, result) {
+  const pushChildren2 = (parent, isElementsOnly, except) => {
+    const count = snapshot.childCount(parent);
+    for (let index = 0; index < count; index++) {
+      const child = snapshot.childAt(parent, index);
+      if (child !== except && (!isElementsOnly || snapshot.isElementAt(child))) result.push(base + child);
+    }
+  };
+  switch (kind) {
+    case "children":
+      pushChildren2(local, true, -1);
+      return true;
+    case "contents":
+      pushChildren2(local, false, -1);
+      return true;
+    case "siblings": {
+      const parent = snapshot.linkOf(local, 1);
+      if (parent !== null && snapshot.isPresent(parent)) pushChildren2(parent, true, local);
+      return true;
+    }
+    case "parent": {
+      const parent = snapshot.linkOf(local, 1);
+      if (parent !== null && snapshot.isPresent(parent) && snapshot.isElementAt(parent)) result.push(base + parent);
+      return true;
+    }
+    case "parents":
+    case "ancestors": {
+      let parent = snapshot.linkOf(local, 1);
+      for (let steps = 0; parent !== null && steps < snapshot.size && snapshot.isPresent(parent) && !snapshot.isRootAt(parent); steps++) {
+        if (snapshot.isElementAt(parent)) result.push(base + parent);
+        parent = snapshot.linkOf(parent, 1);
+      }
+      return true;
+    }
+    case "next":
+    case "prev":
+    case "nextAll":
+    case "prevAll": {
+      const offset = kind === "next" || kind === "nextAll" ? 3 : 2;
+      const isSingle = kind === "next" || kind === "prev";
+      let sibling = snapshot.linkOf(local, offset);
+      for (let steps = 0; sibling !== null && steps < snapshot.size && snapshot.isPresent(sibling); steps++) {
+        if (snapshot.isElementAt(sibling)) {
+          result.push(base + sibling);
+          if (isSingle) break;
+        }
+        sibling = snapshot.linkOf(sibling, offset);
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 function viewAt(state, local) {
   const existing = state.views[local] ?? cachedView(state, local);
   if (existing) return existing;
@@ -1763,9 +1897,9 @@ function viewAt(state, local) {
     state.adapterNodes[local] = void 0;
     return adoptObject(state, local, parsed);
   }
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   let constructor;
-  if (snapshot) constructor = viewConstructor(snapshot.typeOf(local), false);
+  if (snapshot && !snapshot.hasExtraFields(local)) constructor = viewConstructor(snapshot.typeOf(local), false);
   else {
     const record = recordAt(state, local);
     if (!record) return void 0;
@@ -1964,14 +2098,17 @@ function fillChildren(view) {
   if (!target) return;
   const state = view[VIEW_STATE];
   const local = view[VIEW_LOCAL];
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(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]);
+  truncate(target, locals.length);
+}
+function truncate(target, length) {
+  if (target.length !== length) target.length = length;
 }
 function fillFromSnapshot(state, snapshot, local, target) {
   const count = snapshot.childCount(local);
@@ -1980,17 +2117,17 @@ function fillFromSnapshot(state, snapshot, local, target) {
   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;
+      const constructor = isStrong && child < state.baseline && snapshot.isPresent(child) && !snapshot.hasExtraFields(child) ? constructors(snapshot.typeReference(child)) : void 0;
       if (constructor) views[child] = node = new constructor(state, child);
       else node = viewAt(state, child);
     }
     target[index] = node;
   }
+  truncate(target, count);
 }
 function snapshotConstructors(snapshot) {
   let lookup = snapshot.viewConstructors;
@@ -2013,7 +2150,7 @@ var snapshotField = (field) => ({
   get() {
     const state = this[VIEW_STATE];
     const local = this[VIEW_LOCAL];
-    const snapshot = plainSnapshot(state, local);
+    const snapshot = field === "data" ? plainSnapshot(state, local) : structureSnapshot(state, local);
     if (snapshot) return field === "type" ? snapshot.typeOf(local) : field === "name" ? snapshot.nameOf(local) : snapshot.dataOf(local);
     return viewRecord(this)[field];
   },
@@ -2026,7 +2163,7 @@ var pointerField = (field) => ({
   get() {
     const state = this[VIEW_STATE];
     const local = this[VIEW_LOCAL];
-    const snapshot = plainSnapshot(state, local);
+    const snapshot = structureSnapshot(state, local);
     return linkedView(this, snapshot ? snapshot.linkOf(local, linkOffsets[field]) : viewRecord(this)[field]);
   },
   set(value) {
@@ -2879,11 +3016,11 @@ function selectSimpleWithin(document, contexts, selector, options) {
 }
 var isElementType2 = (type) => type === "tag" || type === "script" || type === "style";
 function typeAt(state, local) {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   return snapshot ? snapshot.typeOf(local) : recordAt(state, local)?.type;
 }
 function pushChildren(state, local, stack) {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(state, local);
   if (snapshot) {
     for (let index = snapshot.childCount(local) - 1; index >= 0; index--) stack.push(snapshot.childAt(local, index));
     return;
@@ -2899,7 +3036,7 @@ function sameMatchOptions(documentOptions, isXml, isLowerCaseTags, isLowerCaseAt
   return isDocumentXml === isXml && (documentOptions.lowerCaseTags ?? !isDocumentXml) === isLowerCaseTags && (documentOptions.lowerCaseAttributeNames ?? !isDocumentXml) === isLowerCaseAttributes;
 }
 function matchesCompound(state, local, compound, isLowerCaseTags, isLowerCaseAttributes) {
-  const snapshot = plainSnapshot(state, local);
+  const snapshot = structureSnapshot(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;
@@ -3479,26 +3616,25 @@ var Cheerio = class {
   }
   /** @internal */
   _insert(position, content) {
+    if (typeof content[0] !== "function") {
+      const ids = this.ids;
+      if (ids.length) this.op("insert", { targetIds: ids, nodeIds: this._domIds(content), position });
+      return this;
+    }
     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)
-          return;
-        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 });
-        this.op("insert", { targetIds: [this.ids[index]], nodeIds: nodes2, position });
-      });
-    let nodes = this._domIds(content);
-    if (targets[targets.length - 1] !== this.ids[this.ids.length - 1])
-      nodes = this.op("clone", { ids: nodes, deep: true });
-    this.op("insert", { targetIds: targets, nodeIds: nodes, position });
-    return this;
+    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)
+        return;
+      const value = content[0].call(node, index, this[DOCUMENT].innerHtml(this.ids[index]));
+      let nodes = this._domIds(value);
+      if (index < this.length - 1)
+        nodes = this.op("clone", { ids: nodes, deep: true });
+      this.op("insert", { targetIds: [this.ids[index]], nodeIds: nodes, position });
+    });
   }
   append(...content) {
     return this._insert("append", content);
@@ -3678,28 +3814,30 @@ function plainKeys(map) {
   return !types2.isProxy(map) && (Object.getPrototypeOf(map) === Object.prototype || Object.getPrototypeOf(map) === null) ? Object.keys(map) : void 0;
 }
 function nativePrefix(scope, map, keys, key) {
-  if (!keys || scope._make !== nativeExtractionMethods.make || scope._findBySelector !== nativeExtractionMethods.find || scope.prop !== nativeExtractionMethods.prop || scope.extract !== nativeExtractionMethods.extract) return void 0;
+  if (!keys || !hasNativeExtraction(scope)) return void 0;
+  const prefix = prefixPlan(map, keys, key, scope.options);
+  if (!prefix) return void 0;
+  return { keys: prefix.names, values: runPlan(scope, prefix.plan) };
+}
+function prefixPlan(map, keys, key, options) {
   const prefix = /* @__PURE__ */ Object.create(null);
-  let count = 0;
   let plan;
-  const index = keys.indexOf(key);
-  for (let position = index; position < keys.length; position++) {
+  for (let position = keys.indexOf(key); position < keys.length; position++) {
     const name = keys[position];
     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 compiled2 = compileExtractPlan(prefix, scope.options);
+    const compiled2 = compileExtractPlan(prefix, options);
     if (!compiled2) {
       delete prefix[name];
       break;
     }
     plan = compiled2;
-    count++;
   }
-  if (!plan || !count) return void 0;
-  const values = scope.op("extractPlan", { ids: scope.ids, plan });
-  hydrateExtractResult(values, plan.entries);
-  return { keys: Object.keys(prefix), values };
+  return plan ? { names: Object.keys(prefix), plan } : void 0;
+}
+function hasNativeExtraction(scope) {
+  return scope._make === nativeExtractionMethods.make && scope._findBySelector === nativeExtractionMethods.find && scope.prop === nativeExtractionMethods.prop && scope.extract === nativeExtractionMethods.extract;
 }
 function extract(map) {
   const result = {};
@@ -3744,8 +3882,17 @@ function extract(map) {
   return result;
 }
 function nativeRows(scope, key, all, selector, map) {
+  if (!hasNativeExtraction(scope)) return void 0;
+  const planned = rowsPlan(key, all, selector, map, scope.options);
+  if (!planned) return void 0;
+  const writes = writeCount();
+  const extracted = runPlan(scope, planned.plan)[key];
+  const rows = all ? extracted : extracted === void 0 ? [] : [extracted];
+  return Array.isArray(rows) ? { keys: planned.nativeKeys, rows, writes } : void 0;
+}
+function rowsPlan(key, all, selector, map, options) {
   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;
+  if (!keys) return void 0;
   const subset = /* @__PURE__ */ Object.create(null);
   const nativeKeys = /* @__PURE__ */ new Set();
   for (const name of keys) {
@@ -3753,21 +3900,81 @@ function nativeRows(scope, key, all, selector, map) {
     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;
+    if (!compileExtractPlan(single, 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 });
+  const plan = compileExtractPlan(outer, options);
+  return plan ? { nativeKeys, plan } : void 0;
+}
+function rootExtractPlans(map, options) {
+  if (!isPlainData(map, 0) || hasInheritedEntryFields()) return [];
+  try {
+    return collectRootExtractPlans(map, options);
+  } catch {
+    return [];
+  }
+}
+function isPlainData(value, depth) {
+  if (typeof value !== "object" || value === null) return true;
+  if (depth > 32 || types2.isProxy(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== Array.prototype && prototype !== null) return false;
+  for (const key of Reflect.ownKeys(value)) {
+    const slot = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in slot) || !isPlainData(slot.value, depth + 1)) return false;
+  }
+  return true;
+}
+function hasInheritedEntryFields() {
+  return "selector" in Object.prototype || "value" in Object.prototype || "0" in Array.prototype;
+}
+function collectRootExtractPlans(map, options) {
+  const plans = [];
+  const keys = plainKeys(map);
+  const processed = /* @__PURE__ */ new Set();
+  for (const key in map) {
+    if (processed.has(key)) continue;
+    const prefix = keys ? prefixPlan(map, keys, key, options) : void 0;
+    if (prefix) {
+      for (const name of prefix.names) processed.add(name);
+      plans.push(prefix.plan);
+      continue;
+    }
+    const entry = map[key];
+    const all = Array.isArray(entry);
+    const descriptor = all ? entry[0] : entry;
+    const value = typeof descriptor === "string" ? "textContent" : descriptor.value ?? "textContent";
+    if (typeof value !== "object" || value === null) continue;
+    const planned = rowsPlan(key, all, typeof descriptor === "string" ? descriptor : descriptor.selector, value, options);
+    if (planned) plans.push(planned.plan);
+  }
+  return plans.filter((plan) => !JSON.stringify(plan).includes("innerHTML"));
+}
+var preparedPlans = /* @__PURE__ */ new WeakMap();
+function prepareExtractPlans(document, plans, results) {
+  if (!results) return;
+  const prepared = /* @__PURE__ */ new Map();
+  for (let index = 0; index < plans.length; index++) {
+    const result = results[index];
+    if (typeof result === "string") prepared.set(JSON.stringify(plans[index]), decodeJson(result));
+  }
+  preparedPlans.set(document, { writes: writeCount(), results: prepared });
+}
+function releaseExtractPlans(document) {
+  preparedPlans.delete(document);
+}
+function runPlan(scope, plan) {
+  const document = scope[DOCUMENT];
+  const prepared = preparedPlans.get(document);
+  const isRoot = prepared !== void 0 && prepared.writes === writeCount() && scope.ids.length === 1 && scope.ids[0] === document.rootId();
+  const result = isRoot ? prepared.results.get(JSON.stringify(plan)) : void 0;
+  const values = result !== void 0 ? JSON.parse(result) : 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;
+  return values;
 }
 function completeRow(scope, map, rows, index) {
   const row = {};
@@ -4431,7 +4638,9 @@ var dom = {
   isCDATA,
   hasChildren
 };
+var defaultOptions = { _useHtmlParser2: false };
 function flattenOptions(options, base) {
+  if (!options) return base ?? defaultOptions;
   const result = { _useHtmlParser2: false, ...base, ...options };
   if (options?.xml) {
     result._useHtmlParser2 = true;
@@ -4591,13 +4800,23 @@ function parallelOptions(options) {
   return { options: flattenOptions(opts), threads };
 }
 async function loadAll(content, options, isDocument2 = true) {
+  return loadAllWithPlans(content, options, isDocument2);
+}
+async function loadAllWithPlans(content, options, isDocument2, plans) {
   const { options: opts, threads } = parallelOptions(options);
   if (!Array.isArray(content) || content.some((item) => typeof item !== "string")) throw new TypeError("loadAll expects an array of HTML strings");
   if (!content.length) return [];
   const binding = requireNative();
   if (!binding.parseManyAsync || hasParserHooks(opts)) return Promise.all(content.map((html) => loadAsync(html, opts, isDocument2)));
-  const documents = await binding.parseManyAsync([...content], isDocument2, threads, JSON.stringify(opts));
-  return documents.map((document) => createAPI(routeDocument(document, opts), opts));
+  const documents = await binding.parseManyAsync([...content], isDocument2, threads, JSON.stringify(opts), plans && JSON.stringify(plans));
+  return documents.map((document) => {
+    const routed = routeDocument(document, opts);
+    if (plans) {
+      usePreparedSnapshot(routed);
+      prepareExtractPlans(routed, plans, document.takePreparedPlans?.());
+    }
+    return createAPI(routed, opts);
+  });
 }
 function nativeQueries(map, options) {
   const queries = [];
@@ -4633,11 +4852,16 @@ async function extractAll(content, map, options) {
     }
     return results2;
   }
-  const documents = await loadAll(content, { ...opts, threads });
+  const documents = await loadAllWithPlans(content, { ...opts, threads }, true, hasParserHooks(opts) ? void 0 : rootExtractPlans(map, opts));
   const results = [];
   let yieldedAt = performance.now();
   for (const document of documents) {
-    results.push((await extractCooperatively(document.root(), map)).value);
+    const root = document.root();
+    try {
+      results.push((await extractCooperatively(root, map)).value);
+    } finally {
+      releaseExtractPlans(root[DOCUMENT]);
+    }
     if (performance.now() - yieldedAt >= 4) {
       await yieldToEventLoop();
       yieldedAt = performance.now();
@@ -4664,4 +4888,4 @@ export {
   loadAll,
   extractAll
 };
-//# sourceMappingURL=chunk-FPRP6UIX.mjs.map
+//# sourceMappingURL=chunk-HN63P3U7.mjs.map