cross-image 0.4.0 → 0.4.2

package/script/src/utils/base64.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Base64 utilities.
+ *
+ * Designed to work across Deno, Node.js, and Bun without external dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.toDataUrl = toDataUrl;
+exports.parseDataUrl = parseDataUrl;
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DECODE_TABLE = (() => {
+    const table = new Uint8Array(256);
+    table.fill(0xff);
+    for (let i = 0; i < BASE64_ALPHABET.length; i++) {
+        table[BASE64_ALPHABET.charCodeAt(i)] = i;
+    }
+    return table;
+})();
+function stripWhitespace(input) {
+    // Avoid regex to keep this fast and allocation-light.
+    let out = "";
+    for (let i = 0; i < input.length; i++) {
+        const code = input.charCodeAt(i);
+        // Space, tab, CR, LF
+        if (code === 0x20 || code === 0x09 || code === 0x0d || code === 0x0a)
+            continue;
+        out += input[i];
+    }
+    return out;
+}
+function normalizeBase64(input) {
+    // Accept URL-safe alphabet in decode paths.
+    let s = stripWhitespace(input.trim());
+    if (s.length === 0)
+        return s;
+    // Map base64url to base64.
+    if (s.includes("-") || s.includes("_")) {
+        s = s.replaceAll("-", "+").replaceAll("_", "/");
+    }
+    const remainder = s.length % 4;
+    if (remainder === 1) {
+        throw new Error("Invalid base64: length must not be 1 (mod 4)");
+    }
+    if (remainder === 2)
+        s += "==";
+    if (remainder === 3)
+        s += "=";
+    return s;
+}
+/**
+ * Encode bytes into a standard Base64 string.
+ */
+function encodeBase64(bytes) {
+    if (bytes.length === 0)
+        return "";
+    const outLen = Math.ceil(bytes.length / 3) * 4;
+    const out = new Array(outLen);
+    let i = 0;
+    let o = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        out[o++] = BASE64_ALPHABET[(n >> 18) & 63];
+        out[o++] = BASE64_ALPHABET[(n >> 12) & 63];
+        out[o++] = BASE64_ALPHABET[(n >> 6) & 63];
+        out[o++] = BASE64_ALPHABET[n & 63];
+    }
+    const remaining = bytes.length - i;
+    if (remaining === 1) {
+        const n = bytes[i] << 16;
+        out[o++] = BASE64_ALPHABET[(n >> 18) & 63];
+        out[o++] = BASE64_ALPHABET[(n >> 12) & 63];
+        out[o++] = "=";
+        out[o++] = "=";
+    }
+    else if (remaining === 2) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        out[o++] = BASE64_ALPHABET[(n >> 18) & 63];
+        out[o++] = BASE64_ALPHABET[(n >> 12) & 63];
+        out[o++] = BASE64_ALPHABET[(n >> 6) & 63];
+        out[o++] = "=";
+    }
+    return out.join("");
+}
+/**
+ * Decode a Base64 (or Base64URL) string into bytes.
+ *
+ * - Whitespace is ignored.
+ * - Missing padding is tolerated.
+ * - `-`/`_` are accepted as URL-safe variants.
+ */
+function decodeBase64(base64) {
+    const s = normalizeBase64(base64);
+    if (s.length === 0)
+        return new Uint8Array(0);
+    let padding = 0;
+    if (s.endsWith("=="))
+        padding = 2;
+    else if (s.endsWith("="))
+        padding = 1;
+    const quadCount = s.length / 4;
+    const outLen = quadCount * 3 - padding;
+    const out = new Uint8Array(outLen);
+    let o = 0;
+    for (let i = 0; i < s.length; i += 4) {
+        const c0 = s.charCodeAt(i);
+        const c1 = s.charCodeAt(i + 1);
+        const c2 = s.charCodeAt(i + 2);
+        const c3 = s.charCodeAt(i + 3);
+        const v0 = DECODE_TABLE[c0];
+        const v1 = DECODE_TABLE[c1];
+        if (v0 === 0xff || v1 === 0xff) {
+            throw new Error("Invalid base64: invalid character");
+        }
+        const isPad2 = c2 === 0x3d; // '='
+        const isPad3 = c3 === 0x3d;
+        const v2 = isPad2 ? 0 : DECODE_TABLE[c2];
+        const v3 = isPad3 ? 0 : DECODE_TABLE[c3];
+        if ((!isPad2 && v2 === 0xff) || (!isPad3 && v3 === 0xff)) {
+            throw new Error("Invalid base64: invalid character");
+        }
+        const n = (v0 << 18) | (v1 << 12) | (v2 << 6) | v3;
+        out[o++] = (n >> 16) & 0xff;
+        if (!isPad2) {
+            if (o >= out.length)
+                break;
+            out[o++] = (n >> 8) & 0xff;
+        }
+        if (!isPad3) {
+            if (o >= out.length)
+                break;
+            out[o++] = n & 0xff;
+        }
+        if (isPad2 || isPad3) {
+            // Padding is only valid in the final quartet.
+            if (i + 4 !== s.length) {
+                throw new Error("Invalid base64: padding can only appear at the end");
+            }
+            // If third char is padding, fourth must also be padding.
+            if (isPad2 && !isPad3) {
+                throw new Error("Invalid base64: invalid padding");
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Create a base64 data URL.
+ */
+function toDataUrl(mime, bytes) {
+    if (!mime)
+        throw new Error("mime is required");
+    return `data:${mime};base64,${encodeBase64(bytes)}`;
+}
+/**
+ * Parse a base64 data URL.
+ *
+ * Supports `data:<mime>;base64,<payload>`.
+ */
+function parseDataUrl(url) {
+    if (!url.startsWith("data:")) {
+        throw new Error("Invalid data URL: must start with 'data:'");
+    }
+    const commaIndex = url.indexOf(",");
+    if (commaIndex === -1) {
+        throw new Error("Invalid data URL: missing ',' separator");
+    }
+    const meta = url.slice(5, commaIndex);
+    const payload = url.slice(commaIndex + 1);
+    // We only support base64 payloads.
+    const metaParts = meta.split(";");
+    const mime = metaParts[0] || "application/octet-stream";
+    const isBase64 = metaParts.some((p) => p.toLowerCase() === "base64");
+    if (!isBase64) {
+        throw new Error("Invalid data URL: only base64 payloads are supported");
+    }
+    return { mime, bytes: decodeBase64(payload) };
+}

package/script/src/utils/gif_encoder.d.ts

@@ -25,6 +25,8 @@ export declare class GIFEncoder {
     private quantize;
     private nextPowerOf2;
     private getBitsPerColor;
-    encode(): Uint8Array;
+    encode(options?: {
+        loop?: number;
+    }): Uint8Array;
 }
 //# sourceMappingURL=gif_encoder.d.ts.map

package/script/src/utils/gif_encoder.js

@@ -168,11 +168,13 @@ class GIFEncoder {
         }
         return Math.max(2, bits);
     }
-    encode() {
+    encode(options) {
         if (this.frames.length === 0) {
             throw new Error("No frames to encode");
         }
         const output = [];
+        // Get loop count from options (default to 0 = infinite)
+        const loopCount = options?.loop ?? 0;
         // Quantize first frame for Global Color Table
         const firstFrame = this.frames[0];
         const { palette: globalPalette, indexed: firstIndexed } = this.quantize(firstFrame.data);
@@ -209,7 +211,7 @@ class GIFEncoder {
             this.writeString(output, "NETSCAPE2.0");
             output.push(3); // Sub-block Size
             output.push(1); // Loop Indicator (1 = loop)
-            this.writeUint16LE(output, 0); // Loop Count (0 = infinite)
+            this.writeUint16LE(output, loopCount); // Loop Count (0 = infinite, 1+ = specific count)
             output.push(0); // Block Terminator
         }
         // Encode frames

package/script/src/utils/image_processing.d.ts

@@ -186,4 +186,35 @@ export declare function flipHorizontal(data: Uint8Array, width: number, height:
  * @returns Flipped image data
  */
 export declare function flipVertical(data: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Convert RGB color to CMYK color space
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns CMYK values: [c (0-1), m (0-1), y (0-1), k (0-1)]
+ */
+export declare function rgbToCmyk(r: number, g: number, b: number): [number, number, number, number];
+/**
+ * Convert CMYK color to RGB color space
+ * @param c Cyan component (0-1)
+ * @param m Magenta component (0-1)
+ * @param y Yellow component (0-1)
+ * @param k Key/Black component (0-1)
+ * @returns RGB values: [r (0-255), g (0-255), b (0-255)]
+ */
+export declare function cmykToRgb(c: number, m: number, y: number, k: number): [number, number, number];
+/**
+ * Convert RGBA image data to CMYK representation
+ * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+ * @param data Image data (RGBA)
+ * @returns CMYK image data as Float32Array (4 values per pixel)
+ */
+export declare function rgbaToCmyk(data: Uint8Array): Float32Array;
+/**
+ * Convert CMYK image data to RGBA representation
+ * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+ * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+ * @returns RGBA image data
+ */
+export declare function cmykToRgba(cmykData: Float32Array, alpha?: number): Uint8Array;
 //# sourceMappingURL=image_processing.d.ts.map

package/script/src/utils/image_processing.js

@@ -24,6 +24,10 @@ exports.rotate180 = rotate180;
 exports.rotate270 = rotate270;
 exports.flipHorizontal = flipHorizontal;
 exports.flipVertical = flipVertical;
+exports.rgbToCmyk = rgbToCmyk;
+exports.cmykToRgb = cmykToRgb;
+exports.rgbaToCmyk = rgbaToCmyk;
+exports.cmykToRgba = cmykToRgba;
 /**
  * Detect system endianness
  * Returns true if little-endian (most common), false if big-endian
@@ -765,3 +769,91 @@ function flipVertical(data, width, height) {
     }
     return result;
 }
+/**
+ * Convert RGB color to CMYK color space
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns CMYK values: [c (0-1), m (0-1), y (0-1), k (0-1)]
+ */
+function rgbToCmyk(r, g, b) {
+    // Normalize RGB values to 0-1 range
+    const rNorm = r / 255;
+    const gNorm = g / 255;
+    const bNorm = b / 255;
+    // Calculate K (key/black)
+    const k = 1 - Math.max(rNorm, gNorm, bNorm);
+    // If K is 1 (pure black), CMY are undefined but conventionally set to 0
+    if (k === 1) {
+        return [0, 0, 0, 1];
+    }
+    // Calculate CMY components
+    const c = (1 - rNorm - k) / (1 - k);
+    const m = (1 - gNorm - k) / (1 - k);
+    const y = (1 - bNorm - k) / (1 - k);
+    return [c, m, y, k];
+}
+/**
+ * Convert CMYK color to RGB color space
+ * @param c Cyan component (0-1)
+ * @param m Magenta component (0-1)
+ * @param y Yellow component (0-1)
+ * @param k Key/Black component (0-1)
+ * @returns RGB values: [r (0-255), g (0-255), b (0-255)]
+ */
+function cmykToRgb(c, m, y, k) {
+    // Convert CMYK to RGB
+    const r = 255 * (1 - c) * (1 - k);
+    const g = 255 * (1 - m) * (1 - k);
+    const b = 255 * (1 - y) * (1 - k);
+    return [
+        Math.round(Math.max(0, Math.min(255, r))),
+        Math.round(Math.max(0, Math.min(255, g))),
+        Math.round(Math.max(0, Math.min(255, b))),
+    ];
+}
+/**
+ * Convert RGBA image data to CMYK representation
+ * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+ * @param data Image data (RGBA)
+ * @returns CMYK image data as Float32Array (4 values per pixel)
+ */
+function rgbaToCmyk(data) {
+    const pixelCount = data.length / 4;
+    const result = new Float32Array(pixelCount * 4);
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        const [c, m, y, k] = rgbToCmyk(r, g, b);
+        const outIdx = (i / 4) * 4;
+        result[outIdx] = c;
+        result[outIdx + 1] = m;
+        result[outIdx + 2] = y;
+        result[outIdx + 3] = k;
+    }
+    return result;
+}
+/**
+ * Convert CMYK image data to RGBA representation
+ * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+ * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+ * @returns RGBA image data
+ */
+function cmykToRgba(cmykData, alpha = 255) {
+    const pixelCount = cmykData.length / 4;
+    const result = new Uint8Array(pixelCount * 4);
+    for (let i = 0; i < cmykData.length; i += 4) {
+        const c = cmykData[i];
+        const m = cmykData[i + 1];
+        const y = cmykData[i + 2];
+        const k = cmykData[i + 3];
+        const [r, g, b] = cmykToRgb(c, m, y, k);
+        const outIdx = i;
+        result[outIdx] = r;
+        result[outIdx + 1] = g;
+        result[outIdx + 2] = b;
+        result[outIdx + 3] = alpha;
+    }
+    return result;
+}

package/script/src/utils/jpeg_decoder.d.ts

@@ -8,7 +8,17 @@
  * This is a pure JavaScript implementation that handles common JPEG files.
  * For complex or non-standard JPEGs, the ImageDecoder API fallback is preferred.
  */
-import type { ImageDecoderOptions } from "../types.js";
+import type { ImageDecoderOptions, JPEGQuantizedCoefficients } from "../types.js";
+/**
+ * Extended decoder options including coefficient extraction
+ */
+interface JPEGDecoderOptions extends ImageDecoderOptions {
+    /**
+     * When true, stores quantized DCT coefficients for later retrieval
+     * via getQuantizedCoefficients(). Coefficients are stored in zigzag order.
+     */
+    extractCoefficients?: boolean;
+}
 export declare class JPEGDecoder {
     private data;
     private pos;
@@ -29,8 +39,20 @@ export declare class JPEGDecoder {
     private successiveLow;
     private scanComponentIds;
     private eobRun;
-    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
+    private quantizedCoefficients;
+    constructor(data: Uint8Array, settings?: JPEGDecoderOptions);
     decode(): Uint8Array;
+    /**
+     * Get the quantized DCT coefficients after decoding
+     * Only available if extractCoefficients option was set to true
+     * @returns JPEGQuantizedCoefficients or undefined if not available
+     */
+    getQuantizedCoefficients(): JPEGQuantizedCoefficients | undefined;
+    /**
+     * Store quantized coefficients in the output structure
+     * Called after decoding when extractCoefficients is true
+     */
+    private storeQuantizedCoefficients;
     private readMarker;
     private readUint16;
     private skipSegment;
@@ -49,4 +71,5 @@ export declare class JPEGDecoder {
     private idct;
     private convertToRGB;
 }
+export {};
 //# sourceMappingURL=jpeg_decoder.d.ts.map

package/script/src/utils/jpeg_decoder.js

@@ -214,10 +214,18 @@ class JPEGDecoder {
             writable: true,
             value: 0
         }); // Remaining blocks to skip due to EOBn
+        // Storage for quantized coefficients (when extractCoefficients is true)
+        Object.defineProperty(this, "quantizedCoefficients", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         this.data = data;
         this.options = {
             tolerantDecoding: settings.tolerantDecoding ?? true,
             onWarning: settings.onWarning,
+            extractCoefficients: settings.extractCoefficients ?? false,
         };
     }
     decode() {
@@ -279,7 +287,8 @@ class JPEGDecoder {
         // For progressive JPEGs, perform IDCT on all blocks after all scans are complete
         // This ensures that frequency-domain coefficients from multiple scans are properly
         // accumulated before transformation to spatial domain
-        if (this.isProgressive) {
+        // Skip IDCT when extracting coefficients - we want the quantized DCT values
+        if (this.isProgressive && !this.options.extractCoefficients) {
             for (const component of this.components) {
                 if (component.blocks) {
                     for (const row of component.blocks) {
@@ -290,9 +299,63 @@ class JPEGDecoder {
                 }
             }
         }
+        // If extracting coefficients, store them before converting to RGB
+        if (this.options.extractCoefficients) {
+            this.storeQuantizedCoefficients();
+        }
         // Convert YCbCr to RGB
         return this.convertToRGB();
     }
+    /**
+     * Get the quantized DCT coefficients after decoding
+     * Only available if extractCoefficients option was set to true
+     * @returns JPEGQuantizedCoefficients or undefined if not available
+     */
+    getQuantizedCoefficients() {
+        return this.quantizedCoefficients ?? undefined;
+    }
+    /**
+     * Store quantized coefficients in the output structure
+     * Called after decoding when extractCoefficients is true
+     */
+    storeQuantizedCoefficients() {
+        // Calculate MCU dimensions
+        const maxH = Math.max(...this.components.map((c) => c.h));
+        const maxV = Math.max(...this.components.map((c) => c.v));
+        const mcuWidth = Math.ceil(this.width / (8 * maxH));
+        const mcuHeight = Math.ceil(this.height / (8 * maxV));
+        // Build component coefficients
+        const componentCoeffs = this.components.map((comp) => ({
+            id: comp.id,
+            h: comp.h,
+            v: comp.v,
+            qTable: comp.qTable,
+            blocks: comp.blocks.map((row) => row.map((block) => {
+                // Convert to Int32Array if not already
+                if (block instanceof Int32Array) {
+                    return block;
+                }
+                return new Int32Array(block);
+            })),
+        }));
+        // Copy quantization tables
+        const qTables = this.qTables.map((table) => {
+            if (table instanceof Uint8Array) {
+                return new Uint8Array(table);
+            }
+            return new Uint8Array(table);
+        });
+        this.quantizedCoefficients = {
+            format: "jpeg",
+            width: this.width,
+            height: this.height,
+            isProgressive: this.isProgressive,
+            components: componentCoeffs,
+            quantizationTables: qTables,
+            mcuWidth,
+            mcuHeight,
+        };
+    }
     readMarker() {
         while (this.pos < this.data.length && this.data[this.pos] !== 0xFF) {
             this.pos++;
@@ -593,7 +656,13 @@ class JPEGDecoder {
                 component.pred += dcDiff;
                 // For successive approximation, shift the coefficient left by Al bits
                 const coeff = component.pred << this.successiveLow;
-                block[0] = coeff * this.qTables[component.qTable][0];
+                // When extracting coefficients, store quantized value without dequantization
+                if (this.options.extractCoefficients) {
+                    block[0] = coeff;
+                }
+                else {
+                    block[0] = coeff * this.qTables[component.qTable][0];
+                }
             }
             else {
                 // DC refinement scan: add a refinement bit
@@ -601,7 +670,12 @@ class JPEGDecoder {
                 if (bit) {
                     // Add the refinement bit at position Al
                     const refinement = 1 << this.successiveLow;
-                    block[0] += refinement * this.qTables[component.qTable][0];
+                    if (this.options.extractCoefficients) {
+                        block[0] += refinement;
+                    }
+                    else {
+                        block[0] += refinement * this.qTables[component.qTable][0];
+                    }
                 }
             }
         }
@@ -648,8 +722,14 @@ class JPEGDecoder {
                             break;
                         // For successive approximation, shift the coefficient left by Al bits
                         const coeff = this.receiveBits(s) << this.successiveLow;
-                        block[ZIGZAG[k]] = coeff *
-                            this.qTables[component.qTable][ZIGZAG[k]];
+                        // When extracting coefficients, store quantized value without dequantization
+                        if (this.options.extractCoefficients) {
+                            block[ZIGZAG[k]] = coeff;
+                        }
+                        else {
+                            block[ZIGZAG[k]] = coeff *
+                                this.qTables[component.qTable][ZIGZAG[k]];
+                        }
                         k++;
                     }
                 }
@@ -696,7 +776,10 @@ class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
@@ -711,13 +794,17 @@ class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
                             else {
                                 const newCoeff = successiveACNextValue << this.successiveLow;
-                                block[z] = newCoeff * qTable[z];
+                                // When extracting coefficients, don't dequantize
+                                block[z] = this.options.extractCoefficients ? newCoeff : newCoeff * qTable[z];
                                 successiveACState = 0;
                             }
                             break;
@@ -725,7 +812,10 @@ class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
@@ -744,7 +834,8 @@ class JPEGDecoder {
         // Perform IDCT only for baseline JPEGs
         // For progressive JPEGs, IDCT is deferred until all scans are complete
         // to preserve frequency-domain coefficients for accumulation across scans
-        if (!this.isProgressive) {
+        // Skip IDCT when extracting coefficients - we want the quantized DCT values
+        if (!this.isProgressive && !this.options.extractCoefficients) {
             this.idct(block);
         }
     }

package/script/src/utils/jpeg_encoder.d.ts

@@ -5,6 +5,7 @@
  * This is a simplified implementation focusing on correctness over performance.
  * For production use with better quality/size, the OffscreenCanvas API is preferred.
  */
+import type { JPEGQuantizedCoefficients } from "../types.js";
 export interface JPEGEncoderOptions {
     quality?: number;
     progressive?: boolean;
@@ -43,5 +44,23 @@ export declare class JPEGEncoder {
     private forwardDCT;
     private encodeDC;
     private encodeAC;
+    /**
+     * Encode JPEG from pre-quantized DCT coefficients
+     * Skips DCT and quantization - uses provided coefficients directly
+     * Useful for steganography where coefficients are modified and re-encoded
+     * @param coeffs JPEG quantized coefficients
+     * @param _options Optional encoding options (currently unused)
+     * @returns Encoded JPEG bytes
+     */
+    encodeFromCoefficients(coeffs: JPEGQuantizedCoefficients, _options?: JPEGEncoderOptions): Uint8Array;
+    private writeDQTFromCoeffs;
+    private writeSOF0FromCoeffs;
+    private writeSOF2FromCoeffs;
+    private encodeScanFromCoeffs;
+    private encodeACFromCoeffs;
+    private encodeProgressiveFromCoeffs;
+    private encodeProgressiveDCScanFromCoeffs;
+    private encodeProgressiveACScanFromCoeffs;
+    private encodeOnlyACFromCoeffs;
 }
 //# sourceMappingURL=jpeg_encoder.d.ts.map