@image-marker/web 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 (2026-08-31)
+
+- Added the standalone `@image-marker/web` package for browser rendering with
+  File, Blob, URL, data URL, and loaded image inputs.
+- Added public `headless` and `editor-adapter` entries for custom editor UIs
+  without React Native dependencies.
+- Added a packaged invisible-watermark Worker resource and Vite `?url` usage.
+- Documented cooperative cancellation, host-owned termination, URL/CORS policy,
+  local file handling, and optional C2PA integration boundaries.

package/README.md

@@ -0,0 +1,100 @@
+# `@image-marker/web`
+
+Standalone browser SDK for Image Marker. It runs with Canvas 2D and Web APIs and
+does not install React Native, a Node sidecar, or native modules.
+
+```sh
+npm install @image-marker/web@0.1.0
+```
+
+## Quick start
+
+```ts
+import Marker, { ImageFormat, Position } from '@image-marker/web';
+
+const result = await Marker.markText({
+  backgroundImage: { src: file }, // File, Blob, data URL, URL, or loaded image
+  watermarkTexts: [
+    {
+      text: '© Acme',
+      position: { position: Position.bottomRight, X: 24, Y: 24 },
+      style: { color: '#FFFFFF', fontSize: 28 },
+    },
+  ],
+  saveFormat: ImageFormat.png,
+});
+
+preview.src = result.uri;
+```
+
+The root entry exports the Web `Marker`, the existing public enums and types,
+Recipe v2 helpers, visible watermark methods, and invisible watermark
+embed/detect methods. Web results expose a data URL in `result.uri`.
+
+## Public subpaths
+
+- `@image-marker/web/headless` exports `ImageMarkerEditorController`, geometry,
+  projection, presets, and editor types without React or React Native UI.
+- `@image-marker/web/editor-adapter` exports `createWebEditorAdapter` and
+  `resolveWebEditorSourceInfo`. The adapter connects a headless Recipe to Canvas
+  preview and original export.
+- `@image-marker/web/worker` and
+  `@image-marker/web/worker/invisible-watermark.js` resolve to the packaged
+  invisible-watermark Worker. Vite can resolve it with
+  `import workerUrl from '@image-marker/web/worker?url'`.
+
+```ts
+import { ImageMarkerEditorController } from '@image-marker/web/headless';
+import { createWebEditorAdapter } from '@image-marker/web/editor-adapter';
+
+const controller = new ImageMarkerEditorController({
+  document: { schemaVersion: 2, layers, output: { saveFormat: 'png' } },
+});
+const adapter = createWebEditorAdapter(1024);
+const preview = await adapter.renderPreview({
+  recipe: controller.exportRecipe(),
+  input: { backgroundImage: { src: file } },
+});
+```
+
+## Cancellation and ownership
+
+Pass an `AbortSignal` to Recipe jobs or Worker detection. Abort stops queued and
+cooperative work; synchronous Canvas work already in progress may only be
+discarded when it returns. A host that needs immediate CPU termination must stop
+the Worker or task it owns. Promise timeouts and ignoring late values do not stop
+work. Revoke object URLs and dispose controllers/listeners when their UI or task
+ends.
+
+For a Tauri or other isolated host, use `createWebMarker(options?)` to inject
+`resources` (`createImage`, `createCanvas`, object-URL cleanup, and byte reads)
+and an `execution` adapter. `execution.start()` returns the real task promise
+plus optional `terminate`/`cancel` and `dispose` hooks. `marker.cancel()` and
+`marker.dispose()` wait for the host acknowledgement; a timeout or ignored
+late value is not termination. Inspect `marker.capabilities` to distinguish
+cooperative Worker detection from default DOM work that requires host
+termination.
+
+Create Recipes from that instance when its cancellation boundary should include
+the Recipe task:
+
+```ts
+import { createWebMarker } from '@image-marker/web';
+
+const marker = createWebMarker();
+const recipe = marker.createRecipe(recipeDocument, { resultType: 'blob' });
+const pending = recipe.apply(input, { signal: abortController.signal });
+const completion = pending.catch(() => undefined);
+abortController.abort();
+await marker.cancel();
+await completion;
+await marker.dispose();
+```
+
+The packaged Worker handles invisible watermark detection only. It is not a
+general Canvas image engine. Remote URLs remain supported when the remote server
+allows CORS; local `File` and `Blob` inputs are recommended for desktop apps.
+C2PA is an optional integration boundary and is not installed by this package.
+
+See the [Web SDK guide](../../docs/web-sdk.md) and the runnable
+[Vite example](../../examples/web-sdk/).

package/api-contract.json

@@ -0,0 +1,224 @@
+{
+  "packageExports": [
+    ".",
+    "./headless",
+    "./editor-adapter",
+    "./worker",
+    "./worker/invisible-watermark.js",
+    "./package.json"
+  ],
+  "dependencies": {
+    "@image-marker/recipe": "^0.1.0"
+  },
+  "peerDependencies": {},
+  "entries": {
+    ".": {
+      "values": [
+        "INVISIBLE_WATERMARK_ALGORITHM",
+        "INVISIBLE_WATERMARK_MAX_PAYLOAD_BYTES",
+        "INVISIBLE_WATERMARK_MIN_HEIGHT",
+        "INVISIBLE_WATERMARK_MIN_KEY_BYTES",
+        "INVISIBLE_WATERMARK_MIN_WIDTH",
+        "INVISIBLE_WATERMARK_RESIZE_SCALES",
+        "ImageFormat",
+        "ImageMarkerError",
+        "Marker",
+        "Position",
+        "RotationCanvasMode",
+        "TextBackgroundType",
+        "WATERMARK_RECIPE_SCHEMA_VERSION",
+        "WatermarkRecipeValidationError",
+        "WebMarker",
+        "addWatermarkRecipeLayer",
+        "cloneRecipeValue",
+        "cloneWatermarkRecipe",
+        "cloneWatermarkRecipeLayer",
+        "createWatermarkRecipeDefinition",
+        "createWebMarker",
+        "default",
+        "duplicateWatermarkRecipeLayer",
+        "groupWatermarkRecipeLayers",
+        "materializeWatermarkRecipe",
+        "migrateWatermarkRecipe",
+        "parseEncodedImageInfo",
+        "parseWatermarkRecipe",
+        "recipeValidationPatterns",
+        "removeWatermarkRecipeLayer",
+        "reorderWatermarkRecipeLayer",
+        "resolveWatermarkTemplate",
+        "safeValidateWatermarkRecipe",
+        "serializeWatermarkRecipe",
+        "ungroupWatermarkRecipeLayers",
+        "updateWatermarkRecipeLayer",
+        "validateWatermarkRecipe",
+        "validateWatermarkTemplate"
+      ],
+      "types": [
+        "BlendMode",
+        "ContentCredentialsAdapter",
+        "ContentCredentialsClaim",
+        "ContentCredentialsSignRequest",
+        "ContentCredentialsSignResult",
+        "ContentCredentialsVerificationResult",
+        "CornerRadius",
+        "DetectInvisibleWatermarkOptions",
+        "EmbedInvisibleWatermarkOptions",
+        "EmbedInvisibleWithCredentialsOptions",
+        "EmbedInvisibleWithCredentialsResult",
+        "ImageMarkOptions",
+        "ImageMarkerErrorCode",
+        "ImageOptions",
+        "ImageOrientation",
+        "ImageWatermarkLayer",
+        "InvisibleWatermarkCodec",
+        "InvisibleWatermarkDecodedImage",
+        "InvisibleWatermarkDetectionData",
+        "InvisibleWatermarkDetectionResult",
+        "InvisibleWatermarkImage",
+        "InvisibleWatermarkRuntime",
+        "InvisibleWatermarkRuntimeOptions",
+        "InvisibleWatermarkSearch",
+        "InvisibleWatermarkStrength",
+        "InvisibleWatermarkWorkerOptions",
+        "InvisibleWatermarkWorkerProgressPhase",
+        "LegacyWatermarkRecipeDefinition",
+        "MarkOptions",
+        "MarkerImageFormat",
+        "MarkerImageInfo",
+        "MarkerJobOptions",
+        "MarkerJobPhase",
+        "MarkerJobProgress",
+        "MarkerMetadataResult",
+        "MarkerOperation",
+        "MarkerOutputFormat",
+        "MarkerResult",
+        "MarkerResultDescriptor",
+        "PositionOptions",
+        "RadiusValue",
+        "RuntimeDetectInvisibleWatermarkOptions",
+        "RuntimeEmbedInvisibleWatermarkOptions",
+        "ShadowLayerStyle",
+        "TextBackgroundStyle",
+        "TextMarkOptions",
+        "TextOptions",
+        "TextStrokeStyle",
+        "TextStyle",
+        "TextWatermarkLayer",
+        "VerifyContentCredentialsOptions",
+        "WatermarkBatchAbortedResult",
+        "WatermarkBatchFulfilledResult",
+        "WatermarkBatchOptions",
+        "WatermarkBatchProgress",
+        "WatermarkBatchRejectedResult",
+        "WatermarkBatchResult",
+        "WatermarkBlobRecipeResultOptions",
+        "WatermarkImageOptions",
+        "WatermarkLayer",
+        "WatermarkLayout",
+        "WatermarkMarkerResultRecipeOptions",
+        "WatermarkRecipe",
+        "WatermarkRecipeCondition",
+        "WatermarkRecipeDefinition",
+        "WatermarkRecipeDefinitionLayer",
+        "WatermarkRecipeDocument",
+        "WatermarkRecipeInput",
+        "WatermarkRecipeLayer",
+        "WatermarkRecipeOptions",
+        "WatermarkRecipeOutputOptions",
+        "WatermarkRecipeResultOptions",
+        "WatermarkRecipeSchemaVersion",
+        "WatermarkRecipeValidationFailure",
+        "WatermarkRecipeValidationResult",
+        "WatermarkRecipeValidationSuccess",
+        "WatermarkRecipeVariable",
+        "WatermarkRecipeVariableContext",
+        "WatermarkTextDirection",
+        "WatermarkTextOverflow",
+        "WatermarkTextWrap",
+        "WebMarkerCancellationMode",
+        "WebMarkerCapabilities",
+        "WebMarkerExecutionAdapter",
+        "WebMarkerExecutionOperation",
+        "WebMarkerExecutionRequest",
+        "WebMarkerExecutionResultKind",
+        "WebMarkerExecutionTask",
+        "WebMarkerExecutionTermination",
+        "WebMarkerInstance",
+        "WebMarkerRuntimeOptions",
+        "WebResourceAdapter"
+      ]
+    },
+    "./headless": {
+      "values": [
+        "ImageMarkerEditorController",
+        "addWatermarkRecipeLayer",
+        "angle",
+        "createBrandLogoLayer",
+        "createBrandTextLayer",
+        "createEditorBrandKit",
+        "createEditorTemplate",
+        "createEditorViewportProjection",
+        "distance",
+        "duplicateWatermarkRecipeLayer",
+        "fitEditorSizeWithinMax",
+        "groupWatermarkRecipeLayers",
+        "materializeEditorTemplate",
+        "normalizeSafeArea",
+        "projectEditorPoint",
+        "projectEditorRecipe",
+        "removeWatermarkRecipeLayer",
+        "reorderWatermarkRecipeLayer",
+        "snapLayerPosition",
+        "ungroupWatermarkRecipeLayers",
+        "unprojectEditorPoint",
+        "updateWatermarkRecipeLayer"
+      ],
+      "types": [
+        "EditorAlignment",
+        "EditorAsset",
+        "EditorAutosaveOptions",
+        "EditorBrandKit",
+        "EditorClipboardDocument",
+        "EditorContentCredentialsExport",
+        "EditorDistribution",
+        "EditorExportOptions",
+        "EditorExportResult",
+        "EditorInvisibleExport",
+        "EditorKeyCommand",
+        "EditorLayerBounds",
+        "EditorPoint",
+        "EditorRect",
+        "EditorRenderRequest",
+        "EditorSafeArea",
+        "EditorSelectionMode",
+        "EditorSerializedState",
+        "EditorSize",
+        "EditorSnapContext",
+        "EditorSnapGuide",
+        "EditorState",
+        "EditorTemplate",
+        "EditorTextLayerPatch",
+        "EditorViewportProjection",
+        "EditorViewportState",
+        "ImageMarkerEditorControllerOptions",
+        "ImageMarkerEditorRenderAdapter",
+        "MarkerImageInfo",
+        "WatermarkBlendMode",
+        "WatermarkRecipeDefinition",
+        "WatermarkRecipeDefinitionLayer",
+        "WatermarkRecipeDocument",
+        "WatermarkRecipeInput",
+        "WatermarkTextStyle"
+      ]
+    },
+    "./editor-adapter": {
+      "values": [
+        "createWebEditorAdapter",
+        "resolveWebEditorSourceInfo"
+      ],
+      "types": [
+        "EditorMarkerEngine"
+      ]
+    }
+  }
+}

package/lib/commonjs/core/batch.d.ts

@@ -0,0 +1,32 @@
+export interface WatermarkBatchFulfilledResult<Result> {
+    status: 'fulfilled';
+    value: Result;
+}
+export interface WatermarkBatchRejectedResult {
+    status: 'rejected';
+    reason: unknown;
+}
+export interface WatermarkBatchAbortedResult {
+    status: 'aborted';
+    reason: Error;
+}
+export type WatermarkBatchResult<Result> = WatermarkBatchFulfilledResult<Result> | WatermarkBatchRejectedResult | WatermarkBatchAbortedResult;
+export interface WatermarkBatchProgress<Result> {
+    total: number;
+    settled: number;
+    succeeded: number;
+    failed: number;
+    aborted: number;
+    /** Index of the item that produced this progress update. */
+    index: number;
+    result: WatermarkBatchResult<Result>;
+}
+export interface WatermarkBatchOptions<Result> {
+    /** Requested worker count. Web is capped at 4 and native targets at 1. */
+    concurrency?: number;
+    /** Stops new items from starting. Already-running items are allowed to finish. */
+    signal?: AbortSignal;
+    /** Called once when each item is fulfilled, rejected, or skipped after abort. */
+    onProgress?: (progress: WatermarkBatchProgress<Result>) => void;
+}
+export declare function runWatermarkBatch<Input, Result>(inputs: readonly Input[], task: (input: Input, index: number) => Promise<Result>, batchOptions?: WatermarkBatchOptions<Result>, maximumConcurrency?: number, inputLabel?: string): Promise<Array<WatermarkBatchResult<Result>>>;

package/lib/commonjs/core/batch.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWatermarkBatch = runWatermarkBatch;
+function abortResult() {
+    const reason = new Error('Batch item was not started because the operation was aborted.');
+    reason.name = 'AbortError';
+    return { status: 'aborted', reason };
+}
+async function runWatermarkBatch(inputs, task, batchOptions = {}, maximumConcurrency = 1, inputLabel = 'batch') {
+    if (!Array.isArray(inputs)) {
+        throw new Error(`${inputLabel} inputs must be an array.`);
+    }
+    const requestedConcurrency = batchOptions.concurrency ?? 1;
+    if (!Number.isFinite(requestedConcurrency) ||
+        !Number.isInteger(requestedConcurrency) ||
+        requestedConcurrency <= 0) {
+        throw new Error('concurrency must be a positive finite integer.');
+    }
+    if (inputs.length === 0) {
+        return [];
+    }
+    const concurrency = Math.min(requestedConcurrency, maximumConcurrency, inputs.length);
+    const results = new Array(inputs.length);
+    let cursor = 0;
+    let settled = 0;
+    let succeeded = 0;
+    let failed = 0;
+    let aborted = 0;
+    const report = (index, result) => {
+        settled += 1;
+        if (result.status === 'fulfilled')
+            succeeded += 1;
+        else if (result.status === 'rejected')
+            failed += 1;
+        else
+            aborted += 1;
+        try {
+            batchOptions.onProgress?.({
+                total: inputs.length,
+                settled,
+                succeeded,
+                failed,
+                aborted,
+                index,
+                result,
+            });
+        }
+        catch {
+            // Progress observers must not interrupt the batch or change results.
+        }
+    };
+    const worker = async () => {
+        while (!batchOptions.signal?.aborted) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= inputs.length) {
+                return;
+            }
+            if (batchOptions.signal?.aborted) {
+                return;
+            }
+            let result;
+            try {
+                result = {
+                    status: 'fulfilled',
+                    value: await task(inputs[index], index),
+                };
+            }
+            catch (reason) {
+                result = { status: 'rejected', reason };
+            }
+            results[index] = result;
+            report(index, result);
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, worker));
+    for (let index = 0; index < inputs.length; index += 1) {
+        if (!results[index]) {
+            const result = abortResult();
+            results[index] = result;
+            report(index, result);
+        }
+    }
+    return results;
+}

package/lib/commonjs/core/content-credentials.d.ts

@@ -0,0 +1,53 @@
+import type { EmbedInvisibleWatermarkOptions } from './invisible-watermark.js';
+import { INVISIBLE_WATERMARK_ALGORITHM } from './invisible-watermark.js';
+import type { MarkerResult } from './result.js';
+export interface ContentCredentialsClaim {
+    /** Human-readable asset title included in the signed manifest. */
+    title: string;
+    /** Encoded image type. WebP is supported when the selected adapter accepts it. */
+    format?: 'image/jpeg' | 'image/png' | 'image/webp';
+    /** Claim generator name shown by Content Credentials readers. */
+    generator?: string;
+    /** Adapter-specific public metadata. Never include signing secrets. */
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ContentCredentialsSignRequest {
+    /** Image already containing the invisible locator. */
+    image: string;
+    /** Locator used to correlate the signed record. */
+    locator: string;
+    /** Pixel algorithm that wrote the locator. */
+    algorithm: typeof INVISIBLE_WATERMARK_ALGORITHM;
+    claim: ContentCredentialsClaim;
+}
+export interface ContentCredentialsSignResult {
+    /** Image containing the signed Content Credential. */
+    image: string;
+    manifestId?: string;
+}
+export interface ContentCredentialsVerificationResult {
+    valid: boolean;
+    manifestId?: string;
+    validationStatus?: readonly string[];
+    manifest?: unknown;
+}
+export interface ContentCredentialsAdapter {
+    sign(request: ContentCredentialsSignRequest): Promise<ContentCredentialsSignResult>;
+    verify(image: string): Promise<ContentCredentialsVerificationResult>;
+}
+export interface EmbedInvisibleWithCredentialsOptions {
+    watermark: EmbedInvisibleWatermarkOptions;
+    adapter: ContentCredentialsAdapter;
+    claim: ContentCredentialsClaim;
+}
+export interface EmbedInvisibleWithCredentialsResult {
+    watermarkedImage: MarkerResult;
+    signedImage: string;
+    manifestId?: string;
+}
+export interface VerifyContentCredentialsOptions {
+    image: string;
+    adapter: ContentCredentialsAdapter;
+}
+export declare function embedInvisibleWithCredentials(embed: (options: EmbedInvisibleWatermarkOptions) => Promise<MarkerResult>, options: EmbedInvisibleWithCredentialsOptions): Promise<EmbedInvisibleWithCredentialsResult>;
+export declare function verifyContentCredentials(options: VerifyContentCredentialsOptions): Promise<ContentCredentialsVerificationResult>;

package/lib/commonjs/core/content-credentials.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embedInvisibleWithCredentials = embedInvisibleWithCredentials;
+exports.verifyContentCredentials = verifyContentCredentials;
+const invisible_watermark_js_1 = require("./invisible-watermark.js");
+function validateAdapter(adapter) {
+    if (!adapter ||
+        typeof adapter.sign !== 'function' ||
+        typeof adapter.verify !== 'function') {
+        throw new Error('Content Credentials adapter must provide sign() and verify() functions.');
+    }
+    return adapter;
+}
+function snapshotClaim(claim) {
+    if (!claim || typeof claim.title !== 'string' || !claim.title.trim()) {
+        throw new Error('Content Credentials claim title must not be empty.');
+    }
+    if (claim.format !== undefined &&
+        claim.format !== 'image/jpeg' &&
+        claim.format !== 'image/png' &&
+        claim.format !== 'image/webp') {
+        throw new Error('Content Credentials claim format must be image/jpeg, image/png, or image/webp.');
+    }
+    if (claim.generator !== undefined &&
+        (typeof claim.generator !== 'string' || !claim.generator.trim())) {
+        throw new Error('Content Credentials claim generator must be a non-empty string.');
+    }
+    if (claim.metadata !== undefined &&
+        (!claim.metadata ||
+            typeof claim.metadata !== 'object' ||
+            Array.isArray(claim.metadata))) {
+        throw new Error('Content Credentials claim metadata must be an object.');
+    }
+    return {
+        title: claim.title.trim(),
+        format: claim.format,
+        generator: claim.generator?.trim(),
+        metadata: claim.metadata ? { ...claim.metadata } : undefined,
+    };
+}
+function validateSignResult(result) {
+    if (!result || typeof result.image !== 'string' || !result.image) {
+        throw new Error('Content Credentials adapter returned an invalid signed image.');
+    }
+    if (result.manifestId !== undefined &&
+        typeof result.manifestId !== 'string') {
+        throw new Error('Content Credentials adapter returned an invalid manifest ID.');
+    }
+    return result;
+}
+function validateVerificationResult(result) {
+    if (!result || typeof result.valid !== 'boolean') {
+        throw new Error('Content Credentials adapter returned an invalid verification result.');
+    }
+    if (result.manifestId !== undefined &&
+        typeof result.manifestId !== 'string') {
+        throw new Error('Content Credentials adapter returned an invalid manifest ID.');
+    }
+    if (result.validationStatus !== undefined &&
+        (!Array.isArray(result.validationStatus) ||
+            result.validationStatus.some((status) => typeof status !== 'string'))) {
+        throw new Error('Content Credentials adapter returned invalid validation status data.');
+    }
+    return result;
+}
+async function embedInvisibleWithCredentials(embed, options) {
+    const adapter = validateAdapter(options?.adapter);
+    const claim = snapshotClaim(options?.claim);
+    const watermark = {
+        ...options.watermark,
+        image: { ...options.watermark?.image },
+    };
+    const locator = watermark.payload;
+    const watermarkedImage = await embed(watermark);
+    const signed = validateSignResult(await adapter.sign({
+        image: watermarkedImage.uri,
+        locator,
+        algorithm: invisible_watermark_js_1.INVISIBLE_WATERMARK_ALGORITHM,
+        claim,
+    }));
+    const result = {
+        watermarkedImage,
+        signedImage: signed.image,
+    };
+    if (signed.manifestId !== undefined) {
+        result.manifestId = signed.manifestId;
+    }
+    return result;
+}
+async function verifyContentCredentials(options) {
+    const adapter = validateAdapter(options?.adapter);
+    if (typeof options?.image !== 'string' || !options.image) {
+        throw new Error('Content Credentials image must not be empty.');
+    }
+    return validateVerificationResult(await adapter.verify(options.image));
+}

package/lib/commonjs/core/image-info.d.ts

@@ -0,0 +1,30 @@
+export type ImageOrientation = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export type MarkerImageFormat = 'jpeg' | 'png' | 'webp' | 'gif' | 'heif' | 'bmp' | 'unknown';
+export interface MarkerImageInfo {
+    /** Display width after applying the encoded orientation. */
+    width: number;
+    /** Display height after applying the encoded orientation. */
+    height: number;
+    /** Width stored in the encoded pixel data before orientation is applied. */
+    encodedWidth: number;
+    /** Height stored in the encoded pixel data before orientation is applied. */
+    encodedHeight: number;
+    format: MarkerImageFormat;
+    mimeType?: string;
+    orientation: ImageOrientation;
+    rotationDegrees: 0 | 90 | 180 | 270;
+    mirrored: boolean;
+    requiresNormalization: boolean;
+}
+interface EncodedImageMetadata {
+    width: number;
+    height: number;
+    format: MarkerImageFormat;
+    mimeType?: string;
+    orientation?: ImageOrientation;
+}
+export declare function createMarkerImageInfo(metadata: EncodedImageMetadata): MarkerImageInfo;
+/** Parse encoded metadata without decoding the image pixels. */
+export declare function parseEncodedImageInfo(input: ArrayBuffer | ArrayBufferView): MarkerImageInfo;
+export declare function parseNativeImageInfo(serialized: string): MarkerImageInfo;
+export {};