@uploadcare/file-uploader 1.27.1 → 1.28.0-alpha.0

package/dist/instagramPlugin-k67tMAo3.js

@@ -0,0 +1,8 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import { n as instagramPlugin } from "./plugins-DxjsQUa8.js";
+export { instagramPlugin };

package/dist/lit/BaseComponent.d.ts

@@ -0,0 +1,12 @@
+import { LitElement } from 'lit';
+declare const BaseComponent_base: typeof LitElement & import('./Constructor').Constructor<{
+    willYield: boolean;
+    yield(slot: string, defaultContent?: unknown): unknown;
+}> & import('./Constructor').Constructor<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}> & import('./Constructor').Constructor<import('./SymbioteCompatMixin').SymbioteComponent<Record<string, unknown>>> & import('./Constructor').Constructor<LitElement> & {
+    reg(tagName: string): void;
+};
+export declare class BaseComponent extends BaseComponent_base {
+}
+export {};

package/dist/lit/Constructor.d.ts

@@ -0,0 +1 @@
+export type Constructor<T = unknown> = new (...args: any[]) => T;

package/dist/lit/CssDataMixin.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from 'lit';
+import { Constructor } from './Constructor';
+declare class CssDataMixinClassInterface {
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}
+export declare function CssDataMixin<T extends Constructor<LitElement>>(ctor: T): T & Constructor<CssDataMixinClassInterface>;
+export {};

package/dist/lit/LightDomMixin.d.ts

@@ -0,0 +1,8 @@
+import { LitElement } from 'lit';
+import { Constructor } from './Constructor';
+declare class LightDomElementInterface {
+    willYield: boolean;
+    yield(slot: string, defaultContent?: unknown): unknown;
+}
+export declare function LightDomMixin<T extends Constructor<LitElement>>(ctor: T): T & Constructor<LightDomElementInterface>;
+export {};

package/dist/lit/LitActivityBlock.d.ts

@@ -0,0 +1,53 @@
+import { ActivityParams as CloudImageEditorActivityParams } from '../blocks/CloudImageEditorActivity/CloudImageEditorActivity';
+import { ActivityParams as ExternalSourceActivityParams } from '../blocks/ExternalSource/ExternalSource';
+import { ActivityType, RegisteredActivityType } from './activity-constants';
+import { LitBlock } from './LitBlock';
+declare const ACTIVE_PROP = "___ACTIVITY_IS_ACTIVE___";
+export interface CustomActivities {
+}
+export type ActivityParamsMap = {
+    'cloud-image-edit': CloudImageEditorActivityParams;
+    external: ExternalSourceActivityParams;
+} & {
+    [Key in keyof CustomActivities]: CustomActivities[Key]['params'];
+};
+export declare class LitActivityBlock extends LitBlock {
+    protected historyTracked: boolean;
+    private [ACTIVE_PROP]?;
+    init$: {
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    private _debouncedHistoryFlush;
+    private _deactivate;
+    private _activate;
+    initCallback(): void;
+    private _historyFlush;
+    protected _isActivityRegistered(): boolean;
+    private static _activityCallbacks;
+    static activities: Readonly<{
+        START_FROM: 'start-from';
+        CAMERA: 'camera';
+        UPLOAD_LIST: 'upload-list';
+        URL: 'url';
+        CLOUD_IMG_EDIT: 'cloud-image-edit';
+        EXTERNAL: 'external';
+    }>;
+    protected get isActivityActive(): boolean;
+    get couldOpenActivity(): boolean;
+    /** TODO: remove name argument */
+    protected registerActivity(_name: string, options?: {
+        onActivate?: () => void;
+        onDeactivate?: () => void;
+    }): void;
+    private _unregisterActivity;
+    disconnectedCallback(): void;
+    get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
+    get initActivity(): RegisteredActivityType | null;
+    get doneActivity(): RegisteredActivityType | null;
+    historyBack(): void;
+}
+export type { RegisteredActivityType, ActivityType };

package/dist/lit/LitBlock.d.ts

@@ -0,0 +1,83 @@
+import { LitElement } from 'lit';
+import { ClipboardLayer } from '../abstract/features/ClipboardLayer';
+import { A11y } from '../abstract/managers/a11y';
+import { LocaleManager } from '../abstract/managers/LocaleManager';
+import { ModalManager } from '../abstract/managers/ModalManager';
+import { PluginManager } from '../abstract/managers/plugin';
+import { TelemetryManager } from '../abstract/managers/TelemetryManager';
+import { EventEmitter } from '../blocks/UploadCtxProvider/EventEmitter';
+import { ActivityType } from '../lit/LitActivityBlock';
+import { PubSub } from '../lit/PubSubCompat';
+import { ConfigType } from '../types';
+import { SharedState } from './SharedState';
+import { SharedInstancesBag, SharedInstancesState } from './shared-instances';
+declare const LitBlockBase: typeof LitElement & import('./Constructor').Constructor<{
+    willYield: boolean;
+    yield(slot: string, defaultContent?: unknown): unknown;
+}> & import('./Constructor').Constructor<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}> & import('./Constructor').Constructor<import('./SymbioteCompatMixin').SymbioteComponent<SharedState>> & import('./Constructor').Constructor<LitElement> & {
+    reg(tagName: string): void;
+};
+export declare class LitBlock extends LitBlockBase {
+    private _cfgProxy;
+    static styleAttrs: string[];
+    activityType: ActivityType;
+    init$: {};
+    constructor();
+    l10n: (str: string, variables?: Record<string, string | number>) => string;
+    debugPrint: (...args: unknown[]) => void;
+    protected _sharedInstancesBag: {
+        readonly ctx: PubSub<SharedState>;
+        readonly modalManager: ModalManager | null;
+        readonly pluginManager: PluginManager;
+        readonly telemetryManager: TelemetryManager;
+        readonly localeManager: LocaleManager;
+        readonly a11y: A11y;
+        readonly blocksRegistry: Set<LitBlock>;
+        readonly eventEmitter: EventEmitter;
+        readonly uploadCollection: import('../abstract/TypedCollection').TypedCollection<import('../abstract/uploadEntrySchema').UploadEntryData>;
+        readonly secureUploadsManager: import('../abstract/managers/SecureUploadsManager').SecureUploadsManager;
+        readonly api: import('..').UploaderPublicApi;
+        readonly validationManager: import('../abstract/managers/ValidationManager').ValidationManager;
+        when<TName extends "modalManager" | "pluginManager" | "telemetryManager" | "localeManager" | "a11y" | "clipboard" | "blocksRegistry" | "eventEmitter" | "uploadCollection" | "secureUploadsManager" | "api" | "validationManager">(name: TName, callback: (instance: NonNullable<{
+            modalManager: ModalManager | null;
+            pluginManager: PluginManager;
+            telemetryManager: TelemetryManager;
+            localeManager: LocaleManager;
+            a11y: A11y;
+            clipboard: ClipboardLayer;
+            blocksRegistry: import('./SharedState').BlocksRegistry;
+            eventEmitter: EventEmitter;
+            uploadCollection: import('../abstract/TypedCollection').TypedCollection<import('../abstract/uploadEntrySchema').UploadEntryData>;
+            secureUploadsManager: import('../abstract/managers/SecureUploadsManager').SecureUploadsManager;
+            api: import('..').UploaderPublicApi;
+            validationManager: import('../abstract/managers/ValidationManager').ValidationManager;
+        }[TName]>) => void): () => void;
+    };
+    emit(type: Parameters<EventEmitter['emit']>[0], payload?: Parameters<EventEmitter['emit']>[1], options?: Parameters<EventEmitter['emit']>[2]): void;
+    hasBlockInCtx(callback: (block: LitBlock) => boolean): boolean;
+    connectedCallback(): void;
+    initCallback(): void;
+    get testId(): string;
+    get modalManager(): ModalManager | null;
+    get telemetryManager(): TelemetryManager;
+    get localeManager(): LocaleManager;
+    get a11y(): A11y;
+    get clipboardLayer(): ClipboardLayer;
+    get blocksRegistry(): Set<LitBlock>;
+    get eventEmitter(): EventEmitter;
+    disconnectedCallback(): void;
+    /**
+     * Called when the last block is removed from the context. Note that inheritors must run their callback before that.
+     */
+    private destroyCtxCallback;
+    private _getSharedContextInstances;
+    protected _addSharedContextInstance<TKey extends keyof SharedInstancesState>(key: TKey, resolver: (sharedInstancesBag: SharedInstancesBag) => NonNullable<SharedInstancesState[TKey]>): void;
+    private _destroySharedContextInstances;
+    protected _getSharedContextInstance<TKey extends keyof SharedState, TRequired extends boolean = true>(key: TKey, isRequired?: TRequired): TRequired extends true ? NonNullable<SharedState[TKey]> : SharedState[TKey];
+    protected proxyUrl(url: string): Promise<string>;
+    get cfg(): ConfigType;
+    subConfigValue<T extends keyof ConfigType>(key: T, callback: (value: ConfigType[T]) => void): () => void;
+}
+export {};

package/dist/lit/LitSolutionBlock.d.ts

@@ -0,0 +1,21 @@
+import { LitBlock } from './LitBlock';
+export declare class LitSolutionBlock extends LitBlock {
+    static styleAttrs: string[];
+    init$: {
+        '*solution': string | null;
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*uploadQueue': import('@uploadcare/upload-client').Queue;
+        '*collectionErrors': import('..').OutputErrorCollection[];
+        '*collectionState': import('..').OutputCollectionState | null;
+        '*groupInfo': import('@uploadcare/upload-client').UploadcareGroup | null;
+        '*uploadTrigger': Set<string>;
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    initCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/lit/LitUploaderBlock.d.ts

@@ -0,0 +1,53 @@
+import { FileFromOptions } from '@uploadcare/upload-client';
+import { SecureUploadsManager } from '../abstract/managers/SecureUploadsManager';
+import { ValidationManager } from '../abstract/managers/ValidationManager';
+import { TypedCollection } from '../abstract/TypedCollection';
+import { UploaderPublicApi } from '../abstract/UploaderPublicApi';
+import { UploadEntryData } from '../abstract/uploadEntrySchema';
+import { OutputCollectionState, OutputFileEntry } from '../types/index';
+import { ExternalUploadSource, UploadSource } from '../utils/UploadSource';
+import { LitActivityBlock } from './LitActivityBlock';
+export declare class LitUploaderBlock extends LitActivityBlock {
+    static extSrcList: Readonly<typeof ExternalUploadSource>;
+    static sourceTypes: Readonly<typeof UploadSource>;
+    protected couldBeCtxOwner: boolean;
+    private _isCtxOwner;
+    private _unobserveCollection?;
+    private _unobserveCollectionProperties?;
+    init$: {
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*uploadQueue': import('@uploadcare/upload-client').Queue;
+        '*collectionErrors': import('..').OutputErrorCollection[];
+        '*collectionState': OutputCollectionState | null;
+        '*groupInfo': import('@uploadcare/upload-client').UploadcareGroup | null;
+        '*uploadTrigger': Set<string>;
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    private get _hasCtxOwner();
+    initCallback(): void;
+    getAPI(): UploaderPublicApi;
+    get validationManager(): ValidationManager;
+    get api(): UploaderPublicApi;
+    get uploadCollection(): TypedCollection<UploadEntryData>;
+    get secureUploadsManager(): SecureUploadsManager;
+    disconnectedCallback(): void;
+    connectedCallback(): void;
+    private _initCtxOwner;
+    private _observeUploadCollection;
+    private _unobserveUploadCollection;
+    private _createGroup;
+    private _flushOutputItems;
+    private _handleCollectionUpdate;
+    private _handleCollectionPropertiesUpdate;
+    private _flushCommonUploadProgress;
+    private _openCloudImageEditor;
+    private _setInitialCrop;
+    protected getMetadataFor(entryId: string): Promise<import('@uploadcare/upload-client').Metadata | undefined>;
+    protected getUploadClientOptions(): Promise<FileFromOptions>;
+    getOutputData(): OutputFileEntry[];
+}

package/dist/lit/PubSubCompat.d.ts

@@ -0,0 +1,18 @@
+export type Unsubscriber = () => void;
+export declare class PubSub<T extends Record<string, unknown>> {
+    private static _contexts;
+    private _store;
+    private _ctxId;
+    private constructor();
+    get id(): string;
+    pub<K extends keyof T>(key: K, value: T[K]): void;
+    sub<K extends keyof T>(key: K, callback: (value: T[K]) => void, init?: boolean): Unsubscriber;
+    read<K extends keyof T>(key: K): T[K];
+    add<K extends keyof T>(key: K, value: T[K], rewrite?: boolean): void;
+    has(key: keyof T): boolean;
+    get store(): T;
+    static registerCtx<T extends Record<string, unknown>>(initialValue: T, ctxId: string): PubSub<T>;
+    static deleteCtx(ctxId: string): void;
+    static getCtx<T extends Record<string, unknown> = Record<string, unknown>>(ctxId: string): PubSub<T> | null;
+    static hasCtx(ctxId: string): boolean;
+}

package/dist/lit/RegisterableElementMixin.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from 'lit';
+import { Constructor } from './Constructor';
+type RegisterableElementMixinClassInterface = Constructor<LitElement> & {
+    reg(tagName: string): void;
+};
+export declare function RegisterableElementMixin<T extends Constructor<LitElement>>(ctor: T): T & RegisterableElementMixinClassInterface;
+export {};

package/dist/lit/SharedState.d.ts

@@ -0,0 +1,119 @@
+import { Queue, UploadcareGroup } from '@uploadcare/upload-client';
+import { ClipboardLayer } from '../abstract/features/ClipboardLayer';
+import { LocaleDefinition } from '../abstract/localeRegistry';
+import { A11y } from '../abstract/managers/a11y';
+import { LocaleManager } from '../abstract/managers/LocaleManager';
+import { ModalManager } from '../abstract/managers/ModalManager';
+import { PluginManager } from '../abstract/managers/plugin';
+import { SecureUploadsManager } from '../abstract/managers/SecureUploadsManager';
+import { TelemetryManager } from '../abstract/managers/TelemetryManager';
+import { ValidationManager } from '../abstract/managers/ValidationManager';
+import { TypedCollection } from '../abstract/TypedCollection';
+import { UploaderPublicApi } from '../abstract/UploaderPublicApi';
+import { UploadEntryData } from '../abstract/uploadEntrySchema';
+import { TabIdValue } from '../blocks/CloudImageEditor/src/toolbar-constants';
+import { CropAspectRatio, CropPresetList, LoadingOperations, Transformations } from '../blocks/CloudImageEditor/src/types';
+import { EventEmitter } from '../blocks/UploadCtxProvider/EventEmitter';
+import { ConfigType, OutputCollectionState, OutputErrorCollection } from '../types';
+import { ISharedInstance } from './shared-instances';
+import { RegisteredActivityType } from './LitActivityBlock';
+import { LitBlock } from './LitBlock';
+import { Uid } from './Uid';
+import { EditorImageCropper, EditorImageFader, EditorSlider } from '../blocks/CloudImageEditor';
+type SharedConfigState = {
+    [K in keyof ConfigType as `*cfg/${K}`]: ConfigType[K];
+};
+export type BlocksRegistry = Set<LitBlock>;
+type ActivityBlockCtxState = {
+    '*currentActivity': RegisteredActivityType | null;
+    '*currentActivityParams': Record<string, unknown>;
+    '*history': (RegisteredActivityType | null)[];
+    '*historyBack': (() => void) | null;
+    '*closeModal': () => void;
+};
+type UploaderBlockCtxState = ActivityBlockCtxState & {
+    '*commonProgress': number;
+    '*uploadList': {
+        uid: Uid;
+    }[];
+    '*uploadQueue': Queue;
+    '*collectionErrors': OutputErrorCollection[];
+    '*collectionState': OutputCollectionState | null;
+    '*groupInfo': UploadcareGroup | null;
+    '*uploadTrigger': Set<Uid>;
+};
+type SolutionBlockCtxState = UploaderBlockCtxState & {
+    '*solution': string | null;
+};
+type CloudImageEditorState = {
+    '*originalUrl': string | null;
+    '*loadingOperations': LoadingOperations;
+    '*faderEl': EditorImageFader | null;
+    '*cropperEl': EditorImageCropper | null;
+    '*imgEl': HTMLImageElement | null;
+    '*imgContainerEl': HTMLElement | null;
+    '*networkProblems': boolean;
+    '*imageSize': {
+        width: number;
+        height: number;
+    } | null;
+    '*editorTransformations': Transformations;
+    '*cropPresetList': CropPresetList;
+    '*currentAspectRatio': CropAspectRatio | null;
+    '*tabList': readonly TabIdValue[];
+    '*tabId': TabIdValue;
+    '*on.retryNetwork': () => void;
+    '*on.apply': (transformations: Transformations) => void;
+    '*on.cancel': () => void;
+};
+type EditorImageCropperState = {
+    '*padding': number;
+    '*operations': {
+        rotate: number;
+        mirror: boolean;
+        flip: boolean;
+    };
+    '*imageBox': {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    '*cropBox': {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+type EditorToolbarState = {
+    '*showListAspectRatio': boolean;
+    '*sliderEl': EditorSlider | null;
+    '*showSlider': boolean;
+    '*currentFilter': string;
+    '*currentOperation': string | null;
+    '*operationTooltip': string | null;
+};
+type SharedContextInstances = Map<string, ISharedInstance>;
+type DynamicBlockState = {
+    '*sharedContextInstances': SharedContextInstances;
+    '*blocksRegistry': BlocksRegistry;
+    '*eventEmitter': EventEmitter;
+    '*localeManager': LocaleManager;
+    '*telemetryManager': TelemetryManager;
+    '*a11y': A11y;
+    '*modalManager': ModalManager | null;
+    '*clipboard': ClipboardLayer;
+    '*pluginManager': PluginManager;
+};
+type DynamicUploaderBlockState = {
+    '*uploadCollection': TypedCollection<UploadEntryData>;
+    '*publicApi': UploaderPublicApi;
+    '*validationManager': ValidationManager;
+    '*secureUploadsManager': SecureUploadsManager;
+};
+type LocaleState = {
+    [K in keyof LocaleDefinition as `*l10n/${K}`]: string;
+};
+export type SharedState = SolutionBlockCtxState & SharedConfigState & CloudImageEditorState & EditorImageCropperState & EditorToolbarState & DynamicBlockState & DynamicUploaderBlockState & LocaleState;
+export {};

package/dist/lit/SymbioteCompatMixin.d.ts

@@ -0,0 +1,40 @@
+import { LitElement } from 'lit';
+import { Constructor } from './Constructor';
+import { PubSub } from './PubSubCompat';
+type SymbioteStateBag<T extends Record<string, unknown>> = T;
+export declare const ctxNameContext: {
+    __context__: string;
+};
+/**
+ * Interface for components using SymbioteMixin
+ */
+export declare class SymbioteComponent<TState extends Record<string, unknown> = Record<string, unknown>> {
+    $: SymbioteStateBag<TState>;
+    sub<TKey extends keyof TState>(key: TKey, callback: (value: TState[TKey]) => void, init?: boolean): () => void;
+    pub<TKey extends keyof TState>(key: TKey, value: TState[TKey]): void;
+    set$<T extends {
+        [K in keyof T]: K extends keyof TState ? TState[K] : never;
+    }>(obj: T): void;
+    has<TKey extends keyof TState>(key: TKey): boolean;
+    add<TKey extends keyof TState>(key: TKey, val: TState[TKey], rewrite?: boolean): void;
+    add$<T extends {
+        [K in keyof T]: K extends keyof TState ? TState[K] : never;
+    }>(obj: T, rewrite?: boolean): void;
+    initCallback(): void;
+    sharedCtx: PubSub<TState>;
+    ctxName: string;
+    ctxOwner: boolean;
+}
+/**
+ * SymbioteMixin - Compatibility layer between SymbioteJS and Lit Element
+ *
+ * This decorator allows Lit elements to use Symbiote's reactive state management
+ * and data binding features while maintaining Lit's rendering capabilities.
+ *
+ * Usage:
+ * class MyComponent extends SymbioteMixin<MyStateType>()(LitElement) { ... }
+ * // or without state type:
+ * class MyComponent extends SymbioteMixin()(LitElement) { ... }
+ */
+export declare function SymbioteMixin<TState extends Record<string, unknown> = Record<string, unknown>>(): <TCtor extends Constructor<LitElement>>(ctor: TCtor) => TCtor & Constructor<SymbioteComponent<TState>>;
+export {};

package/dist/lit/TestModeController.d.ts

@@ -0,0 +1,16 @@
+import { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+import { LitBlock } from './LitBlock';
+type TestModeHost = ReactiveControllerHost & LitElement & LitBlock;
+export declare class TestModeController implements ReactiveController {
+    private _trackedElements;
+    private _originalValues;
+    private _enabled;
+    private _unsubscribe?;
+    private _host;
+    constructor(host: TestModeHost);
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    private _collectElements;
+    private _applyTestMode;
+}
+export {};

package/dist/lit/Uid.d.ts

@@ -0,0 +1,3 @@
+export type Uid = string & {
+    __uid: true;
+};

package/dist/lit/activity-constants.d.ts

@@ -0,0 +1,11 @@
+import { CustomActivities } from './LitActivityBlock';
+export declare const ACTIVITY_TYPES: Readonly<{
+    START_FROM: "start-from";
+    CAMERA: "camera";
+    UPLOAD_LIST: "upload-list";
+    URL: "url";
+    CLOUD_IMG_EDIT: "cloud-image-edit";
+    EXTERNAL: "external";
+}>;
+export type RegisteredActivityType = (typeof ACTIVITY_TYPES)[keyof typeof ACTIVITY_TYPES] | keyof CustomActivities;
+export type ActivityType = RegisteredActivityType | null;

package/dist/lit/createDebugPrinter.d.ts

@@ -0,0 +1,3 @@
+import { PubSub } from './PubSubCompat';
+import { SharedState } from './SharedState';
+export declare const createDebugPrinter: (getCtx: () => PubSub<SharedState>, scope?: string) => (...args: unknown[]) => void;

package/dist/lit/findBlockInCtx.d.ts

@@ -0,0 +1,3 @@
+import { LitBlock } from './LitBlock';
+import { BlocksRegistry } from './SharedState';
+export declare const findBlockInCtx: (blocksRegistry: BlocksRegistry, callback: (block: LitBlock) => boolean) => LitBlock | undefined;

package/dist/lit/getOutputData.d.ts

@@ -0,0 +1,2 @@
+import { SharedInstancesBag } from './shared-instances';
+export declare const getOutputData: (bag: SharedInstancesBag) => import('..').OutputFileEntry<import('..').OutputFileStatus>[];

package/dist/lit/hasBlockInCtx.d.ts

@@ -0,0 +1,3 @@
+import { LitBlock } from './LitBlock';
+import { BlocksRegistry } from './SharedState';
+export declare const hasBlockInCtx: (blocksRegistry: BlocksRegistry, callback: (block: LitBlock) => boolean) => boolean;

package/dist/lit/l10n.d.ts

@@ -0,0 +1,5 @@
+import { PubSub } from './PubSubCompat';
+import { SharedState } from './SharedState';
+export type L10nFunction = (str: string, variables?: Record<string, string | number>) => string;
+export declare const createPluralizer: (getL10n: () => L10nFunction) => (key: string, count: number) => string;
+export declare const createL10n: (getCtx: () => PubSub<SharedState>) => (str: string, variables?: Record<string, string | number>) => string;

package/dist/lit/parseCssPropertyValue.d.ts

@@ -0,0 +1 @@
+export declare function parseCssPropertyValue(input: string): string | number | boolean | null | undefined;

package/dist/lit/shared-instances.d.ts

@@ -0,0 +1,65 @@
+import { ConfigType, UploaderPublicApi } from '..';
+import { A11y } from '../abstract/managers/a11y';
+import { LocaleManager } from '../abstract/managers/LocaleManager';
+import { ModalManager } from '../abstract/managers/ModalManager';
+import { PluginManager } from '../abstract/managers/plugin';
+import { SecureUploadsManager } from '../abstract/managers/SecureUploadsManager';
+import { TelemetryManager } from '../abstract/managers/TelemetryManager';
+import { ValidationManager } from '../abstract/managers/ValidationManager';
+import { TypedCollection } from '../abstract/TypedCollection';
+import { UploadEntryData } from '../abstract/uploadEntrySchema';
+import { EventEmitter } from '../blocks/UploadCtxProvider/EventEmitter';
+import { LitBlock } from './LitBlock';
+import { PubSub } from './PubSubCompat';
+import { SharedState } from './SharedState';
+export interface ISharedInstance {
+    destroy?(): void;
+}
+export declare class SharedInstance {
+    protected _ctx: PubSub<SharedState>;
+    protected _sharedInstancesBag: SharedInstancesBag;
+    private _subscriptions;
+    private _cfgProxy;
+    protected _debugPrint: (...args: unknown[]) => void;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    protected addSub(unsub: () => void): void;
+    protected get _cfg(): Readonly<ConfigType>;
+    destroy(): void;
+}
+declare const instanceKeyMap: {
+    modalManager: "*modalManager";
+    pluginManager: "*pluginManager";
+    telemetryManager: "*telemetryManager";
+    localeManager: "*localeManager";
+    a11y: "*a11y";
+    clipboard: "*clipboard";
+    blocksRegistry: "*blocksRegistry";
+    eventEmitter: "*eventEmitter";
+    uploadCollection: "*uploadCollection";
+    secureUploadsManager: "*secureUploadsManager";
+    api: "*publicApi";
+    validationManager: "*validationManager";
+};
+type InstanceTypeMap = {
+    [key in keyof typeof instanceKeyMap]: SharedState[(typeof instanceKeyMap)[key]];
+};
+type InstanceName = keyof typeof instanceKeyMap;
+export type SharedInstancesState = Pick<SharedState, (typeof instanceKeyMap)[keyof typeof instanceKeyMap]>;
+export type SharedInstancesBag = ReturnType<typeof createSharedInstancesBag>;
+export declare const getSharedInstance: <TKey extends keyof SharedInstancesState, TRequired extends boolean = true>(ctx: PubSub<SharedState>, key: TKey, isRequired?: TRequired) => TRequired extends true ? NonNullable<SharedInstancesState[TKey]> : SharedInstancesState[TKey];
+export declare const createSharedInstancesBag: (getCtx: () => PubSub<SharedState>) => {
+    readonly ctx: PubSub<SharedState>;
+    readonly modalManager: ModalManager | null;
+    readonly pluginManager: PluginManager;
+    readonly telemetryManager: TelemetryManager;
+    readonly localeManager: LocaleManager;
+    readonly a11y: A11y;
+    readonly blocksRegistry: Set<LitBlock>;
+    readonly eventEmitter: EventEmitter;
+    readonly uploadCollection: TypedCollection<UploadEntryData>;
+    readonly secureUploadsManager: SecureUploadsManager;
+    readonly api: UploaderPublicApi;
+    readonly validationManager: ValidationManager;
+    when<TName extends InstanceName>(name: TName, callback: (instance: NonNullable<InstanceTypeMap[TName]>) => void): () => void;
+};
+export {};

package/dist/loadFileUploaderFrom-BWJM43Yq.js

@@ -0,0 +1,28 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import { m as defineComponents } from "./plugins-DxjsQUa8.js";
+const UC_WINDOW_KEY = "UC";
+function loadFileUploaderFrom(t, n = !1) {
+	return new Promise((r, i) => {
+		if (typeof document != "object") {
+			r(null);
+			return;
+		}
+		if (typeof window == "object" && window.UC) {
+			r(window.UC);
+			return;
+		}
+		let a = document.createElement("script");
+		a.async = !0, a.src = t, a.onerror = () => {
+			i();
+		}, a.onload = () => {
+			let t = window.UC;
+			n && defineComponents(t), r(t);
+		}, document.head.appendChild(a);
+	});
+}
+export { loadFileUploaderFrom as n, UC_WINDOW_KEY as t };

package/dist/locales/file-uploader/ar.d.ts

@@ -53,7 +53,6 @@ declare const _default: {
     'src-type-local': string;
     'src-type-from-url': string;
     'src-type-camera': string;
-    'src-type-draw': string;
     'src-type-facebook': string;
     'src-type-dropbox': string;
     'src-type-gdrive': string;
@@ -70,7 +69,6 @@ declare const _default: {
     'src-type-mobile-photo-camera': string;
     'caption-from-url': string;
     'caption-camera': string;
-    'caption-draw': string;
     'caption-edit-file': string;
     'file-no-name': string;
     'toggle-fullscreen': string;
@@ -136,5 +134,4 @@ declare const _default: {
     custom: string;
     'freeform-crop': string;
 };
-
-export { _default as default };
+export default _default;