@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-XJXU3VVH.js

@@ -0,0 +1,737 @@
+import {
+  XmlQueryError
+} from "./chunk-NXEQ3ESQ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-xml-engine/src/evaluate.ts
+init_buffer();
+
+// packages/safe-bash-xml-engine/src/predicate.ts
+init_buffer();
+var precedence = { or: 1, and: 2, "=": 3, "!=": 3, "<": 4, "<=": 4, ">": 4, ">=": 4 };
+var arity = {
+  contains: [2],
+  "starts-with": [2],
+  "normalize-space": [0, 1],
+  not: [1],
+  position: [0],
+  last: [0],
+  concat: [2, Infinity],
+  substring: [2, 3],
+  "substring-before": [2],
+  "substring-after": [2],
+  translate: [3],
+  "string-length": [0, 1],
+  string: [0, 1],
+  count: [1],
+  boolean: [1],
+  true: [0],
+  false: [0],
+  number: [0, 1],
+  sum: [1],
+  floor: [1],
+  ceiling: [1],
+  round: [1],
+  name: [0, 1],
+  "local-name": [0, 1],
+  "namespace-uri": [0, 1]
+};
+var whitespace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+var digit = (c) => c >= "0" && c <= "9";
+var nameStart = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+var namePart = (c) => nameStart(c) || digit(c) || c === "-" || c === ".";
+function parsePredicate(source, budget) {
+  const output = [];
+  const stack = [];
+  let at = 0, expecting = true, depth = 0;
+  const fail = () => {
+    throw new XmlQueryError(`unsupported XPath predicate at offset ${at}`, 10);
+  };
+  const space = () => {
+    while (whitespace(source[at] ?? "")) at++;
+  };
+  const name = () => {
+    const start = at;
+    if (!nameStart(source[at] ?? "")) fail();
+    while (namePart(source[at] ?? "")) at++;
+    return source.slice(start, at);
+  };
+  const flush = () => {
+    while (stack.at(-1)?.kind === "operator") output.push(stack.pop());
+  };
+  while (true) {
+    space();
+    if (at === source.length) break;
+    const c = source[at];
+    if (c === ")") {
+      flush();
+      const group = stack.pop();
+      if (!group || group.kind !== "group") return fail();
+      if (expecting && (group.commas > 0 || group.name === void 0)) fail();
+      const count = expecting ? 0 : group.commas + 1;
+      if (group.name !== void 0) {
+        if (!(group.name === "concat" ? count >= 2 : arity[group.name].includes(count))) fail();
+        output.push({ kind: "function", name: group.name, count });
+      }
+      depth--;
+      at++;
+      expecting = false;
+      continue;
+    }
+    if (c === ",") {
+      if (expecting) fail();
+      flush();
+      const group = stack.at(-1);
+      if (!group || group.kind !== "group" || group.name === void 0) return fail();
+      group.commas++;
+      at++;
+      expecting = true;
+      continue;
+    }
+    if (!expecting) {
+      let operator;
+      if (c === "=" || c === "!" || c === "<" || c === ">") {
+        operator = c;
+        at++;
+        if (source[at] === "=") {
+          operator += "=";
+          at++;
+        }
+      } else operator = name();
+      if (!Object.hasOwn(precedence, operator)) fail();
+      const selected = operator;
+      while (stack.at(-1)?.kind === "operator") {
+        const top = stack.at(-1);
+        if (precedence[top.name] < precedence[selected]) break;
+        output.push(stack.pop());
+      }
+      stack.push({ kind: "operator", name: selected });
+      expecting = true;
+      continue;
+    }
+    let probe = at;
+    while (namePart(source[probe] ?? "")) probe++;
+    while (whitespace(source[probe] ?? "")) probe++;
+    const pathStart = c === "/" || c === "@" || c === "." && !digit(source[at + 1] ?? "") || nameStart(c) && (source[probe] !== "(" || source.startsWith("text", at));
+    if (pathStart) {
+      const start = at;
+      let brackets = 0, parentheses = 0, quote = "";
+      while (at < source.length) {
+        const ch = source[at];
+        if (quote) {
+          if (ch === quote) quote = "";
+        } else if (ch === "'" || ch === '"') quote = ch;
+        else if (ch === "[") brackets++;
+        else if (ch === "]") brackets--;
+        else if (!brackets && ch === "(") parentheses++;
+        else if (!brackets && ch === ")") {
+          if (!parentheses) break;
+          parentheses--;
+        } else if (!brackets && !parentheses && (ch === "," || ch === "=" || ch === "!" || ch === "<" || ch === ">")) break;
+        if (!quote && !brackets && !parentheses && whitespace(ch)) {
+          let next = at;
+          while (whitespace(source[next] ?? "")) next++;
+          let previous = at - 1;
+          while (previous >= start && whitespace(source[previous])) previous--;
+          if (!"/|".includes(source[next] ?? " ") && !"/|".includes(source[previous] ?? " ")) break;
+        }
+        at++;
+      }
+      output.push({ kind: "path", source: source.slice(start, at) });
+      expecting = false;
+      continue;
+    }
+    if (c === "(") {
+      stack.push({ kind: "group", commas: 0 });
+      depth++;
+      at++;
+    } else if (c === "'" || c === '"') {
+      const start = ++at;
+      while (at < source.length && source[at] !== c) at++;
+      if (at === source.length) fail();
+      output.push({ kind: "literal", value: source.slice(start, at++) });
+      expecting = false;
+    } else if (digit(c) || c === "-" || c === "." && digit(source[at + 1] ?? "")) {
+      const start = at;
+      if (c === "-") at++;
+      let digits = 0;
+      while (digit(source[at] ?? "")) {
+        at++;
+        digits++;
+      }
+      if (source[at] === ".") {
+        at++;
+        while (digit(source[at] ?? "")) {
+          at++;
+          digits++;
+        }
+      }
+      if (!digits) fail();
+      output.push({ kind: "literal", value: Number(source.slice(start, at)) });
+      expecting = false;
+    } else {
+      const selected = name();
+      space();
+      if (source[at++] !== "(" || !Object.hasOwn(arity, selected)) fail();
+      stack.push({ kind: "group", name: selected, commas: 0 });
+      depth++;
+    }
+    if (depth > budget.limits.maxDepth)
+      throw new XmlQueryError("maxDepth limit exceeded", 5);
+  }
+  if (expecting) fail();
+  flush();
+  if (stack.length) fail();
+  return output;
+}
+var boolean = (value) => Array.isArray(value) ? value.length > 0 : typeof value === "number" ? value !== 0 && !Number.isNaN(value) : Boolean(value);
+var string = (value) => Array.isArray(value) ? value[0]?.text ?? "" : String(value);
+var number = (value) => {
+  if (typeof value === "number") return value;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  const source = string(value);
+  let start = 0, end = source.length;
+  while (start < end && whitespace(source[start])) start++;
+  while (end > start && whitespace(source[end - 1])) end--;
+  const text = source.slice(start, end);
+  let at = text.startsWith("-") ? 1 : 0, digits = 0;
+  while (digit(text[at] ?? "")) {
+    at++;
+    digits++;
+  }
+  if (text[at] === ".") {
+    at++;
+    while (digit(text[at] ?? "")) {
+      at++;
+      digits++;
+    }
+  }
+  if (!digits) return NaN;
+  if (text[at] === "e" || text[at] === "E") {
+    at++;
+    if (text[at] === "+" || text[at] === "-") at++;
+    const start2 = at;
+    while (digit(text[at] ?? "")) at++;
+    if (at === start2) return NaN;
+  }
+  return at === text.length ? Number(text) : NaN;
+};
+async function compare(left, right, operator, budget) {
+  if (operator === "or") return boolean(left) || boolean(right);
+  if (operator === "and") return boolean(left) && boolean(right);
+  const equality = operator === "=" || operator === "!=";
+  if (equality && (typeof left === "boolean" || typeof right === "boolean"))
+    return operator === "=" ? boolean(left) === boolean(right) : boolean(left) !== boolean(right);
+  const numeric = !equality || typeof left === "number" || typeof right === "number";
+  for (const a of Array.isArray(left) ? left.map((item) => item.text) : [left]) for (const b of Array.isArray(right) ? right.map((item) => item.text) : [right]) {
+    const p = budget.tick(string(a).length + string(b).length + 1);
+    if (p) await p;
+    const x = numeric ? number(a) : string(a), y = numeric ? number(b) : string(b);
+    if (operator === "=" ? x === y : operator === "!=" ? x !== y : operator === "<" ? x < y : operator === "<=" ? x <= y : operator === ">" ? x > y : x >= y) return true;
+  }
+  return false;
+}
+function normalize(text) {
+  let result = "", pending = false;
+  for (const c of text) {
+    if (whitespace(c)) pending = result.length > 0;
+    else {
+      if (pending) result += " ";
+      result += c;
+      pending = false;
+    }
+  }
+  return result;
+}
+async function evaluateExpression(program, node, position, last, budget, select) {
+  const values = [];
+  const text = async (selected) => {
+    let value = "";
+    for await (const part of stringValue(selected, budget)) {
+      const p = budget.tick(part.length);
+      if (p) await p;
+      value += part;
+    }
+    return value;
+  };
+  const loaded = /* @__PURE__ */ new WeakSet();
+  const materialize = async (value, all = false) => {
+    if (!Array.isArray(value)) return;
+    for (let index = 0; index < (all ? value.length : Math.min(1, value.length)); index++) {
+      const item = value[index];
+      if (!loaded.has(item)) {
+        item.text = await text(item.node);
+        loaded.add(item);
+      }
+    }
+  };
+  for (const instruction of program) {
+    const p = budget.tick();
+    if (p) await p;
+    if (instruction.kind === "literal") values.push(instruction.value);
+    else if (instruction.kind === "path") {
+      if (!select) throw new XmlQueryError("absolute paths are unavailable in this context", 10);
+      const selected = [];
+      for (const item of await select(instruction.query, instruction.source.startsWith("/"))) selected.push({ text: "", node: item });
+      values.push(selected);
+    } else if (instruction.kind === "operator") {
+      const right = values.pop(), left = values.pop();
+      if (instruction.name !== "and" && instruction.name !== "or" && !(["=", "!="].includes(instruction.name) && (typeof left === "boolean" || typeof right === "boolean"))) {
+        await materialize(left, true);
+        await materialize(right, true);
+      }
+      values.push(await compare(left, right, instruction.name, budget));
+    } else {
+      const args = values.splice(values.length - instruction.count);
+      const first = args[0] ?? [{ text: "", node }];
+      if (!["count", "boolean", "not", "name", "local-name", "namespace-uri", "position", "last", "true", "false"].includes(instruction.name)) {
+        await materialize(first, instruction.name === "sum");
+        for (const arg of args.slice(1)) await materialize(arg);
+      }
+      const a = string(first), b = instruction.count > 1 ? string(args[1]) : "";
+      for (const arg of args) {
+        const p2 = budget.tick(Array.isArray(arg) ? arg.reduce((size, item) => size + item.text.length + 1, 0) : string(arg).length);
+        if (p2) await p2;
+      }
+      const nodes = () => {
+        if (!Array.isArray(first)) throw new XmlQueryError("XPath function requires a node-set", 10);
+        return first;
+      };
+      let result;
+      switch (instruction.name) {
+        case "position":
+          result = position;
+          break;
+        case "last":
+          result = last;
+          break;
+        case "not":
+          result = !boolean(first);
+          break;
+        case "boolean":
+          result = boolean(first);
+          break;
+        case "true":
+          result = true;
+          break;
+        case "false":
+          result = false;
+          break;
+        case "string":
+          result = a;
+          break;
+        case "number":
+          result = number(first);
+          break;
+        case "count":
+          result = nodes().length;
+          break;
+        case "sum": {
+          let total = 0;
+          for (const item of nodes()) {
+            const p2 = budget.tick(item.text.length + 1);
+            if (p2) await p2;
+            total += number(item.text);
+          }
+          result = total;
+          break;
+        }
+        case "floor":
+          result = Math.floor(number(first));
+          break;
+        case "ceiling":
+          result = Math.ceil(number(first));
+          break;
+        case "round":
+          result = Math.round(number(first));
+          break;
+        case "contains":
+          result = a.includes(b);
+          break;
+        case "starts-with":
+          result = a.startsWith(b);
+          break;
+        case "normalize-space":
+          result = normalize(a);
+          break;
+        case "concat": {
+          let size = 0;
+          for (const arg of args) {
+            size += new TextEncoder().encode(string(arg)).byteLength;
+            if (size > budget.limits.maxOutputBytes) throw new XmlQueryError("maxOutputBytes limit exceeded", 5);
+          }
+          result = args.map(string).join("");
+          break;
+        }
+        case "string-length":
+          result = [...a].length;
+          break;
+        case "substring": {
+          const start = Math.round(number(args[1]));
+          const end = args.length === 3 ? start + Math.round(number(args[2])) : Infinity;
+          result = [...a].filter((_, index) => index + 1 >= start && index + 1 < end).join("");
+          break;
+        }
+        case "substring-before":
+          result = a.includes(b) ? a.slice(0, a.indexOf(b)) : "";
+          break;
+        case "substring-after":
+          result = a.includes(b) ? a.slice(a.indexOf(b) + b.length) : "";
+          break;
+        case "translate": {
+          const replacements = [...string(args[2])], mapping = /* @__PURE__ */ new Map();
+          let index = 0;
+          for (const character of b) {
+            if (!mapping.has(character)) mapping.set(character, replacements[index] ?? "");
+            index++;
+          }
+          result = [...a].map((character) => mapping.get(character) ?? character).join("");
+          break;
+        }
+        case "name":
+        case "local-name":
+        case "namespace-uri": {
+          const selected = nodes()[0]?.node;
+          result = selected?.kind === "element" || selected?.kind === "attribute" ? instruction.name === "name" ? selected.value.name : instruction.name === "local-name" ? selected.value.localName : selected.value.namespace : selected?.kind === "processing-instruction" && instruction.name !== "namespace-uri" ? selected.value.kind === "processing-instruction" ? selected.value.target : "" : "";
+          break;
+        }
+      }
+      if (typeof result === "string") {
+        if (new TextEncoder().encode(result).byteLength > budget.limits.maxOutputBytes) throw new XmlQueryError("maxOutputBytes limit exceeded", 5);
+        const p2 = budget.tick(result.length);
+        if (p2) await p2;
+      }
+      values.push(result);
+    }
+  }
+  return values[0];
+}
+async function testPredicate(program, node, position, last, budget, select) {
+  const result = await evaluateExpression(program, node, position, last, budget, select);
+  return typeof result === "number" ? result === position : boolean(result);
+}
+
+// packages/safe-bash-xml-engine/src/evaluate.ts
+var xmlns = "http://www.w3.org/2000/xmlns/";
+async function indexTree(root, budget) {
+  const document = { kind: "document", children: [] };
+  const order = [document];
+  const parentOf = /* @__PURE__ */ new Map();
+  const pending = [
+    { parent: document, content: root }
+  ];
+  while (pending.length) {
+    {
+      const _p = budget.tick();
+      if (_p) await _p;
+    }
+    const { parent, content } = pending.pop();
+    if (content.kind === "element") {
+      const node = { kind: "element", value: content, children: [], attributes: [] };
+      parent.children.push(node);
+      parentOf.set(node, parent);
+      order.push(node);
+      for (const attribute of content.attributes) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        if (attribute.namespace === xmlns) continue;
+        const selected = { kind: "attribute", value: attribute };
+        node.attributes.push(selected);
+        parentOf.set(selected, node);
+        order.push(selected);
+      }
+      for (let index = content.content.length - 1; index >= 0; index--) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        pending.push({ parent: node, content: content.content[index] });
+      }
+    } else {
+      const node = { kind: content.kind, value: content };
+      parent.children.push(node);
+      parentOf.set(node, parent);
+      order.push(node);
+    }
+  }
+  return { document, order, parentOf };
+}
+function matches(node, step) {
+  if (step.kind === "self" || step.kind === "parent") return true;
+  if (step.kind === "text") return node.kind === "text" || node.kind === "cdata";
+  if (node.kind !== step.kind) return false;
+  if (node.kind === "element" || node.kind === "attribute") {
+    return step.name === "*" || node.value.namespace === "" && node.value.localName === step.name;
+  }
+  return false;
+}
+async function evaluateScalar(query, root, budget) {
+  const tree = await indexTree(root, budget);
+  const result = await evaluateExpression(
+    query.expression,
+    tree.document,
+    1,
+    1,
+    budget,
+    async (selected) => evaluatePaths(selected, tree, budget, tree.document)
+  );
+  if (Array.isArray(result)) return result[0]?.text ?? "";
+  return String(result);
+}
+async function evaluate(query, root, budget) {
+  const tree = await indexTree(root, budget);
+  return evaluatePaths(query, tree, budget, tree.document);
+}
+async function evaluatePaths(query, tree, budget, context) {
+  const { order, parentOf } = tree;
+  const union = /* @__PURE__ */ new Set();
+  for (const path of query.paths) {
+    let contexts = [context];
+    for (const step of path) {
+      const parents = /* @__PURE__ */ new Set();
+      const pending = [...contexts];
+      while (pending.length) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        const node = pending.pop();
+        if (parents.has(node)) continue;
+        parents.add(node);
+        if (step.descendant && (node.kind === "document" || node.kind === "element")) {
+          for (const child of node.children) {
+            {
+              const _p = budget.tick();
+              if (_p) await _p;
+            }
+            pending.push(child);
+          }
+        }
+      }
+      const selected = /* @__PURE__ */ new Set();
+      for (const parent of parents) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        const candidates = step.kind === "self" ? [parent] : step.kind === "parent" ? parentOf.has(parent) ? [parentOf.get(parent)] : [] : step.kind === "attribute" ? parent.kind === "element" ? parent.attributes : [] : parent.kind === "element" || parent.kind === "document" ? parent.children : [];
+        let matched = [];
+        for (const candidate of candidates) {
+          {
+            const _p = budget.tick();
+            if (_p) await _p;
+          }
+          if (matches(candidate, step)) matched.push(candidate);
+        }
+        for (const predicate of step.predicates) {
+          {
+            const _p = budget.tick();
+            if (_p) await _p;
+          }
+          const first = predicate[0];
+          if (predicate.length === 1 && first?.kind === "literal" && typeof first.value === "number") {
+            matched = matched[first.value - 1] ? [matched[first.value - 1]] : [];
+            continue;
+          }
+          if (predicate.length === 1 && first?.kind === "function" && first.name === "last") {
+            matched = matched.length ? [matched[matched.length - 1]] : [];
+            continue;
+          }
+          const filtered = [];
+          for (let index = 0; index < matched.length; index++) {
+            const candidate = matched[index];
+            if (await testPredicate(
+              predicate,
+              candidate,
+              index + 1,
+              matched.length,
+              budget,
+              async (selected2, absolute) => evaluatePaths(selected2, tree, budget, absolute ? tree.document : candidate)
+            ))
+              filtered.push(candidate);
+          }
+          matched = filtered;
+        }
+        for (const node of matched) {
+          {
+            const _p = budget.tick();
+            if (_p) await _p;
+          }
+          if (!selected.has(node)) {
+            budget.results(selected.size + 1);
+            selected.add(node);
+          }
+        }
+      }
+      contexts = [];
+      for (const node of order) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        if (selected.has(node)) contexts.push(node);
+      }
+    }
+    for (const node of contexts) {
+      {
+        const _p = budget.tick();
+        if (_p) await _p;
+      }
+      budget.results(union.size + (union.has(node) ? 0 : 1));
+      union.add(node);
+    }
+  }
+  const result = [];
+  for (const node of order) {
+    {
+      const _p = budget.tick();
+      if (_p) await _p;
+    }
+    if (union.has(node)) result.push(node);
+  }
+  return result;
+}
+async function* stringValue(node, budget) {
+  if (node === void 0) return;
+  if (node.kind === "attribute") {
+    yield node.value.value;
+    return;
+  }
+  const pending = [node];
+  while (pending.length) {
+    {
+      const _p = budget.tick();
+      if (_p) await _p;
+    }
+    const current = pending.pop();
+    if (current.kind === "element" || current.kind === "document") {
+      for (let index = current.children.length - 1; index >= 0; index--) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        pending.push(current.children[index]);
+      }
+    } else if (current.kind === "text" || current.kind === "cdata") yield current.value.text;
+  }
+}
+function serializeSimpleSync(node, budget) {
+  if (node.kind === "text" && node.value.text.length > 0 && node.value.text.length < 4096 && !/[&<>"\n\r\t\uD800-\uDFFF]/.test(node.value.text)) {
+    if (!budget.tryTickSync(1 + node.value.text.length)) return void 0;
+    return node.value.text;
+  }
+  return void 0;
+}
+async function* serialize(node, budget) {
+  if (node.kind === "text" && node.value.text.length > 0 && node.value.text.length < 4096 && !/[&<>"\n\r\t\uD800-\uDFFF]/.test(node.value.text)) {
+    {
+      const _p = budget.tick(1 + node.value.text.length);
+      if (_p) await _p;
+    }
+    yield node.value.text;
+    return;
+  }
+  if (node.kind === "attribute") {
+    yield ` ${node.value.name}="`;
+    yield* escape(node.value.value, true, budget);
+    yield '"';
+    return;
+  }
+  if (node.kind === "document") {
+    yield '<?xml version="1.0" encoding="UTF-8"?>\n';
+    for (const child of node.children) {
+      yield* serialize(child, budget);
+      yield "\n";
+    }
+    return;
+  }
+  const pending = [node.value];
+  while (pending.length) {
+    {
+      const _p = budget.tick();
+      if (_p) await _p;
+    }
+    const current = pending.pop();
+    if (typeof current === "string") {
+      yield current;
+      continue;
+    }
+    if (current.kind === "element") {
+      yield `<${current.name}`;
+      for (const attribute of current.attributes) {
+        {
+          const _p = budget.tick();
+          if (_p) await _p;
+        }
+        yield ` ${attribute.name}="`;
+        yield* escape(attribute.value, true, budget);
+        yield '"';
+      }
+      if (!current.content.length) yield "/>";
+      else {
+        yield ">";
+        pending.push(`</${current.name}>`);
+        for (let index = current.content.length - 1; index >= 0; index--) {
+          {
+            const _p = budget.tick();
+            if (_p) await _p;
+          }
+          pending.push(current.content[index]);
+        }
+      }
+    } else if (current.kind === "text") yield* escape(current.text, false, budget);
+    else if (current.kind === "cdata") {
+      yield "<![CDATA[";
+      yield current.text;
+      yield "]]>";
+    } else if (current.kind === "comment") {
+      yield "<!--";
+      yield current.text;
+      yield "-->";
+    } else if (current.kind === "processing-instruction") {
+      yield `<?${current.target}`;
+      if (current.text) {
+        yield " ";
+        yield current.text;
+      }
+      yield "?>";
+    }
+  }
+}
+async function* escape(value, attribute, budget, options = {}) {
+  if (value.length > 0 && value.length < 4096 && !options.ascii && !/[&<>"\n\r\t\uD800-\uDFFF]/.test(value)) {
+    {
+      const _p = budget.tick(value.length);
+      if (_p) await _p;
+    }
+    yield value;
+    return;
+  }
+  let part = "";
+  for (const character of value) {
+    {
+      const _p = budget.tick();
+      if (_p) await _p;
+    }
+    part += character === "&" ? "&amp;" : character === "<" ? "&lt;" : character === ">" ? "&gt;" : attribute && character === '"' ? "&quot;" : attribute && character === "\n" ? options.canonical ? "&#xA;" : "&#10;" : character === "\r" ? options.canonical ? "&#xD;" : "&#13;" : attribute && character === "	" ? options.canonical ? "&#x9;" : "&#9;" : options.ascii && character.codePointAt(0) >= 128 ? `&#x${character.codePointAt(0).toString(16).toUpperCase()};` : character;
+    if (part.length >= 4096) {
+      yield part;
+      part = "";
+    }
+  }
+  if (part) yield part;
+}
+
+export {
+  evaluateScalar,
+  evaluate,
+  stringValue,
+  serializeSimpleSync,
+  serialize,
+  escape,
+  parsePredicate
+};