@thermal-print/escpos 0.1.0

package/dist/generator.js

@@ -0,0 +1,383 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESCPOSGenerator = void 0;
+const escpos_1 = require("./commands/escpos");
+const styles_1 = require("./styles");
+const command_adapters_1 = require("./command-adapters");
+/**
+ * Simple buffer implementation for accumulating ESC/POS commands
+ */
+class ESCPOSBuffer {
+    constructor() {
+        this.buffer = [];
+    }
+    /**
+     * Add raw bytes to buffer
+     */
+    push(...bytes) {
+        this.buffer.push(...bytes);
+    }
+    /**
+     * Add array of bytes to buffer
+     */
+    pushArray(bytes) {
+        this.buffer.push(...bytes);
+    }
+    /**
+     * Get the buffer as a Node.js Buffer
+     */
+    toBuffer() {
+        return Buffer.from(this.buffer);
+    }
+    /**
+     * Get buffer size
+     */
+    get size() {
+        return this.buffer.length;
+    }
+}
+/**
+ * ESC/POS Command Generator
+ * Manages the buffer and context for generating ESC/POS commands
+ * Pure JavaScript implementation - no Node.js dependencies
+ */
+class ESCPOSGenerator {
+    constructor(paperWidth = 48, encoding = "cp860", debug = false, commandAdapter) {
+        this.buffer = new ESCPOSBuffer();
+        // Use provided adapter or default to ESC/POS
+        this.commandAdapter = commandAdapter || new command_adapters_1.ESCPOSCommandAdapter();
+        this.context = {
+            paperWidth,
+            currentAlign: "left",
+            currentSize: { width: 1, height: 1 },
+            currentBold: false,
+            encoding,
+            debug,
+            buffer: [],
+        };
+        // Initialize printer using command adapter
+        this.buffer.pushArray(this.commandAdapter.getInitCommand());
+    }
+    /**
+     * Initialize printer
+     * Sets up the printer with default settings and comfortable line spacing
+     */
+    initialize() {
+        // Initialize with comfortable line spacing (30 dots ≈ default 1/6 inch)
+        // Common values: 10 (tight), 20 (moderate), 30 (default), 40 (spacious)
+        this.setLineSpacing(5);
+        // Apply initial print mode to set Font B explicitly
+        // This ensures the narrower font (9×17) is used from the start
+        this.applyPrintMode();
+    }
+    /**
+     * Set line spacing using command adapter
+     * @param dots - Line spacing in dots (0-255). Use 0 for minimal spacing, undefined for default (1/6 inch)
+     */
+    setLineSpacing(dots) {
+        const command = this.commandAdapter.getLineSpacingCommand(dots);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Set text alignment using command adapter
+     */
+    setAlign(align) {
+        if (this.context.currentAlign !== align) {
+            const command = this.commandAdapter.getAlignCommand(align);
+            this.buffer.pushArray(command);
+            this.context.currentAlign = align;
+        }
+    }
+    /**
+     * Set text bold
+     * Uses ESC ! command which combines size and emphasis
+     */
+    setBold(bold) {
+        if (this.context.currentBold !== bold) {
+            this.context.currentBold = bold;
+            this.applyPrintMode();
+        }
+    }
+    /**
+     * Set text size using width and height multipliers
+     * Uses ESC ! command which combines size and emphasis
+     * @param size - Character size as {width, height} multipliers (max 2x2 for ESC !)
+     */
+    setSize(size) {
+        // Only update if size actually changed
+        if (this.context.currentSize.width !== size.width ||
+            this.context.currentSize.height !== size.height) {
+            this.context.currentSize = size;
+            this.applyPrintMode();
+        }
+    }
+    /**
+     * Apply current print mode (size + bold) using command adapter
+     * This combines character size and emphasis into a single command
+     */
+    applyPrintMode() {
+        const command = this.commandAdapter.getCharacterSizeCommand(this.context.currentSize.width, this.context.currentSize.height, this.context.currentBold);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Reset text formatting to defaults
+     * Note: Alignment is NOT reset here because it should persist for the entire line
+     */
+    resetFormatting() {
+        this.setAlign("left");
+        this.setBold(false);
+        this.setSize({ width: 1, height: 1 });
+    }
+    /**
+     * Add text with current formatting
+     */
+    addText(text) {
+        if (text) {
+            // Encode text to CP860 for Portuguese support
+            const encodedBytes = (0, escpos_1.encodeText)(text);
+            this.buffer.pushArray(encodedBytes);
+        }
+    }
+    /**
+     * Add newline using command adapter
+     */
+    addNewline(count = 1) {
+        const command = this.commandAdapter.getLineFeedCommand(count);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Add line feed using command adapter
+     */
+    addLineFeed(lines = 1) {
+        const command = this.commandAdapter.getLineFeedCommand(lines);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Add divider line
+     */
+    addDivider(dashed = false) {
+        this.setAlign("left");
+        const line = (0, styles_1.generateDividerLine)(this.context.paperWidth, dashed);
+        this.addText(line);
+        this.addNewline();
+    }
+    /**
+     * Add QR code using command adapter
+     */
+    addQRCode(data, size = 6) {
+        try {
+            const command = this.commandAdapter.getQRCodeCommand(data, size);
+            if (command.length > 0) {
+                this.buffer.pushArray(command);
+                this.addNewline();
+            }
+        }
+        catch (error) {
+            // QR code generation failed - silently ignore
+        }
+    }
+    /**
+     * Add image from base64 or data URI
+     * Converts image to monochrome bitmap and prints using ESC/POS raster graphics
+     * @param source - Base64 string, data URI, or object with uri property
+     */
+    async addImage(source) {
+        try {
+            // Import Jimp dynamically to avoid loading if not needed
+            const { Jimp } = await Promise.resolve().then(() => __importStar(require("jimp")));
+            // Extract the actual data URI or base64 string
+            let imageSource;
+            if (typeof source === "string") {
+                imageSource = source;
+            }
+            else if (source && typeof source === "object" && "uri" in source) {
+                imageSource = source.uri;
+            }
+            else {
+                console.warn("Invalid image source format");
+                return;
+            }
+            // Handle base64 strings (with or without data URI prefix)
+            let base64Data = imageSource;
+            if (imageSource.startsWith("data:")) {
+                // Extract base64 from data URI (e.g., "data:image/png;base64,...")
+                const base64Match = imageSource.match(/^data:image\/\w+;base64,(.+)$/);
+                if (base64Match) {
+                    base64Data = base64Match[1];
+                }
+            }
+            // Convert base64 to buffer
+            const imageBuffer = Buffer.from(base64Data, "base64");
+            // Load image with Jimp (v1.x API)
+            const image = await Jimp.read(imageBuffer);
+            // Get paper width in pixels (assuming 8 dots per mm for 80mm thermal printer)
+            // Standard 80mm paper = ~576 pixels at 8 dots/mm (72 dpi)
+            // We'll use 384 pixels as max width (48 chars * 8 pixels per char)
+            const maxWidth = this.context.paperWidth * 8;
+            // Resize image to fit paper width while maintaining aspect ratio
+            if (image.width > maxWidth) {
+                await image.resize({ w: maxWidth });
+            }
+            // Convert to grayscale and apply threshold to create monochrome bitmap
+            await image
+                .greyscale()
+                .contrast(0.2) // Increase contrast for better print quality
+                .posterize(2); // Convert to 2-color (black and white)
+            const width = image.width;
+            const height = image.height;
+            // Convert image to monochrome bitmap data (1 bit per pixel)
+            const bytesPerLine = Math.ceil(width / 8);
+            const bitmapData = [];
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < bytesPerLine; x++) {
+                    let byte = 0;
+                    for (let bit = 0; bit < 8; bit++) {
+                        const pixelX = x * 8 + bit;
+                        if (pixelX < width) {
+                            const pixelIndex = (y * width + pixelX) * 4;
+                            const pixel = image.bitmap.data[pixelIndex]; // Red channel (same for grayscale)
+                            // If pixel is dark (< 128), set bit to 1 (black)
+                            if (pixel < 128) {
+                                byte |= 1 << (7 - bit);
+                            }
+                        }
+                    }
+                    bitmapData.push(byte);
+                }
+            }
+            // Generate and add raster image command using command adapter
+            const imageCommand = this.commandAdapter.getRasterImageCommand(bitmapData, width, height);
+            if (imageCommand.length > 0) {
+                this.buffer.pushArray(imageCommand);
+            }
+        }
+        catch (error) {
+            console.warn("Failed to process image:", error);
+            // Silently fail - don't crash if image processing fails
+        }
+    }
+    /**
+     * Apply text styles from style object
+     */
+    applyTextStyle(style) {
+        const textStyle = (0, styles_1.extractTextStyle)(style);
+        // Set alignment
+        const align = (0, styles_1.mapTextAlign)(textStyle.textAlign);
+        this.setAlign(align);
+        // Set bold
+        const bold = (0, styles_1.isBold)(textStyle);
+        this.setBold(bold);
+        // Set size
+        const size = (0, styles_1.mapFontSizeToESCPOS)(textStyle.fontSize);
+        this.setSize(size);
+    }
+    /**
+     * Apply spacing from view style
+     */
+    applyViewSpacing(style, type) {
+        const viewStyle = (0, styles_1.extractViewStyle)(style);
+        if (type === "before") {
+            // Apply top border
+            if (viewStyle.borderTop) {
+                this.addDivider((0, styles_1.isDashedBorder)(viewStyle.borderTop));
+            }
+        }
+        else {
+            // Apply bottom border
+            if (viewStyle.borderBottom) {
+                this.addDivider((0, styles_1.isDashedBorder)(viewStyle.borderBottom));
+            }
+        }
+    }
+    /**
+     * Cut paper with full cut using command adapter
+     */
+    cutFull() {
+        const command = this.commandAdapter.getCutCommand("full");
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Cut paper with partial cut using command adapter
+     */
+    cutPartial() {
+        const command = this.commandAdapter.getCutCommand("partial");
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Cut paper with feed then full cut using command adapter
+     * @param lines - Number of lines to feed before cutting (1-255)
+     */
+    cutFullWithFeed(lines = 3) {
+        const feedCount = Math.max(1, Math.min(255, lines));
+        const command = this.commandAdapter.getCutCommand("full", feedCount);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Cut paper with feed then partial cut using command adapter
+     * @param lines - Number of lines to feed before cutting (1-255)
+     */
+    cutPartialWithFeed(lines = 3) {
+        const feedCount = Math.max(1, Math.min(255, lines));
+        const command = this.commandAdapter.getCutCommand("partial", feedCount);
+        this.buffer.pushArray(command);
+    }
+    /**
+     * Add raw ESC/POS command
+     * @param data - Raw buffer data to send to printer
+     */
+    addRawCommand(data) {
+        this.buffer.pushArray(Array.from(data));
+    }
+    /**
+     * Get the final buffer
+     */
+    getBuffer() {
+        const buffer = this.buffer.toBuffer();
+        // Remove leading line feeds (0x0A)
+        let start = 0;
+        while (start < buffer.length && buffer[start] === 0x0a) {
+            start++;
+        }
+        return buffer.slice(start);
+    }
+    /**
+     * Get paper width
+     */
+    getPaperWidth() {
+        return this.context.paperWidth;
+    }
+}
+exports.ESCPOSGenerator = ESCPOSGenerator;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @thermal-print/escpos
+ *
+ * ESC/POS command generation and thermal printer control
+ *
+ * Main API: printNodesToESCPOS(printNode, options) -> Buffer
+ */
+export { printNodesToESCPOS, PrintNodeToESCPOSOptions } from './converter';
+export { ESCPOSGenerator } from './generator';
+export { TreeTraverser } from './traverser';
+export { CommandAdapter, CharacterSize } from './command-adapters/types';
+export { ESCPOSCommandAdapter } from './command-adapters/escpos-adapter';
+export { ESCBematechCommandAdapter } from './command-adapters/escbematech-adapter';
+export { extractTextStyle, extractViewStyle, isBold, mapFontSizeToESCPOS, mapTextAlign, calculateSpacing, isDashedBorder, generateDividerLine, mergeStyles, parseWidth, alignTextInColumn, wrapText, } from './styles';
+export { encodeCP860 } from './encodings/cp860';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAG3E,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAGnF,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,QAAQ,GACT,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @thermal-print/escpos
+ *
+ * ESC/POS command generation and thermal printer control
+ *
+ * Main API: printNodesToESCPOS(printNode, options) -> Buffer
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeCP860 = exports.wrapText = exports.alignTextInColumn = exports.parseWidth = exports.mergeStyles = exports.generateDividerLine = exports.isDashedBorder = exports.calculateSpacing = exports.mapTextAlign = exports.mapFontSizeToESCPOS = exports.isBold = exports.extractViewStyle = exports.extractTextStyle = exports.ESCBematechCommandAdapter = exports.ESCPOSCommandAdapter = exports.TreeTraverser = exports.ESCPOSGenerator = exports.printNodesToESCPOS = void 0;
+// Main conversion function
+var converter_1 = require("./converter");
+Object.defineProperty(exports, "printNodesToESCPOS", { enumerable: true, get: function () { return converter_1.printNodesToESCPOS; } });
+// Core classes (for advanced usage)
+var generator_1 = require("./generator");
+Object.defineProperty(exports, "ESCPOSGenerator", { enumerable: true, get: function () { return generator_1.ESCPOSGenerator; } });
+var traverser_1 = require("./traverser");
+Object.defineProperty(exports, "TreeTraverser", { enumerable: true, get: function () { return traverser_1.TreeTraverser; } });
+var escpos_adapter_1 = require("./command-adapters/escpos-adapter");
+Object.defineProperty(exports, "ESCPOSCommandAdapter", { enumerable: true, get: function () { return escpos_adapter_1.ESCPOSCommandAdapter; } });
+var escbematech_adapter_1 = require("./command-adapters/escbematech-adapter");
+Object.defineProperty(exports, "ESCBematechCommandAdapter", { enumerable: true, get: function () { return escbematech_adapter_1.ESCBematechCommandAdapter; } });
+// Style utilities
+var styles_1 = require("./styles");
+Object.defineProperty(exports, "extractTextStyle", { enumerable: true, get: function () { return styles_1.extractTextStyle; } });
+Object.defineProperty(exports, "extractViewStyle", { enumerable: true, get: function () { return styles_1.extractViewStyle; } });
+Object.defineProperty(exports, "isBold", { enumerable: true, get: function () { return styles_1.isBold; } });
+Object.defineProperty(exports, "mapFontSizeToESCPOS", { enumerable: true, get: function () { return styles_1.mapFontSizeToESCPOS; } });
+Object.defineProperty(exports, "mapTextAlign", { enumerable: true, get: function () { return styles_1.mapTextAlign; } });
+Object.defineProperty(exports, "calculateSpacing", { enumerable: true, get: function () { return styles_1.calculateSpacing; } });
+Object.defineProperty(exports, "isDashedBorder", { enumerable: true, get: function () { return styles_1.isDashedBorder; } });
+Object.defineProperty(exports, "generateDividerLine", { enumerable: true, get: function () { return styles_1.generateDividerLine; } });
+Object.defineProperty(exports, "mergeStyles", { enumerable: true, get: function () { return styles_1.mergeStyles; } });
+Object.defineProperty(exports, "parseWidth", { enumerable: true, get: function () { return styles_1.parseWidth; } });
+Object.defineProperty(exports, "alignTextInColumn", { enumerable: true, get: function () { return styles_1.alignTextInColumn; } });
+Object.defineProperty(exports, "wrapText", { enumerable: true, get: function () { return styles_1.wrapText; } });
+// Encodings
+var cp860_1 = require("./encodings/cp860");
+Object.defineProperty(exports, "encodeCP860", { enumerable: true, get: function () { return cp860_1.encodeCP860; } });
+// Types
+__exportStar(require("./types"), exports);

package/dist/styles.d.ts

@@ -0,0 +1,72 @@
+import { TextStyle, ViewStyle } from "@thermal-print/core";
+/**
+ * Extracts text style from a style object
+ */
+export declare function extractTextStyle(style: any): TextStyle;
+/**
+ * Extracts view/layout style from a style object
+ */
+export declare function extractViewStyle(style: any): ViewStyle;
+/**
+ * Determines if text should be bold
+ */
+export declare function isBold(style: TextStyle): boolean;
+/**
+ * Maps fontSize to ESC/POS character size (width x height multipliers)
+ *
+ * Font size mapping using ESC ! command (limited to 2x2 maximum):
+ * - 8-12px  → 1x1 (normal)
+ * - 13-18px → 1x2 (normal width, double height)
+ * - 19-24px → 2x1 (double width, normal height)
+ * - 25+px   → 2x2 (double width, double height)
+ *
+ * Note: ESC ! command only supports up to 2x2 character size.
+ * Larger sizes (3x, 4x, etc.) would require GS ! command which may not
+ * be supported on all thermal printers (e.g., Bematech MP-4200 TH).
+ *
+ * PDF uses zoom factor (default 0.46), so actual sizes are smaller:
+ * - 16 * 0.46 = 7.36 (normal text)
+ * - 18 * 0.46 = 8.28 (medium text)
+ * - 20 * 0.46 = 9.2 (title text)
+ *
+ * We use raw fontSize values (ignoring zoom) for better differentiation
+ */
+export declare function mapFontSizeToESCPOS(fontSize?: number | string): {
+    width: number;
+    height: number;
+};
+/**
+ * Maps textAlign to ESC/POS alignment
+ */
+export declare function mapTextAlign(textAlign?: string): "left" | "center" | "right";
+/**
+ * Calculates spacing (margin/padding) in lines
+ * Approximates pixels to line feeds
+ */
+export declare function calculateSpacing(value?: number): number;
+/**
+ * Determines if a border is dashed
+ */
+export declare function isDashedBorder(border?: string): boolean;
+/**
+ * Generates a divider line based on border style
+ */
+export declare function generateDividerLine(width: number, dashed?: boolean): string;
+/**
+ * Merges multiple style objects (handles spread syntax)
+ */
+export declare function mergeStyles(...styles: any[]): any;
+/**
+ * Parses width percentage to column width in characters
+ * Uses Math.round() to minimize rounding errors
+ */
+export declare function parseWidth(width: string | number | undefined, totalWidth: number): number;
+/**
+ * Aligns text within a column width (using CP860 byte length for accurate padding)
+ */
+export declare function alignTextInColumn(text: string, width: number, align: "left" | "center" | "right"): string;
+/**
+ * Splits text into multiple lines if it exceeds width
+ */
+export declare function wrapText(text: string, width: number): string[];
+//# sourceMappingURL=styles.d.ts.map

package/dist/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../src/styles.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAOtD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAoBtD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAOhD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAcA;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAI5E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,UAAQ,GAAG,MAAM,CAGzE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,CAEjD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,GACjB,MAAM,CAaR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GACjC,MAAM,CA8BR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAyB9D"}