@amazon/vinyl-util 1.0.0

package/dist/types/current/client/userAgent/tokenizeUserAgent.js

@@ -0,0 +1,167 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { last } from '../../util/collection/array';
+import { memoize } from '../../util/fun/memoize';
+import { substringBefore, tokenizeWords } from '../../util/string/string';
+import { parseVersion } from '../../client/Version';
+const MAX_USER_AGENT_LENGTH = 500;
+/**
+ * Separates system and platform parts.
+ * group 1 - System group (The entire parenthetical)
+ * group 2 - Platform name part
+ * group 3 - Platform version part
+ */
+const userAgentRegex = /[([]([^\])]*)[\])]|([^\s/([]+)(?:\/(\S+))?/g;
+/**
+ * In system parts, (semicolon separated sections within a parenthetical), captures the parts when
+ * there is a version part separated by a slash.
+ *
+ * group 1 - The part before the Name/Version
+ * group 2 - The Name in Name/Version
+ * group 3 - The Version in Name/Version
+ */
+const nameVersionRegex = /(.*?)([^\s/([]+)\/(\S+)\s*$/i;
+/**
+ * Matches a version-like string in a system part.
+ * Slightly more strict than the {@link parseVersion} Regex.
+ */
+const versionRegex = /\s\w*\d(?:[._]\d+)*[\w-._]*/g;
+/**
+ * Builds a tokenized user agent for faster queries.
+ *
+ * @param userAgent
+ */
+export function tokenizeUserAgent(userAgent) {
+    userAgent = userAgent.substring(0, MAX_USER_AGENT_LENGTH);
+    const systemParts = [];
+    const platformParts = [];
+    let match;
+    while ((match = userAgentRegex.exec(userAgent))) {
+        if (match[1]) {
+            // System part
+            const split = match[1].split(';');
+            split.forEach((section) => {
+                const versionMatch = nameVersionRegex.exec(section);
+                if (versionMatch) {
+                    // name is the part before the Name/Version pair
+                    const name = versionMatch[1].trim();
+                    const versionStr = versionMatch[3];
+                    systemParts.push({
+                        name,
+                        version: parseVersion(versionStr),
+                        tokens: tokenizeWords(section),
+                    });
+                }
+                else {
+                    // No Name/Version pair
+                    // Finds the last version-like string in the section, if any exists.
+                    const versionMatches = section.match(versionRegex);
+                    systemParts.push({
+                        name: section.trim(),
+                        // Finds the first version-like string in the section, if any exists.
+                        version: parseVersion(last(versionMatches)),
+                        tokens: tokenizeWords(section),
+                    });
+                }
+            });
+        }
+        else {
+            // Platform part
+            const name = match[2];
+            platformParts.push({
+                name,
+                version: parseVersionPart(match[3] ?? ''),
+                tokens: tokenizeWords(name),
+            });
+        }
+    }
+    return {
+        userAgent,
+        system: new TokenizedInfo(systemParts),
+        platform: new TokenizedInfo(platformParts),
+    };
+}
+function parseVersionPart(str) {
+    // If there are multiple versions, e.g. `Firefox/85.0/10csO9CgK-99` use the first.
+    return parseVersion(substringBefore(str, '/'));
+}
+export class TokenizedInfo {
+    parts;
+    /**
+     * A token map of lowercase token strings to name/version pairs.
+     */
+    tokenMap;
+    constructor(parts) {
+        this.parts = parts;
+        const map = new Map();
+        parts.forEach((part) => {
+            part.tokens.forEach((token) => {
+                if (!map.has(token) ||
+                    map.get(token).tokens.length > part.tokens.length)
+                    // When there is a token key collision, the parts with fewer tokens take
+                    // precedence in the map. This allows the parts with more tokens to be
+                    // disambiguated using the tokens not shared.
+                    map.set(token, part);
+            });
+        });
+        this.tokenMap = map;
+    }
+    /**
+     * Given lowercase tokens of only alpha characters, returns the mapped token part if all tokens
+     * are contained in the section.
+     */
+    get(...tokens) {
+        for (const token of tokens) {
+            const part = this.tokenMap.get(token);
+            if (!part)
+                return null;
+            if (tokens.every((iToken) => part.tokens.includes(iToken))) {
+                return { name: part.name, version: part.version };
+            }
+        }
+        return null;
+    }
+    /**
+     * Given an expression of logical operators, returns the name and version of the part
+     * that matches the expression.
+     *
+     * Logical operators currently supported: | for OR and & for AND.
+     * Operands between operators will be tokenized via {@link tokenizeWords}.
+     *
+     * @param expr The expression of tokens and operators. Example: 'windows phone|windows&mobile'
+     * will match when one part has both 'windows' and 'phone' or there are two parts, one with
+     * 'windows' and another part with 'mobile'
+     * (Case insensitive)
+     */
+    query(expr) {
+        return tokenQuery(expr, (tokens) => this.get(...tokens));
+    }
+}
+/**
+ * Executes a logical expression mapping tokens with a predicate, using the result as operands.
+ *
+ * Logical operators currently supported: | for OR and & for AND.
+ * Operands between operators will be tokenized via {@link tokenizeWords}.
+ *
+ * @param expr The expression of tokens and operators.
+ * @param predicate Each token set operand will be mapped using this function.
+ */
+export function tokenQuery(expr, predicate) {
+    const parsedExpr = parsedExpression(expr);
+    for (const orGroup of parsedExpr) {
+        let found = null;
+        for (const words of orGroup) {
+            found = predicate(words);
+            if (found == null)
+                break;
+        }
+        if (found)
+            return found;
+    }
+    return null;
+}
+const parsedExpression = memoize((expr) => {
+    return expr.split('|').map((g) => g.split('&').map(tokenizeWords));
+}, (expr) => expr);

package/dist/types/current/client/userAgent/userAgentRuleHelpers.d.ts

@@ -0,0 +1,52 @@
+import type { Maybe } from '../../util/type';
+import type { DeviceInfoRule, SystemInfoLikeRule, SystemInfoRule, TokenizedUserAgent } from './tokenizeUserAgent';
+/**
+ * A rule to match platform information (parts outside parentheticals).
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ */
+export declare function uaPlatformRule(name: string, expr: string): SystemInfoRule;
+/**
+ * A rule to match system information. (Matches parts within parentheticals.)
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ * @param hasVersion If true, the version will be inferred from the matched part.
+ */
+export declare function uaSystemRule(name: string, expr: string, hasVersion: boolean): SystemInfoRule;
+/**
+ * A rule to match platform or system information.
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr A token expression.
+ */
+export declare function uaPlatformOrSystemRule(name: string, expr: string): SystemInfoRule;
+/**
+ * Changes the name of the Name/Version part returned from the given rule.
+ *
+ * @param name
+ * @param rule
+ */
+export declare function uaName(name: string, rule: SystemInfoRule): SystemInfoRule;
+export declare function uaSystemLike(name: string, derived: readonly string[]): SystemInfoLikeRule;
+/**
+ * A rule to match system or platform information, providing vendor and type information.
+ *
+ * @param vendor The device make/vendor to use when there's a match.
+ * @param type The type of device, e.g. 'mobile' or 'tablet'.
+ * @param expr The token expression to use to determine a match. If there is a match, the
+ * matched name will be used as the model unless model is explicit.
+ * @param model If defined, will be used as the model string instead of the matched expression
+ * name.
+ */
+export declare function uaDeviceRule(vendor: string | null, type: string | null, expr: string, model?: Maybe<string>): DeviceInfoRule;
+/**
+ * A rule that executes a regex, transforming the match result.
+ *
+ * @param expr
+ * @param onMatch When the expression matches, onMatch will be given the RegExpExecArray and return
+ * the final info object.
+ */
+export declare function regexRule<T>(expr: RegExp, onMatch: (match: RegExpMatchArray) => T): (t: TokenizedUserAgent) => T | null;
+//# sourceMappingURL=userAgentRuleHelpers.d.ts.map

package/dist/types/current/client/userAgent/userAgentRuleHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userAgentRuleHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/client/userAgent/userAgentRuleHelpers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,EACR,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EACrB,MAAM,qBAAqB,CAAA;AAI5B;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,OAAO,GACpB,cAAc,CAOhB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACb,cAAc,CAOhB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAKzE;AAED,wBAAgB,YAAY,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,MAAM,EAAE,GAC3B,kBAAkB,CASpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,GACtB,cAAc,CAchB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,CAAC,GACxC,CAAC,CAAC,EAAE,kBAAkB,KAAK,CAAC,GAAG,IAAI,CAMrC"}

package/dist/types/current/client/userAgent/userAgentRuleHelpers.js

@@ -0,0 +1,96 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { tokenQuery } from './tokenizeUserAgent';
+/**
+ * A rule to match platform information (parts outside parentheticals).
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ */
+export function uaPlatformRule(name, expr) {
+    return uaName(name, (t) => t.platform.query(expr));
+}
+/**
+ * A rule to match system information. (Matches parts within parentheticals.)
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ * @param hasVersion If true, the version will be inferred from the matched part.
+ */
+export function uaSystemRule(name, expr, hasVersion) {
+    return (t) => {
+        const found = t.system.query(expr);
+        if (!found)
+            return null;
+        const version = hasVersion ? found.version : null;
+        return { name, version };
+    };
+}
+/**
+ * A rule to match platform or system information.
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr A token expression.
+ */
+export function uaPlatformOrSystemRule(name, expr) {
+    return uaName(name, (t) => tokenQuery(expr, (tokens) => t.platform.get(...tokens) || t.system.get(...tokens)));
+}
+/**
+ * Changes the name of the Name/Version part returned from the given rule.
+ *
+ * @param name
+ * @param rule
+ */
+export function uaName(name, rule) {
+    return (t) => {
+        const found = rule(t);
+        return found && { name, version: found.version };
+    };
+}
+export function uaSystemLike(name, derived) {
+    return (_, systemInfo) => {
+        return derived.some((name) => name === systemInfo?.name)
+            ? {
+                name,
+                version: null,
+            }
+            : null;
+    };
+}
+/**
+ * A rule to match system or platform information, providing vendor and type information.
+ *
+ * @param vendor The device make/vendor to use when there's a match.
+ * @param type The type of device, e.g. 'mobile' or 'tablet'.
+ * @param expr The token expression to use to determine a match. If there is a match, the
+ * matched name will be used as the model unless model is explicit.
+ * @param model If defined, will be used as the model string instead of the matched expression
+ * name.
+ */
+export function uaDeviceRule(vendor, type, expr, model) {
+    return (t) => {
+        const found = tokenQuery(expr, (tokens) => t.system.get(...tokens) || t.platform.get(...tokens));
+        return (found && {
+            vendor: vendor,
+            model: model === undefined ? found.name : model,
+            type,
+        });
+    };
+}
+/**
+ * A rule that executes a regex, transforming the match result.
+ *
+ * @param expr
+ * @param onMatch When the expression matches, onMatch will be given the RegExpExecArray and return
+ * the final info object.
+ */
+export function regexRule(expr, onMatch) {
+    return (t) => {
+        const match = expr.exec(t.userAgent);
+        if (!match)
+            return null;
+        return onMatch(match);
+    };
+}

package/dist/types/current/core/Unsubscribe.d.ts

@@ -0,0 +1,2 @@
+export type Unsubscribe = () => void;
+//# sourceMappingURL=Unsubscribe.d.ts.map

package/dist/types/current/core/Unsubscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Unsubscribe.d.ts","sourceRoot":"","sources":["../../../../src/core/Unsubscribe.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAA"}

package/dist/types/current/core/Unsubscribe.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/core/clearable.d.ts

@@ -0,0 +1,19 @@
+export interface Clearable {
+    /**
+     * Clears this object.
+     */
+    clear(): void;
+}
+/**
+ * Returns true if the value implements Clearable.
+ *
+ * @param value
+ */
+export declare function isClearable(value: any): value is Clearable;
+/**
+ * If the given object implements Clearable, executes clear.
+ *
+ * @param value
+ */
+export declare function maybeClear(value: any): void;
+//# sourceMappingURL=clearable.d.ts.map

package/dist/types/current/core/clearable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearable.d.ts","sourceRoot":"","sources":["../../../../src/core/clearable.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,SAAS;IACtB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAA;CAChB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,SAAS,CAO1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAE3C"}

package/dist/types/current/core/clearable.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true if the value implements Clearable.
+ *
+ * @param value
+ */
+export function isClearable(value) {
+    return (value != null &&
+        'clear' in value &&
+        typeof value.clear === 'function' &&
+        value.clear.length === 0);
+}
+/**
+ * If the given object implements Clearable, executes clear.
+ *
+ * @param value
+ */
+export function maybeClear(value) {
+    if (isClearable(value))
+        value.clear();
+}

package/dist/types/current/core/cloneable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An interface that may be implemented to provide custom clone behavior.
+ */
+export interface Cloneable<T> {
+    /**
+     * Produces a copy of this object.
+     */
+    clone(): T;
+}
+/**
+ * Returns true if the given value implements Cloneable.
+ */
+export declare function isCloneable<T>(value: T): value is T & Cloneable<T>;
+//# sourceMappingURL=cloneable.d.ts.map

package/dist/types/current/core/cloneable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneable.d.ts","sourceRoot":"","sources":["../../../../src/core/cloneable.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB;;OAEG;IACH,KAAK,IAAI,CAAC,CAAA;CACb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAQlE"}

package/dist/types/current/core/cloneable.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true if the given value implements Cloneable.
+ */
+export function isCloneable(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        'clone' in value &&
+        typeof value.clone === 'function' &&
+        value.clone.length === 0);
+}

package/dist/types/current/core/disposable.d.ts

@@ -0,0 +1,66 @@
+import { IllegalStateError } from '../error/IllegalStateError';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { Maybe } from '../util/type';
+/**
+ * Any object that may be disposed.
+ */
+export interface Disposable {
+    dispose(): void;
+}
+/**
+ * Returns true if the given value is disposable.
+ *
+ * @param value Any value. The value will be considered Disposable if it contains a method named
+ * 'dispose', and that function requires zero parameters. This value will be type guarded to
+ * Disposable if true is returned.
+ */
+export declare function isDisposable(value: any): value is Disposable;
+/**
+ * Disposes all the given {@link Disposable} objects.
+ *
+ * @param disposables
+ */
+export declare function disposeAll(disposables: Iterable<Disposable>): void;
+/**
+ * Returns a Disposable that invokes the given function on dispose.
+ *
+ * @param unsub
+ */
+export declare function toDisposable(unsub: () => void): Disposable;
+export type AddDisposable = <T extends Maybe<Disposable | Unsubscribe>>(disposable: T) => T;
+/**
+ * A Disposer disposes added disposables as a group.
+ * The method members may be called without a receiver.
+ */
+export interface Disposer extends Disposable {
+    readonly disposed: boolean;
+    readonly add: AddDisposable;
+    readonly dispose: () => void;
+}
+/**
+ * Creates a Disposer, an object on which {@link Disposable} instances may be added, and disposed
+ * as a group.
+ *
+ * The method members may be called without a receiver, thus allowing destructuring.
+ * Example:
+ * ```
+ * function create(): Disposable {
+ *   const { dispose, add } = disposer()
+ *   add(someDisposable)
+ *   add(anotherDisposable)
+ *   return {
+ *     dispose
+ *   }
+ * }
+ * ```
+ *
+ */
+export declare function createDisposer(): Disposer;
+/**
+ * An illegal state error indicating that an object has been disposed.
+ */
+export declare class DisposedError extends IllegalStateError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/types/current/core/disposable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../../src/core/disposable.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,OAAO,IAAI,IAAI,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,UAAU,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAIlE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,IAAI,GAAG,UAAU,CAE1D;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,GAAG,WAAW,CAAC,EAClE,UAAU,EAAE,CAAC,KACZ,CAAC,CAAA;AAEN;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,UAAU;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CA2BzC;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,iBAAiB;IAChD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAEW,OAAO,SAAyB;CAI/C"}

package/dist/types/current/core/disposable.js

@@ -0,0 +1,91 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IllegalStateError } from '../error/IllegalStateError';
+/**
+ * Returns true if the given value is disposable.
+ *
+ * @param value Any value. The value will be considered Disposable if it contains a method named
+ * 'dispose', and that function requires zero parameters. This value will be type guarded to
+ * Disposable if true is returned.
+ */
+export function isDisposable(value) {
+    return (value != null &&
+        typeof value.dispose === 'function' &&
+        value.dispose.length === 0);
+}
+/**
+ * Disposes all the given {@link Disposable} objects.
+ *
+ * @param disposables
+ */
+export function disposeAll(disposables) {
+    for (const disposable of disposables) {
+        disposable.dispose();
+    }
+}
+/**
+ * Returns a Disposable that invokes the given function on dispose.
+ *
+ * @param unsub
+ */
+export function toDisposable(unsub) {
+    return { dispose: unsub };
+}
+/**
+ * Creates a Disposer, an object on which {@link Disposable} instances may be added, and disposed
+ * as a group.
+ *
+ * The method members may be called without a receiver, thus allowing destructuring.
+ * Example:
+ * ```
+ * function create(): Disposable {
+ *   const { dispose, add } = disposer()
+ *   add(someDisposable)
+ *   add(anotherDisposable)
+ *   return {
+ *     dispose
+ *   }
+ * }
+ * ```
+ *
+ */
+export function createDisposer() {
+    const disposables = [];
+    let _disposed = false;
+    const add = (disposableOrUnsub) => {
+        if (_disposed)
+            throw new DisposedError();
+        if (disposableOrUnsub) {
+            disposables.push('dispose' in disposableOrUnsub
+                ? disposableOrUnsub
+                : toDisposable(disposableOrUnsub));
+        }
+        return disposableOrUnsub;
+    };
+    return {
+        dispose() {
+            if (_disposed)
+                throw new DisposedError();
+            _disposed = true;
+            disposeAll(disposables);
+        },
+        add,
+        get disposed() {
+            return _disposed;
+        },
+    };
+}
+/**
+ * An illegal state error indicating that an object has been disposed.
+ */
+export class DisposedError extends IllegalStateError {
+    get [Symbol.toStringTag]() {
+        return 'DisposedError';
+    }
+    constructor(message = 'Instance is disposed') {
+        super(message);
+        Object.setPrototypeOf(this, DisposedError.prototype);
+    }
+}

package/dist/types/current/error/AbortError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from './ReportableError';
+export declare class AbortError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=AbortError.d.ts.map

package/dist/types/current/error/AbortError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbortError.d.ts","sourceRoot":"","sources":["../../../../src/error/AbortError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAG/D,qBAAa,UAAW,SAAQ,eAAe;IAC3C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,OAAO,SAAsB,EAC7B,MAAM,GAAE,MAA6B,EACrC,KAAK,GAAE,UAA8B;CAK5C"}

package/dist/types/current/error/AbortError.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorLevel, ReportableError } from './ReportableError';
+import { ErrorOrigin } from '../error/ErrorOrigin';
+export class AbortError extends ReportableError {
+    get [Symbol.toStringTag]() {
+        return 'AbortError';
+    }
+    constructor(message = 'Operation aborted', origin = ErrorOrigin.INTERNAL, level = ErrorLevel.SILENT) {
+        super(message, origin, level);
+        Object.setPrototypeOf(this, AbortError.prototype);
+    }
+}

package/dist/types/current/error/ErrorOrigin.d.ts

@@ -0,0 +1,45 @@
+export declare const ErrorOrigin: {
+    /**
+     * The error originated from Vinyl and was reported from the uncaught exception or promise
+     * rejection handlers.
+     */
+    UNCAUGHT: string;
+    /**
+     * The error originated from Vinyl and was caught.
+     */
+    INTERNAL: string;
+    /**
+     * A Vinyl interface was used incorrectly by a consumer.
+     */
+    API: string;
+    /**
+     * The error originated from a failed service call (500 errors).
+     */
+    SERVICE_EXTERNAL: string;
+    /**
+     * The error originated from a failed service call (400 errors).
+     */
+    SERVICE_INTERNAL: string;
+    /**
+     * The error originated from a problem playing provided media.
+     * The reporter is from a component such as the element, source buffer, media source, etc.
+     */
+    MEDIA: string;
+    /**
+     * The error originated from a problem parsing input data.
+     * Such as a malformed Dash or HLS manifest.
+     */
+    PARSING: string;
+    /**
+     * The error originated from an incompatibility with browser APIs,
+     * such as EME.
+     */
+    COMPATIBILITY: string;
+    /**
+     * The error originated from DRM.
+     * This does not include internal or service errors, only errors from the creation of media keys or media key
+     * sessions.
+     */
+    DRM: string;
+};
+//# sourceMappingURL=ErrorOrigin.d.ts.map

package/dist/types/current/error/ErrorOrigin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorOrigin.d.ts","sourceRoot":"","sources":["../../../../src/error/ErrorOrigin.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;IACpB;;;OAGG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;CAEN,CAAA"}