@amritk/lint 0.3.2 → 0.3.3

package/dist/core/jsonpath.js

@@ -1,610 +1,536 @@
-const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-// jsonpath-plus emits numeric array indices as strings and Linter historically
-// normalized *any* all-digit segment (including object keys like "200") to a
-// number. Replicate that exactly so source-map lookups are unchanged.
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const normalizeSegment = (segment) => {
-    if (typeof segment === 'number')
-        return segment;
-    if (segment.length > 0 && /^\d+$/.test(segment))
-        return Number(segment);
+  if (typeof segment === "number")
     return segment;
+  if (segment.length > 0 && /^\d+$/.test(segment))
+    return Number(segment);
+  return segment;
 };
 const normalizePath = (path) => path.map(normalizeSegment);
-/**
- * Renders a concrete path as the jsonpath-plus string form (`$['a'][0]`). This
- * is what `@path` exposes inside a filter, so ruleset filters authored for
- * Spectral (which run on jsonpath-plus) see the same value.
- */
 const pathToJsonPathString = (path) => {
-    let out = '$';
-    for (const segment of path) {
-        if (typeof segment === 'number')
-            out += `[${segment}]`;
-        else
-            out += `['${segment.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}']`;
-    }
-    return out;
+  let out = "$";
+  for (const segment of path) {
+    if (typeof segment === "number")
+      out += `[${segment}]`;
+    else
+      out += `['${segment.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+  }
+  return out;
 };
-// ---------------------------------------------------------------------------
-// Compilation
-// ---------------------------------------------------------------------------
-const compileCache = new Map();
-const filterCache = new Map();
-/**
- * Rewrites jsonpath-plus' `@`-context tokens onto real identifiers, skipping any
- * `@` that sits inside a quoted string literal (so an expression like
- * `@.name.indexOf("@")` keeps the literal `@` intact). Longer tokens are matched
- * first so `@parentProperty` is not eaten by `@parent`.
- */
+const compileCache = /* @__PURE__ */ new Map();
+const filterCache = /* @__PURE__ */ new Map();
 const substituteContext = (source) => {
-    let out = '';
-    let quote = '';
-    for (let i = 0; i < source.length; i++) {
-        const ch = source[i];
-        if (quote) {
-            out += ch;
-            if (ch === '\\' && i + 1 < source.length) {
-                out += source[i + 1];
-                i++;
-            }
-            else if (ch === quote) {
-                quote = '';
-            }
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            quote = ch;
-            out += ch;
-            continue;
-        }
-        if (ch === '@') {
-            const rest = source.slice(i);
-            if (rest.startsWith('@parentProperty')) {
-                out += '_pp';
-                i += '@parentProperty'.length - 1;
-            }
-            else if (rest.startsWith('@parent')) {
-                out += '_parent';
-                i += '@parent'.length - 1;
-            }
-            else if (rest.startsWith('@property')) {
-                out += '_prop';
-                i += '@property'.length - 1;
-            }
-            else if (rest.startsWith('@path')) {
-                out += '_path';
-                i += '@path'.length - 1;
-            }
-            else if (rest.startsWith('@root')) {
-                out += '_root';
-                i += '@root'.length - 1;
-            }
-            else {
-                out += '_v';
-            }
-            continue;
-        }
-        out += ch;
+  let out = "";
+  let quote = "";
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (quote) {
+      out += ch;
+      if (ch === "\\" && i + 1 < source.length) {
+        out += source[i + 1];
+        i++;
+      } else if (ch === quote) {
+        quote = "";
+      }
+      continue;
     }
-    return out;
-};
-const compileFilter = (source) => {
-    const cached = filterCache.get(source);
-    if (cached)
-        return cached;
-    const body = substituteContext(source);
-    let fn;
-    try {
-        // `_pp` (`@parentProperty`) is supplied directly by the caller rather than
-        // derived from a materialized path, so most filters never force a path
-        // allocation. `_path` (`@path`) is only materialized for filters that use it.
-        const compiled = new Function('_v', '_prop', '_parent', '_root', '_path', '_pp', `try { return !!(${body}); } catch (_e) { return false; }`);
-        fn = compiled;
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      out += ch;
+      continue;
     }
-    catch {
-        fn = () => false;
+    if (ch === "@") {
+      const rest = source.slice(i);
+      if (rest.startsWith("@parentProperty")) {
+        out += "_pp";
+        i += "@parentProperty".length - 1;
+      } else if (rest.startsWith("@parent")) {
+        out += "_parent";
+        i += "@parent".length - 1;
+      } else if (rest.startsWith("@property")) {
+        out += "_prop";
+        i += "@property".length - 1;
+      } else if (rest.startsWith("@path")) {
+        out += "_path";
+        i += "@path".length - 1;
+      } else if (rest.startsWith("@root")) {
+        out += "_root";
+        i += "@root".length - 1;
+      } else {
+        out += "_v";
+      }
+      continue;
     }
-    filterCache.set(source, fn);
-    return fn;
+    out += ch;
+  }
+  return out;
+};
+const compileFilter = (source) => {
+  const cached = filterCache.get(source);
+  if (cached)
+    return cached;
+  const body = substituteContext(source);
+  let fn;
+  try {
+    const compiled = new Function("_v", "_prop", "_parent", "_root", "_path", "_pp", `try { return !!(${body}); } catch (_e) { return false; }`);
+    fn = compiled;
+  } catch {
+    fn = () => false;
+  }
+  filterCache.set(source, fn);
+  return fn;
 };
-/** Splits bracket content on top-level commas, respecting quotes (and their escapes). */
 const splitUnion = (content) => {
-    const parts = [];
-    let depth = 0;
-    let quote = '';
-    let current = '';
-    for (let i = 0; i < content.length; i++) {
-        const ch = content[i];
-        if (quote) {
-            if (ch === '\\' && i + 1 < content.length) {
-                current += ch + content[i + 1];
-                i++;
-                continue;
-            }
-            if (ch === quote)
-                quote = '';
-            current += ch;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            quote = ch;
-            current += ch;
-            continue;
-        }
-        if (ch === '[' || ch === '(')
-            depth++;
-        else if (ch === ']' || ch === ')')
-            depth--;
-        if (ch === ',' && depth === 0) {
-            parts.push(current);
-            current = '';
-            continue;
-        }
-        current += ch;
+  const parts = [];
+  let depth = 0;
+  let quote = "";
+  let current = "";
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (quote) {
+      if (ch === "\\" && i + 1 < content.length) {
+        current += ch + content[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = "";
+      current += ch;
+      continue;
     }
-    parts.push(current);
-    return parts;
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "[" || ch === "(")
+      depth++;
+    else if (ch === "]" || ch === ")")
+      depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts;
 };
-/** Unquotes a `'...'` / `"..."` token, honoring backslash escapes; returns null when not a quoted literal. */
 const unquote = (token) => {
-    const t = token.trim();
-    const quote = t[0];
-    if (t.length < 2 || (quote !== '"' && quote !== "'"))
-        return null;
-    let out = '';
-    let i = 1;
-    let closed = false;
-    while (i < t.length) {
-        const ch = t[i];
-        if (ch === '\\' && i + 1 < t.length) {
-            out += t[i + 1];
-            i += 2;
-            continue;
-        }
-        if (ch === quote) {
-            closed = true;
-            i++;
-            break;
-        }
-        out += ch;
-        i++;
+  const t = token.trim();
+  const quote = t[0];
+  if (t.length < 2 || quote !== '"' && quote !== "'")
+    return null;
+  let out = "";
+  let i = 1;
+  let closed = false;
+  while (i < t.length) {
+    const ch = t[i];
+    if (ch === "\\" && i + 1 < t.length) {
+      out += t[i + 1];
+      i += 2;
+      continue;
     }
-    // A valid literal closes exactly at the end of the token.
-    if (!closed || i !== t.length)
-        return null;
-    return out;
+    if (ch === quote) {
+      closed = true;
+      i++;
+      break;
+    }
+    out += ch;
+    i++;
+  }
+  if (!closed || i !== t.length)
+    return null;
+  return out;
 };
-// A slice is `start:end` or `start:end:step`, each part optional and possibly
-// negative, e.g. `0:2`, `-1:`, `::2`, `:`.
 const SLICE_RE = /^-?\d*:-?\d*(:-?\d+)?$/;
 const buildSlice = (trimmed) => {
-    const [s, e, st] = trimmed.split(':');
-    const num = (value) => value === undefined || value === '' ? undefined : Number(value);
-    const selector = { kind: 'slice' };
-    const start = num(s);
-    const end = num(e);
-    const step = num(st);
-    if (start !== undefined)
-        selector.start = start;
-    if (end !== undefined)
-        selector.end = end;
-    if (step !== undefined)
-        selector.step = step;
-    return selector;
+  const [s, e, st] = trimmed.split(":");
+  const num = (value) => value === void 0 || value === "" ? void 0 : Number(value);
+  const selector = { kind: "slice" };
+  const start = num(s);
+  const end = num(e);
+  const step = num(st);
+  if (start !== void 0)
+    selector.start = start;
+  if (end !== void 0)
+    selector.end = end;
+  if (step !== void 0)
+    selector.step = step;
+  return selector;
 };
 const bracketSelector = (content, onError) => {
-    const trimmed = content.trim();
-    if (trimmed === '*')
-        return { kind: 'wildcard' };
-    if (trimmed.startsWith('?')) {
-        // `?(expr)` — extract the inner expression between the first `(` and last `)`.
-        const open = trimmed.indexOf('(');
-        const close = trimmed.lastIndexOf(')');
-        const expr = open !== -1 && close > open ? trimmed.slice(open + 1, close) : trimmed.slice(1);
-        return { kind: 'filter', test: compileFilter(expr), source: expr, usesPath: expr.includes('@path') };
-    }
-    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
-        // Script subscript `[(expr)]`. We support the common `(@.length - N)` form
-        // (a from-the-end index); anything else is rejected loudly so a typo does not
-        // silently match nothing.
-        const inner = trimmed.slice(1, -1).trim();
-        const lengthOnly = /^@\.length$/.test(inner);
-        const withOffset = /^@\.length\s*-\s*(\d+)$/.exec(inner);
-        if (lengthOnly)
-            return { kind: 'scriptIndex', offset: 0 };
-        if (withOffset)
-            return { kind: 'scriptIndex', offset: -Number(withOffset[1]) };
-        onError(`Unsupported script subscript "[${content}]"`);
-        return { kind: 'none' };
-    }
-    // A slice is only a slice when it is a single (comma-free) `:`-delimited token.
-    if (!content.includes(',') && SLICE_RE.test(trimmed))
-        return buildSlice(trimmed);
-    const parts = splitUnion(content);
-    const names = [];
-    for (const part of parts) {
-        const token = part.trim();
-        const literal = unquote(token);
-        if (literal !== null) {
-            names.push(literal);
-        }
-        else if (/^-?\d+$/.test(token)) {
-            names.push(Number(token));
-        }
-        else {
-            names.push(token);
-        }
-    }
-    if (names.length === 1) {
-        const only = names[0];
-        return typeof only === 'number' ? { kind: 'index', index: only } : { kind: 'child', name: only };
+  const trimmed = content.trim();
+  if (trimmed === "*")
+    return { kind: "wildcard" };
+  if (trimmed.startsWith("?")) {
+    const open = trimmed.indexOf("(");
+    const close = trimmed.lastIndexOf(")");
+    const expr = open !== -1 && close > open ? trimmed.slice(open + 1, close) : trimmed.slice(1);
+    return { kind: "filter", test: compileFilter(expr), source: expr, usesPath: expr.includes("@path") };
+  }
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1).trim();
+    const lengthOnly = /^@\.length$/.test(inner);
+    const withOffset = /^@\.length\s*-\s*(\d+)$/.exec(inner);
+    if (lengthOnly)
+      return { kind: "scriptIndex", offset: 0 };
+    if (withOffset)
+      return { kind: "scriptIndex", offset: -Number(withOffset[1]) };
+    onError(`Unsupported script subscript "[${content}]"`);
+    return { kind: "none" };
+  }
+  if (!content.includes(",") && SLICE_RE.test(trimmed))
+    return buildSlice(trimmed);
+  const parts = splitUnion(content);
+  const names = [];
+  for (const part of parts) {
+    const token = part.trim();
+    const literal = unquote(token);
+    if (literal !== null) {
+      names.push(literal);
+    } else if (/^-?\d+$/.test(token)) {
+      names.push(Number(token));
+    } else {
+      names.push(token);
     }
-    return { kind: 'union', names };
+  }
+  if (names.length === 1) {
+    const only = names[0];
+    return typeof only === "number" ? { kind: "index", index: only } : { kind: "child", name: only };
+  }
+  return { kind: "union", names };
 };
-/** Finds the index of the `]` that closes the `[` at `start`, respecting quotes (and escapes) and nesting. */
 const findBracketEnd = (expression, start) => {
-    let depth = 0;
-    let quote = '';
-    for (let i = start; i < expression.length; i++) {
-        const ch = expression[i];
-        if (quote) {
-            if (ch === '\\') {
-                // Skip the escaped character so an escaped quote does not end the string.
-                i++;
-                continue;
-            }
-            if (ch === quote)
-                quote = '';
-            continue;
-        }
-        if (ch === '"' || ch === "'")
-            quote = ch;
-        else if (ch === '[' || ch === '(')
-            depth++;
-        else if (ch === ')')
-            depth--;
-        else if (ch === ']') {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
+  let depth = 0;
+  let quote = "";
+  for (let i = start; i < expression.length; i++) {
+    const ch = expression[i];
+    if (quote) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'")
+      quote = ch;
+    else if (ch === "[" || ch === "(")
+      depth++;
+    else if (ch === ")")
+      depth--;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0)
+        return i;
     }
-    return -1;
+  }
+  return -1;
 };
 const readName = (expression, start) => {
-    let i = start;
-    while (i < expression.length && !'.[]^~'.includes(expression[i]))
-        i++;
-    return { name: expression.slice(start, i), end: i };
+  let i = start;
+  while (i < expression.length && !".[]^~".includes(expression[i]))
+    i++;
+  return { name: expression.slice(start, i), end: i };
 };
-/** Compiles a JSONPath `expression` into a {@link CompiledPath}, cached by string so repeats are free. */
-export const compileQuery = (expression) => {
-    const cached = compileCache.get(expression);
-    if (cached)
-        return cached;
-    const steps = [];
-    const errors = [];
-    const onError = (message) => {
-        errors.push(message);
-    };
-    let hasDescent = false;
-    let i = 0;
-    // Every well-formed JSONPath is rooted at `$`. Without it the expression would
-    // otherwise compile to zero steps and match the document root — a silent bug.
-    if (expression[0] === '$')
-        i = 1;
-    else
-        onError('JSONPath must start with "$"');
-    let recursive = false;
-    while (i < expression.length) {
-        const ch = expression[i];
-        if (ch === '.') {
-            if (expression[i + 1] === '.') {
-                recursive = true;
-                hasDescent = true;
-                i += 2;
-                // A bare `..` followed by `.`/end is unusual; loop handles the selector.
-                continue;
-            }
-            i++;
-            if (expression[i] === '*') {
-                steps.push({ recursive, selector: { kind: 'wildcard' } });
-                recursive = false;
-                i++;
-                continue;
-            }
-            const { name, end } = readName(expression, i);
-            steps.push({ recursive, selector: { kind: 'child', name } });
-            recursive = false;
-            i = end;
-            continue;
-        }
-        if (ch === '[') {
-            const end = findBracketEnd(expression, i);
-            if (end === -1) {
-                onError(`Unterminated "[" in "${expression}"`);
-                break;
-            }
-            const content = expression.slice(i + 1, end);
-            steps.push({ recursive, selector: bracketSelector(content, onError) });
-            recursive = false;
-            i = end + 1;
-            continue;
-        }
-        if (ch === '^') {
-            // Honor a pending `..` so `$..^` selects every node's parent (fixing a
-            // flag leak where the descent was dropped and the selector matched nothing).
-            steps.push({ recursive, selector: { kind: 'parent' } });
-            recursive = false;
-            i++;
-            continue;
-        }
-        if (ch === '~') {
-            steps.push({ recursive, selector: { kind: 'keys' } });
-            recursive = false;
-            i++;
-            continue;
-        }
-        if (ch === '*') {
-            steps.push({ recursive, selector: { kind: 'wildcard' } });
-            recursive = false;
-            i++;
-            continue;
-        }
-        // Bare name following `..` (e.g. `$..foo`) or other unexpected token.
-        if (recursive) {
-            const { name, end } = readName(expression, i);
-            if (end > i) {
-                steps.push({ recursive: true, selector: { kind: 'child', name } });
-                recursive = false;
-                i = end;
-                continue;
-            }
-        }
+const compileQuery = (expression) => {
+  const cached = compileCache.get(expression);
+  if (cached)
+    return cached;
+  const steps = [];
+  const errors = [];
+  const onError = (message) => {
+    errors.push(message);
+  };
+  let hasDescent = false;
+  let i = 0;
+  if (expression[0] === "$")
+    i = 1;
+  else
+    onError('JSONPath must start with "$"');
+  let recursive = false;
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (ch === ".") {
+      if (expression[i + 1] === ".") {
+        recursive = true;
+        hasDescent = true;
+        i += 2;
+        continue;
+      }
+      i++;
+      if (expression[i] === "*") {
+        steps.push({ recursive, selector: { kind: "wildcard" } });
+        recursive = false;
         i++;
+        continue;
+      }
+      const { name, end } = readName(expression, i);
+      steps.push({ recursive, selector: { kind: "child", name } });
+      recursive = false;
+      i = end;
+      continue;
     }
-    const compiled = {
-        expression,
-        steps,
-        hasDescent,
-        ...(errors.length > 0 ? { error: errors.join('; ') } : {}),
-    };
-    compileCache.set(expression, compiled);
-    return compiled;
+    if (ch === "[") {
+      const end = findBracketEnd(expression, i);
+      if (end === -1) {
+        onError(`Unterminated "[" in "${expression}"`);
+        break;
+      }
+      const content = expression.slice(i + 1, end);
+      steps.push({ recursive, selector: bracketSelector(content, onError) });
+      recursive = false;
+      i = end + 1;
+      continue;
+    }
+    if (ch === "^") {
+      steps.push({ recursive, selector: { kind: "parent" } });
+      recursive = false;
+      i++;
+      continue;
+    }
+    if (ch === "~") {
+      steps.push({ recursive, selector: { kind: "keys" } });
+      recursive = false;
+      i++;
+      continue;
+    }
+    if (ch === "*") {
+      steps.push({ recursive, selector: { kind: "wildcard" } });
+      recursive = false;
+      i++;
+      continue;
+    }
+    if (recursive) {
+      const { name, end } = readName(expression, i);
+      if (end > i) {
+        steps.push({ recursive: true, selector: { kind: "child", name } });
+        recursive = false;
+        i = end;
+        continue;
+      }
+    }
+    i++;
+  }
+  const compiled = {
+    expression,
+    steps,
+    hasDescent,
+    ...errors.length > 0 ? { error: errors.join("; ") } : {}
+  };
+  compileCache.set(expression, compiled);
+  return compiled;
 };
-/** Materializes the concrete (un-normalized) path from root to `node`. */
 const pathOf = (node) => {
-    let depth = 0;
-    for (let n = node; n !== undefined && n.parent !== undefined; n = n.parent)
-        depth++;
-    const out = new Array(depth);
-    let i = depth - 1;
-    for (let n = node; n !== undefined && n.parent !== undefined; n = n.parent) {
-        out[i--] = n.key;
-    }
-    return out;
+  let depth = 0;
+  for (let n = node; n !== void 0 && n.parent !== void 0; n = n.parent)
+    depth++;
+  const out = new Array(depth);
+  let i = depth - 1;
+  for (let n = node; n !== void 0 && n.parent !== void 0; n = n.parent) {
+    out[i--] = n.key;
+  }
+  return out;
 };
 const applySelector = (node, selector, root, out) => {
-    const value = node.value;
-    switch (selector.kind) {
-        case 'child': {
-            if (isObject(value)) {
-                if (Object.hasOwn(value, selector.name))
-                    out.push({ value: value[selector.name], parent: node, key: selector.name });
-            }
-            else if (Array.isArray(value) && /^\d+$/.test(selector.name)) {
-                const idx = Number(selector.name);
-                if (idx < value.length)
-                    out.push({ value: value[idx], parent: node, key: idx });
-            }
-            return;
-        }
-        case 'index': {
-            if (Array.isArray(value)) {
-                const idx = selector.index < 0 ? value.length + selector.index : selector.index;
-                if (idx >= 0 && idx < value.length)
-                    out.push({ value: value[idx], parent: node, key: idx });
-            }
-            else if (isObject(value) && Object.hasOwn(value, selector.index)) {
-                out.push({ value: value[selector.index], parent: node, key: selector.index });
-            }
-            return;
-        }
-        case 'wildcard': {
-            if (Array.isArray(value)) {
-                for (let idx = 0; idx < value.length; idx++)
-                    out.push({ value: value[idx], parent: node, key: idx });
-            }
-            else if (isObject(value)) {
-                for (const key of Object.keys(value))
-                    out.push({ value: value[key], parent: node, key });
-            }
-            return;
-        }
-        case 'union': {
-            for (const name of selector.names) {
-                if (Array.isArray(value)) {
-                    if (typeof name === 'number') {
-                        const idx = name < 0 ? value.length + name : name;
-                        if (idx >= 0 && idx < value.length)
-                            out.push({ value: value[idx], parent: node, key: idx });
-                    }
-                }
-                else if (isObject(value) && Object.hasOwn(value, name)) {
-                    out.push({ value: value[name], parent: node, key: name });
-                }
-            }
-            return;
-        }
-        case 'slice': {
-            if (!Array.isArray(value))
-                return;
-            const len = value.length;
-            const step = selector.step ?? 1;
-            if (step === 0)
-                return;
-            const clamp = (raw, fallback) => {
-                if (raw === undefined)
-                    return fallback;
-                return raw < 0 ? raw + len : raw;
-            };
-            if (step > 0) {
-                const start = Math.max(0, clamp(selector.start, 0));
-                const end = Math.min(len, clamp(selector.end, len));
-                for (let idx = start; idx < end; idx += step)
-                    out.push({ value: value[idx], parent: node, key: idx });
-            }
-            else {
-                const start = Math.min(len - 1, clamp(selector.start, len - 1));
-                const end = Math.max(-1, clamp(selector.end, -1));
-                for (let idx = start; idx > end; idx += step)
-                    out.push({ value: value[idx], parent: node, key: idx });
-            }
-            return;
-        }
-        case 'scriptIndex': {
-            // `[(@.length - N)]` indexes from the end; N === 0 (`@.length`) is out of range.
-            if (!Array.isArray(value))
-                return;
-            const idx = value.length + selector.offset;
+  const value = node.value;
+  switch (selector.kind) {
+    case "child": {
+      if (isObject(value)) {
+        if (Object.hasOwn(value, selector.name))
+          out.push({ value: value[selector.name], parent: node, key: selector.name });
+      } else if (Array.isArray(value) && /^\d+$/.test(selector.name)) {
+        const idx = Number(selector.name);
+        if (idx < value.length)
+          out.push({ value: value[idx], parent: node, key: idx });
+      }
+      return;
+    }
+    case "index": {
+      if (Array.isArray(value)) {
+        const idx = selector.index < 0 ? value.length + selector.index : selector.index;
+        if (idx >= 0 && idx < value.length)
+          out.push({ value: value[idx], parent: node, key: idx });
+      } else if (isObject(value) && Object.hasOwn(value, selector.index)) {
+        out.push({ value: value[selector.index], parent: node, key: selector.index });
+      }
+      return;
+    }
+    case "wildcard": {
+      if (Array.isArray(value)) {
+        for (let idx = 0; idx < value.length; idx++)
+          out.push({ value: value[idx], parent: node, key: idx });
+      } else if (isObject(value)) {
+        for (const key of Object.keys(value))
+          out.push({ value: value[key], parent: node, key });
+      }
+      return;
+    }
+    case "union": {
+      for (const name of selector.names) {
+        if (Array.isArray(value)) {
+          if (typeof name === "number") {
+            const idx = name < 0 ? value.length + name : name;
             if (idx >= 0 && idx < value.length)
-                out.push({ value: value[idx], parent: node, key: idx });
-            return;
-        }
-        case 'filter': {
-            // `@parentProperty` is `node.key`; `@path` is materialized only when used.
-            const pp = node.key;
-            if (Array.isArray(value)) {
-                for (let idx = 0; idx < value.length; idx++) {
-                    const child = { value: value[idx], parent: node, key: idx };
-                    const path = selector.usesPath ? pathToJsonPathString(pathOf(child)) : '';
-                    if (selector.test(value[idx], idx, value, root, path, pp))
-                        out.push(child);
-                }
-            }
-            else if (isObject(value)) {
-                for (const key of Object.keys(value)) {
-                    const child = { value: value[key], parent: node, key };
-                    const path = selector.usesPath ? pathToJsonPathString(pathOf(child)) : '';
-                    if (selector.test(value[key], key, value, root, path, pp))
-                        out.push(child);
-                }
-            }
-            return;
-        }
-        case 'parent': {
-            if (node.parent !== undefined)
-                out.push(node.parent);
-            return;
-        }
-        case 'keys': {
-            if (node.parent === undefined)
-                return;
-            // The selected value is the node's own key, but it occupies the same path.
-            out.push({ value: node.key, parent: node.parent, key: node.key });
-            return;
+              out.push({ value: value[idx], parent: node, key: idx });
+          }
+        } else if (isObject(value) && Object.hasOwn(value, name)) {
+          out.push({ value: value[name], parent: node, key: name });
         }
-        case 'none':
-            return;
+      }
+      return;
     }
-};
-/** Visits `node` and every descendant (preorder), invoking `visit` on each. */
-const walkDescendants = (node, visit) => {
-    visit(node);
-    const value = node.value;
-    if (Array.isArray(value)) {
-        for (let idx = 0; idx < value.length; idx++)
-            walkDescendants({ value: value[idx], parent: node, key: idx }, visit);
+    case "slice": {
+      if (!Array.isArray(value))
+        return;
+      const len = value.length;
+      const step = selector.step ?? 1;
+      if (step === 0)
+        return;
+      const clamp = (raw, fallback) => {
+        if (raw === void 0)
+          return fallback;
+        return raw < 0 ? raw + len : raw;
+      };
+      if (step > 0) {
+        const start = Math.max(0, clamp(selector.start, 0));
+        const end = Math.min(len, clamp(selector.end, len));
+        for (let idx = start; idx < end; idx += step)
+          out.push({ value: value[idx], parent: node, key: idx });
+      } else {
+        const start = Math.min(len - 1, clamp(selector.start, len - 1));
+        const end = Math.max(-1, clamp(selector.end, -1));
+        for (let idx = start; idx > end; idx += step)
+          out.push({ value: value[idx], parent: node, key: idx });
+      }
+      return;
     }
-    else if (isObject(value)) {
-        for (const key of Object.keys(value))
-            walkDescendants({ value: value[key], parent: node, key }, visit);
+    case "scriptIndex": {
+      if (!Array.isArray(value))
+        return;
+      const idx = value.length + selector.offset;
+      if (idx >= 0 && idx < value.length)
+        out.push({ value: value[idx], parent: node, key: idx });
+      return;
+    }
+    case "filter": {
+      const pp = node.key;
+      if (Array.isArray(value)) {
+        for (let idx = 0; idx < value.length; idx++) {
+          const child = { value: value[idx], parent: node, key: idx };
+          const path = selector.usesPath ? pathToJsonPathString(pathOf(child)) : "";
+          if (selector.test(value[idx], idx, value, root, path, pp))
+            out.push(child);
+        }
+      } else if (isObject(value)) {
+        for (const key of Object.keys(value)) {
+          const child = { value: value[key], parent: node, key };
+          const path = selector.usesPath ? pathToJsonPathString(pathOf(child)) : "";
+          if (selector.test(value[key], key, value, root, path, pp))
+            out.push(child);
+        }
+      }
+      return;
     }
+    case "parent": {
+      if (node.parent !== void 0)
+        out.push(node.parent);
+      return;
+    }
+    case "keys": {
+      if (node.parent === void 0)
+        return;
+      out.push({ value: node.key, parent: node.parent, key: node.key });
+      return;
+    }
+    case "none":
+      return;
+  }
+};
+const walkDescendants = (node, visit) => {
+  visit(node);
+  const value = node.value;
+  if (Array.isArray(value)) {
+    for (let idx = 0; idx < value.length; idx++)
+      walkDescendants({ value: value[idx], parent: node, key: idx }, visit);
+  } else if (isObject(value)) {
+    for (const key of Object.keys(value))
+      walkDescendants({ value: value[key], parent: node, key }, visit);
+  }
 };
-/** Applies a list of steps to an existing set of nodes. */
 const applySteps = (root, initial, steps) => {
-    let current = initial;
-    for (const step of steps) {
-        const next = [];
-        if (step.recursive) {
-            for (const node of current)
-                walkDescendants(node, (n) => applySelector(n, step.selector, root, next));
-        }
-        else {
-            for (const node of current)
-                applySelector(node, step.selector, root, next);
-        }
-        current = next;
+  let current = initial;
+  for (const step of steps) {
+    const next = [];
+    if (step.recursive) {
+      for (const node of current)
+        walkDescendants(node, (n) => applySelector(n, step.selector, root, next));
+    } else {
+      for (const node of current)
+        applySelector(node, step.selector, root, next);
     }
-    return current;
+    current = next;
+  }
+  return current;
 };
-const runSteps = (root, steps) => applySteps(root, [{ value: root, parent: undefined, key: undefined }], steps);
+const runSteps = (root, steps) => applySteps(root, [{ value: root, parent: void 0, key: void 0 }], steps);
 const toMatches = (nodes) => {
-    const out = new Array(nodes.length);
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        out[i] = { value: node.value, path: normalizePath(pathOf(node)) };
-    }
-    return out;
+  const out = new Array(nodes.length);
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    out[i] = { value: node.value, path: normalizePath(pathOf(node)) };
+  }
+  return out;
 };
-/** Evaluates a pre-compiled path against `data`. */
-export const queryCompiled = (data, compiled) => {
-    // A malformed path matches nothing rather than falling back to the root.
-    if (compiled.error !== undefined)
-        return [];
-    if (data === null || data === undefined)
-        return [];
-    return toMatches(runSteps(data, compiled.steps));
+const queryCompiled = (data, compiled) => {
+  if (compiled.error !== void 0)
+    return [];
+  if (data === null || data === void 0)
+    return [];
+  return toMatches(runSteps(data, compiled.steps));
 };
-/**
- * Evaluates many pre-compiled paths against `data`, sharing a *single* recursive
- * descent of the tree across every `$..`-rooted path. The ruleset has ~16
- * descent `given`s; walking the (post-deref, ~60k-node) tree once and testing
- * each path's first selector at every node — instead of one full traversal per
- * path — is the dominant rule-run speedup on large specs. Non-recursive paths
- * are evaluated directly (cheap, no descent).
- *
- * Returns one match array per input path, index-aligned with `compiled`.
- */
-export const queryMany = (data, compiled) => {
-    const out = new Array(compiled.length);
-    if (data === null || data === undefined) {
-        for (let i = 0; i < compiled.length; i++)
-            out[i] = [];
-        return out;
-    }
-    const recursive = [];
-    for (let i = 0; i < compiled.length; i++) {
-        const c = compiled[i];
-        // Skip malformed paths entirely; they contribute no matches.
-        if (c.error !== undefined) {
-            out[i] = [];
-            continue;
-        }
-        const first = c.steps[0];
-        if (first?.recursive)
-            recursive.push(i);
-        else
-            out[i] = queryCompiled(data, c);
+const queryMany = (data, compiled) => {
+  const out = new Array(compiled.length);
+  if (data === null || data === void 0) {
+    for (let i = 0; i < compiled.length; i++)
+      out[i] = [];
+    return out;
+  }
+  const recursive = [];
+  for (let i = 0; i < compiled.length; i++) {
+    const c = compiled[i];
+    if (c.error !== void 0) {
+      out[i] = [];
+      continue;
     }
-    if (recursive.length > 0) {
-        // Walk the whole tree exactly once, applying every descent path's first
-        // selector at each visited node in the same pass (fused descent), so the
-        // ~15k-node resolved tree is traversed a single time rather than once per
-        // `$..` given. Each path's surviving seeds then run its remaining steps.
-        const firsts = recursive.map((i) => compiled[i].steps[0]);
-        const seeds = recursive.map(() => []);
-        const root = { value: data, parent: undefined, key: undefined };
-        walkDescendants(root, (node) => {
-            for (let r = 0; r < recursive.length; r++)
-                applySelector(node, firsts[r].selector, data, seeds[r]);
-        });
-        for (let r = 0; r < recursive.length; r++) {
-            const c = compiled[recursive[r]];
-            out[recursive[r]] = toMatches(applySteps(data, seeds[r], c.steps.slice(1)));
-        }
+    const first = c.steps[0];
+    if (first?.recursive)
+      recursive.push(i);
+    else
+      out[i] = queryCompiled(data, c);
+  }
+  if (recursive.length > 0) {
+    const firsts = recursive.map((i) => compiled[i].steps[0]);
+    const seeds = recursive.map(() => []);
+    const root = { value: data, parent: void 0, key: void 0 };
+    walkDescendants(root, (node) => {
+      for (let r = 0; r < recursive.length; r++)
+        applySelector(node, firsts[r].selector, data, seeds[r]);
+    });
+    for (let r = 0; r < recursive.length; r++) {
+      const c = compiled[recursive[r]];
+      out[recursive[r]] = toMatches(applySteps(data, seeds[r], c.steps.slice(1)));
     }
-    return out;
+  }
+  return out;
+};
+const query = (data, expression) => queryCompiled(data, compileQuery(expression));
+export {
+  compileQuery,
+  query,
+  queryCompiled,
+  queryMany
 };
-/** Runs a JSONPath expression and returns each match with its concrete path. */
-export const query = (data, expression) => queryCompiled(data, compileQuery(expression));