@image-marker/web 0.1.0

package/lib/commonjs/core/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationCanvasMode = exports.ImageFormat = exports.TextBackgroundType = exports.Position = exports.INVISIBLE_WATERMARK_RESIZE_SCALES = exports.INVISIBLE_WATERMARK_MIN_WIDTH = exports.INVISIBLE_WATERMARK_MIN_KEY_BYTES = exports.INVISIBLE_WATERMARK_MIN_HEIGHT = exports.INVISIBLE_WATERMARK_MAX_PAYLOAD_BYTES = exports.INVISIBLE_WATERMARK_ALGORITHM = exports.WatermarkRecipeValidationError = exports.validateWatermarkTemplate = exports.validateWatermarkRecipe = exports.updateWatermarkRecipeLayer = exports.ungroupWatermarkRecipeLayers = exports.serializeWatermarkRecipe = exports.safeValidateWatermarkRecipe = exports.resolveWatermarkTemplate = exports.reorderWatermarkRecipeLayer = exports.removeWatermarkRecipeLayer = exports.recipeValidationPatterns = exports.parseWatermarkRecipe = exports.materializeWatermarkRecipe = exports.groupWatermarkRecipeLayers = exports.duplicateWatermarkRecipeLayer = exports.createWatermarkRecipeDefinition = exports.cloneWatermarkRecipeLayer = exports.cloneWatermarkRecipe = exports.cloneRecipeValue = exports.addWatermarkRecipeLayer = exports.WATERMARK_RECIPE_SCHEMA_VERSION = exports.migrateWatermarkRecipe = exports.ImageMarkerError = exports.parseEncodedImageInfo = void 0;
+const marker_js_1 = __importDefault(require("./marker.js"));
+var image_info_js_1 = require("./image-info.js");
+Object.defineProperty(exports, "parseEncodedImageInfo", { enumerable: true, get: function () { return image_info_js_1.parseEncodedImageInfo; } });
+var job_js_1 = require("./job.js");
+Object.defineProperty(exports, "ImageMarkerError", { enumerable: true, get: function () { return job_js_1.ImageMarkerError; } });
+var recipe_js_1 = require("./recipe.js");
+Object.defineProperty(exports, "migrateWatermarkRecipe", { enumerable: true, get: function () { return recipe_js_1.migrateWatermarkRecipe; } });
+Object.defineProperty(exports, "WATERMARK_RECIPE_SCHEMA_VERSION", { enumerable: true, get: function () { return recipe_js_1.WATERMARK_RECIPE_SCHEMA_VERSION; } });
+var recipe_1 = require("@image-marker/recipe");
+Object.defineProperty(exports, "addWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.addWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "cloneRecipeValue", { enumerable: true, get: function () { return recipe_1.cloneRecipeValue; } });
+Object.defineProperty(exports, "cloneWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.cloneWatermarkRecipe; } });
+Object.defineProperty(exports, "cloneWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.cloneWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "createWatermarkRecipeDefinition", { enumerable: true, get: function () { return recipe_1.createWatermarkRecipeDefinition; } });
+Object.defineProperty(exports, "duplicateWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.duplicateWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "groupWatermarkRecipeLayers", { enumerable: true, get: function () { return recipe_1.groupWatermarkRecipeLayers; } });
+Object.defineProperty(exports, "materializeWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.materializeWatermarkRecipe; } });
+Object.defineProperty(exports, "parseWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.parseWatermarkRecipe; } });
+Object.defineProperty(exports, "recipeValidationPatterns", { enumerable: true, get: function () { return recipe_1.recipeValidationPatterns; } });
+Object.defineProperty(exports, "removeWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.removeWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "reorderWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.reorderWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "resolveWatermarkTemplate", { enumerable: true, get: function () { return recipe_1.resolveWatermarkTemplate; } });
+Object.defineProperty(exports, "safeValidateWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.safeValidateWatermarkRecipe; } });
+Object.defineProperty(exports, "serializeWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.serializeWatermarkRecipe; } });
+Object.defineProperty(exports, "ungroupWatermarkRecipeLayers", { enumerable: true, get: function () { return recipe_1.ungroupWatermarkRecipeLayers; } });
+Object.defineProperty(exports, "updateWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.updateWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "validateWatermarkRecipe", { enumerable: true, get: function () { return recipe_1.validateWatermarkRecipe; } });
+Object.defineProperty(exports, "validateWatermarkTemplate", { enumerable: true, get: function () { return recipe_1.validateWatermarkTemplate; } });
+Object.defineProperty(exports, "WatermarkRecipeValidationError", { enumerable: true, get: function () { return recipe_1.WatermarkRecipeValidationError; } });
+var invisible_watermark_js_1 = require("./invisible-watermark.js");
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_ALGORITHM", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_ALGORITHM; } });
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_MAX_PAYLOAD_BYTES", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_MAX_PAYLOAD_BYTES; } });
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_MIN_HEIGHT", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_MIN_HEIGHT; } });
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_MIN_KEY_BYTES", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_MIN_KEY_BYTES; } });
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_MIN_WIDTH", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_MIN_WIDTH; } });
+Object.defineProperty(exports, "INVISIBLE_WATERMARK_RESIZE_SCALES", { enumerable: true, get: function () { return invisible_watermark_js_1.INVISIBLE_WATERMARK_RESIZE_SCALES; } });
+/**
+ * Position enum for text watermark and image watermark
+ * @enum
+ */
+var Position;
+(function (Position) {
+    Position["topLeft"] = "topLeft";
+    Position["topCenter"] = "topCenter";
+    Position["topRight"] = "topRight";
+    Position["bottomLeft"] = "bottomLeft";
+    Position["bottomCenter"] = "bottomCenter";
+    Position["bottomRight"] = "bottomRight";
+    Position["center"] = "center";
+})(Position || (exports.Position = Position = {}));
+/**
+ * TextBackgroundType enum for text watermark
+ * @enum
+ */
+var TextBackgroundType;
+(function (TextBackgroundType) {
+    TextBackgroundType["stretchX"] = "stretchX";
+    TextBackgroundType["stretchY"] = "stretchY";
+    TextBackgroundType["none"] = "fit";
+})(TextBackgroundType || (exports.TextBackgroundType = TextBackgroundType = {}));
+/**
+ * ImageFormat enum for save image format
+ * @enum
+ */
+var ImageFormat;
+(function (ImageFormat) {
+    ImageFormat["png"] = "png";
+    ImageFormat["jpg"] = "jpg";
+    /** WebP output on Android and compatible browsers. iOS rejects it explicitly. */
+    ImageFormat["webp"] = "webp";
+    // base64 string
+    ImageFormat["base64"] = "base64";
+})(ImageFormat || (exports.ImageFormat = ImageFormat = {}));
+/**
+ * Controls the output canvas after the composed image is rotated.
+ *
+ * `expand` preserves the entire rotated image by growing the output canvas.
+ * `crop` keeps the original canvas dimensions and clips content outside it.
+ * @enum
+ */
+var RotationCanvasMode;
+(function (RotationCanvasMode) {
+    RotationCanvasMode["expand"] = "expand";
+    RotationCanvasMode["crop"] = "crop";
+})(RotationCanvasMode || (exports.RotationCanvasMode = RotationCanvasMode = {}));
+exports.default = marker_js_1.default;

package/lib/commonjs/core/invisible-watermark.d.ts

@@ -0,0 +1,102 @@
+import type { ImageFormat } from './index.js';
+export declare const INVISIBLE_WATERMARK_ALGORITHM: "dct-qim-v1";
+export declare const INVISIBLE_WATERMARK_MAX_PAYLOAD_BYTES = 12;
+export declare const INVISIBLE_WATERMARK_MIN_KEY_BYTES = 16;
+export declare const INVISIBLE_WATERMARK_MIN_WIDTH = 128;
+export declare const INVISIBLE_WATERMARK_MIN_HEIGHT = 88;
+export declare const INVISIBLE_WATERMARK_RESIZE_SCALES: readonly [0.95, 1.05, 0.9, 1.1];
+/** Pixel-change strength used by the DCT-QIM invisible watermark. */
+export type InvisibleWatermarkStrength = 'subtle' | 'balanced' | 'robust';
+/** Detection search cost. Robust search also checks light resizing, shifted block grids, and tile phases. */
+export type InvisibleWatermarkSearch = 'fast' | 'robust';
+/** Source image accepted by the invisible watermark APIs. */
+export interface InvisibleWatermarkImage {
+    /** Native image asset, URI object, URL/data URL, Blob, File, or loaded browser image. */
+    src: any;
+}
+export type InvisibleWatermarkWorkerProgressPhase = 'queued' | 'detecting' | 'complete';
+/** Browser-only dedicated Worker settings for CPU-intensive detection. */
+export interface InvisibleWatermarkWorkerOptions {
+    /** Trusted same-origin URL of the packaged invisible watermark worker. */
+    scriptUrl: string;
+    /** Cancels the current detection and terminates its one-time Worker. */
+    signal?: AbortSignal;
+    /** Coarse lifecycle updates. Exceptions thrown here are ignored. */
+    onProgress?: (progress: {
+        phase: InvisibleWatermarkWorkerProgressPhase;
+    }) => void;
+}
+/** Options for writing an authenticated short locator into image pixels. */
+export interface EmbedInvisibleWatermarkOptions {
+    /** Source image. It must be at least 128×88 pixels after `maxSize` is applied. */
+    image: InvisibleWatermarkImage;
+    /** Locator containing 1–12 UTF-8 bytes. Do not store personal data directly. */
+    payload: string;
+    /** Secret containing at least 16 UTF-8 bytes. Do not bundle a production master key. */
+    key: string;
+    /** Pixel-change strength. Use the same value during detection. @defaultValue `balanced` */
+    strength?: InvisibleWatermarkStrength;
+    /** JPEG encoder quality from 0–100. */
+    quality?: number;
+    /** Safe output basename on iOS and Android. */
+    filename?: string;
+    /** Output encoding. Web returns a data URL; native returns a cache path. */
+    saveFormat?: ImageFormat;
+    /** Maximum decoded width or height. @defaultValue 2048 */
+    maxSize?: number;
+}
+/** Options for recovering and authenticating an invisible trace locator. */
+export interface DetectInvisibleWatermarkOptions {
+    /** Image that may contain an invisible trace watermark. */
+    image: InvisibleWatermarkImage;
+    /** The same secret that was used to embed the locator. */
+    key: string;
+    /** The same pixel-change strength used during embedding. @defaultValue `balanced` */
+    strength?: InvisibleWatermarkStrength;
+    /** Use `robust` for 0.9×–1.1× resize and limited crop recovery at a higher CPU cost. @defaultValue `fast` */
+    search?: InvisibleWatermarkSearch;
+    /** Maximum decoded width or height. Keep this consistent with embedding. @defaultValue 2048 */
+    maxSize?: number;
+    /** Run pixel detection in a dedicated browser Worker. Ignored on native. */
+    worker?: InvisibleWatermarkWorkerOptions;
+}
+/** Authenticated detector payload before a public Core job envelope is added. */
+export interface InvisibleWatermarkDetectionData {
+    /** Whether the frame passed magic, CRC, and authentication checks. */
+    detected: boolean;
+    /** Recovered locator, present only when `detected` is true. */
+    payload?: string;
+    /** Normalized detector confidence from 0–1. */
+    confidence: number;
+    /** Disagreement between decoded frame bits and individual block votes. */
+    bitErrorRate?: number;
+    /** Versioned pixel algorithm identifier. */
+    algorithm: typeof INVISIBLE_WATERMARK_ALGORITHM;
+    /** Estimated input scale when robust resize recovery was required. */
+    scale?: number;
+}
+/** Structured public detection result. A positive result does not prove the image was unmodified. */
+export interface InvisibleWatermarkDetectionResult extends InvisibleWatermarkDetectionData {
+    jobId: string;
+    operation: 'detectInvisible';
+    durationMs: number;
+}
+export interface InvisibleWatermarkPixelBuffer {
+    data: Uint8Array | Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+/** Small dependency-free SHA-256 used to keep Web frame vectors deterministic. */
+export declare function sha256(input: Uint8Array): Uint8Array;
+export declare function hmacSha256(key: Uint8Array, message: Uint8Array): Uint8Array;
+export declare function encodeUtf8(value: string): Uint8Array;
+export declare function decodeUtf8(bytes: Uint8Array): string;
+export declare function crc16Ccitt(bytes: Uint8Array): number;
+export declare function buildInvisibleWatermarkFrame(payload: string, key: string): Uint8Array;
+export declare function createInvisibleWatermarkPermutation(key: string): Uint16Array;
+export declare function validateEmbedInvisibleOptions(options: EmbedInvisibleWatermarkOptions): void;
+export declare function validateDetectInvisibleOptions(options: DetectInvisibleWatermarkOptions): void;
+export declare function embedInvisibleWatermarkPixels(buffer: InvisibleWatermarkPixelBuffer, options: Pick<EmbedInvisibleWatermarkOptions, 'payload' | 'key' | 'strength'>): void;
+export declare function resizeInvisibleWatermarkPixels(buffer: InvisibleWatermarkPixelBuffer, width: number, height: number): InvisibleWatermarkPixelBuffer;
+export declare function detectInvisibleWatermarkPixels(buffer: InvisibleWatermarkPixelBuffer, options: Pick<DetectInvisibleWatermarkOptions, 'key' | 'strength' | 'search'>): InvisibleWatermarkDetectionData;
+export declare function detectInvisibleWatermarkPixelsAsync(buffer: InvisibleWatermarkPixelBuffer, options: Pick<DetectInvisibleWatermarkOptions, 'key' | 'strength' | 'search'>): Promise<InvisibleWatermarkDetectionData>;