rusteerio 0.0.0-stage → 0.1.0

package/dist/chunk-DKULX6VO.mjs

@@ -0,0 +1,3185 @@
+import {
+  isHtml
+} from "./chunk-OHPGEY3E.mjs";
+
+// src/native.ts
+import { createRequire } from "module";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/codec.ts
+var reserved = /[\ud800-\ue800]/;
+var encoded = /[\ue000-\ue800]/;
+var escapeUnit = 59392;
+var isWellFormed = String.prototype.isWellFormed;
+function encodeString(value) {
+  if (!encoded.test(value) && (isWellFormed ? isWellFormed.call(value) : !reserved.test(value))) return value;
+  const parts = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        index++;
+        continue;
+      }
+    }
+    let replacement;
+    if (unit >= 55296 && unit <= 57343) replacement = String.fromCharCode(57344 + unit - 55296);
+    else if (unit >= 57344 && unit <= escapeUnit) replacement = "\uE800" + value[index];
+    if (replacement !== void 0) {
+      parts.push(value.slice(start, index), replacement);
+      start = index + 1;
+    }
+  }
+  return start === 0 ? value : parts.join("") + value.slice(start);
+}
+function decodeString(value) {
+  if (!encoded.test(value)) return value;
+  const parts = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index);
+    if (unit < 57344 || unit > escapeUnit) continue;
+    const next = value.charCodeAt(index + 1);
+    if (unit === escapeUnit) {
+      if (next < 57344 || next > escapeUnit || Number.isNaN(next)) continue;
+      parts.push(value.slice(start, index), value[++index]);
+    } else parts.push(value.slice(start, index), String.fromCharCode(55296 + unit - 57344));
+    start = index + 1;
+  }
+  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))));
+}
+function decodeJson(value) {
+  return decodeJsonCandidate.test(value) ? value.replace(stringToken, (token) => JSON.stringify(decodeString(JSON.parse(token)))) : value;
+}
+function encodeOptions(value) {
+  if (value === void 0) return '{"__utf16Codec":true}';
+  const json = encodeJson(value);
+  if (!json.trimStart().startsWith("{")) return '{"__utf16Codec":true}';
+  const end = json.lastIndexOf("}");
+  const prefix = json.slice(0, end);
+  return prefix + (prefix.trimEnd().endsWith("{") ? "" : ",") + '"__utf16Codec":true' + json.slice(end);
+}
+
+// src/transport.ts
+var registryKey = /* @__PURE__ */ Symbol.for("rusteerio.native-transport.v1");
+var globals = globalThis;
+var registry = globals[registryKey] ??= { documents: /* @__PURE__ */ new WeakMap(), originals: /* @__PURE__ */ new WeakMap(), userErrors: /* @__PURE__ */ new WeakSet() };
+function wrapNativeBinding(binding) {
+  const raw = binding;
+  const { documents, originals, userErrors } = registry;
+  const restoreError = (error) => {
+    if (error instanceof Error && !userErrors.has(error)) {
+      const message = decodeString(error.message);
+      if (message !== error.message) {
+        const stack = error.stack;
+        error.message = message;
+        if (stack) error.stack = decodeString(stack);
+      }
+    }
+    throw error;
+  };
+  const invoke = (call) => {
+    try {
+      const result = call();
+      return result instanceof Promise ? result.catch(restoreError) : result;
+    } catch (error) {
+      return restoreError(error);
+    }
+  };
+  const wrapBridge = (bridge) => (request) => {
+    try {
+      return encodeJson(bridge(decodeJson(request)));
+    } catch (error) {
+      if (error !== null && (typeof error === "object" || typeof error === "function")) userErrors.add(error);
+      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;
+      }
+    });
+    documents.set(document, wrapped2);
+    originals.set(wrapped2, document);
+    return wrapped2;
+  };
+  const wrapStream = (stream) => {
+    let carry = "";
+    return {
+      async write(chunk) {
+        let source = carry + chunk;
+        carry = "";
+        const last = source.charCodeAt(source.length - 1);
+        if (last >= 55296 && last <= 56319) {
+          carry = source.slice(-1);
+          source = source.slice(0, -1);
+        }
+        if (source) await invoke(() => stream.write(encodeString(source)));
+      },
+      async finish() {
+        if (carry) {
+          const final = carry;
+          carry = "";
+          await invoke(() => stream.write(encodeString(final)));
+        }
+        return wrapDocument(await invoke(() => stream.finish()));
+      },
+      abort() {
+        carry = "";
+        return invoke(() => stream.abort());
+      }
+    };
+  };
+  const wrapConstructor = (Constructor, argumentsFor, wrap) => new Proxy(Constructor, {
+    construct(target, args) {
+      return wrap(invoke(() => Reflect.construct(target, argumentsFor(args))));
+    }
+  });
+  const wrapped = { ...raw };
+  wrapped.NativeDocument = wrapConstructor(raw.NativeDocument, ([html, isDocument2, options]) => [encodeString(html), isDocument2, encodeOptions(options)], wrapDocument);
+  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.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;
+}
+
+// src/native.ts
+var cached;
+var attempted = false;
+var bindingError;
+function nativeBinding() {
+  if (attempted) return cached;
+  attempted = true;
+  const moduleDirectory = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
+  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;
+  const platform = `${process.platform}-${process.arch}${libc ? `-${libc}` : process.platform === "win32" ? "-msvc" : ""}`;
+  const names = [`rusteerio.${platform}.node`, "rusteerio.node"];
+  const candidates = [...new Set(directories.flatMap((directory) => names.map((name) => join(directory, name))))];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const loaded = require2(candidate);
+      if (typeof loaded.NativeDocument === "function") {
+        cached = wrapNativeBinding(loaded);
+        return cached;
+      }
+    } catch (error) {
+      bindingError ??= error;
+    }
+  }
+  return void 0;
+}
+function requireNative() {
+  const binding = nativeBinding();
+  if (binding) return binding;
+  throw new Error('Rusteerio could not load its Rust native binding. Reinstall rusteerio for this platform or run "npm run build:native" from a source checkout.', { cause: bindingError });
+}
+function nativeStatus() {
+  const available = !!nativeBinding();
+  return available ? { available } : { available, error: String(bindingError ?? "Native binding not found") };
+}
+
+// src/hooks.ts
+var tokenCallbacks = ["onattribdata", "onattribentity", "onattribend", "onattribname", "oncdata", "onclosetag", "oncomment", "ondeclaration", "onend", "onopentagend", "onopentagname", "onprocessinginstruction", "onselfclosingtag", "ontext", "ontextentity"];
+function createTokenizerSession(options) {
+  const events = [];
+  const callbacks = Object.fromEntries(tokenCallbacks.map((name) => [name, (...args) => {
+    if (name === "ontextentity" || name === "onattribentity") {
+      const codePoint = +args[0];
+      String.fromCodePoint(codePoint);
+      args[0] = codePoint;
+    }
+    events.push([name, ...args]);
+  }]));
+  const Constructor = options.Tokenizer;
+  const tokenizer = new Constructor(options, callbacks);
+  return {
+    write(chunk) {
+      if (tokenizer.running) tokenizer.write(chunk);
+    },
+    end() {
+      tokenizer.end();
+      const result = cleanParserOptions(options);
+      result.__tokenEvents = events;
+      return result;
+    }
+  };
+}
+function cleanParserOptions(options) {
+  const result = { ...options };
+  delete result.Tokenizer;
+  delete result.treeAdapter;
+  delete result.onParseError;
+  delete result.__tokenEvents;
+  if (!options._useHtmlParser2 && options.onParseError) {
+    result.__collectParseErrors = true;
+    result.sourceCodeLocationInfo = true;
+  }
+  return result;
+}
+function parserOptions(source, options) {
+  if (options._useHtmlParser2 && options.Tokenizer) {
+    const session = createTokenizerSession(options);
+    session.write(source);
+    return session.end();
+  }
+  return cleanParserOptions(options);
+}
+function deliverParseErrors(document, options) {
+  if (options._useHtmlParser2 || !options.onParseError) return;
+  const diagnostics = document.parserDiagnostics?.();
+  const errors = typeof diagnostics === "string" ? JSON.parse(diagnostics) : diagnostics ?? [];
+  for (const error of errors) options.onParseError(error);
+}
+function hasParserHooks(options) {
+  return !!(options._useHtmlParser2 ? options.Tokenizer : options.treeAdapter || options.onParseError);
+}
+function treeAdapterBridge(adapter, options) {
+  const deliveredErrors = /* @__PURE__ */ new Set();
+  const nodes = [];
+  const ids = /* @__PURE__ */ new WeakMap();
+  const identify = (node) => {
+    if (node == null) return null;
+    if (typeof node !== "object") throw new TypeError("treeAdapter methods must return DOM node objects");
+    let id = ids.get(node);
+    if (id === void 0) {
+      id = nodes.length;
+      ids.set(node, id);
+      nodes.push(node);
+    }
+    return id;
+  };
+  const nodeArgs = {
+    appendChild: [0, 1],
+    insertBefore: [0, 1, 2],
+    setTemplateContent: [0, 1],
+    getTemplateContent: [0],
+    setDocumentType: [0],
+    setDocumentMode: [0],
+    getDocumentMode: [0],
+    detachNode: [0],
+    insertText: [0],
+    insertTextBefore: [0, 2],
+    adoptAttributes: [0],
+    getFirstChild: [0],
+    getChildNodes: [0],
+    getParentNode: [0],
+    getAttrList: [0],
+    getTagName: [0],
+    getNamespaceURI: [0],
+    getTextNodeContent: [0],
+    getCommentNodeContent: [0],
+    getDocumentTypeNodeName: [0],
+    getDocumentTypeNodePublicId: [0],
+    getDocumentTypeNodeSystemId: [0],
+    isTextNode: [0],
+    isCommentNode: [0],
+    isElementNode: [0],
+    isDocumentTypeNode: [0],
+    setNodeSourceCodeLocation: [0],
+    getNodeSourceCodeLocation: [0],
+    updateNodeSourceCodeLocation: [0],
+    onItemPop: [0, 1],
+    onItemPush: [0]
+  };
+  const nodeReturns = /* @__PURE__ */ new Set(["createDocument", "createDocumentFragment", "createElement", "createCommentNode", "createTextNode", "getTemplateContent", "getFirstChild", "getParentNode"]);
+  const invoke = (method, args) => {
+    const fn = adapter[method];
+    if (typeof fn !== "function") {
+      if (method === "onItemPop" || method === "onItemPush") return void 0;
+      throw new TypeError(`treeAdapter.${method} must be a function`);
+    }
+    return Reflect.apply(fn, adapter, args);
+  };
+  const snapshot = () => {
+    const records = [];
+    for (let id = 0; id < nodes.length; id++) {
+      const node = nodes[id];
+      const element = invoke("isElementNode", [node]);
+      const text = invoke("isTextNode", [node]);
+      const comment = invoke("isCommentNode", [node]);
+      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])) };
+      if (name !== void 0) record.name = name;
+      if (element) {
+        record.namespace = invoke("getNamespaceURI", [node]);
+        record.attribs = /* @__PURE__ */ Object.create(null);
+        record.attribsNamespace = /* @__PURE__ */ Object.create(null);
+        record.attribsPrefix = /* @__PURE__ */ Object.create(null);
+        for (const attr2 of invoke("getAttrList", [node])) {
+          Object.defineProperty(record.attribs, attr2.name, { value: attr2.value, enumerable: true, configurable: true, writable: true });
+          record.attribsNamespace[attr2.name] = attr2.namespace;
+          record.attribsPrefix[attr2.name] = attr2.prefix;
+        }
+      } else if (text || comment) record.data = invoke(text ? "getTextNodeContent" : "getCommentNodeContent", [node]);
+      else if (doctype) {
+        record.data = node.data;
+        for (const [field, method] of [["x-name", "getDocumentTypeNodeName"], ["x-publicId", "getDocumentTypeNodePublicId"], ["x-systemId", "getDocumentTypeNodeSystemId"]]) record[field] = invoke(method, [node]);
+      }
+      if (type === "root" && node["x-mode"] !== void 0) record["x-mode"] = invoke("getDocumentMode", [node]);
+      for (const field of ["startIndex", "endIndex", "sourceCodeLocation"]) if (node[field] !== void 0) record[field] = node[field];
+      records.push(record);
+    }
+    return records;
+  };
+  const bridge = (request) => {
+    const { method, args = [] } = JSON.parse(request);
+    if (method === "__parseError") {
+      deliveredErrors.add(JSON.stringify(args[0]));
+      options.onParseError?.(args[0]);
+      return "null";
+    }
+    if (method === "__snapshot") return JSON.stringify(snapshot());
+    if (method === "__locations") {
+      for (const entry of args[0]) invoke("setNodeSourceCodeLocation", [nodes[entry.id], hydrateLocation(entry.location)]);
+      return "null";
+    }
+    const values = args.slice();
+    if (method === "setNodeSourceCodeLocation" || method === "updateNodeSourceCodeLocation") hydrateLocation(values[1]);
+    for (const index of nodeArgs[method] ?? []) values[index] = values[index] == null ? null : nodes[values[index]];
+    const result = invoke(method, values);
+    return JSON.stringify(method === "getChildNodes" ? Array.from(result ?? [], identify) : nodeReturns.has(method) ? identify(result) : result ?? null);
+  };
+  return { bridge, nodes, deliveredErrors };
+}
+function bindAdapterDocument(document, options, adapter) {
+  if (options.onParseError) {
+    const errors = document.parserDiagnostics?.();
+    for (const error of errors ? JSON.parse(errors) : []) if (!adapter.deliveredErrors.has(JSON.stringify(error))) options.onParseError(error);
+  }
+  const routed = routeDocument(document, options);
+  const globalId = routed.localNodeId.bind(routed);
+  for (let id = 0; id < adapter.nodes.length; id++) getNode(routed, globalId(id), adapter.nodes[id]);
+  return routed;
+}
+function createTreeAdapterSession(options, isDocument2) {
+  const binding = requireNative();
+  if (!binding.NativeHookStream) throw new Error("This native addon does not support streaming treeAdapter hooks; rebuild the Rust addon.");
+  const adapter = treeAdapterBridge(options.treeAdapter, options);
+  let hasFailure = false;
+  let failure;
+  let aborted = false;
+  const bridge = (request) => {
+    if (hasFailure || aborted) return '{"__rusteerioHookError":true}';
+    try {
+      return adapter.bridge(request);
+    } catch (error) {
+      hasFailure = true;
+      failure = error;
+      return '{"__rusteerioHookError":true}';
+    }
+  };
+  const parser = new binding.NativeHookStream(isDocument2, JSON.stringify(cleanParserOptions(options)), bridge);
+  const restoreFailure = (error) => {
+    if (hasFailure) throw failure;
+    throw error;
+  };
+  return {
+    async write(chunk) {
+      try {
+        await parser.write(chunk);
+        if (hasFailure) throw failure;
+      } catch (error) {
+        restoreFailure(error);
+      }
+    },
+    async end() {
+      try {
+        const document = await parser.finish();
+        if (hasFailure) throw failure;
+        return bindAdapterDocument(document, options, adapter);
+      } catch (error) {
+        return restoreFailure(error);
+      }
+    },
+    abort() {
+      aborted = true;
+      parser.abort();
+    }
+  };
+}
+function parseNativeDocument(source, options, isDocument2) {
+  const binding = requireNative();
+  const nativeOptions = parserOptions(source, options);
+  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 adapter = treeAdapterBridge(options.treeAdapter, options);
+    return bindAdapterDocument(parse2(source, isDocument2, JSON.stringify(nativeOptions), adapter.bridge), options, adapter);
+  }
+  const document = new binding.NativeDocument(source, isDocument2, JSON.stringify(nativeOptions));
+  deliverParseErrors(document, options);
+  return routeDocument(document, options);
+}
+function createDiagnosticSession(options, isDocument2 = true) {
+  const binding = requireNative();
+  if (!binding.NativeStream) throw new Error("This native addon does not support incremental parser diagnostics; rebuild the Rust addon.");
+  let hasFailure = false;
+  let failure;
+  let aborted = false;
+  const bridge = (request) => {
+    if (hasFailure || aborted) return '{"__rusteerioHookError":true}';
+    try {
+      const { method, args } = JSON.parse(request);
+      if (method === "__parseError") options.onParseError?.(args[0]);
+      return "null";
+    } catch (error) {
+      hasFailure = true;
+      failure = error;
+      return '{"__rusteerioHookError":true}';
+    }
+  };
+  const parser = new binding.NativeStream(JSON.stringify(cleanParserOptions(options)), isDocument2, bridge);
+  const restoreFailure = (error) => {
+    if (hasFailure) throw failure;
+    throw error;
+  };
+  return {
+    async write(chunk) {
+      try {
+        await parser.write(chunk);
+        if (hasFailure) throw failure;
+      } catch (error) {
+        restoreFailure(error);
+      }
+    },
+    async end() {
+      try {
+        const document = await parser.finish();
+        if (hasFailure) throw failure;
+        return routeDocument(document, options);
+      } catch (error) {
+        return restoreFailure(error);
+      }
+    },
+    abort() {
+      aborted = true;
+      parser.abort();
+    }
+  };
+}
+
+// src/router.ts
+var registryKey2 = /* @__PURE__ */ Symbol.for("rusteerio.native-handles.v2");
+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?.();
+    }
+  };
+  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);
+    }
+  }) };
+})();
+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 {
+  nodeSpace = registry2.space;
+  options;
+  anchor;
+  get raw() {
+    return this.anchor.document;
+  }
+  constructor(document, options = {}, anchor) {
+    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));
+  }
+  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));
+  }
+  collectGarbage() {
+    registry2.snapshots.delete(this.raw);
+    return this.raw.collectGarbage?.();
+  }
+  retainNodeData(id, data2) {
+    this.lookup(id).data = data2;
+  }
+  nodeData(id) {
+    return this.lookup(id).data;
+  }
+  nodeDataOperation(id) {
+    const handle = this.lookup(id);
+    const options = this.options;
+    return (command, args) => rawOperation(handle.document, command, { ...args, ids: [handle.local], options });
+  }
+  localNodeId(id) {
+    return this.global(this.raw, id);
+  }
+  rootId() {
+    return this.global(this.raw, this.raw.rootId());
+  }
+  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;
+  }
+  groups(ids) {
+    const groups = [];
+    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] });
+    }
+    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);
+        }
+      }
+      return ids.map((id) => this.lookup(id).local);
+    }
+    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 }));
+        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));
+      result.push(...adopted.roots);
+    }
+    return result;
+  }
+  scratch(command, args, ids) {
+    const documents = [...new Set(ids.map((id) => this.lookup(id).document))];
+    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());
+      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));
+      for (const [local, copy] of copied.mapping) {
+        const global = this.global(document, local);
+        toScratch.set(global, copy);
+        fromScratch.set(copy, global);
+      }
+    }
+    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);
+    return ["select", "matches", "uniqueSort"].includes(command) ? result.map((id) => fromScratch.get(id)).filter((id) => id !== void 0) : result;
+  }
+  select(selector, contexts) {
+    const ids = contexts ?? [this.rootId()];
+    if (!ids.length) return this.call(this.raw, "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);
+    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);
+  }
+  text(ids) {
+    return this.groups(ids).map((group) => group.document.text(group.ids)).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] });
+  }
+  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("");
+  }
+  attr(id, name) {
+    const handle = this.lookup(id);
+    return this.call(handle.document, "attr", { ids: [handle.local], name }) ?? void 0;
+  }
+  tagName(id) {
+    const handle = this.lookup(id);
+    return rawOperation(handle.document, "node", { id: handle.local })?.name;
+  }
+  exportTree() {
+    return JSON.stringify(JSON.parse(this.raw.exportTree()).map((record) => this.record(this.raw, record)));
+  }
+  create(html, contextId) {
+    return JSON.parse(this.op("create", JSON.stringify({ 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;
+    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;
+      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);
+        }
+        value = this.lookup(args.value).local;
+      }
+      result = this.call(handle.document, command, { ...args, id: handle.local, value });
+    } else if (command === "insert") {
+      const targets = args.targetIds ?? [];
+      const nodes = args.nodeIds ?? [];
+      result = [];
+      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));
+      }
+    } 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;
+      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 });
+      }
+    } 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 result ?? null;
+  }
+};
+function routeDocument(document, options = {}) {
+  return document.nodeSpace === registry2.space ? document : new RoutedDocument(document, options);
+}
+function sameNodeSpace(first, second) {
+  return first === second || !!first.nodeSpace && first.nodeSpace === second.nodeSpace;
+}
+
+// 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*)$/;
+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 nodeBinding(node) {
+  return node && typeof node === "object" ? bindings.get(node) : void 0;
+}
+function nodeId(node, document) {
+  const binding = nodeBinding(node);
+  return binding && (!document || sameNodeSpace(document, binding.document)) ? binding.id : void 0;
+}
+function hydrateLocation(location) {
+  if (!location || typeof location !== "object") return location;
+  const value = location;
+  if (value.attrs && typeof value.attrs === "object") Object.setPrototypeOf(value.attrs, null);
+  if (value.startTag?.attrs && typeof value.startTag.attrs === "object") {
+    Object.setPrototypeOf(value.startTag.attrs, null);
+    if (value.attrs && JSON.stringify(value.attrs) === JSON.stringify(value.startTag.attrs)) value.startTag.attrs = value.attrs;
+  }
+  return location;
+}
+function nodeRecord(document, id) {
+  return operation(document, "node", { id });
+}
+function setField(document, id, field, value) {
+  operation(document, "setNode", { id, field, value });
+}
+function attributes(document, id, field = "attribs", prototype = document.options?._useHtmlParser2 === false ? null : Object.prototype) {
+  const read = () => nodeRecord(document, id)?.[field] ?? {};
+  const target = Object.create(prototype);
+  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);
+    },
+    set(_target, key, value) {
+      setField(document, id, field, { ...read(), [key]: String(value) });
+      return true;
+    },
+    deleteProperty(_target, key) {
+      const values = { ...read() };
+      delete values[key];
+      setField(document, id, field, values);
+      return true;
+    },
+    ownKeys() {
+      return Reflect.ownKeys(read());
+    },
+    has(_target, key) {
+      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;
+    },
+    defineProperty(_target, key, descriptor) {
+      const values = { ...read(), [key]: String(descriptor.value) };
+      setField(document, id, field, values);
+      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 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 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;
+}
+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);
+    }
+    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);
+  },
+  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));
+  },
+  ownKeys(target) {
+    const state = nodeState.views.get(target);
+    return [.../* @__PURE__ */ new Set([...viewKeys(nodeRecord(state.document, state.id)), ...Reflect.ownKeys(target)])];
+  },
+  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;
+  }
+};
+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);
+  };
+  const define = (key, get, set, enumerable = true) => {
+    try {
+      Object.defineProperty(node, key, { configurable: true, enumerable, get, ...set ? { set } : {} });
+    } catch {
+    }
+  };
+  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;
+}
+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 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);
+    if (existing !== void 0) {
+      document.retainNode?.(existing);
+      result.push(existing);
+      continue;
+    }
+    if (typeof node !== "object" || typeof node.type !== "string") continue;
+    const records = [];
+    const originals = /* @__PURE__ */ new Map();
+    const visit = (value, parent) => {
+      const id = records.length;
+      const record = { id, type: value.type, children: [], ...parent === void 0 ? {} : { parent } };
+      records.push(record);
+      originals.set(id, value);
+      for (const field of ["name", "data", "namespace", "prefix", "startIndex", "endIndex", "sourceCodeLocation", "x-name", "x-publicId", "x-systemId", "x-mode"]) if (value[field] !== void 0) record[field] = value[field];
+      if (value.attribs) record.attribs = { ...value.attribs };
+      if (value["x-attribsNamespace"]) record.attribsNamespace = { ...value["x-attribsNamespace"] };
+      if (value["x-attribsPrefix"]) record.attribsPrefix = { ...value["x-attribsPrefix"] };
+      record.children = (value.children ?? []).map((child) => visit(child, id));
+      return id;
+    };
+    const root = visit(node);
+    const imported = operation(document, "import", { nodes: records, roots: [root] });
+    if (!imported.length) continue;
+    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);
+      for (let i = 0; i < oldChildren.length; i++) if (newChildren[i] !== void 0) adopt(oldChildren[i], newChildren[i]);
+    };
+    adopt(root, imported[0]);
+    result.push(imported[0]);
+  }
+  return result;
+}
+
+// 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 = []) {
+  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) });
+  return getNode(document, id, node);
+}
+var Node = class {
+  static [Symbol.hasInstance](value) {
+    const binding = nodeBinding(value);
+    if (!binding) return Function.prototype[Symbol.hasInstance].call(this, value);
+    const type = value.type;
+    switch (this.name) {
+      case "Node":
+        return true;
+      case "DataNode":
+        return ["text", "comment", "directive"].includes(type);
+      case "NodeWithChildren":
+        return ["root", "tag", "script", "style", "cdata"].includes(type);
+      case "Element":
+        return ["tag", "script", "style"].includes(type);
+      case "Document":
+        return type === "root";
+      case "CDATA":
+        return type === "cdata";
+      case "Text":
+        return type === "text";
+      case "Comment":
+        return type === "comment";
+      case "ProcessingInstruction":
+        return type === "directive";
+      default:
+        return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+  }
+};
+var DataNode = class extends Node {
+};
+var NodeWithChildren = class extends Node {
+};
+var Text = class extends DataNode {
+  constructor(data2) {
+    super();
+    return initialize(this, "text", { data: data2 });
+  }
+};
+var Comment = class extends DataNode {
+  constructor(data2) {
+    super();
+    return initialize(this, "comment", { data: data2 });
+  }
+};
+var ProcessingInstruction = class extends DataNode {
+  constructor(name, data2) {
+    super();
+    return initialize(this, "directive", { name, data: data2 });
+  }
+};
+var Document = class extends NodeWithChildren {
+  constructor(children2) {
+    super();
+    return initialize(this, "root", {}, children2);
+  }
+};
+var CDATA = class extends NodeWithChildren {
+  constructor(children2) {
+    super();
+    return initialize(this, "cdata", {}, children2);
+  }
+};
+var Element = class extends NodeWithChildren {
+  constructor(name, attribs, children2 = [], type) {
+    super();
+    return initialize(this, type ?? (name === "script" || name === "style" ? name : "tag"), { name, attribs }, children2);
+  }
+};
+function nodePrototype(type) {
+  return ({ root: Document, text: Text, comment: Comment, directive: ProcessingInstruction, cdata: CDATA, tag: Element, script: Element, style: Element }[type] ?? Node).prototype;
+}
+var isTag = (node) => ["tag", "script", "style"].includes(node.type);
+var isText = (node) => node.type === "text";
+var isComment = (node) => node.type === "comment";
+var isDirective = (node) => node.type === "directive";
+var isDocument = (node) => node.type === "root";
+var isCDATA = (node) => node.type === "cdata";
+var hasChildren = (node) => "children" in node;
+Object.defineProperties(Node.prototype, {
+  cloneNode: { configurable: true, writable: true, value: cloneNode },
+  parentNode: { configurable: true, get() {
+    return this.parent;
+  }, set(value) {
+    this.parent = value;
+  } },
+  previousSibling: { configurable: true, get() {
+    return this.prev;
+  }, set(value) {
+    this.prev = value;
+  } },
+  nextSibling: { configurable: true, get() {
+    return this.next;
+  }, set(value) {
+    this.next = value;
+  } },
+  nodeType: { configurable: true, get() {
+    return { root: 9, text: 3, comment: 8, cdata: 4 }[this.type] ?? 1;
+  } }
+});
+Object.defineProperty(DataNode.prototype, "nodeValue", { configurable: true, get() {
+  return this.data;
+}, set(value) {
+  this.data = value;
+} });
+Object.defineProperties(NodeWithChildren.prototype, {
+  childNodes: { configurable: true, get() {
+    return this.children;
+  }, set(value) {
+    this.children = value;
+  } },
+  firstChild: { configurable: true, get() {
+    return this.children[0] ?? null;
+  } },
+  lastChild: { configurable: true, get() {
+    return this.children[this.children.length - 1] ?? null;
+  } }
+});
+Object.defineProperties(Element.prototype, {
+  tagName: { configurable: true, get() {
+    return this.name;
+  }, set(value) {
+    this.name = value;
+  } },
+  attributes: { configurable: true, get() {
+    return Object.keys(this.attribs).map((name) => ({ name, value: this.attribs[name], namespace: this["x-attribsNamespace"]?.[name], prefix: this["x-attribsPrefix"]?.[name] }));
+  } }
+});
+
+// src/extract-plan.ts
+import { types } from "util";
+var scalarProperties = /* @__PURE__ */ new Set([
+  "textContent",
+  "innerText",
+  "innerHTML",
+  "outerHTML",
+  "tagName",
+  "nodeName",
+  "nodeType",
+  "id",
+  "class",
+  "className",
+  "title",
+  "href",
+  "src",
+  "alt",
+  "name",
+  "value",
+  "type",
+  "checked",
+  "selected",
+  "disabled",
+  "multiple",
+  "readOnly",
+  "required",
+  "hidden",
+  "open",
+  "autofocus",
+  "controls",
+  "loop",
+  "muted"
+]);
+function dataValue(object, key) {
+  for (let current = object; current; current = Object.getPrototypeOf(current)) {
+    if (types.isProxy(current)) return void 0;
+    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+    if (descriptor) return "value" in descriptor ? { value: descriptor.value } : void 0;
+  }
+  return { value: void 0 };
+}
+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) => {
+    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;
+    }
+    ancestors.add(input);
+    try {
+      const entries2 = [];
+      for (const key in input) {
+        if (key === "__proto__") return void 0;
+        const inherited = Object.getOwnPropertyDescriptor(Object.prototype, key);
+        if (inherited && (!("value" in inherited) || !inherited.writable)) return void 0;
+        const slot = dataValue(input, key);
+        if (!slot) return void 0;
+        const all = Array.isArray(slot.value);
+        if (slot.value && typeof slot.value === "object" && types.isProxy(slot.value)) return void 0;
+        const first = all ? dataValue(slot.value, "0") : slot;
+        if (!first) return void 0;
+        const descriptor = first.value;
+        let selector;
+        let value;
+        if (typeof descriptor === "string") {
+          selector = descriptor;
+          value = "textContent";
+        } else if (descriptor && typeof descriptor === "object") {
+          if (types.isProxy(descriptor)) return void 0;
+          const selectorSlot = dataValue(descriptor, "selector");
+          const valueSlot = dataValue(descriptor, "value");
+          if (!selectorSlot || !valueSlot) return void 0;
+          selector = selectorSlot.value;
+          value = valueSlot.value ?? "textContent";
+        } else return void 0;
+        if (typeof selector !== "string") return void 0;
+        if (typeof value === "string") {
+          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);
+          if (!nested) return void 0;
+          entries2.push({ key, selector, all, value: { kind: "map", entries: nested } });
+        }
+      }
+      return entries2;
+    } finally {
+      ancestors.delete(input);
+    }
+  };
+  const entries = compile(map);
+  return entries && { version: 1, entries };
+}
+function hydrateExtractResult(result, entries) {
+  const values = entries.map((entry) => Object.hasOwn(result, entry.key) ? result[entry.key] : entry.all ? [] : void 0);
+  for (const entry of entries) delete result[entry.key];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    Object.defineProperty(result, entry.key, { value: values[index], enumerable: true, configurable: true, writable: true });
+    if (entry.value.kind !== "map") continue;
+    const nested = result[entry.key];
+    for (const value of entry.all && Array.isArray(nested) ? nested : [nested]) {
+      if (value && typeof value === "object" && !Array.isArray(value)) hydrateExtractResult(value, entry.value.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);
+});
+function isElement(selection, id) {
+  return ["tag", "script", "style"].includes(nodeRecord(selection._document, id)?.type);
+}
+function nativeValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const json = JSON.stringify(value, (_key, value2) => {
+    if (typeof value2 === "function" || typeof value2 === "symbol" || typeof value2 === "bigint" || value2 === void 0) return { __opaqueJavaScriptValue: true };
+    if (typeof value2 === "number" && !Number.isFinite(value2)) return { __nativeNumber: String(value2) };
+    if (value2 && typeof value2 === "object") {
+      if (seen.has(value2)) return { __opaqueJavaScriptValue: true };
+      seen.add(value2);
+    }
+    return value2;
+  });
+  return json === void 0 ? { __opaqueJavaScriptValue: true } : JSON.parse(json);
+}
+function hydrateValue(value) {
+  if (value && typeof value === "object") {
+    if (Object.keys(value).length === 1 && typeof value.__nativeNumber === "string") return Number(value.__nativeNumber);
+    for (const key of Object.keys(value)) value[key] = hydrateValue(value[key]);
+  }
+  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);
+  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 target = {};
+    data2 = new Proxy(target, {
+      set(object, name, value) {
+        Reflect.set(object, name, value);
+        if (typeof name === "string") dispatch("data", { ids: [id], name, value: nativeValue(value) });
+        return true;
+      },
+      defineProperty(object, name, descriptor) {
+        Reflect.defineProperty(object, name, descriptor);
+        if (typeof name === "string" && "value" in descriptor) dispatch("data", { ids: [id], name, value: nativeValue(descriptor.value) });
+        return true;
+      },
+      deleteProperty(object, name) {
+        Reflect.deleteProperty(object, name);
+        if (typeof name === "string") dispatch("removeData", { ids: [id], name });
+        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];
+    } });
+  }
+  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;
+}
+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;
+  return value;
+}
+function attr(name, value) {
+  if (typeof name === "object" || value !== void 0) {
+    if (typeof value === "function") {
+      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 current = node.attribs[name];
+        const next = value.call(node, index, current);
+        this.op("attr", { ids: [id], name, value: 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]) });
+    } else {
+      this.op("attr", { ids: this.ids, name, value: value === null ? null : String(value) });
+    }
+    return this;
+  }
+  if (arguments.length > 1) return this;
+  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;
+}
+function prop(name, value) {
+  if (typeof name === "string" && value === void 0) return this.ids.length ? property(this, this.ids[0], name) : void 0;
+  if (typeof name === "object" || value !== void 0) {
+    if (typeof value === "function") {
+      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));
+        this.op("prop", { ids: [id], name, value: propertyValue(this, name, next) });
+      });
+    } else if (typeof name === "object") {
+      for (const key of Object.keys(name)) this.op("prop", { ids: this.ids, name: key, value: propertyValue(this, key, name[key]) });
+    } else {
+      this.op("prop", { ids: this.ids, name, value: propertyValue(this, name, value) });
+    }
+    return this;
+  }
+  return void 0;
+}
+function data(name, value) {
+  const first = this.ids[0];
+  if (first === void 0 || !isElement(this, first)) return void 0;
+  if (name != null && (typeof name === "object" || value !== void 0)) {
+    for (const id of this.ids) {
+      if (!isElement(this, id)) continue;
+      const record2 = dataObject(this, id);
+      if (typeof name === "object") for (const key of Object.keys(name)) record2[key] = name[key];
+      else if (typeof name === "string") record2[name] = value;
+    }
+    return this;
+  }
+  const record = dataObject(this, first);
+  if (typeof name === "string" && Object.hasOwn(record, name)) return record[name];
+  const found = this.op("data", { ids: [first], ...name == null ? {} : { name } });
+  if (!found.found) return void 0;
+  if (name == null) {
+    for (const key of Object.keys(found.value)) if (!Object.hasOwn(record, key)) record[key] = hydrateValue(found.value[key]);
+    return record;
+  }
+  record[name] = hydrateValue(found.value);
+  return record[name];
+}
+function css(name, value) {
+  if (name != null && value != null || typeof name === "object" && !Array.isArray(name)) {
+    if (typeof name === "object") {
+      for (const [propertyIndex, key] of Object.keys(name).entries()) {
+        if (typeof name[key] === "function") {
+          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);
+            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]) });
+      }
+    } else if (typeof name === "string" && typeof value === "function") {
+      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);
+        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) });
+    return this;
+  }
+  return this.op("css", { ids: this.ids, ...name === void 0 ? {} : { name } }) ?? void 0;
+}
+function classMethod(command) {
+  return function(name, state) {
+    if (typeof name === "function") {
+      this.ids.forEach((id, index) => {
+        if (!isElement(this, id)) return;
+        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 } : {} });
+      });
+    } else if (typeof name === "string" || command === "removeClass" && arguments.length === 0) {
+      this.op(command, { ids: this.ids, ...typeof name === "string" ? { name } : { all: true }, ...typeof state === "boolean" ? { state } : {} });
+    }
+    return this;
+  };
+}
+function installAttributes(CheerioClass) {
+  Object.assign(CheerioClass.prototype, {
+    attr,
+    prop,
+    data,
+    css,
+    removeAttr(name) {
+      this.op("removeAttr", { ids: this.ids, name });
+      return this;
+    },
+    hasClass(name) {
+      return this.op("hasClass", { ids: this.ids, name });
+    },
+    addClass: classMethod("addClass"),
+    removeClass: classMethod("removeClass"),
+    toggleClass: classMethod("toggleClass"),
+    val(value) {
+      if (arguments.length === 0) return this.op("val", { ids: this.ids }) ?? void 0;
+      const result = this.op("val", { ids: this.ids, value: value === void 0 ? { __undefinedJavaScriptValue: true } : value });
+      return result?.chain === false ? result.returnValue : result === false ? void 0 : this;
+    },
+    serializeArray() {
+      return this.op("serializeArray", { ids: this.ids });
+    },
+    serialize() {
+      return this.op("serialize", { ids: this.ids });
+    }
+  });
+}
+
+// src/parse.ts
+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 root = operation(document2, "createNode", { type: "root", options });
+    operation(document2, "setNode", { id: root, field: "children", value: children2, options });
+    return getNode(document2, root);
+  }
+  const document = parseNativeDocument(content, options, isDocument2);
+  return getNode(document, document.rootId());
+}
+function parseWithParse5(content, options, isDocument2, context) {
+  return parseWithNative(content, { ...options, _useHtmlParser2: false, xml: false, xmlMode: false }, isDocument2, context);
+}
+function parseWithHtmlparser2(content, options) {
+  return parseWithNative(content, { ...options, _useHtmlParser2: true }, false, null);
+}
+function getParse(parser) {
+  return function parse2(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;
+    const document = routeDocument(new (requireNative()).NativeDocument("", false, JSON.stringify(cleanParserOptions(options))), options);
+    const ids = importNodes(document, content);
+    if (!Array.isArray(content) && content.type === "root") return getNode(document, ids[0]);
+    operation(document, "setNode", { id: document.rootId(), field: "children", value: ids, options });
+    return getNode(document, document.rootId());
+  };
+}
+var parse = getParse((content, options, isDocument2, context) => options._useHtmlParser2 ? parseWithHtmlparser2(content, options) : parseWithParse5(content, options, isDocument2, context));
+
+// src/selection.ts
+var numeric = /^(?:0|[1-9]\d*)$/;
+var isMarkup = (value) => /<[a-zA-Z!/?]/.test(value);
+function* customPseudoArguments(selector, name) {
+  let attributeDepth = 0;
+  let quote = "";
+  for (let index = 0; index < selector.length; index++) {
+    const character = selector[index];
+    if (character === "\\") {
+      index++;
+      continue;
+    }
+    if (quote) {
+      if (character === quote)
+        quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "[") {
+      attributeDepth++;
+      continue;
+    }
+    if (character === "]") {
+      attributeDepth--;
+      continue;
+    }
+    if (attributeDepth || character !== ":" || selector[index - 1] === ":")
+      continue;
+    const start = index + 1;
+    let end = start;
+    while (/[\w-]/.test(selector[end] ?? "") && end < selector.length)
+      end++;
+    if (selector.slice(start, end).toLowerCase() !== name.toLowerCase())
+      continue;
+    index = end - 1;
+    if (selector[end] !== "(") {
+      yield void 0;
+      continue;
+    }
+    const argumentStart = end + 1;
+    let depth = 1;
+    let argumentQuote = "";
+    for (end++; end < selector.length; end++) {
+      const next = selector[end];
+      if (next === "\\") {
+        end++;
+        continue;
+      }
+      if (argumentQuote) {
+        if (next === argumentQuote)
+          argumentQuote = "";
+        continue;
+      }
+      if (next === '"' || next === "'") {
+        argumentQuote = next;
+        continue;
+      }
+      if (next === "(")
+        depth++;
+      else if (next === ")" && --depth === 0)
+        break;
+    }
+    if (depth)
+      continue;
+    yield selector.slice(argumentStart, end);
+    index = end;
+  }
+}
+var Cheerio = class {
+  cheerio = "[cheerio object]";
+  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);
+      }
+    });
+  }
+  /** @internal */
+  get ids() {
+    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 });
+  }
+  /** @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 pseudoMatches = {};
+    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));
+      }
+    }
+    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);
+    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);
+    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]);
+    result.prevObject = this;
+    return result;
+  }
+  _parse(content, options, isDocument2, context) {
+    return parse(content, options, isDocument2, context);
+  }
+  _render(content) {
+    return this._document.outerHtml(importNodes(this._document, content));
+  }
+  /** @internal */
+  _domIds(content, contextId) {
+    if (content == null || content === false)
+      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 (typeof content === "object" && "length" in content && !content.type)
+      return Array.from(content).flatMap((item) => this._domIds(item, contextId));
+    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));
+  }
+  find(selector) {
+    if (!selector)
+      return this._fromIds([]);
+    if (typeof selector === "string")
+      return this._findBySelector(selector, Infinity);
+    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) {
+    const ids = this._query("select", { selector, contexts: this.ids });
+    return this._fromIds(Number.isFinite(limit) ? ids.slice(0, limit) : ids);
+  }
+  /** @internal */
+  _filterIds(ids, selector) {
+    if (!selector)
+      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));
+  }
+  /** @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;
+    if (selector?.cheerio)
+      return selector.toArray().includes(node);
+    return node === selector;
+  }
+  /** @internal */
+  _traverse(kind, selector) {
+    let ids = this.op("traverse", { ids: this.ids, kind });
+    ids = this._filterIds(ids, selector);
+    if (this.length > 1 && ids.length > 1) {
+      if (kind === "parents" || kind === "siblings")
+        ids = this.op("uniqueSort", { ids });
+      else if (!["next", "prev", "contents"].includes(kind))
+        ids = [...new Set(ids)];
+      if (kind === "parents")
+        ids.reverse();
+    }
+    return this._fromIds(ids);
+  }
+  parent(selector) {
+    return this._traverse("parent", selector);
+  }
+  parents(selector) {
+    return this._traverse("parents", selector);
+  }
+  next(selector) {
+    return this._traverse("next", selector);
+  }
+  prev(selector) {
+    return this._traverse("prev", selector);
+  }
+  nextAll(selector) {
+    return this._traverse("nextAll", selector);
+  }
+  prevAll(selector) {
+    return this._traverse("prevAll", selector);
+  }
+  siblings(selector) {
+    return this._traverse("siblings", selector);
+  }
+  children(selector) {
+    return this._traverse("children", selector);
+  }
+  contents() {
+    return this._traverse("contents");
+  }
+  /** @internal */
+  _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))
+          break;
+        ids.push(candidate);
+      }
+    ids = this._filterIds(ids, filter);
+    if (this.length > 1 && ids.length > 1)
+      ids = kind === "parents" ? this.op("uniqueSort", { ids }).reverse() : [...new Set(ids)];
+    return this._fromIds(ids);
+  }
+  parentsUntil(until, filter) {
+    return this._until("parents", until, filter);
+  }
+  nextUntil(until, filter) {
+    return this._until("nextAll", until, filter);
+  }
+  prevUntil(until, filter) {
+    return this._until("prevAll", until, filter);
+  }
+  closest(selector) {
+    if (!selector)
+      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));
+      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)
+        break;
+    return this;
+  }
+  map(callback) {
+    const result = [];
+    for (let i = 0; i < this.length; i++) {
+      const value = callback.call(this[i], i, this[i]);
+      if (value != null)
+        result.push(...Array.isArray(value) ? value : [value]);
+    }
+    return this._fromValues(result);
+  }
+  filter(selector) {
+    return typeof selector === "string" ? this._fromIds(this._query("matches", { ids: this.ids, selector, options: this.options })) : this._fromValues(this.toArray().filter((node, i) => this._predicate(selector, node, i)));
+  }
+  filterArray(nodes, match, xmlMode, root) {
+    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 ids = importNodes(document, nodes);
+    const selected = new Set(operation(document, "matches", { ids, selector: match, options: { xmlMode } }));
+    return nodes.filter((node) => {
+      const id = nodeId(node, document);
+      return id !== void 0 && selected.has(id);
+    });
+  }
+  not(selector) {
+    if (typeof selector === "string") {
+      const matched = new Set(this._query("matches", { ids: this.ids, selector, options: this.options }));
+      return this._fromIds(this.ids.filter((id) => !matched.has(id)));
+    }
+    return this._fromValues(this.toArray().filter((node, i) => !this._predicate(selector, node, i)));
+  }
+  is(selector) {
+    return typeof selector === "string" ? this._query("matches", { ids: this.ids, selector, options: this.options }).length > 0 : !!selector && this.toArray().some((node, i) => this._predicate(selector, node, i));
+  }
+  has(selector) {
+    return this.filter(((_i, node) => this._make(node).find(selector).length > 0));
+  }
+  first() {
+    return this.length > 1 ? this.slice(0, 1) : this;
+  }
+  last() {
+    return this.length > 0 ? this.slice(-1) : this;
+  }
+  eq(index) {
+    index = +index;
+    if (index === 0 && this.length <= 1)
+      return this;
+    if (index < 0)
+      index += this.length;
+    return this._fromValues(this[index] === void 0 ? [] : [this[index]]);
+  }
+  get(index) {
+    return index == null ? this.toArray() : this[index < 0 ? this.length + index : index];
+  }
+  toArray() {
+    return Array.from({ length: this.length }, (_unused, i) => this[i]);
+  }
+  slice(start, end) {
+    return this._values ? this._fromValues(this._values.slice(start, end)) : this._fromIds(this._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] }));
+  }
+  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 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];
+  }
+  /** @internal */
+  _insert(position, content) {
+    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;
+  }
+  append(...content) {
+    return this._insert("append", content);
+  }
+  prepend(...content) {
+    return this._insert("prepend", content);
+  }
+  before(...content) {
+    return this._insert("before", content);
+  }
+  after(...content) {
+    return this._insert("after", content);
+  }
+  appendTo(target) {
+    this._api(target).append(this);
+    return this;
+  }
+  prependTo(target) {
+    this._api(target).prepend(this);
+    return this;
+  }
+  /** @internal */
+  _insertRelative(target, position) {
+    const targets = this._api(target).ids;
+    this.remove();
+    const inserted = [];
+    for (const id of targets) {
+      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 });
+      inserted.push(...clones);
+    }
+    return this._fromIds(inserted);
+  }
+  insertBefore(target) {
+    return this._insertRelative(target, "before");
+  }
+  insertAfter(target) {
+    return this._insertRelative(target, "after");
+  }
+  remove(selector) {
+    this.op("remove", { ids: selector ? this.filter(selector).ids : this.ids });
+    return this;
+  }
+  replaceWith(content) {
+    return this.each((index, node) => {
+      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" });
+    });
+  }
+  empty() {
+    for (const id of this.ids)
+      this.op("setNode", { id, field: "children", value: [] });
+    return this;
+  }
+  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;
+    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);
+      this.op("setNode", { id, field: "children", value: nodes });
+    }
+    return this;
+  }
+  text(content) {
+    if (content === void 0)
+      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;
+      this.op("text", { ids: [id], value: String(value) });
+    }
+    return this;
+  }
+  toString() {
+    return this._document.outerHtml(this.ids);
+  }
+  clone() {
+    return this._fromIds(this.op("clone", { ids: this.ids, deep: true }));
+  }
+  /** @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];
+      if (child === void 0)
+        return id;
+      id = child;
+    }
+  }
+  /** @internal */
+  _wrap(content, inner) {
+    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 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))
+        continue;
+      const deepest = this._deepest(wrapper);
+      if (inner) {
+        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, 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] });
+      }
+    }
+    return this;
+  }
+  wrap(content) {
+    return this._wrap(content, false);
+  }
+  wrapInner(content) {
+    return this._wrap(content, true);
+  }
+  unwrap(selector) {
+    this.op("remove", { ids: this.parent(selector).not("body").ids, keepChildren: true });
+    return this;
+  }
+  wrapAll(content) {
+    if (!this.length)
+      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");
+    if (root !== void 0)
+      this.op("insert", { targetIds: [this._deepest(root, true)], nodeIds: this.ids, position: "append" });
+    return this;
+  }
+  extract(map) {
+    return extract.call(this, map);
+  }
+};
+Object.defineProperty(Cheerio.prototype, "cheerio", { value: "[cheerio object]", writable: true, configurable: true });
+installAttributes(Cheerio);
+var nativeExtractionMethods = Object.freeze({
+  make: Cheerio.prototype._make,
+  find: Cheerio.prototype._findBySelector,
+  prop: Cheerio.prototype.prop,
+  extract: Cheerio.prototype.extract
+});
+
+// src/extract.ts
+import { types as types2 } from "util";
+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;
+  const prefix = /* @__PURE__ */ Object.create(null);
+  let count = 0;
+  let plan;
+  const index = keys.indexOf(key);
+  for (let position = index; 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 compiled = compileExtractPlan(prefix, scope.options);
+    if (!compiled) {
+      delete prefix[name];
+      break;
+    }
+    plan = compiled;
+    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 };
+}
+function extract(map) {
+  const result = {};
+  const keys = plainKeys(map);
+  const processed = /* @__PURE__ */ new Set();
+  for (const key in map) {
+    if (processed.has(key)) continue;
+    const prefix = Object.getPrototypeOf(result) === Object.prototype ? nativePrefix(this, map, keys, key) : void 0;
+    if (prefix) {
+      for (const name of prefix.keys) {
+        Object.defineProperty(result, name, { value: prefix.values[name], enumerable: true, configurable: true, writable: true });
+        processed.add(name);
+      }
+      continue;
+    }
+    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 = this._findBySelector(selector, all ? Infinity : 1);
+    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);
+    };
+    let extracted;
+    if (all) {
+      const values = [];
+      for (let index = 0; index < selection.length; index += 1) {
+        const value2 = read(index);
+        if (value2 != null) values.push(...Array.isArray(value2) ? value2 : [value2]);
+      }
+      extracted = values;
+    } else {
+      extracted = selection.length ? read(0) : void 0;
+    }
+    result[key] = extracted;
+  }
+  return result;
+}
+async function extractCooperatively(selection, map) {
+  let deadline = performance.now() + 4;
+  let visits = 0;
+  const checkpoint = async () => {
+    if (++visits % 32 || performance.now() < deadline) return;
+    await new Promise((resolve) => setImmediate(resolve));
+    deadline = performance.now() + 4;
+  };
+  const walk = async (scope, descriptors) => {
+    const result = {};
+    const keys = plainKeys(descriptors);
+    const processed = /* @__PURE__ */ new Set();
+    for (const key in descriptors) {
+      if (processed.has(key)) continue;
+      const prefix = Object.getPrototypeOf(result) === Object.prototype ? nativePrefix(scope, descriptors, keys, key) : void 0;
+      if (prefix) {
+        for (const name of prefix.keys) {
+          Object.defineProperty(result, name, { value: prefix.values[name], enumerable: true, configurable: true, writable: true });
+          processed.add(name);
+        }
+        continue;
+      }
+      const entry = descriptors[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 found = scope._findBySelector(selector, all ? Infinity : 1);
+      const output = [];
+      let single;
+      const count = all ? found.length : Math.min(found.length, 1);
+      for (let index = 0; index < count; index++) {
+        await checkpoint();
+        let extracted;
+        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);
+        }
+        if (all) {
+          if (extracted != null) output.push(...Array.isArray(extracted) ? extracted : [extracted]);
+        } else single = extracted;
+      }
+      result[key] = all ? output : single;
+    }
+    return { value: result };
+  };
+  return await walk(selection, map);
+}
+
+// src/index.ts
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+import { availableParallelism } from "os";
+
+// src/workers.ts
+function configureWorkers(options) {
+  const threads = typeof options === "number" ? options : options?.threads;
+  if (!Number.isSafeInteger(threads) || threads < 1 || threads > 256) throw new RangeError("threads must be an integer from 1 to 256");
+  const binding = requireNative();
+  if (!binding.configureWorkerPool || !binding.workerPoolInfo) throw new Error("This native build does not support a shared worker pool");
+  binding.configureWorkerPool(threads);
+  return binding.workerPoolInfo();
+}
+function workerPoolInfo() {
+  const binding = requireNative();
+  if (!binding.workerPoolInfo) throw new Error("This native build does not support worker pool diagnostics");
+  return binding.workerPoolInfo();
+}
+
+// src/io.ts
+import { Readable, Writable } from "stream";
+import { request as requestHTTP } from "http";
+import { request as requestHTTPS } from "https";
+import { stringify as stringifyQuery } from "querystring";
+import { MIMEType } from "util";
+function encodingLabel(label) {
+  if (!label) return void 0;
+  if (label.trim().toLowerCase() === "x-user-defined") return "x-user-defined";
+  try {
+    return new TextDecoder(label.trim()).encoding;
+  } catch {
+    return void 0;
+  }
+}
+function sniffEncoding(buffer, options = {}) {
+  let label;
+  if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) label = "utf-8";
+  else if (buffer[0] === 255 && buffer[1] === 254) label = "utf-16le";
+  else if (buffer[0] === 254 && buffer[1] === 255) label = "utf-16be";
+  label ??= encodingLabel(options.userEncoding);
+  label ??= encodingLabel(options.transportLayerEncodingLabel);
+  if (!label && buffer[0] === 0 && buffer[1] === 60 && buffer[2] === 0 && buffer[3] === 63 && buffer[4] === 0 && buffer[5] === 120) label = "utf-16be";
+  if (!label && buffer[0] === 60 && buffer[1] === 0 && buffer[2] === 63 && buffer[3] === 0 && buffer[4] === 120 && buffer[5] === 0) label = "utf-16le";
+  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 = {};
+      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] ?? "";
+      }
+      const declared = attributes2.charset ?? (attributes2["http-equiv"]?.toLowerCase() === "content-type" ? /\bcharset\s*=\s*["']?([^\s;"']+)/i.exec(attributes2.content ?? "")?.[1] : void 0);
+      label = encodingLabel(declared);
+      if (label) {
+        if (label === "utf-16le" || label === "utf-16be") label = "utf-8";
+        if (label === "x-user-defined") label = "windows-1252";
+        break;
+      }
+    }
+    if (!label) {
+      const declaration = /<\?xml\b[^>]*\bencoding\s*=\s*["']([^"']+)["']/i.exec(prefix);
+      label = encodingLabel(declaration?.[1]);
+      if (label === "utf-16le" || label === "utf-16be") label = "utf-8";
+    }
+  }
+  label ??= encodingLabel(options.defaultEncoding) ?? "windows-1252";
+  return label;
+}
+function decodeBuffer(buffer, options = {}) {
+  const label = sniffEncoding(buffer, options);
+  if (label === "x-user-defined") {
+    let decoded = "";
+    for (const byte of buffer) decoded += String.fromCharCode(byte < 128 ? byte : 63232 + byte);
+    return decoded;
+  }
+  return new TextDecoder(label).decode(buffer);
+}
+function decodedInput(buffer, options) {
+  const { encoding, ...parserOptions2 } = options;
+  const xml = !!(options.xmlMode || options.xml);
+  return [decodeBuffer(buffer, { defaultEncoding: xml ? "utf-8" : "windows-1252", ...encoding }), parserOptions2];
+}
+function loadBuffer(buffer, options = {}) {
+  return load(...decodedInput(buffer, options));
+}
+function completion(callback) {
+  let completed = false;
+  return (error, document) => {
+    if (completed) return;
+    completed = true;
+    callback(error, document);
+  };
+}
+function requestHeaders(input) {
+  if (!input) return new Headers();
+  if (input instanceof Headers) return new Headers(input);
+  const headers = new Headers();
+  if (Array.isArray(input)) {
+    if (input.length % 2) throw new TypeError("HTTP header arrays must contain name/value pairs");
+    for (let index = 0; index < input.length; index += 2) headers.append(input[index], input[index + 1]);
+  } else {
+    const entries = Symbol.iterator in input ? input : Object.entries(input);
+    for (const [name, value] of entries) {
+      if (value == null) continue;
+      for (const item of Array.isArray(value) ? value : [value]) headers.append(name, item);
+    }
+  }
+  return headers;
+}
+async function requestDocument(url, method, headers, body, options, signal) {
+  if (options.typeOfService != null && (!Number.isInteger(options.typeOfService) || options.typeOfService < 0 || options.typeOfService > 255)) {
+    throw Object.assign(new Error("typeOfService must be an integer between 0 and 255"), { name: "InvalidArgumentError", code: "UND_ERR_INVALID_ARG" });
+  }
+  let payload = body;
+  if (body && typeof body === "object" && !(body instanceof Uint8Array) && !(body instanceof Readable)) {
+    let form;
+    if (body instanceof FormData) form = body;
+    else {
+      form = new FormData();
+      for (const [name, value] of body) {
+        if (typeof value === "string") form.append(name, value);
+        else if ("name" in value && typeof value.name === "string") form.append(name, value, value.name);
+        else form.append(name, value);
+      }
+    }
+    const encoded2 = new Request(url, { method: "POST", body: form });
+    payload = Readable.from((async function* () {
+      let previous = -1;
+      let last = -1;
+      for await (const chunk of Readable.fromWeb(encoded2.body)) {
+        const bytes = chunk;
+        if (bytes.length >= 2) previous = bytes[bytes.length - 2];
+        else if (bytes.length === 1) previous = last;
+        if (bytes.length) last = bytes[bytes.length - 1];
+        yield bytes;
+      }
+      if (previous !== 13 || last !== 10) yield Buffer.from("\r\n");
+    })());
+    if (!requestHeaders(options.headers).has("content-type")) headers.set("content-type", encoded2.headers.get("content-type"));
+  }
+  if (payload != null && !(payload instanceof Readable) && !(typeof payload === "object" && "getReader" in payload) && !headers.has("content-length") && !headers.has("transfer-encoding")) {
+    headers.set("content-length", String(typeof payload === "string" ? Buffer.byteLength(payload) : payload.byteLength));
+  }
+  const declaredLength = headers.has("content-length") ? Number(headers.get("content-length")) : void 0;
+  const lengthError = () => Object.assign(new Error("Request body length does not match content-length header"), { name: "RequestContentLengthMismatchError", code: "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH" });
+  const knownLength = typeof payload === "string" ? Buffer.byteLength(payload) : payload instanceof Uint8Array ? payload.byteLength : void 0;
+  if (declaredLength != null && knownLength != null && declaredLength !== knownLength) throw lengthError();
+  if (options.reset === true && !headers.has("connection")) headers.set("connection", "close");
+  return new Promise((resolve, reject) => {
+    let informationalError;
+    const request = (url.protocol === "https:" ? requestHTTPS : requestHTTP)(url, {
+      method,
+      headers: Object.fromEntries(headers),
+      signal,
+      ...typeof options.highWaterMark === "number" ? { highWaterMark: options.highWaterMark } : {}
+    }, (response) => {
+      if (informationalError) {
+        response.destroy();
+        return;
+      }
+      const rawHeaders = {};
+      for (let index = 0; index < response.rawHeaders.length; index += 2) {
+        const name = response.rawHeaders[index].toLowerCase();
+        const value = response.rawHeaders[index + 1];
+        if (!Object.hasOwn(rawHeaders, name)) Object.defineProperty(rawHeaders, name, { value, enumerable: true, writable: true, configurable: true });
+        else rawHeaders[name] = [...Array.isArray(rawHeaders[name]) ? rawHeaders[name] : [rawHeaders[name]], value];
+      }
+      const responseHeaders = new Headers();
+      for (const [name, value] of Object.entries(rawHeaders)) {
+        if (value == null) continue;
+        for (const item of Array.isArray(value) ? name === "content-type" ? value.slice(0, 1) : value : [value]) responseHeaders.append(name, item);
+      }
+      const status = response.statusCode ?? 0;
+      resolve({ status, ok: status >= 200 && status < 300, headers: responseHeaders, rawHeaders, body: Readable.toWeb(response) });
+    });
+    request.once("error", (error) => reject(signal.aborted ? signal.reason : error));
+    request.on("information", (information) => {
+      try {
+        options.onInfo?.({ statusCode: information.statusCode, headers: information.headers });
+      } catch (error) {
+        informationalError = error;
+        reject(error);
+        request.destroy(error);
+      }
+    });
+    request.once("socket", (socket) => {
+      const transport = socket;
+      try {
+        if (transport.setTypeOfService && options.typeOfService != null) transport.setTypeOfService(options.typeOfService);
+      } catch (error) {
+        request.destroy(error);
+        return;
+      }
+      if (socket.connecting) {
+        const timer = setTimeout(() => request.destroy(Object.assign(new Error("Connect Timeout Error"), { name: "ConnectTimeoutError", code: "UND_ERR_CONNECT_TIMEOUT" })), 1e4);
+        timer.unref();
+        socket.once(url.protocol === "https:" ? "secureConnect" : "connect", () => clearTimeout(timer));
+        request.once("close", () => clearTimeout(timer));
+      }
+    });
+    if (payload instanceof Readable || payload && typeof payload === "object" && "getReader" in payload) {
+      const source = payload instanceof Readable ? payload : Readable.fromWeb(payload);
+      if (declaredLength != null) {
+        let sent = 0;
+        source.on("data", (chunk) => {
+          sent += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.byteLength;
+          if (sent > declaredLength) {
+            request.destroy(lengthError());
+            source.destroy();
+          }
+        });
+        source.once("end", () => {
+          if (sent !== declaredLength) request.destroy(lengthError());
+        });
+      }
+      source.once("error", (error) => request.destroy(error));
+      request.once("close", () => {
+        if (!source.destroyed) source.destroy();
+      });
+      source.pipe(request);
+    } else request.end(payload);
+  });
+}
+function stringStream(options, callback) {
+  const complete = completion(callback);
+  const opts = flattenOptions(options);
+  const xml = !!opts._useHtmlParser2;
+  const binding = requireNative();
+  let native;
+  let writeNative;
+  let finishNative;
+  let abortNative;
+  let carry = "";
+  if (opts._useHtmlParser2 && opts.Tokenizer) {
+    const session = createTokenizerSession(opts);
+    const chunks = [];
+    writeNative = async (chunk) => {
+      chunks.push(chunk);
+      session.write(chunk);
+    };
+    finishNative = async () => {
+      const document = new binding.NativeDocument(chunks.join(""), true, JSON.stringify(session.end()));
+      chunks.length = 0;
+      return createAPI(routeDocument(document, opts), opts);
+    };
+    abortNative = () => {
+      chunks.length = 0;
+    };
+  } else if (!opts._useHtmlParser2 && opts.treeAdapter) {
+    const session = createTreeAdapterSession(opts, true);
+    writeNative = (chunk) => session.write(chunk);
+    finishNative = async () => createAPI(await session.end(), opts);
+    abortNative = () => session.abort();
+  } else if (!opts._useHtmlParser2 && opts.onParseError) {
+    const session = createDiagnosticSession(opts, true);
+    writeNative = (chunk) => session.write(chunk);
+    finishNative = async () => createAPI(await session.end(), opts);
+    abortNative = () => session.abort();
+  } else {
+    if (!binding.NativeStream) throw new Error("This native build does not support incremental parsing");
+    native = new binding.NativeStream(JSON.stringify(parserOptions("", opts)), true);
+    writeNative = (chunk) => native.write(chunk);
+    finishNative = async () => {
+      const document = await native.finish();
+      deliverParseErrors(document, opts);
+      return createAPI(routeDocument(document, opts), opts);
+    };
+    abortNative = () => native.abort();
+  }
+  const stream = new Writable({
+    decodeStrings: false,
+    write(chunk, _encoding, done) {
+      if (typeof chunk !== "string") throw new TypeError(xml ? "Expected a string" : "Parser can work only with string streams.");
+      if (opts._useHtmlParser2 && opts.Tokenizer) {
+        writeNative(chunk).then(() => done(), (error) => done(error));
+        return;
+      }
+      let text = carry + chunk;
+      carry = "";
+      const last = text.charCodeAt(text.length - 1);
+      if (last >= 55296 && last <= 56319) {
+        carry = text.slice(-1);
+        text = text.slice(0, -1);
+      }
+      if (!text) {
+        done();
+        return;
+      }
+      writeNative(text).then(() => done(), (error) => done(error));
+    },
+    final(done) {
+      (async () => {
+        if (carry) await writeNative(carry);
+        return finishNative();
+      })().then((document) => {
+        complete(null, document);
+        done();
+      }, (error) => done(error));
+    },
+    destroy(error, done) {
+      abortNative();
+      done(error);
+    }
+  });
+  stream.on("error", (error) => complete(error));
+  return stream;
+}
+function decodeStream(options, callback) {
+  const complete = completion(callback);
+  const { encoding = {}, ...parserOptions2 } = options ?? {};
+  const opts = flattenOptions(parserOptions2);
+  const decoderOptions = { defaultEncoding: opts.xmlMode ? "utf-8" : "windows-1252", ...encoding };
+  const maxBytes = decoderOptions.maxBytes ?? 1024;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("encoding.maxBytes must be a non-negative integer");
+  const prefixLimit = Math.max(6, maxBytes);
+  const prefix = [];
+  let prefixLength = 0;
+  let decoder;
+  let userDefined = false;
+  let started = false;
+  const parser = stringStream(opts, (error, document) => complete(error, document));
+  let downstreamError;
+  parser.on("error", (error) => {
+    downstreamError = error;
+    stream.destroy(error);
+  });
+  const writeText = (text) => new Promise((resolve, reject) => {
+    if (downstreamError) {
+      reject(downstreamError);
+      return;
+    }
+    if (!text) {
+      resolve();
+      return;
+    }
+    parser.write(text, (error) => error ? reject(error) : resolve());
+  });
+  const decode = (bytes, final = false) => {
+    if (userDefined) {
+      let text = "";
+      for (const byte of bytes) text += String.fromCharCode(byte < 128 ? byte : 63232 + byte);
+      return text;
+    }
+    return decoder.decode(bytes, { stream: !final });
+  };
+  const start = async () => {
+    const bytes = Buffer.concat(prefix, prefixLength);
+    const label = sniffEncoding(bytes, decoderOptions);
+    userDefined = label === "x-user-defined";
+    if (!userDefined) decoder = new TextDecoder(label);
+    started = true;
+    prefix.length = 0;
+    await writeText(decode(bytes));
+  };
+  const accept = async (bytes) => {
+    if (!started) {
+      const count = Math.min(prefixLimit - prefixLength, bytes.length);
+      if (count) {
+        prefix.push(Buffer.from(bytes.subarray(0, count)));
+        prefixLength += count;
+      }
+      bytes = bytes.subarray(count);
+      const declaredEncoding = encodingLabel(decoderOptions.userEncoding) || encodingLabel(decoderOptions.transportLayerEncodingLabel);
+      if (prefixLength >= prefixLimit || declaredEncoding && prefixLength >= 3) await start();
+    }
+    if (started && bytes.length) await writeText(decode(bytes));
+  };
+  const stream = new Writable({
+    write(chunk, encoding2, done) {
+      accept(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding2)).then(() => done(), (error) => done(error));
+    },
+    final(done) {
+      (async () => {
+        if (!started) await start();
+        await writeText(decode(new Uint8Array(), true));
+        await new Promise((resolve, reject) => {
+          parser.once("error", reject);
+          parser.end(() => {
+            parser.removeListener("error", reject);
+            resolve();
+          });
+        });
+      })().then(() => done(), (error) => done(error));
+    },
+    destroy(error, done) {
+      parser.destroy(error ?? void 0);
+      done(error);
+    }
+  });
+  stream.on("error", (error) => complete(error));
+  return stream;
+}
+async function fromURL(url, options = {}) {
+  const signal = options.requestOptions?.signal;
+  if (!signal) return loadURL(url, options);
+  if (typeof signal !== "object" && typeof signal !== "function") throw new TypeError("signal must be an AbortSignal or EventEmitter");
+  if ("addEventListener" in signal) return loadURL(url, options);
+  if (!("once" in signal) || !("removeListener" in signal)) throw new TypeError("signal must be an AbortSignal or EventEmitter");
+  const emitter = signal;
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  emitter.once("abort", abort);
+  try {
+    return await loadURL(url, { ...options, requestOptions: { ...options.requestOptions, signal: controller.signal } });
+  } finally {
+    emitter.removeListener("abort", abort);
+  }
+}
+async function loadURL(url, options) {
+  const { requestOptions = {}, encoding, ...parserOptions2 } = options;
+  const maxRedirects = requestOptions.maxRedirections ?? 5;
+  if (!Number.isInteger(maxRedirects) || maxRedirects < 0) throw new RangeError("maxRedirections must be a non-negative integer");
+  const headers = requestHeaders(requestOptions.headers);
+  if (!Object.hasOwn(requestOptions, "headers")) headers.set("accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
+  let current = new URL(url);
+  if (requestOptions.query) {
+    if (current.search || current.hash) throw new TypeError("URL must not contain a query or fragment when requestOptions.query is supplied");
+    current.search = stringifyQuery(requestOptions.query);
+  }
+  let method = requestOptions.method ?? "GET";
+  let body = requestOptions.body;
+  let response;
+  const controller = new AbortController();
+  const signal = requestOptions.signal ? AbortSignal.any([requestOptions.signal, controller.signal]) : controller.signal;
+  const timeoutError = (kind) => Object.assign(new Error(`${kind} Timeout Error`), {
+    name: `${kind}TimeoutError`,
+    code: kind === "Headers" ? "UND_ERR_HEADERS_TIMEOUT" : "UND_ERR_BODY_TIMEOUT"
+  });
+  for (const timeout of [requestOptions.headersTimeout, requestOptions.bodyTimeout]) {
+    if (timeout != null && (!Number.isFinite(timeout) || timeout < 0)) throw new RangeError("HTTP timeouts must be non-negative finite numbers");
+  }
+  const suppliedDispatcher = requestOptions.dispatcher;
+  if (suppliedDispatcher && typeof suppliedDispatcher.dispatch !== "function") throw new TypeError("requestOptions.dispatcher must implement dispatch");
+  const dispatcher = suppliedDispatcher && {
+    dispatch(dispatchOptions, handler) {
+      const { dispatcher: _dispatcher, throwOnError: _throwOnError, maxRedirections: _maxRedirections, query: _query, ...transport } = requestOptions;
+      return suppliedDispatcher.dispatch({ ...transport, ...dispatchOptions }, handler);
+    }
+  };
+  for (let redirects = 0; ; redirects += 1) {
+    let timer;
+    const headersTimeout = requestOptions.headersTimeout ?? 3e5;
+    if (headersTimeout) {
+      timer = setTimeout(() => controller.abort(timeoutError("Headers")), headersTimeout);
+      timer.unref();
+    }
+    try {
+      if (dispatcher) {
+        const init = { method, headers, body, redirect: "manual", signal, dispatcher };
+        if (body != null && typeof body !== "string") init.duplex = "half";
+        response = await fetch(current, init);
+      } else response = await requestDocument(current, method, headers, body, requestOptions, signal);
+    } catch (error) {
+      throw signal.aborted ? signal.reason : error;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    const location = response.headers.get("location");
+    if (![300, 301, 302, 303, 307, 308].includes(response.status) || !location) break;
+    const rewriteToGet = response.status === 303 && method.toUpperCase() !== "HEAD" || (response.status === 301 || response.status === 302) && method.toUpperCase() === "POST";
+    if (body instanceof Readable && body.readableDidRead && !rewriteToGet) break;
+    await response.body?.cancel();
+    if (redirects >= maxRedirects) throw new Error("max redirects reached");
+    const next = new URL(location, current);
+    headers.delete("host");
+    if (response.status === 303) {
+      for (const name of [...headers.keys()]) if (name.startsWith("content-")) headers.delete(name);
+    }
+    if (next.origin !== current.origin) {
+      headers.delete("authorization");
+      headers.delete("cookie");
+      headers.delete("proxy-authorization");
+    }
+    if (rewriteToGet) {
+      method = "GET";
+      body = void 0;
+      headers.delete("content-length");
+      headers.delete("content-type");
+    }
+    current = next;
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    const error = new Error("Response Error");
+    error.name = "ResponseError";
+    error.statusCode = response.status;
+    error.code = "UND_ERR_RESPONSE";
+    error.headers = response.rawHeaders ?? Object.fromEntries(response.headers);
+    throw error;
+  }
+  const contentType = response.headers.get("content-type") ?? "text/html";
+  let parsedType;
+  try {
+    parsedType = new MIMEType(contentType);
+  } catch {
+    await response.body?.cancel();
+    throw new Error(`Could not parse MIME type string "${contentType}"`);
+  }
+  const mime = parsedType.essence;
+  const xml = (parsedType.type === "application" || parsedType.type === "text") && parsedType.subtype === "xml" || parsedType.subtype.endsWith("+xml");
+  if (mime !== "text/html" && !xml) {
+    await response.body?.cancel();
+    throw new RangeError(`The content-type "${mime}" is neither HTML nor XML.`);
+  }
+  const charset = parsedType.params.get("charset") ?? void 0;
+  if (encoding) encoding.transportLayerEncodingLabel = charset;
+  const streamOptions = {
+    xmlMode: xml,
+    baseURI: current,
+    ...parserOptions2,
+    encoding: { ...encoding, transportLayerEncodingLabel: charset }
+  };
+  return new Promise((resolve, reject) => {
+    const parser = decodeStream(streamOptions, (error, document) => error ? reject(error) : resolve(document));
+    const reader = response.body?.getReader();
+    parser.once("error", (error) => {
+      controller.abort(error);
+      void reader?.cancel(error).catch(() => {
+      });
+    });
+    (async () => {
+      let received = 0;
+      const maxResponseSize = requestOptions.maxResponseSize;
+      if (maxResponseSize != null && (typeof maxResponseSize !== "number" || !Number.isSafeInteger(maxResponseSize) || maxResponseSize < -1)) throw new RangeError("maxResponseSize must be -1 or a non-negative integer");
+      while (reader) {
+        let timer;
+        const bodyTimeout = requestOptions.bodyTimeout ?? 3e5;
+        if (bodyTimeout) {
+          timer = setTimeout(() => controller.abort(timeoutError("Body")), bodyTimeout);
+          timer.unref();
+        }
+        let chunk;
+        try {
+          chunk = await reader.read();
+        } catch (error) {
+          throw controller.signal.aborted ? controller.signal.reason : error;
+        } finally {
+          if (timer) clearTimeout(timer);
+        }
+        if (chunk.done) break;
+        received += chunk.value.byteLength;
+        if (typeof maxResponseSize === "number" && maxResponseSize >= 0 && received > maxResponseSize) {
+          throw Object.assign(new Error("Response content exceeded maxResponseSize"), { name: "ResponseExceededMaxSizeError", code: "UND_ERR_RES_EXCEEDED_MAX_SIZE" });
+        }
+        await new Promise((resolve2, reject2) => parser.write(Buffer.from(chunk.value.buffer, chunk.value.byteOffset, chunk.value.byteLength), (error) => error ? reject2(error) : resolve2()));
+      }
+      parser.end();
+    })().catch((error) => {
+      parser.destroy(error);
+      reject(error);
+    });
+  });
+}
+
+// src/index.ts
+var dom = {
+  Node,
+  DataNode,
+  NodeWithChildren,
+  Document,
+  Element,
+  Text,
+  Comment,
+  ProcessingInstruction,
+  CDATA,
+  ElementType,
+  isTag,
+  isText,
+  isComment,
+  isDirective,
+  isDocument,
+  isCDATA,
+  hasChildren
+};
+function flattenOptions(options, base) {
+  const result = { _useHtmlParser2: false, ...base, ...options };
+  if (options?.xml) {
+    result._useHtmlParser2 = true;
+    result.xmlMode = true;
+    if (options.xml !== true) Object.assign(result, options.xml);
+  } else if (options?.xmlMode) result._useHtmlParser2 = true;
+  return result;
+}
+function createAPI(document, options, initialRoot = document.rootId()) {
+  const internal = flattenOptions(options);
+  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 rootInstance = new LoadedCheerio(api, document, rootIds, null, opts);
+    rootInstance._root = rootInstance;
+    if (!selector) return new LoadedCheerio(api, document, [], 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];
+      const allNodes = values.every((value) => value && typeof value === "object" && typeof value.type === "string");
+      return new LoadedCheerio(api, document, allNodes ? importNodes(document, values) : [], rootInstance, opts, allNodes ? void 0 : values);
+    }
+    if (typeof selector !== "string") throw new TypeError("Unexpected type of selector");
+    let search = selector;
+    let searchContext = rootInstance;
+    if (context) {
+      if (typeof context === "string") {
+        if (isHtml(context)) searchContext = new LoadedCheerio(api, document, [makeRoot(document, operation(document, "create", { html: context, options: opts }))], rootInstance, opts);
+        else search = `${context} ${search}`;
+      } else if (context.cheerio) searchContext = context;
+      else searchContext = new LoadedCheerio(api, document, importNodes(document, context), rootInstance, opts);
+    }
+    return searchContext.find(search);
+  };
+  api = Object.assign(initialize2, {
+    load,
+    _root: getNode(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
+  });
+  return api;
+}
+function makeRoot(document, children2) {
+  const id = operation(document, "createNode", { type: "root" });
+  operation(document, "setNode", { id, field: "children", value: children2 });
+  return id;
+}
+function load(content, options, isDocument2 = true) {
+  if (content == null) throw new Error("cheerio.load() expects a string");
+  const opts = flattenOptions(options);
+  const binding = requireNative();
+  const string = Buffer.isBuffer(content) ? content.toString() : typeof content === "string" ? content : void 0;
+  const document = string === void 0 ? routeDocument(new binding.NativeDocument("", false, JSON.stringify(cleanParserOptions(opts))), opts) : parseNativeDocument(string, opts, isDocument2);
+  if (string !== void 0) return createAPI(document, opts);
+  const nodes = importNodes(document, content);
+  if (!Array.isArray(content) && content.type === "root") return createAPI(document, opts, nodes[0]);
+  operation(document, "setNode", { id: document.rootId(), field: "children", value: nodes });
+  return createAPI(routeDocument(document, opts), opts);
+}
+async function loadAsync(content, options, isDocument2 = true) {
+  if (content == null) throw new Error("cheerio.load() expects a string");
+  if (typeof content !== "string" && !Buffer.isBuffer(content)) return load(content, options, isDocument2);
+  const binding = requireNative();
+  const opts = flattenOptions(options);
+  const html = String(content);
+  if (!opts._useHtmlParser2 && opts.treeAdapter) {
+    const session = createTreeAdapterSession(opts, isDocument2);
+    try {
+      await session.write(html);
+      return createAPI(await session.end(), opts);
+    } catch (error) {
+      session.abort();
+      throw error;
+    }
+  }
+  if (opts._useHtmlParser2 && opts.Tokenizer) return createAPI(parseNativeDocument(html, opts, isDocument2), opts);
+  const document = binding.parseAsync ? await binding.parseAsync(html, isDocument2, JSON.stringify(parserOptions(html, opts))) : new binding.NativeDocument(html, isDocument2, JSON.stringify(parserOptions(html, opts)));
+  deliverParseErrors(document, opts);
+  return createAPI(routeDocument(document, opts), opts);
+}
+function contains(container, contained) {
+  if (!container || !contained || container === contained) return false;
+  let parent = nodeBinding(container);
+  if (!parent) {
+    const document = routeDocument(new (requireNative()).NativeDocument("", false));
+    importNodes(document, [container]);
+    parent = nodeBinding(container);
+  }
+  const child = nodeBinding(contained);
+  return !!parent && !!child && sameNodeSpace(child.document, parent.document) && operation(parent.document, "contains", { container: parent.id, contained: child.id });
+}
+function merge(first, second) {
+  const arrayLike = (value) => Array.isArray(value) || value && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && Array.from({ length: value.length }, (_unused, i) => i in value).every(Boolean);
+  if (!arrayLike(first) || !arrayLike(second)) return void 0;
+  const writable = first;
+  let length = first.length;
+  for (let i = 0, count = +second.length; i < count; i++) writable[length++] = second[i];
+  writable.length = length;
+  return writable;
+}
+function parallelOptions(options) {
+  const { threads = Math.min(availableParallelism(), 256), ...opts } = options ?? {};
+  if (!Number.isSafeInteger(threads) || threads < 1 || threads > 256) throw new RangeError("threads must be an integer from 1 to 256");
+  return { options: flattenOptions(opts), threads };
+}
+async function loadAll(content, options, isDocument2 = true) {
+  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));
+}
+function nativeQueries(map, options) {
+  const queries = [];
+  const plainProperties = /^(?:id|class|title|href|src|alt|name|data-.+|aria-.+)$/;
+  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";
+    if (typeof value !== "string" || value !== "textContent" && !plainProperties.test(value) || options.baseURI && (value === "href" || value === "src") || options.pseudos) return void 0;
+    queries.push({ key, selector, all, ...value === "textContent" ? {} : { attr: value } });
+  }
+  return queries;
+}
+async function extractAll(content, map, options) {
+  const { options: opts, threads } = parallelOptions(options);
+  if (!Array.isArray(content) || content.some((item) => typeof item !== "string")) throw new TypeError("extractAll expects an array of HTML strings");
+  if (!content.length) return [];
+  const binding = requireNative();
+  const plan = hasParserHooks(opts) ? void 0 : compileExtractPlan(map, opts);
+  if (binding.extractPlanManyAsync && plan) {
+    const results2 = JSON.parse(await binding.extractPlanManyAsync([...content], JSON.stringify(plan), threads, JSON.stringify(opts)));
+    for (const result of results2) hydrateExtractResult(result, plan.entries);
+    return results2;
+  }
+  const queries = binding.extractPlanManyAsync || hasParserHooks(opts) ? void 0 : nativeQueries(map, opts);
+  if (binding.extractManyAsync && queries) {
+    const results2 = JSON.parse(await binding.extractManyAsync([...content], queries, threads, true, JSON.stringify(opts)));
+    for (const result of results2) for (const query of queries) {
+      if (!Object.hasOwn(result, query.key)) Object.defineProperty(result, query.key, { value: query.all ? [] : void 0, configurable: true, writable: true, enumerable: true });
+      if (query.all && Array.isArray(result[query.key])) result[query.key] = result[query.key].filter((value) => value != null);
+    }
+    return results2;
+  }
+  const documents = await loadAll(content, { ...opts, threads });
+  const results = [];
+  let yieldedAt = performance.now();
+  for (const document of documents) {
+    results.push((await extractCooperatively(document.root(), map)).value);
+    if (performance.now() - yieldedAt >= 4) {
+      await yieldToEventLoop();
+      yieldedAt = performance.now();
+    }
+  }
+  return results;
+}
+
+export {
+  nativeStatus,
+  configureWorkers,
+  workerPoolInfo,
+  loadBuffer,
+  stringStream,
+  decodeStream,
+  fromURL,
+  dom,
+  flattenOptions,
+  createAPI,
+  load,
+  loadAsync,
+  contains,
+  merge,
+  loadAll,
+  extractAll
+};
+//# sourceMappingURL=chunk-DKULX6VO.mjs.map