@amazon/vinyl-util 1.0.0

package/dist/types/current/util/range/IntersectionRanges.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyRangesImpl } from './Ranges';
+/**
+ * Takes a list of ranges and computes the intersection ranges on read.
+ */
+export class IntersectionRanges extends ReadonlyRangesImpl {
+    options;
+    backingRanges = [];
+    valid = false;
+    _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the intersection.
+     */
+    innerRanges, options) {
+        super();
+        this.options = options;
+        this._innerRanges = innerRanges;
+    }
+    get innerRanges() {
+        return this._innerRanges;
+    }
+    set innerRanges(value) {
+        this._innerRanges = value;
+        this.invalidate();
+    }
+    get ranges() {
+        if (!this.valid)
+            this.validate();
+        return this.backingRanges;
+    }
+    /**
+     * Flags the intersection ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate() {
+        this.valid = false;
+    }
+    /**
+     * Refreshes the backing ranges by computing intersection.
+     */
+    validate() {
+        if (this._innerRanges.length === 0) {
+            this.backingRanges = [];
+            if (this.options?.useCache === true) {
+                this.valid = true;
+            }
+            return;
+        }
+        // Start with the first range set
+        this.backingRanges = this._innerRanges[0].ranges;
+        // Intersect with each subsequent range set
+        for (let i = 1; i < this._innerRanges.length; i++) {
+            const currentRanges = this._innerRanges[i];
+            const tempRanges = [];
+            // Find intersections between backingRanges and currentRanges
+            for (let j = 0; j < this.backingRanges.length; j++) {
+                const [backStart, backEnd] = this.backingRanges[j];
+                for (const [currStart, currEnd] of currentRanges) {
+                    const intersectionStart = Math.max(backStart, currStart);
+                    const intersectionEnd = Math.min(backEnd, currEnd);
+                    if (intersectionStart < intersectionEnd) {
+                        tempRanges.push([intersectionStart, intersectionEnd]);
+                    }
+                }
+            }
+            // Replace backing ranges with intersection result
+            this.backingRanges = tempRanges;
+        }
+        if (this.options?.useCache === true) {
+            this.valid = true;
+        }
+    }
+}

package/dist/types/current/util/range/Ranges.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Query utilities for a list of ranges.
+ * Ranges are expected to be start, end pairs where no two ranges overlap or touch.
+ * All ranges are in incremental order.
+ */
+export interface ReadonlyRanges extends Iterable<Range> {
+    /**
+     * Returns true if there are zero ranges.
+     */
+    readonly empty: boolean;
+    /**
+     * The ranges array like this reader encapsulates.
+     * Ranges are [start, end] tuples, they will always be ordered, never touch, and never overlap.
+     */
+    readonly ranges: ArrayLike<Range>;
+    /**
+     * Returns the range at the given value, or null if all ranges are outside the given tolerance.
+     * Range values are considered inclusive.
+     * That is, a ReadonlyRanges with `[0, 1]` will return `[0, 1]` for value `1`.
+     *
+     * @param value The value to compare to current ranges.
+     * @param tolerance The tolerance the value may be outside a range and still considered
+     * to be within. Default: 0
+     */
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    /**
+     * Returns the range that includes the entire from-to span, within a given tolerance.
+     *
+     * Range values are considered inclusive.
+     * That is, a `ReadonlyRanges` with `[0, 2]` will return `[0, 2]` for
+     * `getRangeContaining(2, 2)` or `getRangeContaining(0, 0)`.
+     *
+     * `from` does not need to be lesser than `to`.
+     *
+     * @param from
+     * @param to
+     * @param tolerance
+     */
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    /**
+     * Returns all ranges where at least part of the range is within the given from-to span.
+     *
+     * `from` does not need to be lesser than `to`.
+     *
+     * @param from
+     * @param to
+     * @param tolerance
+     */
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    [Symbol.iterator](): IterableIterator<Range>;
+}
+/**
+ * A [start, end] tuple.
+ */
+export type Range = readonly [start: number, end: number];
+export declare abstract class ReadonlyRangesImpl implements ReadonlyRanges {
+    /**
+     * An accessor to the backed ranges.
+     * Implementations must provide an ArrayLike<Range> for random-access reading.
+     * This will be called at most once per read operation.
+     */
+    abstract get ranges(): ArrayLike<Range>;
+    get empty(): boolean;
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    [Symbol.iterator](): IterableIterator<Range>;
+    toString(): string;
+}
+/**
+ * Creates a ReadonlyRanges view for the given array of ranges.
+ *
+ * @param value An array of ranges. The ReadonlyRanges reader does not clone
+ * this value and will access this backing array directly.
+ */
+export declare function rangesOf(value: readonly Range[]): ReadonlyRanges;
+/**
+ * A static, empty ranges representation.
+ */
+export declare const emptyRanges: ReadonlyRanges;
+/**
+ * A collection of Range start/end tuples.
+ * When ranges are added they are merged and sorted, making for fast within range checks.
+ */
+export declare class RangesImpl implements ReadonlyRanges {
+    private readonly reader;
+    readonly ranges: Range[];
+    /**
+     * @param ranges The non-normalized ranges to add.
+     * @see #add
+     */
+    constructor(ranges?: readonly Range[]);
+    get empty(): boolean;
+    /**
+     * Adds the given range to this list.
+     * If end is less than start, the range will not be added.
+     * Ranges will be merged when there is overlap or touching. Example,
+     * `add(1, 4); add(2, 5)` results in the final ranges: `[1, 5]`
+     */
+    add(start: number, end: number): void;
+    /**
+     * Removes the given range span from this list.
+     * Ranges partially intersecting will be changed to not include the start-end span.
+     * If start is after end, nothing will be removed.
+     */
+    remove(start: number, end: number): void;
+    /**
+     * Clears all ranges.
+     */
+    clear(): void;
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    clone(): RangesImpl;
+    [Symbol.iterator](): IterableIterator<Range>;
+    toString(): string;
+}
+/**
+ * Returns true if the two ranges intersect.
+ * Adjacent ranges (touching but not overlapping) will not be considered to intersect.
+ */
+export declare function rangeIntersects(rangeA: Range, rangeB: Range): boolean;
+//# sourceMappingURL=Ranges.d.ts.map

package/dist/types/current/util/range/Ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ranges.d.ts","sourceRoot":"","sources":["../../../../../src/util/range/Ranges.ts"],"names":[],"mappings":"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"}

package/dist/types/current/util/range/Ranges.js

@@ -0,0 +1,192 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createArrayLikeIterator, slice, sortedInsertionIndex, } from '../../util/collection/array';
+// Compares with a Range's start value.
+function startComparator(value, range) {
+    return value < range[0] ? -1 : 1;
+}
+// Compares with a Range's end value.
+function endComparator(value, range) {
+    return value <= range[1] ? -1 : 1;
+}
+export class ReadonlyRangesImpl {
+    get empty() {
+        return this.ranges.length === 0;
+    }
+    getRangeAt(value, tolerance = 0) {
+        const ranges = this.ranges;
+        if (ranges.length === 0)
+            return null;
+        const index = sortedInsertionIndex(ranges, value, startComparator);
+        // The insertion index will be 1 higher than the last range where start >= value.
+        const range = index <= 0 ? null : ranges[index - 1];
+        if (range && value <= range[1] + tolerance)
+            return range;
+        if (index >= ranges.length)
+            return null;
+        const next = ranges[index];
+        if (next[0] - tolerance <= value)
+            return next;
+        return null;
+    }
+    getRangeContaining(from, to, tolerance) {
+        const ranges = this.ranges;
+        if (ranges.length === 0)
+            return null;
+        const startRange = this.getRangeAt(from, tolerance);
+        if (startRange == null)
+            return null;
+        const endRange = this.getRangeAt(to, tolerance);
+        if (endRange === startRange)
+            return startRange;
+        return null;
+    }
+    getRangesWithin(from, to, tolerance = 0) {
+        const ranges = this.ranges;
+        if (ranges.length === 0)
+            return [];
+        const startIndex = sortedInsertionIndex(ranges, Math.min(from, to) - tolerance, endComparator);
+        const endIndex = sortedInsertionIndex(ranges, Math.max(from, to) + tolerance, startComparator);
+        return slice(ranges, startIndex, endIndex);
+    }
+    [Symbol.iterator]() {
+        return createArrayLikeIterator(this.ranges);
+    }
+    toString() {
+        return `[${Array.from(this.ranges)
+            .map((range) => `[${range[0]}, ${range[1]}]`)
+            .join(', ')}]`;
+    }
+}
+/**
+ * Returns a ReadonlyRanges reader for a fixed array of ranges.
+ */
+class RangesArrayReader extends ReadonlyRangesImpl {
+    _ranges;
+    constructor(_ranges) {
+        super();
+        this._ranges = _ranges;
+    }
+    get ranges() {
+        return this._ranges;
+    }
+}
+/**
+ * Creates a ReadonlyRanges view for the given array of ranges.
+ *
+ * @param value An array of ranges. The ReadonlyRanges reader does not clone
+ * this value and will access this backing array directly.
+ */
+export function rangesOf(value) {
+    return new RangesArrayReader(value);
+}
+/**
+ * A static, empty ranges representation.
+ */
+export const emptyRanges = new RangesArrayReader([]);
+/**
+ * A collection of Range start/end tuples.
+ * When ranges are added they are merged and sorted, making for fast within range checks.
+ */
+export class RangesImpl {
+    reader;
+    ranges = [];
+    /**
+     * @param ranges The non-normalized ranges to add.
+     * @see #add
+     */
+    constructor(ranges = []) {
+        for (const range of ranges) {
+            this.add(range[0], range[1]);
+        }
+        this.reader = new RangesArrayReader(this.ranges);
+    }
+    get empty() {
+        return this.reader.empty;
+    }
+    /**
+     * Adds the given range to this list.
+     * If end is less than start, the range will not be added.
+     * Ranges will be merged when there is overlap or touching. Example,
+     * `add(1, 4); add(2, 5)` results in the final ranges: `[1, 5]`
+     */
+    add(start, end) {
+        if (end < start)
+            return;
+        const startIndex = sortedInsertionIndex(this.ranges, start, endComparator);
+        const endIndex = sortedInsertionIndex(this.ranges, end, startComparator, startIndex);
+        const newStart = startIndex < this.ranges.length
+            ? Math.min(this.ranges[startIndex][0], start)
+            : start;
+        const newEnd = endIndex > 0 ? Math.max(this.ranges[endIndex - 1][1], end) : end;
+        this.ranges.splice(startIndex, endIndex - startIndex, [
+            newStart,
+            newEnd,
+        ]);
+    }
+    /**
+     * Removes the given range span from this list.
+     * Ranges partially intersecting will be changed to not include the start-end span.
+     * If start is after end, nothing will be removed.
+     */
+    remove(start, end) {
+        if (end < start || this.empty)
+            return;
+        // New ranges created due to cutting existing ones
+        const newRanges = [];
+        const startIndex = sortedInsertionIndex(this.ranges, start, endComparator);
+        const endIndex = sortedInsertionIndex(this.ranges, end, startComparator);
+        if (start === end && startIndex === endIndex - 1) {
+            // Do not split an encompassing range when start is equal to end.
+            const range = this.ranges[startIndex];
+            if (range[0] !== range[1])
+                return;
+        }
+        if (startIndex < this.ranges.length) {
+            const previousRange = this.ranges[startIndex];
+            if (previousRange[0] < start) {
+                newRanges.push([previousRange[0], start]);
+            }
+        }
+        if (endIndex > 0) {
+            const nextRange = this.ranges[endIndex - 1];
+            if (nextRange[1] > end) {
+                newRanges.push([end, nextRange[1]]);
+            }
+        }
+        this.ranges.splice(startIndex, endIndex - startIndex, ...newRanges);
+    }
+    /**
+     * Clears all ranges.
+     */
+    clear() {
+        this.ranges.length = 0;
+    }
+    getRangeAt(value, tolerance = 0) {
+        return this.reader.getRangeAt(value, tolerance);
+    }
+    getRangeContaining(from, to, tolerance) {
+        return this.reader.getRangeContaining(from, to, tolerance);
+    }
+    getRangesWithin(from, to, tolerance) {
+        return this.reader.getRangesWithin(from, to, tolerance);
+    }
+    clone() {
+        return new RangesImpl(this.ranges.slice());
+    }
+    [Symbol.iterator]() {
+        return this.reader[Symbol.iterator]();
+    }
+    toString() {
+        return this.reader.toString();
+    }
+}
+/**
+ * Returns true if the two ranges intersect.
+ * Adjacent ranges (touching but not overlapping) will not be considered to intersect.
+ */
+export function rangeIntersects(rangeA, rangeB) {
+    return rangeA[0] < rangeB[1] && rangeA[1] > rangeB[0];
+}

package/dist/types/current/util/range/UnionRanges.d.ts

@@ -0,0 +1,37 @@
+import { type Range, type ReadonlyRanges, ReadonlyRangesImpl } from './Ranges';
+import type { Maybe } from '../../util/type';
+export interface UnionRangesOptions {
+    /**
+     * If true, only recomputes ranges after a call to `invalidate`.
+     * After `invalidate()`, the ranges are recalculated on next read.
+     * Default: false
+     */
+    readonly useCache?: boolean;
+}
+/**
+ * Takes a list of ranges and computes the union ranges on read.
+ */
+export declare class UnionRanges extends ReadonlyRangesImpl {
+    private readonly options?;
+    private readonly backingRanges;
+    private valid;
+    private _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the union.
+     */
+    innerRanges: readonly ReadonlyRanges[], options?: Maybe<UnionRangesOptions>);
+    get innerRanges(): readonly ReadonlyRanges[];
+    set innerRanges(value: readonly ReadonlyRanges[]);
+    get ranges(): readonly Range[];
+    /**
+     * Flags the union ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate(): void;
+    /**
+     * Refreshes the backing ranges.
+     */
+    private validate;
+}
+//# sourceMappingURL=UnionRanges.d.ts.map

package/dist/types/current/util/range/UnionRanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnionRanges.d.ts","sourceRoot":"","sources":["../../../../../src/util/range/UnionRanges.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,KAAK,KAAK,EAEV,KAAK,cAAc,EACnB,kBAAkB,EACrB,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,WAAW,kBAAkB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,kBAAkB;IAW3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAV7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IACjD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAA2B;;IAG3C;;OAEG;IACH,WAAW,EAAE,SAAS,cAAc,EAAE,EAErB,OAAO,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC;IAMxD,IAAI,WAAW,IAAI,SAAS,cAAc,EAAE,CAE3C;IAED,IAAI,WAAW,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,EAG/C;IAED,IAAI,MAAM,IAAI,SAAS,KAAK,EAAE,CAG7B;IAED;;;OAGG;IACH,UAAU;IAIV;;OAEG;IACH,OAAO,CAAC,QAAQ;CAWnB"}

package/dist/types/current/util/range/UnionRanges.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RangesImpl, ReadonlyRangesImpl, } from './Ranges';
+/**
+ * Takes a list of ranges and computes the union ranges on read.
+ */
+export class UnionRanges extends ReadonlyRangesImpl {
+    options;
+    backingRanges = new RangesImpl();
+    valid = false;
+    _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the union.
+     */
+    innerRanges, options) {
+        super();
+        this.options = options;
+        this._innerRanges = innerRanges;
+    }
+    get innerRanges() {
+        return this._innerRanges;
+    }
+    set innerRanges(value) {
+        this._innerRanges = value;
+        this.invalidate();
+    }
+    get ranges() {
+        if (!this.valid)
+            this.validate();
+        return this.backingRanges.ranges;
+    }
+    /**
+     * Flags the union ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate() {
+        this.valid = false;
+    }
+    /**
+     * Refreshes the backing ranges.
+     */
+    validate() {
+        this.backingRanges.clear();
+        for (const ranges of this._innerRanges) {
+            for (const [start, end] of ranges) {
+                this.backingRanges.add(start, end);
+            }
+        }
+        if (this.options?.useCache === true) {
+            this.valid = true;
+        }
+    }
+}

package/dist/types/current/util/range/timeRanges.d.ts

@@ -0,0 +1,14 @@
+import { type Range, type ReadonlyRanges } from './Ranges';
+/**
+ * Converts a `TimeRanges` object to an Array for utility purposes.
+ *
+ * @param timeRanges
+ */
+export declare function timeRangesToArray(timeRanges: TimeRanges): Range[];
+/**
+ * Creates a reader for a TimeRanges object for easier querying.
+ *
+ * @param timeRanges
+ */
+export declare function createTimeRangesReader(timeRanges: TimeRanges): ReadonlyRanges;
+//# sourceMappingURL=timeRanges.d.ts.map

package/dist/types/current/util/range/timeRanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeRanges.d.ts","sourceRoot":"","sources":["../../../../../src/util/range/timeRanges.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,cAAc,EAAY,MAAM,UAAU,CAAA;AAEpE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,KAAK,EAAE,CAMjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,CAE7E"}

package/dist/types/current/util/range/timeRanges.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { rangesOf } from './Ranges';
+/**
+ * Converts a `TimeRanges` object to an Array for utility purposes.
+ *
+ * @param timeRanges
+ */
+export function timeRangesToArray(timeRanges) {
+    const ranges = [];
+    for (let i = 0; i < timeRanges.length; i++) {
+        ranges.push([timeRanges.start(i), timeRanges.end(i)]);
+    }
+    return ranges;
+}
+/**
+ * Creates a reader for a TimeRanges object for easier querying.
+ *
+ * @param timeRanges
+ */
+export function createTimeRangesReader(timeRanges) {
+    return rangesOf(timeRangesToArray(timeRanges));
+}

package/dist/types/current/util/serialization/ParseError.d.ts

@@ -0,0 +1,48 @@
+export interface ParseError {
+    /**
+     * The full reason and location.
+     */
+    readonly message: string;
+    /**
+     * The reason for the error.
+     */
+    readonly reason: string;
+    /**
+     * A description of the location the error occurred.
+     */
+    readonly location: string;
+}
+export interface PrintStringPositionOptions {
+    /**
+     * The maximum number of character columns to output.
+     * The number of columns shown will be the min of this value and the number of columns
+     * at the index row.
+     * The default is 60.
+     */
+    maxColumns?: number;
+    /**
+     * The caret indicator.
+     * The caret will be printed on a second row, directly underneath the column index
+     * represents. This may more than one character, where the first character will align
+     * with the index column.
+     * The default value is '^'.
+     */
+    caret?: string;
+    /**
+     * A number between 0 and 1 representing the percentage of trailing to leading characters.
+     * 0 Indicates all trailing, 1 indicates all leading, and 0.5 indicates that the index
+     * column is as close to the middle as possible.
+     * The default value is 0.6.
+     */
+    split?: number;
+}
+/**
+ * Given a string and a position index, gets the row the index represents, displaying the
+ * surrounding characters, with a second row showing a caret indicator pointing at the index.
+ *
+ * @param str
+ * @param index The
+ * @param options Display options
+ */
+export declare function printStringPosition(str: string, index: number, options?: PrintStringPositionOptions): string;
+//# sourceMappingURL=ParseError.d.ts.map

package/dist/types/current/util/serialization/ParseError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParseError.d.ts","sourceRoot":"","sources":["../../../../../src/util/serialization/ParseError.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,UAAU;IACvB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACvC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,0BAA0B,GACrC,MAAM,CAwBR"}

package/dist/types/current/util/serialization/ParseError.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { clamp } from '../../util/math/math';
+/**
+ * Given a string and a position index, gets the row the index represents, displaying the
+ * surrounding characters, with a second row showing a caret indicator pointing at the index.
+ *
+ * @param str
+ * @param index The
+ * @param options Display options
+ */
+export function printStringPosition(str, index, options) {
+    const caret = options?.caret || '^';
+    index = clamp(index, 0, str.length);
+    const minIndex = str.lastIndexOf('\n', index - 1) + 1;
+    let maxIndex = str.indexOf('\n', index);
+    if (maxIndex === -1)
+        maxIndex = str.length;
+    const split = options?.split === undefined ? 0.6 : options.split;
+    const cols = (options?.maxColumns ?? 60) - caret.length;
+    let leadingChars = cols * split;
+    let trailingChars = cols * (1 - split);
+    const maxLeadingChars = index - minIndex;
+    const maxTrailingChars = maxIndex - index;
+    if (leadingChars > maxLeadingChars) {
+        trailingChars += leadingChars - maxLeadingChars;
+        leadingChars = maxLeadingChars;
+        if (trailingChars > maxTrailingChars)
+            trailingChars = maxTrailingChars;
+    }
+    else if (trailingChars > maxTrailingChars) {
+        leadingChars += trailingChars - maxTrailingChars;
+        trailingChars = maxTrailingChars;
+        if (leadingChars > maxLeadingChars)
+            leadingChars = maxLeadingChars;
+    }
+    let out = str.substring(index - leadingChars, index + trailingChars) + '\n';
+    out += ' '.repeat(leadingChars) + caret;
+    return out;
+}

package/dist/types/current/util/serialization/json.d.ts

@@ -0,0 +1,30 @@
+import type { AnyRecord, Fun, IsAny } from '../../util/type';
+/**
+ * A representation of the conversion the toJson function will apply to make an input JSON compatible.
+ */
+export type Json<T = any> = IsAny<T> extends true ? AnyRecord : unknown extends T ? never : T extends bigint | symbol | Fun ? string : T extends {
+    toJSON(): infer R;
+} ? R : T extends boolean | number | string | null | undefined ? T : T extends Set<infer U> ? Json<U>[] : T extends readonly any[] ? Json<T[number]>[] : {
+    [P in keyof T]: Json<T[P]>;
+};
+/**
+ * Converts a dynamic value to a serializable value.
+ * The value must be either an object with a toJSON function, a primitive, or a plain object
+ * where all enumerable properties map to values supported by this function.
+ * Properties not enumerable will be omitted, properties not serializable will be converted
+ * to strings.
+ * - bigint -> value.toString
+ * - function -> [function <name>]
+ * - symbol -> [symbol <name>]
+ *
+ * Error instances have a special case where non-serializable errors will still have their
+ * name, message, and stack properties serialized.
+ *
+ * Note that this is not intended for use in serializing objects where all values are known;
+ * it's intended to cover the case of reporting or logging an unknown object that may or may not
+ * be serializable.
+ *
+ * @param value
+ */
+export declare function toJson<T>(value: T): Json<T>;
+//# sourceMappingURL=json.d.ts.map

package/dist/types/current/util/serialization/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../../../src/util/serialization/json.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExD;;GAEG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,GAAG,IACpB,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GAEf,SAAS,GACT,OAAO,SAAS,CAAC,GACf,KAAK,GACL,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,GAAG,GAC7B,MAAM,GACN,CAAC,SAAS;IAAE,MAAM,IAAI,MAAM,CAAC,CAAA;CAAE,GAC7B,CAAC,GACD,CAAC,SAAS,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACpD,CAAC,GACD,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GACpB,IAAI,CAAC,CAAC,CAAC,EAAE,GACT,CAAC,SAAS,SAAS,GAAG,EAAE,GACtB,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GACjB;KACK,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC7B,CAAA;AAEvB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAE3C"}