@amazon/vinyl-util 1.0.0

package/dist/types/ts4.7/util/mpeg/parseSidxBox.d.ts

@@ -0,0 +1,100 @@
+/**
+ * ISO_IEC_14496-12 Segment Index Box
+ * @module
+ */
+/**
+ * Represents the base structure of a Segment Index ('sidx') Box.
+ * The 'sidx' box is used in MPEG-4 media files to provide indexing information for efficient data access and retrieval.
+ */
+export interface SidxBoxBase {
+    /**
+     * The version, 0 and 1 supported.
+     */
+    readonly version: number;
+    /**
+     * The ID of the track.
+     */
+    readonly referenceId: number;
+    /**
+     * The timescale for the media in this 'sidx' box. It is a 32-bit unsigned integer.
+     * This value represents the number of time units that pass in one second.
+     */
+    readonly timescale: number;
+    /**
+     * An array of segment references. Each segment reference provides information about individual media segments.
+     */
+    readonly references: readonly SidxSegmentReference[];
+}
+/**
+ * Properties specific to version 0 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV0 extends SidxBoxBase {
+    readonly version: 0;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: number;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     * For version 0, this is a 32-bit unsigned integer.
+     */
+    readonly firstOffset: number;
+}
+/**
+ * Properties specific to version 1 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV1 extends SidxBoxBase {
+    readonly version: 1;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: bigint;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     */
+    readonly firstOffset: bigint;
+}
+export type SidxBox = SidxBoxV0 | SidxBoxV1;
+/**
+ * A single segment reference within a sidx box.
+ */
+export interface SidxSegmentReference {
+    /**
+     * Indicates the reference type. A value of 0 means the reference is to a media segment. A value of 1 indicates
+     * the reference is to a hint track segment.
+     */
+    readonly referenceType: number;
+    /**
+     * The size of the referenced segment in bytes.
+     */
+    readonly referencedSize: number;
+    /**
+     * The duration of the subsegment. This is expressed in the timescale provided in the 'sidx' box.
+     */
+    readonly subsegmentDuration: number;
+    /**
+     * Indicates if the segment starts with a SAP (Stream Access Point). If `true`, the segment starts with a SAP,
+     * facilitating random access and efficient streaming.
+     */
+    readonly startsWithSap: boolean;
+    /**
+     * The SAP type indicates the type of stream access point that starts the segment. This is a 3-bit field. The
+     * SAP types are defined in ISO/IEC 14496-12, and they describe the characteristics of the stream access points.
+     */
+    readonly sapType: number;
+    /**
+     * The SAP delta time specifies the difference in time (in the timescale of the 'sidx' box) between the earliest
+     * presentation time of the segment and the first SAP within it. This allows players to quickly locate the SAP
+     * for efficient playback startup or seeking.
+     */
+    readonly sapDeltaTime: number;
+}
+export declare function parseSidxBox(buffer: ArrayBuffer): SidxBox;
+/**
+ * Creates a timeline of the segment start times, in timescale units.
+ * The last element will be the last segment's end time.
+ *
+ * @param sidx
+ */
+export declare function getSidxSampleTimes(sidx: SidxBox): number[];
+//# sourceMappingURL=parseSidxBox.d.ts.map

package/dist/types/ts4.7/util/network/request.d.ts

@@ -0,0 +1,18 @@
+import type { Maybe } from '../../util/type';
+/**
+ * Given request parameters, returns the header for the given key, or null.
+ */
+export declare function getHeaderFromRequestParams(input: RequestInfo | URL, init: Maybe<RequestInit>, key: string): string | null;
+export declare function getHeaderFromHeadersInit(headers: Readonly<HeadersInit>, key: string): string | null;
+/**
+ * Given fetch input, clones the input, transforms the URL and returns a new `RequestInfo | URL` input parameter.
+ */
+export declare function changeRequestInputUrl(input: RequestInfo | URL, transform: (url: URL) => void): RequestInfo | URL;
+/**
+ * Given an object of HeadersInit type (a Headers instance, array of key-value pairs, or and object of key-value pairs),
+ * returns a Record of key-value pairs.
+ *
+ * @param headers
+ */
+export declare function normalizeHeadersInit(headers: Maybe<HeadersInit>): Record<string, string>;
+//# sourceMappingURL=request.d.ts.map

package/dist/types/ts4.7/util/object/clone.d.ts

@@ -0,0 +1,68 @@
+import type { MergeRule } from './mergeDeep';
+import type { MutableDeep } from './mutableType';
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface CloneOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true the reference will be
+     * copied. If false (default), a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first clone rule that matches will be used.
+     *
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false (default), in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly CloneRule<any>[];
+}
+/**
+ * A CloneRule defines if and how an object should be cloned.
+ */
+export interface CloneRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Clones the given value.
+     *
+     * @param source A value guaranteed to have matched with `matches`.
+     * @param clone This callback may be used to clone sub-properties.
+     */
+    readonly clone: (source: T, clone: CloneCallback) => MutableDeep<T>;
+}
+/**
+ * A function to clone a sub-object from a clone rule.
+ */
+export type CloneCallback = <T>(
+/**
+ * The source object to clone.
+ */
+source: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => MutableDeep<T>;
+/**
+ * Performs a deep clone on the target object.
+ *
+ * This is an alias for `mergeDeep(target)` that additionally converts clone rules to one-sided
+ * merge rules.
+ *
+ * @param target The target object to clone.
+ * @param options The merge options to use.
+ * `clone`, unlike `mergeDeep`, `allowReferenceCopy` will default to false.
+ * @see mergeDeep
+ */
+export declare function clone<T>(target: T, options?: Partial<CloneOptions>): MutableDeep<T>;
+/**
+ * Creates a wrapper to convert a clone rule to a merge rule.
+ */
+export declare function toMergeRule<T>(cloneRule: CloneRule<T>): MergeRule<T>;
+//# sourceMappingURL=clone.d.ts.map

package/dist/types/ts4.7/util/object/equalDeep.d.ts

@@ -0,0 +1,54 @@
+import type { TypedArray } from '../../util/collection/typedArray';
+/**
+ * Recursively compares the values of all the enumerable own properties from two source objects.
+ *
+ * @param objectA
+ * @param objectB
+ * @param options
+ */
+export declare function equalDeep<T>(objectA: T, objectB: T, options?: EqualOptions): boolean;
+/**
+ * Configuration for the equalDeep comparator.
+ */
+export interface EqualOptions {
+    /**
+     * The first equal rule where the first source object matches will be used.
+     * If the second object does not match, the two objects will not be considered equal.
+     */
+    readonly rules: readonly EqualRule<any>[];
+}
+/**
+ * A equal function to be provided to equal rules.
+ */
+export type EqualCallback<T = any> = (objectA: T, objectB: T) => boolean;
+export interface EqualRule<T> {
+    /**
+     * Returns true if this EqualRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Equals the two sources.
+     * @param objectA May be undefined, the first object to equal.
+     * @param objectB The second object to equal or clone if objectA is undefined.
+     * @param equal This callback may be used to equal or clone sub-properties.
+     */
+    readonly equal: (objectA: T, objectB: T, equal: EqualCallback) => boolean;
+}
+export declare const arrayEqualRule: EqualRule<any[]>;
+export declare const plainObjectEqualRule: EqualRule<Record<any, any>>;
+export declare const regexpEqualRule: EqualRule<RegExp>;
+export declare const dateEqualRule: EqualRule<Date>;
+export declare const mapEqualRule: EqualRule<Map<any, any>>;
+export declare const setEqualRule: EqualRule<Set<any>>;
+/**
+ * A typed array will always have primitive elements, compare that the lengths are equal and every
+ * element is equal.
+ */
+export declare const typedArrayEqualRule: EqualRule<TypedArray>;
+/**
+ * The default equal options provide rules for comparing arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultEqualOptions: EqualOptions;
+//# sourceMappingURL=equalDeep.d.ts.map

package/dist/types/ts4.7/util/object/lazy.d.ts

@@ -0,0 +1,54 @@
+import type { Disposable } from '../../core/disposable';
+export interface ReadonlyLazy<T> {
+    /**
+     * True if the lazy instance has been constructed.
+     */
+    readonly constructed: boolean;
+    /**
+     * When invoked the first time, constructs the value and returns it.
+     * Consecutive calls will return that cached value.
+     * @throws DisposedError If this lazy factory is disposed.
+     */
+    get value(): T;
+}
+export interface Lazy<T> extends ReadonlyLazy<T>, Disposable {
+    /**
+     * Sets the lazy instance's value.
+     * If disposed, a {@link DisposedError} will be thrown.
+     * @param value
+     */
+    set value(value: T);
+    /**
+     * Clears the lazy instance, disposing its value.
+     * Unlike dispose(), this allows the lazy instance to be reconstructed upon the next get.
+     * Typically used only in unit testing. May be used after {@link dispose}.
+     */
+    clear(): void;
+}
+/**
+ * A factory to lazily instantiate a single cached instance.
+ */
+export declare class LazyImpl<T> implements Lazy<T>, Disposable {
+    private readonly factory;
+    private _constructing;
+    private _constructed;
+    private disposed;
+    private _value;
+    /**
+     * @param factory A factory function that will be invoked at most once.
+     */
+    constructor(factory: () => T);
+    get constructed(): boolean;
+    get value(): T;
+    set value(value: T);
+    clear(): void;
+    dispose(): void;
+}
+/**
+ * Creates a new {@link Lazy} instance.
+ *
+ * @param factory A factory function that will be invoked at most once. If the instance produced
+ * is disposable, it will be disposed on clear.
+ */
+export declare function lazy<T>(factory: () => T): Lazy<T>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/types/ts4.7/util/object/merge.d.ts

@@ -0,0 +1,72 @@
+/**
+ * An intersection of T & U where common keys of T and U are overwritten by U.
+ */
+export type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T>(source1: T): T;
+/**
+ * Concatenates arrays.
+ *
+ * @return Returns a new concatenated array.
+ */
+export declare function merge<T>(...sources: T[][]): T[];
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U>(source1: T, source2: U): Merge<T, U>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V>(source1: T, source2: U, source3: V): Merge<Merge<T, U>, V>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @param source4 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V, W>(source1: T, source2: U, source3: V, source4: W): Merge<Merge<Merge<T, U>, V>, W>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param sources
+ * @return Returns the new merged object.
+ */
+export declare function merge(...sources: any[]): any;
+//# sourceMappingURL=merge.d.ts.map

package/dist/types/ts4.7/util/object/mergeDeep.d.ts

@@ -0,0 +1,153 @@
+import type { TypedArray } from '../../util/collection/typedArray';
+import { ReportableError } from '../../error/ReportableError';
+import { type Cloneable } from '../../core/cloneable';
+/**
+ * Concatenates multiple arrays together where each element is deeply cloned.
+ */
+export declare function mergeDeep<T extends Array<any>>(sources: readonly T[], options?: Partial<MergeOptions>): T;
+/**
+ * Deep clones the given object.
+ */
+export declare function mergeDeep<T>(sources: readonly [
+    T
+], options?: Partial<MergeOptions>): T;
+/**
+ * Deep merges the two objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B>(sources: readonly [
+    A,
+    B
+], options?: Partial<MergeOptions>): A & B;
+/**
+ * Deep merges the three objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C>(sources: readonly [
+    A,
+    B,
+    C
+], options?: Partial<MergeOptions>): A & B & C;
+/**
+ * Deep merges the four objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D>(sources: readonly [
+    A,
+    B,
+    C,
+    D
+], options?: Partial<MergeOptions>): A & B & C & D;
+/**
+ * Deep merges the five objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E>(sources: readonly [
+    A,
+    B,
+    C,
+    D,
+    E
+], options?: Partial<MergeOptions>): A & B & C & D & E;
+/**
+ * Deep merges the six objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E, F>(sources: readonly [
+    A,
+    B,
+    C,
+    D,
+    E,
+    F
+], options?: Partial<MergeOptions>): A & B & C & D & E & F;
+/**
+ * Deep merges all objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep(sources: readonly any[], options?: Partial<MergeOptions>): any;
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface MergeOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true (default) the reference will be
+     * copied. If false, a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first merge rule where the second source object matches will be used.
+     * Rules are only checked for values that have a typeof value of 'object'
+     * If the first object does not pass the match, undefined will be passed to sourceA and the
+     * rule is expected to return a clone of sourceB.
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false, in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly MergeRule<any>[];
+}
+/**
+ * A merge function to be provided to merge rules.
+ */
+export type MergeCallback<T = any> = (
+/**
+ * The first like object to merge, or undefined. If undefined is provided, a
+ * clone of sourceB is expected to be returned. If defined, this object is guaranteed to have
+ * passed {@link MergeRule.matches}
+ */
+sourceA: T | undefined, 
+/**
+ * The second object to merge or clone.
+ */
+sourceB: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => T;
+export interface MergeRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Merges the two sources.
+     * @param sourceA May be undefined, the first object to merge.
+     * @param sourceB The second object to merge or clone if sourceA is undefined.
+     * @param merge This callback may be used to merge or clone sub-properties.
+     */
+    readonly merge: (sourceA: T | undefined, sourceB: T, merge: MergeCallback) => T;
+}
+export declare class MergeReferenceError extends ReportableError {
+    constructor(propPath: string, source: any);
+}
+/**
+ * Cloneable objects are not expected to be mergeable, but should be cloned.
+ */
+export declare const cloneableMergeRule: MergeRule<Cloneable<any>>;
+export declare const arrayMergeRule: MergeRule<any[]>;
+export declare const plainObjectMergeRule: MergeRule<Record<any, any>>;
+export declare const regexpMergeRule: MergeRule<RegExp>;
+export declare const dateMergeRule: MergeRule<Date>;
+export declare const mapMergeRule: MergeRule<Map<any, any>>;
+export declare const setMergeRule: MergeRule<Set<any>>;
+/**
+ * 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 declare const typedArrayMergeRule: MergeRule<TypedArray>;
+export declare const urlMergeRule: MergeRule<URL>;
+/**
+ * The default merge options provide rules for merging arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultMergeOptions: MergeOptions;
+//# sourceMappingURL=mergeDeep.d.ts.map

package/dist/types/ts4.7/util/object/mutableType.d.ts

@@ -0,0 +1,87 @@
+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/ts4.7/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