@amazon/vinyl-util 1.0.0

package/dist/types/current/util/object/mergeDeep.js

@@ -0,0 +1,256 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IllegalArgumentError } from '../../error/IllegalArgumentError';
+import { cloneTypedArray, isTypedArray } from '../../util/collection/typedArray';
+import { union } from '../../util/set/set';
+import { substitute } from '../../util/string/string';
+import { ownKeys, isPlainObject } from './object';
+import { ReportableError } from '../../error/ReportableError';
+import { isCloneable } from '../../core/cloneable';
+const locale = {
+    cyclicRefError: 'Cyclic reference found at: {path}',
+    mergeReferenceError: `No merge rule found at {path} for "{source}" and reference copy not allowed`,
+};
+/**
+ * Recursively copies the values of all the enumerable own properties from one or two source
+ * objects to a new object.
+ * Arrays will be concatenated.
+ *
+ * @param sources One or more source objects from which to copy properties. A single source
+ * provided will return a deep clone. Incompatible objects, for example given a number and an
+ * array, will return a clone of the last argument.
+ * @param options
+ * @see merge
+ */
+export function mergeDeep(sources, options) {
+    if (!sources.length)
+        return undefined;
+    const finalOpts = {
+        ...defaultMergeOptions,
+        ...options,
+    };
+    const stack = new PropStack();
+    const n = sources.length;
+    if (n === 1)
+        // Clone the single element.
+        return _mergeDeep(undefined, sources[0], stack, 0, finalOpts);
+    // Initial accumulator:
+    let out = _mergeDeep(sources[0], sources[1], stack, 1, finalOpts);
+    for (let i = 2; i < n; i++) {
+        out = _mergeDeep(out, sources[i], stack, i, finalOpts);
+    }
+    return out;
+}
+/**
+ * A stack of the current property recursion.
+ * PropStack has two purposes, it provides the current property path in the node traversal and
+ * ensures that nodes do not cyclically reference themselves.
+ */
+class PropStack {
+    /**
+     * Object references for sourceA.
+     */
+    refsA = new Set();
+    /**
+     * Object references for sourceB.
+     */
+    refsB = new Set();
+    propStack = [];
+    /**
+     * The property stack, joined by .
+     */
+    get currentPath() {
+        return this.propStack
+            .map((e) => e[2])
+            .filter((e) => e != null)
+            .join('.');
+    }
+    push(sourceA, sourceB, prop) {
+        this.propStack.push([sourceA, sourceB, prop]);
+        this.addRef(this.refsA, sourceA);
+        this.addRef(this.refsB, sourceB);
+    }
+    pop() {
+        const last = this.propStack.pop();
+        this.refsA.delete(last[0]);
+        this.refsB.delete(last[1]);
+    }
+    addRef(refSet, source) {
+        if (typeof source !== 'object')
+            return;
+        if (refSet.has(source)) {
+            throw new IllegalArgumentError(substitute(locale.cyclicRefError, { path: this.currentPath }));
+        }
+        refSet.add(source);
+    }
+}
+function _mergeDeep(sourceA, sourceB, propStack, prop, options) {
+    if (typeof sourceB !== 'object' || sourceB === null)
+        return sourceB;
+    const merge = (sourceA, sourceB, prop) => {
+        return _mergeDeep(sourceA, sourceB, propStack, prop, options);
+    };
+    for (const rule of options.rules) {
+        if (rule.matches(sourceB)) {
+            propStack.push(sourceA, sourceB, prop);
+            const result = rule.merge(rule.matches(sourceA) ? sourceA : undefined, sourceB, merge);
+            propStack.pop();
+            return result;
+        }
+    }
+    if (!options.allowReferenceCopy) {
+        // push before throwing to get the full currentPath:
+        propStack.push(sourceA, sourceB, prop);
+        throw new MergeReferenceError(propStack.currentPath, sourceB);
+    }
+    return sourceB;
+}
+export class MergeReferenceError extends ReportableError {
+    constructor(propPath, source) {
+        super(substitute(locale.mergeReferenceError, {
+            path: propPath,
+            source,
+        }));
+        Object.setPrototypeOf(this, MergeReferenceError.prototype);
+    }
+}
+/**
+ * Cloneable objects are not expected to be mergeable, but should be cloned.
+ */
+export const cloneableMergeRule = {
+    matches(object) {
+        return isCloneable(object);
+    },
+    merge(_1, sourceB, _2) {
+        return sourceB.clone();
+    },
+};
+export const arrayMergeRule = {
+    matches(object) {
+        return Array.isArray(object);
+    },
+    merge(sourceA, sourceB, merge) {
+        const out = [];
+        if (sourceA) {
+            for (const element of sourceA) {
+                out.push(merge(undefined, element, out.length));
+            }
+        }
+        for (const element of sourceB) {
+            out.push(merge(undefined, element, out.length));
+        }
+        return out;
+    },
+};
+export const plainObjectMergeRule = {
+    matches(object) {
+        return isPlainObject(object);
+    },
+    merge(sourceA, sourceB, merge) {
+        const out = {};
+        // Iterate over the unique set of the union of keys between the two objects.
+        for (const key of union(ownKeys(sourceA), ownKeys(sourceB))) {
+            if (sourceA && key in sourceB && key in sourceA) {
+                out[key] = merge(sourceA[key], sourceB[key], key);
+            }
+            else if (sourceA && key in sourceA) {
+                out[key] = merge(undefined, sourceA[key], key);
+            }
+            else {
+                out[key] = merge(undefined, sourceB[key], key);
+            }
+        }
+        return out;
+    },
+};
+export const regexpMergeRule = {
+    matches(object) {
+        return object instanceof RegExp;
+    },
+    merge(_1, sourceB, _2) {
+        // Clone the regex; they are stateful.
+        return new RegExp(sourceB.source, sourceB.flags);
+    },
+};
+export const dateMergeRule = {
+    matches(object) {
+        return object instanceof Date;
+    },
+    merge(_1, sourceB, _2) {
+        return new Date(sourceB.getTime());
+    },
+};
+export const mapMergeRule = {
+    matches(object) {
+        return object instanceof Map;
+    },
+    merge(sourceA, sourceB, merge) {
+        const out = new Map();
+        // Iterate over the unique set of the union of keys between the two objects.
+        for (const key of new Set([
+            ...(sourceA?.keys() ?? []),
+            ...sourceB.keys(),
+        ])) {
+            if (sourceB.has(key) && sourceA?.has(key)) {
+                out.set(key, merge(sourceA.get(key), sourceB.get(key), key));
+            }
+            else if (sourceA?.has(key)) {
+                out.set(key, merge(undefined, sourceA.get(key), key));
+            }
+            else {
+                out.set(key, merge(undefined, sourceB.get(key), key));
+            }
+        }
+        return out;
+    },
+};
+export const setMergeRule = {
+    matches(object) {
+        return object instanceof Set;
+    },
+    merge(sourceA, sourceB, merge) {
+        return new Set([...(sourceA?.values() ?? []), ...sourceB.values()].map((element, index) => {
+            return merge(undefined, element, index);
+        }));
+    },
+};
+/**
+ * Typed arrays will not concatenate by default like arrays. Typed arrays generally represent data,
+ * not configuration, and the more reasonable default is to clone, not concatenate.
+ */
+export const typedArrayMergeRule = {
+    matches(object) {
+        return isTypedArray(object);
+    },
+    merge(_1, sourceB, _2) {
+        return cloneTypedArray(sourceB);
+    },
+};
+export const urlMergeRule = {
+    matches(object) {
+        return object instanceof URL;
+    },
+    merge(_1, sourceB, _2) {
+        return new URL(sourceB.toString());
+    },
+};
+/**
+ * The default merge options provide rules for merging arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export const defaultMergeOptions = {
+    allowReferenceCopy: true,
+    rules: [
+        cloneableMergeRule,
+        arrayMergeRule,
+        plainObjectMergeRule,
+        regexpMergeRule,
+        dateMergeRule,
+        mapMergeRule,
+        setMergeRule,
+        typedArrayMergeRule,
+        urlMergeRule,
+    ],
+};

package/dist/types/current/util/object/mutableType.d.ts

@@ -0,0 +1,64 @@
+import type { Fun } from '../../util/type';
+import type { ReadonlyDate, ReadonlyMap, ReadonlySet } from './readonlyType';
+/**
+ * Recursively removes read only modifiers.
+ * Special core types such as read only Dates, Maps, and Sets will be converted to their writable
+ * variants.
+ */
+export type MutableDeep<T> = T extends readonly any[] ? MutableTupleOrArrayDeep<T> : T extends Fun | Blob ? T : T extends ReadonlyDate ? Date : T extends ReadonlyMap<infer K, infer V> ? MutableMapDeep<K, V> : T extends ReadonlySet<infer V> ? MutableSetDeep<V> : T extends object ? MutableObjectDeep<T> : T;
+/**
+ * Recursively marks a tuple (up to 4 in length) or an array as read only.
+ */
+export type MutableTupleOrArrayDeep<T extends readonly any[]> = T extends readonly [infer V0] ? [
+    MutableDeep<V0>
+] : T extends readonly [infer V0, infer V1] ? [MutableDeep<V0>, MutableDeep<V1>] : T extends readonly [infer V0, infer V1, infer V2] ? [MutableDeep<V0>, MutableDeep<V1>, MutableDeep<V2>] : T extends readonly [infer V0, infer V1, infer V2, infer V3] ? [
+    MutableDeep<V0>,
+    MutableDeep<V1>,
+    MutableDeep<V2>,
+    MutableDeep<V3>
+] : T extends readonly [
+    infer V0,
+    infer V1,
+    infer V2,
+    infer V3,
+    infer V4
+] ? [
+    MutableDeep<V0>,
+    MutableDeep<V1>,
+    MutableDeep<V2>,
+    MutableDeep<V3>,
+    MutableDeep<V4>
+] : MutableArrayDeep<T[number]>;
+/**
+ * A recursively deep mutable array. Do not use this directly, use {@link MutableDeep} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableArrayDeep<T> = MutableDeep<T>[];
+/**
+ * A recursively deep mutable object. Do not use this directly, use {@link MutableDeep} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableObjectDeep<T> = {
+    -readonly [P in keyof T]: MutableDeep<T[P]>;
+};
+/**
+ * A map with mutable values.
+ */
+export type MutableMapDeep<K, V> = Map<K, MutableDeep<V>>;
+/**
+ * A Set type with mutable values.
+ */
+export type MutableSetDeep<V> = Set<MutableDeep<V>>;
+/**
+ * Removes read only modifiers from Objects, Arrays, Maps, Sets, or Dates.
+ * Other non-primitive types will retain their method signatures.
+ */
+export type Mutable<T> = T extends readonly any[] ? [...T] : T extends Fun | Blob ? T : T extends ReadonlyDate ? Date : T extends ReadonlyMap<infer K, infer V> ? Map<K, V> : T extends ReadonlySet<infer V> ? Set<V> : T extends object ? MutableObject<T> : T;
+/**
+ * A mutable object. Do not use this directly, use {@link Mutable} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableObject<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+//# sourceMappingURL=mutableType.d.ts.map

package/dist/types/current/util/object/mutableType.d.ts.map

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

package/dist/types/current/util/object/mutableType.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/util/object/object.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Returns the keys (both property names and symbols) of all own properties.
+ * Unlike `Object.keys`, this will also return non-enumerable properties.
+ * Does not return keys inherited from the object's prototype.
+ *
+ * Implementation details:
+ * If Reflect is supported, Reflect.ownKeys will be used, wrapping in a Set, otherwise
+ * Object.getOwnPropertyNames and Object.getOwnPropertySymbols will be used. This will typically
+ * be equivalent. Proxies may alter the order of keys but platforms that do not support Reflect
+ * will also typically not support Proxies.
+ *
+ * @see Reflect.ownKeys
+ * @see Object.getOwnPropertyNames
+ * @see Object.getOwnPropertySymbols
+ * @param obj
+ * @return Returns a `Set` of the own properties of the target object, including non-enumerable.
+ * The ordering will be: positive numeric indexes in order, strings in insertion order,
+ * symbols in insertion order.
+ */
+export declare function ownKeys<T>(obj: T): Set<keyof T>;
+/**
+ * Returns the prototype chain of the given object.
+ *
+ * Example:
+ * ```
+ * class A {}
+ * class B extends A {}
+ * class C extends B {}
+ * const c = new C()
+ * getPrototypeChain(c) // [c, C.prototype, B.prototype, A.prototype, Object.prototype]
+ * ```
+ * @param obj
+ */
+export declare function getPrototypeChain(obj: any): any[];
+/**
+ * Returns true if the given object represents a plain object and not a class instance.
+ */
+export declare function isPlainObject(value: any): boolean;
+/**
+ * Gets the object's value for the given key if it exists, otherwise sets [key] to
+ * `defaultValue`, returning the newly set value.
+ *
+ * @param object
+ * @param key
+ * @param defaultValue
+ */
+export declare function getOrSetProp<K extends keyof T, T extends object>(object: T, key: K, defaultValue: () => T[K]): T[K];
+/**
+ * Returns true if value is not null. Provides a type guard which can be used in filters.
+ * Example:
+ * [1, null, 2, 3, null, 4].filter(isNonNull) // type number[]
+ * @param value
+ */
+export declare function isNonNull<T>(value: T): value is NonNullable<T>;
+//# sourceMappingURL=object.d.ts.map

package/dist/types/current/util/object/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/object.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAQ/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,CAOjD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAMjD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,SAAS,MAAM,EAC5D,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,EACN,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GACzB,CAAC,CAAC,CAAC,CAAC,CAQN;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAE9D"}

package/dist/types/current/util/object/object.js

@@ -0,0 +1,91 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns the keys (both property names and symbols) of all own properties.
+ * Unlike `Object.keys`, this will also return non-enumerable properties.
+ * Does not return keys inherited from the object's prototype.
+ *
+ * Implementation details:
+ * If Reflect is supported, Reflect.ownKeys will be used, wrapping in a Set, otherwise
+ * Object.getOwnPropertyNames and Object.getOwnPropertySymbols will be used. This will typically
+ * be equivalent. Proxies may alter the order of keys but platforms that do not support Reflect
+ * will also typically not support Proxies.
+ *
+ * @see Reflect.ownKeys
+ * @see Object.getOwnPropertyNames
+ * @see Object.getOwnPropertySymbols
+ * @param obj
+ * @return Returns a `Set` of the own properties of the target object, including non-enumerable.
+ * The ordering will be: positive numeric indexes in order, strings in insertion order,
+ * symbols in insertion order.
+ */
+export function ownKeys(obj) {
+    if (!obj)
+        return new Set();
+    if (typeof Reflect !== 'undefined')
+        return new Set(Reflect.ownKeys(obj));
+    const properties = new Set();
+    Object.getOwnPropertyNames(obj).forEach((item) => properties.add(item));
+    Object.getOwnPropertySymbols(obj).forEach((item) => properties.add(item));
+    return properties;
+}
+/**
+ * Returns the prototype chain of the given object.
+ *
+ * Example:
+ * ```
+ * class A {}
+ * class B extends A {}
+ * class C extends B {}
+ * const c = new C()
+ * getPrototypeChain(c) // [c, C.prototype, B.prototype, A.prototype, Object.prototype]
+ * ```
+ * @param obj
+ */
+export function getPrototypeChain(obj) {
+    const out = [];
+    let current = obj;
+    do {
+        out.push(current);
+    } while ((current = Object.getPrototypeOf(current)));
+    return out;
+}
+/**
+ * Returns true if the given object represents a plain object and not a class instance.
+ */
+export function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    // if not the null prototype, not a plain object:
+    return !proto || !Object.getPrototypeOf(proto);
+}
+/**
+ * Gets the object's value for the given key if it exists, otherwise sets [key] to
+ * `defaultValue`, returning the newly set value.
+ *
+ * @param object
+ * @param key
+ * @param defaultValue
+ */
+export function getOrSetProp(object, key, defaultValue) {
+    if (key in object) {
+        return object[key];
+    }
+    else {
+        const value = defaultValue();
+        object[key] = value;
+        return value;
+    }
+}
+/**
+ * Returns true if value is not null. Provides a type guard which can be used in filters.
+ * Example:
+ * [1, null, 2, 3, null, 4].filter(isNonNull) // type number[]
+ * @param value
+ */
+export function isNonNull(value) {
+    return value != null;
+}

package/dist/types/current/util/object/readonlyType.d.ts

@@ -0,0 +1,71 @@
+import type { Fun } from '../../util/type';
+/**
+ * Recursively marks Objects, Arrays, Maps, Sets, or Dates as read only.
+ * Other non-primitive types will retain their method signatures, potentially exposing mutation
+ * methods.
+ * This type does not represent an immutable value, merely a readonly variant of T.
+ */
+export type ReadonlyDeep<T> = T extends Array<any> ? ReadonlyTupleOrArrayDeep<T> : T extends Fun ? T : T extends Date ? ReadonlyDate : T extends Map<infer K, infer V> ? ReadonlyMapDeep<K, V> : T extends Set<infer V> ? ReadonlySetDeep<ReadonlyDeep<V>> : T extends object ? ReadonlyObjectDeep<T> : T;
+/**
+ * Recursively marks a tuple (up to 5 in length) or an array as read only.
+ */
+export type ReadonlyTupleOrArrayDeep<T extends any[]> = T extends [infer V0] ? readonly [ReadonlyDeep<V0>] : T extends [infer V0, infer V1] ? readonly [ReadonlyDeep<V0>, ReadonlyDeep<V1>] : T extends [infer V0, infer V1, infer V2] ? readonly [ReadonlyDeep<V0>, ReadonlyDeep<V1>, ReadonlyDeep<V2>] : T extends [infer V0, infer V1, infer V2, infer V3] ? readonly [
+    ReadonlyDeep<V0>,
+    ReadonlyDeep<V1>,
+    ReadonlyDeep<V2>,
+    ReadonlyDeep<V3>
+] : T extends [infer V0, infer V1, infer V2, infer V3, infer V4] ? readonly [
+    ReadonlyDeep<V0>,
+    ReadonlyDeep<V1>,
+    ReadonlyDeep<V2>,
+    ReadonlyDeep<V3>,
+    ReadonlyDeep<V4>
+] : ReadonlyArrayDeep<T[number]>;
+/**
+ * A recursively deep read only array. Do not use this directly, use {@link ReadonlyDeep} instead,
+ * which works for Objects and Arrays.
+ */
+export type ReadonlyArrayDeep<E> = readonly ReadonlyDeep<E>[];
+/**
+ * A recursively deep read only object. Do not use this directly, use {@link ReadonlyDeep} instead,
+ * which works for Objects and Arrays.
+ */
+export type ReadonlyObjectDeep<T> = {
+    readonly [P in keyof T]: ReadonlyDeep<T[P]>;
+};
+/**
+ * A shallow, readonly Record.
+ * Note, this differs from Record only by readonly modifiers, as such there is no compile time
+ * safety preventing a ReadonlyRecord from being assigned to a Record type.
+ */
+export type ReadonlyRecord<K extends keyof any, T> = {
+    readonly [P in K]: T;
+};
+/**
+ * A Date type with mutation functions omitted.
+ */
+export type ReadonlyDate = Readonly<Omit<Date, 'setDate' | 'setFullYear' | 'setHours' | 'setMilliseconds' | 'setMinutes' | 'setMonth' | 'setSeconds' | 'setTime' | 'setUTCDate' | 'setUTCFullYear' | 'setUTCHours' | 'setUTCMilliseconds' | 'setUTCMinutes' | 'setUTCMonth' | 'setUTCSeconds'>>;
+/**
+ * A Map type with mutation functions omitted.
+ */
+export type ReadonlyMap<K, out V> = Readonly<Omit<Map<K, V>, 'clear' | 'delete' | 'set'>>;
+/**
+ * A deep, readonly map.
+ */
+export type ReadonlyMapDeep<K, out V> = ReadonlyMap<K, ReadonlyDeep<V>>;
+/**
+ * A Set type with mutation functions omitted.
+ */
+export type ReadonlySet<out E> = Readonly<Omit<Set<E>, 'add' | 'clear' | 'delete'>>;
+/**
+ * A deep, readonly set.
+ */
+export type ReadonlySetDeep<out E> = ReadonlySet<ReadonlyDeep<E>>;
+/**
+ * A type alias to ReadonlyDeep that has the additional connotation that the value is constant.
+ *
+ * An immutable object may or may not be frozen, but write access should always consider to be
+ * forbidden.
+ */
+export type Immutable<T> = ReadonlyDeep<T>;
+//# sourceMappingURL=readonlyType.d.ts.map

package/dist/types/current/util/object/readonlyType.d.ts.map

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

package/dist/types/current/util/object/readonlyType.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

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

@@ -0,0 +1,37 @@
+import { type Range, type ReadonlyRanges, ReadonlyRangesImpl } from './Ranges';
+import type { Maybe } from '../../util/type';
+export interface IntersectionRangesOptions {
+    /**
+     * 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 intersection ranges on read.
+ */
+export declare class IntersectionRanges extends ReadonlyRangesImpl {
+    private readonly options?;
+    private backingRanges;
+    private valid;
+    private _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the intersection.
+     */
+    innerRanges: readonly ReadonlyRanges[], options?: Maybe<IntersectionRangesOptions>);
+    get innerRanges(): readonly ReadonlyRanges[];
+    set innerRanges(value: readonly ReadonlyRanges[]);
+    get ranges(): ArrayLike<Range>;
+    /**
+     * Flags the intersection ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate(): void;
+    /**
+     * Refreshes the backing ranges by computing intersection.
+     */
+    private validate;
+}
+//# sourceMappingURL=IntersectionRanges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IntersectionRanges.d.ts","sourceRoot":"","sources":["../../../../../src/util/range/IntersectionRanges.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,WAAW,yBAAyB;IACtC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,kBAAkB;IAWlD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAV7B,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAA2B;;IAG3C;;OAEG;IACH,WAAW,EAAE,SAAS,cAAc,EAAE,EAErB,OAAO,CAAC,EAAE,KAAK,CAAC,yBAAyB,CAAC;IAM/D,IAAI,WAAW,IAAI,SAAS,cAAc,EAAE,CAE3C;IAED,IAAI,WAAW,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,EAG/C;IAED,IAAI,MAAM,IAAI,SAAS,CAAC,KAAK,CAAC,CAG7B;IAED;;;OAGG;IACH,UAAU;IAIV;;OAEG;IACH,OAAO,CAAC,QAAQ;CAsCnB"}