@contentful/optimization-core 0.1.0-alpha → 0.1.0-alpha11

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAA6B,MAAM,WAAW,CAAA;AAE7E,cAAc,qCAAqC,CAAA;AACnD,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AAEjC,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/lib/decorators/guardedBy.d.ts

@@ -1,113 +0,0 @@
-/**
- * A callback invoked when a method call is blocked by {@link guardedBy}.
- *
- * @param methodName - The name of the method that was attempted.
- * @param args - The readonly array of arguments supplied to the blocked call.
- * @returns Nothing.
- *
- * @public
- */
-type BlockHandler = (methodName: string, args: readonly unknown[]) => void;
-/**
- * The original method implementation.
- *
- * @typeParam A - The parameter tuple of the original method.
- * @typeParam R - The return type of the original method.
- * @param value - The method being decorated.
- * @param context - The Stage-3 decorator context for a class method.
- * @returns Nothing.
- *
- * @remarks
- * Users do not call this directly; it's returned by {@link guardedBy}.
- */
-type GuardedByFunction<T extends object> = <A extends readonly unknown[], R>(value: (...args: A) => R, context: ClassMethodDecoratorContext<T, (...args: A) => R>) => void;
-/**
- * Options that tweak the behavior of {@link guardedBy}.
- *
- * @typeParam T - The instance type on which the decorator is applied.
- *
- * @public
- */
-export interface GuardedByOptions<T extends object> {
-    /**
-     * Inverts the predicate result.
-     *
-     * When `true`, a truthy predicate result **blocks** the method.
-     * When `false` (default) or omitted, a truthy predicate result **allows** the method.
-     *
-     * @defaultValue `false`
-     * @remarks
-     * This option is useful when the predicate expresses a *forbid* condition
-     * (e.g. "isLocked" or "isDestroyed") rather than an *allow* condition.
-     */
-    readonly invert?: boolean;
-    /**
-     * Either a function to call when a method is blocked, or the name/symbol of
-     * an instance method on `this` to call when blocked.
-     *
-     * Both forms are **synchronous** and receive `(methodName, argsArray)`.
-     * If omitted, blocked calls fail silently (i.e., return `undefined` or
-     * `Promise<undefined>` for async methods).
-     *
-     * @remarks
-     * - If a property key is supplied and the instance does not have a callable at that key,
-     *   the hook is ignored.
-     * - The hook **must not** be `async`; any async work should be scheduled manually.
-     */
-    readonly onBlocked?: BlockHandler | (keyof T & (string | symbol));
-}
-/**
- * Decorator factory that **guards** class methods behind a synchronous predicate.
- *
- * When a decorated method is invoked:
- * - If the predicate returns a value that evaluates to **allowed** (see `invert`), the original
- *   method is executed and its result is returned.
- * - If the call is **blocked**, the optional `onBlocked` hook is invoked (if configured) and:
- *   - `undefined` is returned for sync methods; or
- *   - `Promise<undefined>` is returned for async methods (to preserve `await` compatibility).
- *
- * @typeParam T - The instance type that owns both the predicate and the decorated method.
- *
- * @param predicateName - The name (string or symbol) of a **synchronous** instance method on `this`
- * that acts as the predicate. It is called as `this[predicateName](methodName, argsArray)`.
- * @param opts - Optional {@link GuardedByOptions | options} to configure inversion and `onBlocked`.
- *
- * @returns A methods-only class decorator compatible with Stage-3 decorators that wraps the method.
- *
- * @throws TypeError
- * Thrown at initialization time (first instance construction) if `predicateName` does not resolve
- * to a **synchronous function** on the instance.
- *
- * @remarks
- * - This is a **methods-only** decorator; applying it to accessors/fields is a no-op.
- * - The decorator preserves the original method's sync/async shape.
- * - The predicate is invoked with `(decoratedMethodName, argsArray)` to support context-aware checks.
- *
- * @example
- * Here, `canRun` allows the call when it returns truthy:
- * ```ts
- * class Runner {
- *   canRun(method: string, _args: readonly unknown[]) { return method !== 'stop'; }
- *
- *   @guardedBy<Runner>('canRun')
- *   go() { console.log('running'); }
- * }
- * ```
- *
- * @example
- * Invert the predicate and call a handler on block:
- * ```ts
- * class Door {
- *   isLocked() { return true } // truthy means "locked"
- *   onBlocked(method: string) { console.warn(`${method} blocked`) }
- *
- *   @guardedBy<Door>('isLocked', { invert: true, onBlocked: 'onBlocked' })
- *   open() { /* ... *\/ }
- * }
- * ```
- *
- * @public
- */
-export declare function guardedBy<T extends object>(predicateName: keyof T & (string | symbol), opts?: GuardedByOptions<T>): GuardedByFunction<T>;
-export {};
-//# sourceMappingURL=guardedBy.d.ts.map

package/dist/lib/decorators/guardedBy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guardedBy.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/guardedBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,KAAK,YAAY,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,OAAO,EAAE,KAAK,IAAI,CAAA;AAE1E;;;;;;;;;;;GAWG;AACH,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EACzE,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,2BAA2B,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KACvD,IAAI,CAAA;AAET;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM;IAChD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IAEzB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,YAAY,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAA;CAClE;AAiDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EACxC,aAAa,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAC1C,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GACzB,iBAAiB,CAAC,CAAC,CAAC,CAgEtB"}

package/dist/lib/decorators/guardedBy.js

@@ -1,143 +0,0 @@
-/**
- * Type guard for functions.
- *
- * @internal
- */
-const isFunction = (v) => typeof v === 'function';
-/**
- * Converts a property key to a readable string for logs and messages.
- *
- * @param name - The property key to stringify.
- * @returns A human-friendly name.
- *
- * @internal
- */
-const nameToString = (name) => typeof name === 'string'
-    ? name
-    : typeof name === 'symbol'
-        ? (name.description ?? String(name))
-        : String(name);
-/**
- * True when the `onBlocked` option is a property key (string or symbol).
- *
- * @typeParam T - The instance type.
- * @param v - The `onBlocked` option value.
- * @returns Whether `v` is a property key.
- *
- * @internal
- */
-const isOnBlockedKey = (v) => typeof v === 'string' || typeof v === 'symbol';
-/**
- * Detects declared `async` functions.
- *
- * @param fn - The candidate to test.
- * @returns `true` if `fn` is an async function, else `false`.
- *
- * @internal
- */
-const isAsyncFunction = (fn) => Object.prototype.toString.call(fn) === '[object AsyncFunction]';
-/**
- * Decorator factory that **guards** class methods behind a synchronous predicate.
- *
- * When a decorated method is invoked:
- * - If the predicate returns a value that evaluates to **allowed** (see `invert`), the original
- *   method is executed and its result is returned.
- * - If the call is **blocked**, the optional `onBlocked` hook is invoked (if configured) and:
- *   - `undefined` is returned for sync methods; or
- *   - `Promise<undefined>` is returned for async methods (to preserve `await` compatibility).
- *
- * @typeParam T - The instance type that owns both the predicate and the decorated method.
- *
- * @param predicateName - The name (string or symbol) of a **synchronous** instance method on `this`
- * that acts as the predicate. It is called as `this[predicateName](methodName, argsArray)`.
- * @param opts - Optional {@link GuardedByOptions | options} to configure inversion and `onBlocked`.
- *
- * @returns A methods-only class decorator compatible with Stage-3 decorators that wraps the method.
- *
- * @throws TypeError
- * Thrown at initialization time (first instance construction) if `predicateName` does not resolve
- * to a **synchronous function** on the instance.
- *
- * @remarks
- * - This is a **methods-only** decorator; applying it to accessors/fields is a no-op.
- * - The decorator preserves the original method's sync/async shape.
- * - The predicate is invoked with `(decoratedMethodName, argsArray)` to support context-aware checks.
- *
- * @example
- * Here, `canRun` allows the call when it returns truthy:
- * ```ts
- * class Runner {
- *   canRun(method: string, _args: readonly unknown[]) { return method !== 'stop'; }
- *
- *   @guardedBy<Runner>('canRun')
- *   go() { console.log('running'); }
- * }
- * ```
- *
- * @example
- * Invert the predicate and call a handler on block:
- * ```ts
- * class Door {
- *   isLocked() { return true } // truthy means "locked"
- *   onBlocked(method: string) { console.warn(`${method} blocked`) }
- *
- *   @guardedBy<Door>('isLocked', { invert: true, onBlocked: 'onBlocked' })
- *   open() { /* ... *\/ }
- * }
- * ```
- *
- * @public
- */
-export function guardedBy(predicateName, opts) {
-    return function (_value, context) {
-        const decoratedName = nameToString(context.name);
-        context.addInitializer(function init() {
-            // Original method on the instance
-            const originalUnknown = Reflect.get(this, context.name);
-            if (!isFunction(originalUnknown)) {
-                return; // defensive: nothing to wrap
-            }
-            const original = originalUnknown;
-            const originalIsAsync = isAsyncFunction(original);
-            const resolvePredicate = (self) => {
-                const { [predicateName]: cand } = self;
-                if (!isFunction(cand)) {
-                    throw new TypeError(`@guardedBy expects predicate "${String(predicateName)}" to be a synchronous function.`);
-                }
-                return cand;
-            };
-            const computeAllowed = (self, args) => {
-                const pred = resolvePredicate(self);
-                const ok = Boolean(pred.call(self, decoratedName, args));
-                return opts?.invert === true ? !ok : ok;
-            };
-            const runOnBlocked = (self, args) => {
-                const { onBlocked } = opts ?? {};
-                if (onBlocked === undefined) {
-                    return;
-                }
-                if (isFunction(onBlocked)) {
-                    onBlocked.call(self, decoratedName, args);
-                    return;
-                }
-                if (isOnBlockedKey(onBlocked)) {
-                    const { [onBlocked]: handlerCandidate } = self;
-                    if (isFunction(handlerCandidate)) {
-                        handlerCandidate.call(self, decoratedName, args);
-                    }
-                }
-            };
-            const blockedReturn = () => originalIsAsync ? Promise.resolve(undefined) : undefined;
-            const wrapped = function (...args) {
-                if (!computeAllowed(this, args)) {
-                    runOnBlocked(this, args);
-                    return blockedReturn();
-                }
-                return original.call(this, ...args);
-            };
-            // Replace the instance method with our wrapper
-            Reflect.set(this, context.name, wrapped);
-        });
-    };
-}
-//# sourceMappingURL=guardedBy.js.map

package/dist/lib/decorators/guardedBy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"guardedBy.js","sourceRoot":"","sources":["../../../src/lib/decorators/guardedBy.ts"],"names":[],"mappings":"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"}

package/dist/lib/decorators/index.d.ts

@@ -1,2 +0,0 @@
-export { guardedBy } from './guardedBy';
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/decorators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/lib/decorators/index.js

@@ -1,2 +0,0 @@
-export { guardedBy } from './guardedBy';
-//# sourceMappingURL=index.js.map

package/dist/lib/decorators/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/lib/interceptor/InterceptorManager.d.ts

@@ -1,127 +0,0 @@
-/**
- * A utility type representing a value that may be synchronously available or
- * produced asynchronously.
- *
- * @typeParam T - The resolved value type.
- * @public
- */
-type MaybePromise<T> = T | Promise<T>;
-/**
- * A function that receives a value of type `T` and returns a (possibly async)
- * value of the same type `T`. The input is marked as `readonly` to discourage
- * mutation of the original object.
- *
- * @typeParam T - The value type intercepted and returned.
- * @param value - The current (readonly) value in the interception chain.
- * @returns The next value for the chain, either directly or via a promise.
- * @remarks Implementations SHOULD avoid mutating `value` and instead return a
- * new or safely-updated instance.
- * @see {@link InterceptorManager}
- * @public
- */
-export type Interceptor<T> = (value: Readonly<T>) => MaybePromise<T>;
-/**
- * Manages a list of interceptors and provides a way to run them in sequence.
- *
- * Interceptors are executed in insertion order. Each interceptor receives the
- * result of the previous interceptor (or the initial input for the first one)
- * and may return a new value synchronously or asynchronously.
- *
- * @typeParam T - The value type processed by the interceptors.
- * @remarks This class snapshots the current interceptor list at invocation time
- * so additions/removals during `run` do not affect the in-flight execution.
- * @example
- * ```ts
- * const mgr = new InterceptorManager<number>();
- * const id = mgr.add((n) => n + 1);
- * const final = await mgr.run(1); // 2
- * mgr.remove(id);
- * ```
- * @public
- */
-export declare class InterceptorManager<T> {
-    /**
-     * The registry of interceptors keyed by their insertion id.
-     *
-     * @privateRemarks Internal storage; use {@link add}, {@link remove}, and
-     * {@link clear} to manage contents.
-     * @readonly
-     * @defaultValue `new Map()`
-     */
-    private readonly interceptors;
-    /**
-     * The next numeric id to assign to an added interceptor.
-     *
-     * @privateRemarks Used only to generate unique, monotonically increasing ids.
-     * @defaultValue `0`
-     */
-    private nextId;
-    /**
-     * Add an interceptor and return its identifier.
-     *
-     * @param interceptor - The interceptor function to register.
-     * @returns The numeric id that can later be used with {@link remove}.
-     * @remarks Interceptors are executed in the order they are added.
-     * @example
-     * ```ts
-     * const id = manager.add(async (value) => transform(value));
-     * ```
-     * @public
-     */
-    add(interceptor: Interceptor<T>): number;
-    /**
-     * Remove an interceptor by its identifier.
-     *
-     * @param id - The id previously returned by {@link add}.
-     * @returns `true` if an interceptor was removed; otherwise `false`.
-     * @example
-     * ```ts
-     * const removed = manager.remove(id);
-     * ```
-     * @public
-     */
-    remove(id: number): boolean;
-    /**
-     * Remove all registered interceptors.
-     *
-     * @returns Nothing.
-     * @remarks After calling this, {@link count} will return `0`.
-     * @example
-     * ```ts
-     * manager.clear();
-     * ```
-     * @public
-     */
-    clear(): void;
-    /**
-     * Get the number of currently registered interceptors.
-     *
-     * @returns The count of interceptors.
-     * @example
-     * ```ts
-     * if (manager.count() === 0) { /* ... *\/ }
-     * ```
-     * @public
-     */
-    count(): number;
-    /**
-     * Run all interceptors in sequence on an input value and return the final result.
-     *
-     * Supports both sync and async interceptors; the return type is always `Promise<T>`
-     * for consistency.
-     *
-     * @param input - The initial value to pass to the first interceptor.
-     * @returns A promise resolving to the final value after all interceptors have run.
-     * @throws May rethrow any error thrown by an interceptor. <!-- Intentionally vague: error type depends on interceptor implementation -->
-     * @remarks The interceptor list is snapshotted at invocation time; changes to
-     * the registry during execution do not affect the running sequence.
-     * @example
-     * ```ts
-     * const result = await manager.run(initial);
-     * ```
-     * @public
-     */
-    run(input: T): Promise<T>;
-}
-export {};
-//# sourceMappingURL=InterceptorManager.d.ts.map

package/dist/lib/interceptor/InterceptorManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InterceptorManager.d.ts","sourceRoot":"","sources":["../../../src/lib/interceptor/InterceptorManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAErC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAAA;AAEpE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,kBAAkB,CAAC,CAAC;IAC/B;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IAEjE;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAI;IAElB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM;IAOxC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI3B;;;;;;;;;;OAUG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;OASG;IACH,KAAK,IAAI,MAAM;IAIf;;;;;;;;;;;;;;;;OAgBG;IACG,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAchC"}

package/dist/lib/interceptor/InterceptorManager.js

@@ -1,125 +0,0 @@
-/**
- * Manages a list of interceptors and provides a way to run them in sequence.
- *
- * Interceptors are executed in insertion order. Each interceptor receives the
- * result of the previous interceptor (or the initial input for the first one)
- * and may return a new value synchronously or asynchronously.
- *
- * @typeParam T - The value type processed by the interceptors.
- * @remarks This class snapshots the current interceptor list at invocation time
- * so additions/removals during `run` do not affect the in-flight execution.
- * @example
- * ```ts
- * const mgr = new InterceptorManager<number>();
- * const id = mgr.add((n) => n + 1);
- * const final = await mgr.run(1); // 2
- * mgr.remove(id);
- * ```
- * @public
- */
-export class InterceptorManager {
-    /**
-     * The registry of interceptors keyed by their insertion id.
-     *
-     * @privateRemarks Internal storage; use {@link add}, {@link remove}, and
-     * {@link clear} to manage contents.
-     * @readonly
-     * @defaultValue `new Map()`
-     */
-    interceptors = new Map();
-    /**
-     * The next numeric id to assign to an added interceptor.
-     *
-     * @privateRemarks Used only to generate unique, monotonically increasing ids.
-     * @defaultValue `0`
-     */
-    nextId = 0;
-    /**
-     * Add an interceptor and return its identifier.
-     *
-     * @param interceptor - The interceptor function to register.
-     * @returns The numeric id that can later be used with {@link remove}.
-     * @remarks Interceptors are executed in the order they are added.
-     * @example
-     * ```ts
-     * const id = manager.add(async (value) => transform(value));
-     * ```
-     * @public
-     */
-    add(interceptor) {
-        const { nextId: id } = this;
-        this.nextId += 1;
-        this.interceptors.set(id, interceptor);
-        return id;
-    }
-    /**
-     * Remove an interceptor by its identifier.
-     *
-     * @param id - The id previously returned by {@link add}.
-     * @returns `true` if an interceptor was removed; otherwise `false`.
-     * @example
-     * ```ts
-     * const removed = manager.remove(id);
-     * ```
-     * @public
-     */
-    remove(id) {
-        return this.interceptors.delete(id);
-    }
-    /**
-     * Remove all registered interceptors.
-     *
-     * @returns Nothing.
-     * @remarks After calling this, {@link count} will return `0`.
-     * @example
-     * ```ts
-     * manager.clear();
-     * ```
-     * @public
-     */
-    clear() {
-        this.interceptors.clear();
-    }
-    /**
-     * Get the number of currently registered interceptors.
-     *
-     * @returns The count of interceptors.
-     * @example
-     * ```ts
-     * if (manager.count() === 0) { /* ... *\/ }
-     * ```
-     * @public
-     */
-    count() {
-        return this.interceptors.size;
-    }
-    /**
-     * Run all interceptors in sequence on an input value and return the final result.
-     *
-     * Supports both sync and async interceptors; the return type is always `Promise<T>`
-     * for consistency.
-     *
-     * @param input - The initial value to pass to the first interceptor.
-     * @returns A promise resolving to the final value after all interceptors have run.
-     * @throws May rethrow any error thrown by an interceptor. <!-- Intentionally vague: error type depends on interceptor implementation -->
-     * @remarks The interceptor list is snapshotted at invocation time; changes to
-     * the registry during execution do not affect the running sequence.
-     * @example
-     * ```ts
-     * const result = await manager.run(initial);
-     * ```
-     * @public
-     */
-    async run(input) {
-        // Snapshot to avoid issues if interceptors are added/removed during execution.
-        const fns = Array.from(this.interceptors.values());
-        let acc = input;
-        for (const fn of fns) {
-            // Pass a readonly view to discourage mutation of intermediate values.
-            // Each interceptor must return a T (or Promise<T>).
-            acc = await fn(acc);
-        }
-        return acc;
-    }
-}
-//# sourceMappingURL=InterceptorManager.js.map

package/dist/lib/interceptor/InterceptorManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InterceptorManager.js","sourceRoot":"","sources":["../../../src/lib/interceptor/InterceptorManager.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;OAOG;IACc,YAAY,GAAG,IAAI,GAAG,EAA0B,CAAA;IAEjE;;;;;OAKG;IACK,MAAM,GAAG,CAAC,CAAA;IAElB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,WAA2B;QAC7B,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAA;QAC3B,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,EAAE,WAAW,CAAC,CAAA;QACtC,OAAO,EAAE,CAAA;IACX,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAU;QACf,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IACrC,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK;QACH,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAA;IAC3B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAA;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,GAAG,CAAC,KAAQ;QAChB,+EAA+E;QAC/E,MAAM,GAAG,GAAkC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAA;QAEjF,IAAI,GAAG,GAAM,KAAK,CAAA;QAElB,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;YACrB,sEAAsE;YACtE,oDAAoD;YACpD,GAAG,GAAG,MAAM,EAAE,CAAC,GAAkB,CAAC,CAAA;QACpC,CAAC;QAED,OAAO,GAAG,CAAA;IACZ,CAAC;CACF"}

package/dist/lib/interceptor/index.d.ts

@@ -1,2 +0,0 @@
-export * from './InterceptorManager';
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/interceptor/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/interceptor/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA"}

package/dist/lib/interceptor/index.js

@@ -1,2 +0,0 @@
-export * from './InterceptorManager';
-//# sourceMappingURL=index.js.map

package/dist/lib/interceptor/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/interceptor/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA"}