@crewhaus/tool-data 0.7.0 → 0.8.0

package/dist/lib/csv.d.ts

@@ -31,6 +31,20 @@ export declare class CsvError extends Error {
     readonly line: number;
     constructor(message: string, line: number);
 }
+/**
+ * Why a delimiter/quote pair cannot describe a CSV file, or null when it can.
+ *
+ * One check for the reader and the writer, so neither accepts a dialect the
+ * other cannot honour. A line break cannot be the delimiter or the quote:
+ * rows are separated by line breaks, so a `\n` delimiter turns every field
+ * into a row (a writer's output read back as one header line of values and
+ * zero records), and a `\r` one splits CRLF rows into phantom columns. The
+ * quote character cannot be the delimiter, or a quoted field cannot be told
+ * from a field boundary. U+FEFF cannot be either: a reader drops it from the
+ * start of a file as a byte-order mark, so `["", "x"]` written with it as
+ * the delimiter read back as `["x"]`.
+ */
+export declare function csvDialectError(delimiter: string, quote: string): string | null;
 /** Split CSV text into rows of raw string fields. Throws `CsvError` on an unterminated quote. */
 export declare function parseCsv(text: string, options: CsvParseOptions): CsvParseResult;
 /**
@@ -65,6 +79,13 @@ export type CsvWriteOptions = {
     /** Quote every field, not only the ones that need it. */
     quoteAll: boolean;
     header: string[] | null;
+    /**
+     * Throw `OutputLimitError` once the text would pass this many characters.
+     * Records with keys that differ make a column for every key and a cell for
+     * every column in every row, so the output can be rows x columns even
+     * when the input was rows + columns.
+     */
+    maxChars?: number;
 };
 /** Quote a single field if it contains the delimiter, a quote, or a line break. */
 export declare function escapeCsvField(value: string, options: CsvWriteOptions): string;
@@ -74,7 +95,11 @@ export declare function escapeCsvField(value: string, options: CsvWriteOptions):
  * `[object Object]` is how a pipeline loses data without noticing.
  */
 export declare function cellToString(value: unknown): string;
-/** Serialize rows of already-stringified cells. */
-export declare function writeCsvRows(rows: ReadonlyArray<ReadonlyArray<unknown>>, options: CsvWriteOptions): string;
+/**
+ * Serialize rows of already-stringified cells. Throws `CsvError` for a
+ * dialect `parseCsv` would refuse or misread (see `csvDialectError`), so
+ * nothing is written that this package cannot read back.
+ */
+export declare function writeCsvRows(rows: Iterable<ReadonlyArray<unknown>>, options: CsvWriteOptions): string;
 /** Column order for a set of records: keys in first-seen order across every record. */
 export declare function unionKeys(records: ReadonlyArray<Record<string, unknown>>): string[];

package/dist/lib/csv.js

@@ -13,6 +13,7 @@
  * caller's problem, and there is no support for backslash escapes, which
  * RFC 4180 does not define.
  */
+import { OutputLimitError, setOwn } from "./json";
 export class CsvError extends Error {
     line;
     constructor(message, line) {
@@ -20,15 +21,43 @@ export class CsvError extends Error {
         this.line = line;
     }
 }
-/** Split CSV text into rows of raw string fields. Throws `CsvError` on an unterminated quote. */
-export function parseCsv(text, options) {
-    const { delimiter, quote } = options;
+/**
+ * Why a delimiter/quote pair cannot describe a CSV file, or null when it can.
+ *
+ * One check for the reader and the writer, so neither accepts a dialect the
+ * other cannot honour. A line break cannot be the delimiter or the quote:
+ * rows are separated by line breaks, so a `\n` delimiter turns every field
+ * into a row (a writer's output read back as one header line of values and
+ * zero records), and a `\r` one splits CRLF rows into phantom columns. The
+ * quote character cannot be the delimiter, or a quoted field cannot be told
+ * from a field boundary. U+FEFF cannot be either: a reader drops it from the
+ * start of a file as a byte-order mark, so `["", "x"]` written with it as
+ * the delimiter read back as `["x"]`.
+ */
+export function csvDialectError(delimiter, quote) {
     if (delimiter.length !== 1)
-        throw new CsvError("delimiter must be a single character", 0);
+        return "delimiter must be a single character";
     if (quote.length !== 1)
-        throw new CsvError("quote must be a single character", 0);
+        return "quote must be a single character";
+    if (delimiter === "\ufeff" || quote === "\ufeff") {
+        return "neither delimiter nor quote can be U+FEFF — a reader drops it from the start of a file as a byte-order mark";
+    }
+    if (delimiter === "\r" || delimiter === "\n") {
+        return "delimiter cannot be a line break (CR or LF) — rows are separated by line breaks";
+    }
+    if (quote === "\r" || quote === "\n") {
+        return "quote cannot be a line break (CR or LF) — rows are separated by line breaks";
+    }
     if (delimiter === quote)
-        throw new CsvError("delimiter and quote must differ", 0);
+        return "delimiter and quote must differ";
+    return null;
+}
+/** Split CSV text into rows of raw string fields. Throws `CsvError` on an unterminated quote. */
+export function parseCsv(text, options) {
+    const { delimiter, quote } = options;
+    const dialect = csvDialectError(delimiter, quote);
+    if (dialect !== null)
+        throw new CsvError(dialect, 0);
     const src = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
     const rows = [];
     let row = [];
@@ -154,10 +183,10 @@ export function rowsToRecords(rows, header, infer, nullTokens) {
         header.forEach((name, j) => {
             const cell = row[j];
             if (cell === undefined) {
-                rec[name] = null;
+                setOwn(rec, name, null);
                 return;
             }
-            rec[name] = infer ? inferScalar(cell, nullTokens) : cell;
+            setOwn(rec, name, infer ? inferScalar(cell, nullTokens) : cell);
         });
         records.push(rec);
     });
@@ -211,16 +240,50 @@ export function cellToString(value) {
         return value;
     if (typeof value === "number" || typeof value === "boolean")
         return String(value);
-    return JSON.stringify(value);
+    // JSON.stringify answers undefined for a function or a symbol, which no
+    // JSON value is; an empty field beats a crash in the quoting step.
+    return JSON.stringify(value) ?? "";
 }
-/** Serialize rows of already-stringified cells. */
+/**
+ * Serialize rows of already-stringified cells. Throws `CsvError` for a
+ * dialect `parseCsv` would refuse or misread (see `csvDialectError`), so
+ * nothing is written that this package cannot read back.
+ */
 export function writeCsvRows(rows, options) {
+    const dialect = csvDialectError(options.delimiter, options.quote);
+    if (dialect !== null)
+        throw new CsvError(dialect, 0);
+    const max = options.maxChars ?? Number.POSITIVE_INFINITY;
     const lines = [];
-    if (options.header !== null) {
-        lines.push(options.header.map((h) => escapeCsvField(h, options)).join(options.delimiter));
-    }
+    let chars = -options.newline.length;
+    const push = (line) => {
+        chars += line.length + options.newline.length;
+        if (chars > max)
+            throw new OutputLimitError(max, "the CSV");
+        lines.push(line);
+    };
+    const q = options.quote;
+    // Two cases a reader would otherwise misread, so both are quoted: a row
+    // whose only field is empty is a blank line, which a reader skips, and a
+    // leading U+FEFF in the file's first field is taken for a byte-order mark
+    // and dropped.
+    const encode = (cells) => {
+        if (cells.length === 1 && cells[0] === "")
+            return q + q;
+        return cells
+            .map((cell, i) => i === 0 && lines.length === 0 && cell.startsWith("\ufeff")
+            ? q + cell.split(q).join(q + q) + q
+            : escapeCsvField(cell, options))
+            .join(options.delimiter);
+    };
+    if (options.header !== null)
+        push(encode(options.header));
     for (const row of rows) {
-        lines.push(row.map((cell) => escapeCsvField(cellToString(cell), options)).join(options.delimiter));
+        // A row's cells are delimiter-separated at the least; checked before the
+        // row is built, so one enormous row is not built to be refused.
+        if (chars + row.length > max)
+            throw new OutputLimitError(max, "the CSV");
+        push(encode(row.map(cellToString)));
     }
     return lines.join(options.newline);
 }

package/dist/lib/diff.js

@@ -7,7 +7,7 @@
  * wrong one for a list of records — for records, key the arrays first with
  * `keyArraysBy`, which matches elements by a field instead of by position.
  */
-import { deepEqual, isPlainObject, typeOf } from "./json";
+import { deepEqual, getOwn, isPlainObject, typeOf } from "./json";
 import { formatPointer } from "./patch";
 /** Compare two values, returning a flat list of differences by JSON Pointer path. */
 export function deepDiff(a, b, options) {
@@ -119,7 +119,7 @@ function canKey(arr, key) {
     for (const el of arr) {
         if (!isPlainObject(el))
             return false;
-        const v = el[key];
+        const v = getOwn(el, key);
         if (v === undefined || v === null || typeof v === "object")
             return false;
         const s = String(v);
@@ -133,7 +133,7 @@ function diffKeyedArrays(left, right, key, path, depth, recurse, push) {
     const index = (arr) => {
         const m = new Map();
         arr.forEach((el, i) => {
-            const v = el[key];
+            const v = getOwn(el, key);
             m.set(String(v), { i, value: el });
         });
         return m;

package/dist/lib/json.d.ts

@@ -11,6 +11,24 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | {
 };
 /** A plain object, as distinct from an array or a primitive. */
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Read `key` only when it is the object's OWN property. A key taken from the
+ * data (a dotted path segment, a TOML table name, an XML element name) must
+ * never reach an inherited member: `constructor` would read
+ * `Object.prototype.constructor`, and `__proto__` would hand back
+ * `Object.prototype` itself as something to write into — which is how one
+ * hostile document polluted every object in the process.
+ */
+export declare function getOwn(obj: Record<string, unknown>, key: string): unknown;
+/**
+ * Write `key` as an own data property. For every key but `__proto__` plain
+ * assignment already does that; `__proto__` alone is an accessor inherited
+ * from `Object.prototype`, whose setter would replace the object's prototype
+ * (dropping the key) instead of storing it. `defineProperty` stores it as the
+ * data it is, so `{"__proto__": …}` round-trips like any other key — the
+ * way `JSON.parse` itself reads it.
+ */
+export declare function setOwn(obj: Record<string, unknown>, key: string, value: unknown): void;
 /** Structural equality over JSON values. Key order is irrelevant; NaN never appears in JSON. */
 export declare function deepEqual(a: unknown, b: unknown): boolean;
 /** A structured clone that only has to handle JSON shapes, so no cycles exist. */
@@ -63,3 +81,36 @@ export declare function parseJson(text: string): {
 };
 /** A short, human-readable type name used in diffs and error messages. */
 export declare function typeOf(value: unknown): string;
+/**
+ * The deepest nesting a document may have: each `[` or `{` is one level, a
+ * scalar document is depth 0. XmlParse's own ceiling, and far past any real
+ * configuration, API response or AST dump.
+ */
+export declare const MAX_NESTING_DEPTH = 256;
+/**
+ * Whether JSON text nests deeper than `limit`, from one linear pass over the
+ * characters: brackets inside string literals (escapes honoured) do not
+ * count, and nothing is parsed, so a hostile document is refused before a
+ * deep tree exists. Malformed text may be over-counted; it would fail to
+ * parse anyway.
+ */
+export declare function jsonTextNestsDeeper(text: string, limit: number): boolean;
+/** Whether a parsed value nests deeper than `limit`. Iterative: no recursion to overflow. */
+export declare function nestingDepthExceeds(value: unknown, limit: number): boolean;
+/** A result, or a part of one, that would be larger than its tool may return. */
+export declare class OutputLimitError extends Error {
+    readonly limit: number;
+    constructor(limit: number, what?: string);
+}
+/**
+ * The length of `JSON.stringify(value, null, indent)`, computed without
+ * building it, and abandoned as soon as it passes `cap` (the answer is then
+ * some number above `cap`). Iterative and exact for JSON values; a
+ * non-plain object (none of this package's readers make one) is measured by
+ * serializing it.
+ *
+ * Measured first so that a result too large to return is refused before it
+ * exists: pretty-printing multiplies every line by depth x indent, and a
+ * record set can repeat a long key once per row.
+ */
+export declare function jsonTextLength(value: unknown, indent: number, cap: number): number;

package/dist/lib/json.js

@@ -10,6 +10,38 @@
 export function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * Read `key` only when it is the object's OWN property. A key taken from the
+ * data (a dotted path segment, a TOML table name, an XML element name) must
+ * never reach an inherited member: `constructor` would read
+ * `Object.prototype.constructor`, and `__proto__` would hand back
+ * `Object.prototype` itself as something to write into — which is how one
+ * hostile document polluted every object in the process.
+ */
+export function getOwn(obj, key) {
+    return Object.hasOwn(obj, key) ? obj[key] : undefined;
+}
+/**
+ * Write `key` as an own data property. For every key but `__proto__` plain
+ * assignment already does that; `__proto__` alone is an accessor inherited
+ * from `Object.prototype`, whose setter would replace the object's prototype
+ * (dropping the key) instead of storing it. `defineProperty` stores it as the
+ * data it is, so `{"__proto__": …}` round-trips like any other key — the
+ * way `JSON.parse` itself reads it.
+ */
+export function setOwn(obj, key, value) {
+    if (key === "__proto__") {
+        Object.defineProperty(obj, key, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+}
 /** Structural equality over JSON values. Key order is irrelevant; NaN never appears in JSON. */
 export function deepEqual(a, b) {
     if (a === b)
@@ -45,7 +77,7 @@ export function deepClone(value) {
     if (isPlainObject(value)) {
         const out = {};
         for (const k of Object.keys(value))
-            out[k] = deepClone(value[k]);
+            setOwn(out, k, deepClone(value[k]));
         return out;
     }
     return value;
@@ -74,7 +106,7 @@ export function sortKeysDeep(value) {
     if (isPlainObject(value)) {
         const out = {};
         for (const k of Object.keys(value).sort())
-            out[k] = sortKeysDeep(value[k]);
+            setOwn(out, k, sortKeysDeep(value[k]));
         return out;
     }
     return value;
@@ -131,3 +163,143 @@ export function typeOf(value) {
         return "array";
     return typeof value;
 }
+// ---------------------------------------------------------------------------
+// Bounds on nesting and on output.
+//
+// A document's cost here is not its length. Every tool that walks a value
+// does work per level as well as per node — a merge that cloned the rest of
+// the tree at each level, a query that copied the path at each level, a
+// pretty-printer that writes depth x indent spaces on every line — so a
+// 48 KB document nested 8,000 deep cost gigabytes. Depth is capped at the
+// door, and every result is measured before it is built.
+/**
+ * The deepest nesting a document may have: each `[` or `{` is one level, a
+ * scalar document is depth 0. XmlParse's own ceiling, and far past any real
+ * configuration, API response or AST dump.
+ */
+export const MAX_NESTING_DEPTH = 256;
+/**
+ * Whether JSON text nests deeper than `limit`, from one linear pass over the
+ * characters: brackets inside string literals (escapes honoured) do not
+ * count, and nothing is parsed, so a hostile document is refused before a
+ * deep tree exists. Malformed text may be over-counted; it would fail to
+ * parse anyway.
+ */
+export function jsonTextNestsDeeper(text, limit) {
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (inString) {
+            // A backslash escapes the character after it.
+            if (c === 0x5c)
+                i += 1;
+            else if (c === 0x22)
+                inString = false;
+            continue;
+        }
+        if (c === 0x22)
+            inString = true;
+        else if (c === 0x5b || c === 0x7b) {
+            depth += 1;
+            if (depth > limit)
+                return true;
+        }
+        else if (c === 0x5d || c === 0x7d) {
+            if (depth > 0)
+                depth -= 1;
+        }
+    }
+    return false;
+}
+/** Whether a parsed value nests deeper than `limit`. Iterative: no recursion to overflow. */
+export function nestingDepthExceeds(value, limit) {
+    const stack = [[value, 0]];
+    while (stack.length > 0) {
+        const [node, depth] = stack.pop();
+        const children = Array.isArray(node) ? node : isPlainObject(node) ? Object.values(node) : null;
+        if (children === null)
+            continue;
+        if (depth + 1 > limit)
+            return true;
+        for (const child of children) {
+            if (typeof child === "object" && child !== null)
+                stack.push([child, depth + 1]);
+        }
+    }
+    return false;
+}
+/** A result, or a part of one, that would be larger than its tool may return. */
+export class OutputLimitError extends Error {
+    limit;
+    constructor(limit, what = "the result") {
+        super(`${what} would be more than ${limit} characters`);
+        this.limit = limit;
+    }
+}
+/** Nothing a value's JSON form renders as: skipped in an object, `null` in an array. */
+const renders = (v) => v !== undefined && typeof v !== "function" && typeof v !== "symbol";
+/**
+ * The length of `JSON.stringify(value, null, indent)`, computed without
+ * building it, and abandoned as soon as it passes `cap` (the answer is then
+ * some number above `cap`). Iterative and exact for JSON values; a
+ * non-plain object (none of this package's readers make one) is measured by
+ * serializing it.
+ *
+ * Measured first so that a result too large to return is refused before it
+ * exists: pretty-printing multiplies every line by depth x indent, and a
+ * record set can repeat a long key once per row.
+ */
+export function jsonTextLength(value, indent, cap) {
+    if (!renders(value))
+        return 0;
+    const k = Math.min(10, Math.max(0, Math.floor(indent)));
+    let total = 0;
+    const stack = [[value, 0]];
+    while (stack.length > 0) {
+        const [node, depth] = stack.pop();
+        if (node === null || !renders(node)) {
+            total += 4; // null, or a non-rendering array element, which becomes null
+        }
+        else if (typeof node === "string") {
+            total += JSON.stringify(node).length;
+        }
+        else if (typeof node === "number") {
+            total += Number.isFinite(node) ? String(node).length : 4;
+        }
+        else if (typeof node === "boolean") {
+            total += node ? 4 : 5;
+        }
+        else if (Array.isArray(node)) {
+            const n = node.length;
+            if (n === 0)
+                total += 2;
+            else {
+                total += 2 + (n - 1) + (k === 0 ? 0 : n * (1 + (depth + 1) * k) + 1 + depth * k);
+                for (let i = n - 1; i >= 0; i--)
+                    stack.push([node[i], depth + 1]);
+            }
+        }
+        else if (isPlainObject(node)) {
+            let m = 0;
+            for (const key of Object.keys(node)) {
+                const v = node[key];
+                if (!renders(v))
+                    continue;
+                m += 1;
+                total += JSON.stringify(key).length + (k === 0 ? 1 : 2);
+                stack.push([v, depth + 1]);
+            }
+            if (m === 0)
+                total += 2;
+            else
+                total += 2 + (m - 1) + (k === 0 ? 0 : m * (1 + (depth + 1) * k) + 1 + depth * k);
+        }
+        else {
+            total += (JSON.stringify(node) ?? "null").length;
+        }
+        if (total > cap)
+            return total;
+    }
+    return total;
+}

package/dist/lib/jsonl.d.ts

@@ -1,12 +1,3 @@
-/**
- * Line-delimited JSON. One value per line, which is what log shippers,
- * dataset files and streaming APIs emit.
- *
- * Reading is tolerant where tolerance is safe — a trailing newline, blank
- * lines, CRLF endings, and a byte-order mark are all fine — and strict where
- * it is not: a line that does not parse is reported with its 1-based line
- * number and the parser's message, never dropped in silence.
- */
 export type JsonlRecord = {
     line: number;
     value: unknown;
@@ -33,7 +24,7 @@ export declare function parseJsonl(text: string, maxRecords: number, stopOnError
  * format relies on. `undefined` entries are skipped and counted, since
  * `JSON.stringify(undefined)` is not a value at all.
  */
-export declare function writeJsonl(values: ReadonlyArray<unknown>, trailingNewline: boolean): {
+export declare function writeJsonl(values: ReadonlyArray<unknown>, trailingNewline: boolean, maxChars?: number): {
     text: string;
     skipped: number;
 };

package/dist/lib/jsonl.js

@@ -7,6 +7,7 @@
  * it is not: a line that does not parse is reported with its 1-based line
  * number and the parser's message, never dropped in silence.
  */
+import { MAX_NESTING_DEPTH, OutputLimitError, jsonTextLength, jsonTextNestsDeeper } from "./json";
 /**
  * Parse JSONL. `maxRecords` bounds the result; `stopOnError` makes the first
  * bad line end the parse, which is what a caller wants when the file is a
@@ -27,6 +28,10 @@ export function parseJsonl(text, maxRecords, stopOnError) {
             break;
         }
         try {
+            // Checked before parsing, like every JSON document this package reads.
+            if (jsonTextNestsDeeper(raw, MAX_NESTING_DEPTH)) {
+                throw new Error(`nests deeper than ${MAX_NESTING_DEPTH} levels`);
+            }
             records.push({ line: i + 1, value: JSON.parse(raw) });
         }
         catch (err) {
@@ -47,15 +52,24 @@ export function parseJsonl(text, maxRecords, stopOnError) {
  * format relies on. `undefined` entries are skipped and counted, since
  * `JSON.stringify(undefined)` is not a value at all.
  */
-export function writeJsonl(values, trailingNewline) {
+export function writeJsonl(values, trailingNewline, maxChars = Number.POSITIVE_INFINITY) {
     const lines = [];
     let skipped = 0;
+    let chars = 0;
     for (const value of values) {
+        // Measured before it is built: a record converted from CSV repeats every
+        // column name, so one line can be far larger than its source row.
+        if (maxChars !== Number.POSITIVE_INFINITY) {
+            const size = jsonTextLength(value, 0, maxChars - chars);
+            if (chars + size + 1 > maxChars)
+                throw new OutputLimitError(maxChars, "the JSONL");
+        }
         const text = JSON.stringify(value);
         if (text === undefined) {
             skipped += 1;
             continue;
         }
+        chars += text.length + 1;
         lines.push(text);
     }
     const body = lines.join("\n");

package/dist/lib/jsonpath.d.ts

@@ -33,6 +33,7 @@
  * `&&`. Anything unsupported raises a parse error naming the offending
  * position, never a silent empty result.
  */
+import { type RegexAnswers } from "@crewhaus/tool-schema";
 export type PathStep = {
     kind: "child";
     name: string;
@@ -72,11 +73,46 @@ export type PathMatch = {
  * back as an array index and matches nothing.
  */
 export type PathSegment = string | number;
-/** Run a parsed path over a value, returning matches in document order. */
-export declare function queryPath(root: unknown, steps: ReadonlyArray<PathStep>, limit: number): {
+/**
+ * The most nodes one query may visit, counting every node a step produces
+ * and every node a `..` walk passes. A single pass over the largest document
+ * this package accepts is well inside it; a path that walks the document
+ * again for each node it found (`$..*..x` over a deep document) is what it
+ * stops.
+ */
+export declare const MAX_QUERY_VISITS = 5000000;
+export type QueryResult = {
     matches: PathMatch[];
+    /**
+     * True when there are, or may be, matches past the ones returned: the
+     * limit was reached, or the query stopped at the visit budget.
+     */
     truncated: boolean;
+    /** Set when the query stopped at MAX_QUERY_VISITS rather than at the limit. */
+    stoppedAtVisits?: number;
+    /**
+     * Nodes a `=~` filter could not be answered on (the regex worker's
+     * deadline, the engine giving up): left out, neither matched nor ruled
+     * out, with their paths. Absent when there were none.
+     */
+    undetermined?: {
+        count: number;
+        paths: string[];
+    };
 };
+/**
+ * Run a parsed path over a value, returning matches in document order.
+ *
+ * Evaluated lazily, depth first: each node a step produces runs through the
+ * remaining steps before the next is produced, which gives exactly the
+ * step-by-step, document-order result, and lets the query stop as soon as it
+ * has one match more than `limit` (to know it truncated). 0.7.0 built each
+ * step's whole node list first and then cut it at 20 x limit — so `$..*`
+ * materialized every node with its path, and a cut in the middle of a path
+ * silently dropped real matches: `$[*].b` over thirty records with `b` only
+ * in the last answered zero matches, not truncated.
+ */
+export declare function queryPath(root: unknown, steps: ReadonlyArray<PathStep>, limit: number, maxVisits?: number, regex?: RegexAnswers): QueryResult;
 /** Python slice semantics, including negative bounds and a negative step. */
 export declare function sliceIndices(length: number, start: number | null, end: number | null, step: number): number[];
 /**