frond-js 0.4.0

package/dist/chunk-2SUG7YFZ.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+// src/core/formats/probe.ts
+var PROBE_PREFIX_BYTES = 1024;
+var PDF_MAGIC = "%PDF-";
+var ZIP_MAGIC = [80, 75, 3, 4];
+var MOBI_MARKER = "BOOKMOBI";
+var MOBI_MARKER_OFFSET = 60;
+var XML_DECLARATION = "<?xml";
+var FB2_ROOT = "<FictionBook";
+var UTF8_BOM = [239, 187, 191];
+var EPUB_CONTAINER_ENTRY = "META-INF/container.xml";
+var FB2_EXTENSION = ".fb2";
+var IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif"];
+function probeFormat(prefix) {
+  if (matchesAscii(prefix, 0, PDF_MAGIC)) {
+    return { kind: "format", format: "pdf", evidence: `%PDF- \u9B54\u6570\uFF08offset 0\uFF09` };
+  }
+  if (matchesBytes(prefix, 0, ZIP_MAGIC)) {
+    return {
+      kind: "container",
+      container: "zip",
+      evidence: "PK\\x03\\x04 \u9B54\u6570\uFF08offset 0\uFF09\u2014\u2014 ZIP \u5BB9\u5668\uFF0C\u9700\u8BFB\u6761\u76EE\u540D\u624D\u80FD\u5B9A\u683C\u5F0F"
+    };
+  }
+  if (matchesAscii(prefix, MOBI_MARKER_OFFSET, MOBI_MARKER)) {
+    return {
+      kind: "format",
+      format: "mobi",
+      evidence: `BOOKMOBI \u6807\u8BB0\uFF08offset ${String(MOBI_MARKER_OFFSET)}\uFF0CPalmDB \u5934\uFF09`
+    };
+  }
+  if (looksLikeFb2(prefix)) {
+    return {
+      kind: "format",
+      format: "fb2",
+      evidence: "XML \u58F0\u660E\u6216 <FictionBook> \u6839\u5143\u7D20 + \u542B <FictionBook>"
+    };
+  }
+  return null;
+}
+function probeZipContainer(names) {
+  const entries = names.filter((name) => !name.endsWith("/"));
+  if (entries.includes(EPUB_CONTAINER_ENTRY)) {
+    return {
+      kind: "format",
+      format: "epub",
+      evidence: `ZIP \u5185\u542B ${EPUB_CONTAINER_ENTRY}\uFF08OCF \u89C4\u8303\u56FA\u5B9A\u4F4D\u7F6E\uFF09`
+    };
+  }
+  if (entries.some((name) => name.toLowerCase().endsWith(FB2_EXTENSION))) {
+    return {
+      kind: "format",
+      format: "fb2",
+      evidence: `ZIP \u5185\u542B ${FB2_EXTENSION} \u4E14\u65E0 ${EPUB_CONTAINER_ENTRY}\uFF08.fb2.zip \u53D8\u4F53\uFF09`
+    };
+  }
+  if (entries.some(
+    (name) => IMAGE_EXTENSIONS.some((extension) => name.toLowerCase().endsWith(extension))
+  )) {
+    return {
+      kind: "format",
+      format: "cbz",
+      evidence: `ZIP \u5185\u53EA\u6709\u56FE\u7247\u6761\u76EE\u4E14\u65E0 ${EPUB_CONTAINER_ENTRY}\uFF08CBZ\uFF09`
+    };
+  }
+  return null;
+}
+function matchesAscii(bytes, offset, text) {
+  if (offset < 0 || offset + text.length > bytes.byteLength) return false;
+  for (let i = 0; i < text.length; i++) {
+    if (bytes[offset + i] !== text.charCodeAt(i)) return false;
+  }
+  return true;
+}
+function matchesBytes(bytes, offset, expected) {
+  if (offset + expected.length > bytes.byteLength) return false;
+  for (let i = 0; i < expected.length; i++) {
+    if (bytes[offset + i] !== expected[i]) return false;
+  }
+  return true;
+}
+function indexOfAscii(bytes, text) {
+  const limit = bytes.byteLength - text.length;
+  for (let start = 0; start <= limit; start++) {
+    if (matchesAscii(bytes, start, text)) return start;
+  }
+  return -1;
+}
+function looksLikeFb2(prefix) {
+  if (indexOfAscii(prefix, FB2_ROOT) === -1) return false;
+  let start = matchesBytes(prefix, 0, UTF8_BOM) ? UTF8_BOM.length : 0;
+  for (; ; ) {
+    const byte = prefix[start];
+    if (byte === void 0 || !isAsciiWhitespace(byte)) break;
+    start++;
+  }
+  return matchesAscii(prefix, start, XML_DECLARATION) || matchesAscii(prefix, start, FB2_ROOT);
+}
+function isAsciiWhitespace(byte) {
+  return byte === 32 || byte === 9 || byte === 13 || byte === 10 || byte === 12 || byte === 11;
+}
+
+exports.EPUB_CONTAINER_ENTRY = EPUB_CONTAINER_ENTRY;
+exports.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS;
+exports.PROBE_PREFIX_BYTES = PROBE_PREFIX_BYTES;
+exports.probeFormat = probeFormat;
+exports.probeZipContainer = probeZipContainer;

package/dist/chunk-B2L2YVXD.js

@@ -0,0 +1,89 @@
+// src/errors.ts
+var FrondError = class extends Error {
+  /** 稳定错误码，用于程序化分支。 */
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "FrondError";
+    this.code = code;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ParseError = class extends FrondError {
+  constructor(message, options) {
+    super("ERR_PARSE", message, options);
+    this.name = "ParseError";
+  }
+};
+var FormatError = class extends FrondError {
+  constructor(message, options) {
+    super("ERR_FORMAT", message, options);
+    this.name = "FormatError";
+  }
+};
+var NetworkError = class extends FrondError {
+  constructor(message, options) {
+    super("ERR_NETWORK", message, options);
+    this.name = "NetworkError";
+  }
+};
+var SecurityError = class extends FrondError {
+  constructor(message, options) {
+    super("ERR_SECURITY", message, options);
+    this.name = "SecurityError";
+  }
+};
+var AbortError = class extends FrondError {
+  constructor(message = "\u64CD\u4F5C\u5DF2\u53D6\u6D88", options) {
+    super("ERR_ABORT", message, options);
+    this.name = "AbortError";
+  }
+};
+var StateError = class extends FrondError {
+  constructor(message, options) {
+    super("ERR_STATE", message, options);
+    this.name = "StateError";
+  }
+};
+function isFrondError(value) {
+  return value instanceof FrondError;
+}
+function isAbortError(value) {
+  if (value instanceof AbortError) return true;
+  return value instanceof Error && value.name === "AbortError";
+}
+
+// src/core/abort.ts
+function createAbortError(reason) {
+  const message = reason instanceof Error && reason.message !== "" ? reason.message : "\u64CD\u4F5C\u5DF2\u53D6\u6D88";
+  return new AbortError(message, reason === void 0 ? void 0 : { cause: reason });
+}
+function throwIfAborted(signal) {
+  if (signal === void 0 || !signal.aborted) return;
+  throw createAbortError(signal.reason);
+}
+function linkSignals(...signals) {
+  const active = signals.filter((signal) => signal !== void 0);
+  if (active.length === 0) return void 0;
+  if (active.length === 1) return active[0];
+  return AbortSignal.any(active);
+}
+function onAbort(signal, handler) {
+  if (signal === void 0) return () => void 0;
+  if (signal.aborted) {
+    handler();
+    return () => void 0;
+  }
+  const listener = () => {
+    handler();
+  };
+  signal.addEventListener("abort", listener, { once: true });
+  return () => {
+    signal.removeEventListener("abort", listener);
+  };
+}
+
+export { AbortError, FormatError, FrondError, NetworkError, ParseError, SecurityError, StateError, createAbortError, isAbortError, isFrondError, linkSignals, onAbort, throwIfAborted };

package/dist/chunk-D4KWSEZD.js

@@ -0,0 +1,393 @@
+import { ParseError } from './chunk-B2L2YVXD.js';
+
+// src/core/xml/parse.ts
+var PREDEFINED_ENTITIES = /* @__PURE__ */ new Map([
+  ["lt", "<"],
+  ["gt", ">"],
+  ["amp", "&"],
+  ["quot", '"'],
+  ["apos", "'"]
+]);
+var COMMENT_OPEN = "<!--";
+var COMMENT_CLOSE = "-->";
+var CDATA_OPEN = "<![CDATA[";
+var CDATA_CLOSE = "]]>";
+var DOCTYPE_OPEN = "<!DOCTYPE";
+var PROCESSING_INSTRUCTION_CLOSE = "?>";
+var CODE_TAB = 9;
+var CODE_LF = 10;
+var CODE_CR = 13;
+var CODE_SPACE = 32;
+var CODE_BANG = 33;
+var CODE_QUOTE = 34;
+var CODE_HASH = 35;
+var CODE_APOS = 39;
+var CODE_SLASH = 47;
+var CODE_LT = 60;
+var CODE_EQ = 61;
+var CODE_GT = 62;
+var CODE_QUESTION = 63;
+var CODE_OPEN_BRACKET = 91;
+var CODE_CLOSE_BRACKET = 93;
+var CODE_LOWER_X = 120;
+var CODE_BOM = 65279;
+var MAX_CODE_POINT = 1114111;
+var DEFAULT_MAX_DEPTH = 512;
+function isWhitespaceCode(code) {
+  return code === CODE_SPACE || code === CODE_TAB || code === CODE_LF || code === CODE_CR;
+}
+function isNameTerminator(code) {
+  return Number.isNaN(code) || isWhitespaceCode(code) || code === CODE_LT || code === CODE_GT || code === CODE_SLASH || code === CODE_EQ || code === CODE_QUESTION || code === CODE_QUOTE || code === CODE_APOS || code === CODE_BANG;
+}
+function normalizeNewlines(value) {
+  return value.includes("\r") ? value.replace(/\r\n?/g, "\n") : value;
+}
+function parseDecimalDigits(text) {
+  if (text === "") return void 0;
+  let value = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code < 48 || code > 57) return void 0;
+    value = value * 10 + (code - 48);
+    if (value > MAX_CODE_POINT) return void 0;
+  }
+  return value;
+}
+function parseHexDigits(text) {
+  if (text === "") return void 0;
+  let value = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    let digit;
+    if (code >= 48 && code <= 57) {
+      digit = code - 48;
+    } else if (code >= 97 && code <= 102) {
+      digit = code - 97 + 10;
+    } else if (code >= 65 && code <= 70) {
+      digit = code - 65 + 10;
+    } else {
+      return void 0;
+    }
+    value = value * 16 + digit;
+    if (value > MAX_CODE_POINT) return void 0;
+  }
+  return value;
+}
+function decodeReference(body) {
+  if (body === "") return void 0;
+  if (body.charCodeAt(0) !== CODE_HASH) return PREDEFINED_ENTITIES.get(body);
+  const digits = body.slice(1);
+  if (digits === "") return void 0;
+  let codePoint;
+  if (digits.charCodeAt(0) === CODE_LOWER_X) {
+    codePoint = parseHexDigits(digits.slice(1));
+  } else {
+    codePoint = parseDecimalDigits(digits);
+  }
+  if (codePoint === void 0 || codePoint > MAX_CODE_POINT) return void 0;
+  return String.fromCodePoint(codePoint);
+}
+function decodeEntities(raw) {
+  if (!raw.includes("&")) return raw;
+  let result = "";
+  let cursor = 0;
+  for (; ; ) {
+    const amp = raw.indexOf("&", cursor);
+    if (amp === -1) return result + raw.slice(cursor);
+    result += raw.slice(cursor, amp);
+    const semicolon = raw.indexOf(";", amp + 1);
+    if (semicolon === -1) {
+      return result + raw.slice(amp);
+    }
+    const decoded = decodeReference(raw.slice(amp + 1, semicolon));
+    result += decoded ?? raw.slice(amp, semicolon + 1);
+    cursor = semicolon + 1;
+  }
+}
+function splitName(name) {
+  const colon = name.indexOf(":");
+  if (colon === -1) return { prefix: "", localName: name };
+  return { prefix: name.slice(0, colon), localName: name.slice(colon + 1) };
+}
+var XmlParser = class {
+  #source;
+  #label;
+  #maxDepth;
+  #pos = 0;
+  /** 当前**已进入**的元素层数（根元素为 0 → 进入后即 1）。由 `#parseElement` 维护。 */
+  #depth = 0;
+  constructor(source, label, maxDepth) {
+    this.#source = source;
+    this.#label = label;
+    this.#maxDepth = maxDepth;
+  }
+  parseDocument() {
+    if (this.#source.charCodeAt(0) === CODE_BOM) this.#pos = 1;
+    for (; ; ) {
+      this.#skipMisc();
+      if (this.#startsWith(DOCTYPE_OPEN)) {
+        this.#skipDoctype();
+        continue;
+      }
+      break;
+    }
+    if (this.#atEnd()) this.#fail("\u6587\u6863\u7F3A\u5C11\u6839\u5143\u7D20", this.#pos);
+    const root = this.#parseElement();
+    this.#skipMisc();
+    if (!this.#atEnd()) this.#fail("\u6839\u5143\u7D20\u4E4B\u540E\u5B58\u5728\u591A\u4F59\u5185\u5BB9", this.#pos);
+    return root;
+  }
+  // -- 位置与错误 ----------------------------------------------------------
+  #atEnd() {
+    return this.#pos >= this.#source.length;
+  }
+  #startsWith(text) {
+    return this.#source.startsWith(text, this.#pos);
+  }
+  #skipWhitespace() {
+    while (isWhitespaceCode(this.#source.charCodeAt(this.#pos))) this.#pos += 1;
+  }
+  #fail(reason, offset) {
+    throw new ParseError(`XML \u89E3\u6790\u5931\u8D25\uFF1A${reason}\uFF08\u6E90: ${this.#label}\uFF0C\u504F\u79FB ${String(offset)}\uFF09`);
+  }
+  // -- 跳过类构造 ----------------------------------------------------------
+  #skipMisc() {
+    for (; ; ) {
+      const code = this.#source.charCodeAt(this.#pos);
+      if (isWhitespaceCode(code)) {
+        this.#pos += 1;
+        continue;
+      }
+      if (this.#startsWith(COMMENT_OPEN)) {
+        this.#skipComment();
+        continue;
+      }
+      if (this.#startsWith("<?")) {
+        this.#skipProcessingInstruction();
+        continue;
+      }
+      return;
+    }
+  }
+  #skipComment() {
+    const start = this.#pos;
+    const end = this.#source.indexOf(COMMENT_CLOSE, start + COMMENT_OPEN.length);
+    if (end === -1) this.#fail("\u6CE8\u91CA\u672A\u95ED\u5408", start);
+    this.#pos = end + COMMENT_CLOSE.length;
+  }
+  #skipProcessingInstruction() {
+    const start = this.#pos;
+    const end = this.#source.indexOf(PROCESSING_INSTRUCTION_CLOSE, start + 2);
+    if (end === -1) this.#fail("\u5904\u7406\u6307\u4EE4\u672A\u95ED\u5408", start);
+    this.#pos = end + PROCESSING_INSTRUCTION_CLOSE.length;
+  }
+  /** 跳过 DOCTYPE。内部子集用方括号计数，引号内的 `>` 不视为结束。 */
+  #skipDoctype() {
+    const start = this.#pos;
+    let index = start + DOCTYPE_OPEN.length;
+    let depth = 0;
+    while (index < this.#source.length) {
+      const code = this.#source.charCodeAt(index);
+      if (code === CODE_QUOTE || code === CODE_APOS) {
+        const close = this.#source.indexOf(String.fromCharCode(code), index + 1);
+        if (close === -1) this.#fail("DOCTYPE \u4E2D\u7684\u5F15\u53F7\u672A\u95ED\u5408", index);
+        index = close + 1;
+        continue;
+      }
+      if (code === CODE_OPEN_BRACKET) {
+        depth += 1;
+      } else if (code === CODE_CLOSE_BRACKET) {
+        depth -= 1;
+      } else if (code === CODE_GT && depth <= 0) {
+        this.#pos = index + 1;
+        return;
+      }
+      index += 1;
+    }
+    this.#fail("DOCTYPE \u672A\u95ED\u5408", start);
+  }
+  // -- 元素 ----------------------------------------------------------------
+  #parseElement() {
+    if (this.#depth >= this.#maxDepth) {
+      this.#fail(
+        `\u5143\u7D20\u5D4C\u5957\u8D85\u8FC7\u4E0A\u9650 ${String(this.#maxDepth)} \u5C42 \u2014\u2014 \u7578\u5F62\u6587\u6863\u5E38\u4EE5\u6781\u6DF1\u5D4C\u5957\u89E6\u53D1\u5BBF\u4E3B\u6808\u6EA2\u51FA\uFF0C\u6545\u6309\u89E3\u6790\u5931\u8D25\u5904\u7406\u800C\u975E\u7EE7\u7EED\u9012\u5F52`,
+        this.#pos
+      );
+    }
+    const { name, attributes, selfClosing } = this.#parseStartTag();
+    const { prefix, localName } = splitName(name);
+    if (selfClosing) {
+      return { type: "element", name, prefix, localName, attributes, children: [] };
+    }
+    this.#depth += 1;
+    const children = this.#parseContent(name);
+    this.#depth -= 1;
+    return { type: "element", name, prefix, localName, attributes, children };
+  }
+  #parseStartTag() {
+    const start = this.#pos;
+    if (this.#source.charCodeAt(this.#pos) !== CODE_LT) {
+      this.#fail('\u671F\u671B\u5143\u7D20\u8D77\u59CB\u6807\u8BB0 "<"', start);
+    }
+    this.#pos += 1;
+    const name = this.#readName();
+    if (name === "") this.#fail("\u5143\u7D20\u540D\u7F3A\u5931", start);
+    const attributes = /* @__PURE__ */ new Map();
+    for (; ; ) {
+      const beforeSpace = this.#pos;
+      this.#skipWhitespace();
+      const hadSpace = this.#pos > beforeSpace;
+      const code = this.#source.charCodeAt(this.#pos);
+      if (code === CODE_SLASH) {
+        if (this.#source.charCodeAt(this.#pos + 1) !== CODE_GT) {
+          this.#fail('\u81EA\u95ED\u5408\u6807\u8BB0\u683C\u5F0F\u9519\u8BEF\uFF0C\u671F\u671B "/>"', this.#pos);
+        }
+        this.#pos += 2;
+        return { name, attributes, selfClosing: true };
+      }
+      if (code === CODE_GT) {
+        this.#pos += 1;
+        return { name, attributes, selfClosing: false };
+      }
+      if (!hadSpace) this.#fail("\u5C5E\u6027\u4E4B\u95F4\u7F3A\u5C11\u7A7A\u767D\u5206\u9694", this.#pos);
+      const attributeStart = this.#pos;
+      const attributeName = this.#readName();
+      if (attributeName === "") this.#fail("\u5C5E\u6027\u540D\u7F3A\u5931", attributeStart);
+      if (attributes.has(attributeName)) {
+        this.#fail(`\u5C5E\u6027 "${attributeName}" \u91CD\u590D`, attributeStart);
+      }
+      this.#skipWhitespace();
+      if (this.#source.charCodeAt(this.#pos) !== CODE_EQ) {
+        this.#fail(`\u5C5E\u6027 "${attributeName}" \u7F3A\u5C11 "="`, this.#pos);
+      }
+      this.#pos += 1;
+      this.#skipWhitespace();
+      const quote = this.#source.charCodeAt(this.#pos);
+      if (quote !== CODE_QUOTE && quote !== CODE_APOS) {
+        this.#fail(`\u5C5E\u6027 "${attributeName}" \u7684\u503C\u5FC5\u987B\u7528\u5F15\u53F7\u5305\u88F9`, this.#pos);
+      }
+      this.#pos += 1;
+      const close = this.#source.indexOf(String.fromCharCode(quote), this.#pos);
+      if (close === -1) {
+        this.#fail(`\u5C5E\u6027 "${attributeName}" \u7684\u5F15\u53F7\u672A\u95ED\u5408`, this.#pos);
+      }
+      const rawValue = this.#source.slice(this.#pos, close);
+      attributes.set(attributeName, decodeEntities(normalizeNewlines(rawValue)));
+      this.#pos = close + 1;
+    }
+  }
+  #parseContent(expectedName) {
+    const children = [];
+    for (; ; ) {
+      if (this.#atEnd()) this.#fail(`\u5143\u7D20 <${expectedName}> \u672A\u95ED\u5408`, this.#pos);
+      if (this.#source.charCodeAt(this.#pos) !== CODE_LT) {
+        children.push(this.#readText());
+        continue;
+      }
+      const next = this.#source.charCodeAt(this.#pos + 1);
+      if (next === CODE_SLASH) {
+        this.#parseEndTag(expectedName);
+        return children;
+      }
+      if (this.#startsWith(COMMENT_OPEN)) {
+        this.#skipComment();
+        continue;
+      }
+      if (this.#startsWith(CDATA_OPEN)) {
+        children.push(this.#readCdata());
+        continue;
+      }
+      if (next === CODE_QUESTION) {
+        this.#skipProcessingInstruction();
+        continue;
+      }
+      if (next === CODE_BANG) {
+        this.#fail('\u5143\u7D20\u5185\u5BB9\u4E2D\u4E0D\u5141\u8BB8\u51FA\u73B0 "<!" \u58F0\u660E', this.#pos);
+      }
+      children.push(this.#parseElement());
+    }
+  }
+  #parseEndTag(expectedName) {
+    const start = this.#pos;
+    this.#pos += 2;
+    const name = this.#readName();
+    if (name === "") this.#fail("\u7ED3\u675F\u6807\u8BB0\u7F3A\u5C11\u5143\u7D20\u540D", start);
+    this.#skipWhitespace();
+    if (this.#source.charCodeAt(this.#pos) !== CODE_GT) {
+      this.#fail(`\u7ED3\u675F\u6807\u8BB0 </${name}> \u683C\u5F0F\u9519\u8BEF\uFF0C\u671F\u671B ">"`, this.#pos);
+    }
+    this.#pos += 1;
+    if (name !== expectedName) {
+      this.#fail(`\u6807\u7B7E\u4E0D\u5339\u914D\uFF1A\u671F\u671B </${expectedName}>\uFF0C\u5B9E\u9645 </${name}>`, start);
+    }
+  }
+  #readName() {
+    const start = this.#pos;
+    while (!isNameTerminator(this.#source.charCodeAt(this.#pos))) this.#pos += 1;
+    return this.#source.slice(start, this.#pos);
+  }
+  #readText() {
+    const start = this.#pos;
+    const next = this.#source.indexOf("<", this.#pos);
+    this.#pos = next === -1 ? this.#source.length : next;
+    const raw = this.#source.slice(start, this.#pos);
+    return { type: "text", value: decodeEntities(normalizeNewlines(raw)), cdata: false };
+  }
+  #readCdata() {
+    const start = this.#pos;
+    const contentStart = start + CDATA_OPEN.length;
+    const end = this.#source.indexOf(CDATA_CLOSE, contentStart);
+    if (end === -1) this.#fail("CDATA \u6BB5\u672A\u95ED\u5408", start);
+    this.#pos = end + CDATA_CLOSE.length;
+    return {
+      type: "text",
+      value: normalizeNewlines(this.#source.slice(contentStart, end)),
+      cdata: true
+    };
+  }
+};
+function parseXml(source, options) {
+  return new XmlParser(
+    source,
+    options?.source ?? "<anonymous>",
+    options?.maxDepth ?? DEFAULT_MAX_DEPTH
+  ).parseDocument();
+}
+
+// src/core/xml/query.ts
+function findAll(root, localName) {
+  const matched = [];
+  const walk = (node) => {
+    for (const child of node.children) {
+      if (child.type !== "element") continue;
+      if (child.localName === localName) matched.push(child);
+      walk(child);
+    }
+  };
+  walk(root);
+  return matched;
+}
+function findFirst(root, localName) {
+  for (const child of root.children) {
+    if (child.type !== "element") continue;
+    if (child.localName === localName) return child;
+    const found = findFirst(child, localName);
+    if (found !== void 0) return found;
+  }
+  return void 0;
+}
+function getAttribute(element, name) {
+  return element.attributes.get(name);
+}
+function getText(element) {
+  let text = "";
+  for (const child of element.children) {
+    text += child.type === "text" ? child.value : getText(child);
+  }
+  return text;
+}
+function isElement(node) {
+  return node.type === "element";
+}
+
+export { findAll, findFirst, getAttribute, getText, isElement, parseXml };