@willwade/aac-processors 0.0.3 → 0.0.5

package/README.md

@@ -39,7 +39,7 @@ A comprehensive **TypeScript library** for processing AAC (Augmentative and Alte
 ### From npm (Recommended)
 
 ```bash
-npm install aac-processors
+npm install @willwade/aac-processors
 ```
 
 ### From Source

package/dist/processors/gridset/styleHelpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Grid3 Style Helpers
+ *
+ * Utilities for creating and managing Grid3 styles, including default styles,
+ * style XML generation, and style conversion utilities.
+ */
+/**
+ * Grid3 Style object structure
+ */
+export interface Grid3Style {
+    BackColour?: string;
+    TileColour?: string;
+    BorderColour?: string;
+    FontColour?: string;
+    FontName?: string;
+    FontSize?: string | number;
+}
+/**
+ * Default Grid3 styles for common use cases
+ * Colors are in 8-digit ARGB hex format (#AARRGGBBFF)
+ */
+export declare const DEFAULT_GRID3_STYLES: Record<string, Grid3Style>;
+/**
+ * Category-specific styles for navigation and organization
+ */
+export declare const CATEGORY_STYLES: Record<string, Grid3Style>;
+/**
+ * Ensure a color has an alpha channel (Grid3 format requires 8-digit ARGB)
+ * @param color - Color string (hex format)
+ * @returns Color with alpha channel in format #AARRGGBBFF
+ */
+export declare function ensureAlphaChannel(color: string | undefined): string;
+/**
+ * Create a Grid3 style XML string with default and category styles
+ * @param includeCategories - Whether to include category-specific styles (default: true)
+ * @returns XML string for Settings0/styles.xml
+ */
+export declare function createDefaultStylesXml(includeCategories?: boolean): string;
+/**
+ * Create a custom category style
+ * @param categoryName - Name of the category
+ * @param backgroundColor - Background color in hex format
+ * @param fontColor - Font color in hex format (default: white)
+ * @returns Grid3Style object
+ */
+export declare function createCategoryStyle(categoryName: string, backgroundColor: string, fontColor?: string): Grid3Style;

package/dist/processors/gridset/styleHelpers.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Grid3 Style Helpers
+ *
+ * Utilities for creating and managing Grid3 styles, including default styles,
+ * style XML generation, and style conversion utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATEGORY_STYLES = exports.DEFAULT_GRID3_STYLES = void 0;
+exports.ensureAlphaChannel = ensureAlphaChannel;
+exports.createDefaultStylesXml = createDefaultStylesXml;
+exports.createCategoryStyle = createCategoryStyle;
+const fast_xml_parser_1 = require("fast-xml-parser");
+/**
+ * Default Grid3 styles for common use cases
+ * Colors are in 8-digit ARGB hex format (#AARRGGBBFF)
+ */
+exports.DEFAULT_GRID3_STYLES = {
+    Default: {
+        BackColour: '#E2EDF8FF',
+        TileColour: '#FFFFFFFF',
+        BorderColour: '#000000FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    Workspace: {
+        BackColour: '#FFFFFFFF',
+        TileColour: '#FFFFFFFF',
+        BorderColour: '#CCCCCCFF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Auto content': {
+        BackColour: '#E8F4F8FF',
+        TileColour: '#E8F4F8FF',
+        BorderColour: '#2C82C9FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Vocab cell': {
+        BackColour: '#E8F4F8FF',
+        TileColour: '#E8F4F8FF',
+        BorderColour: '#2C82C9FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Keyboard key': {
+        BackColour: '#F0F0F0FF',
+        TileColour: '#F0F0F0FF',
+        BorderColour: '#808080FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '12',
+    },
+};
+/**
+ * Category-specific styles for navigation and organization
+ */
+exports.CATEGORY_STYLES = {
+    'Actions category style': {
+        BackColour: '#4472C4FF',
+        TileColour: '#4472C4FF',
+        BorderColour: '#2F5496FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'People category style': {
+        BackColour: '#ED7D31FF',
+        TileColour: '#ED7D31FF',
+        BorderColour: '#C65911FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Places category style': {
+        BackColour: '#A5A5A5FF',
+        TileColour: '#A5A5A5FF',
+        BorderColour: '#595959FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Descriptive category style': {
+        BackColour: '#70AD47FF',
+        TileColour: '#70AD47FF',
+        BorderColour: '#4F7C2FFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Social category style': {
+        BackColour: '#FFC000FF',
+        TileColour: '#FFC000FF',
+        BorderColour: '#BF8F00FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Questions category style': {
+        BackColour: '#5B9BD5FF',
+        TileColour: '#5B9BD5FF',
+        BorderColour: '#2E5C8AFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Little words category style': {
+        BackColour: '#C55A11FF',
+        TileColour: '#C55A11FF',
+        BorderColour: '#8B3F0AFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+};
+/**
+ * Ensure a color has an alpha channel (Grid3 format requires 8-digit ARGB)
+ * @param color - Color string (hex format)
+ * @returns Color with alpha channel in format #AARRGGBBFF
+ */
+function ensureAlphaChannel(color) {
+    if (!color)
+        return '#FFFFFFFF';
+    // If already 8 digits (with alpha), return as is
+    if (color.match(/^#[0-9A-Fa-f]{8}$/))
+        return color;
+    // If 6 digits (no alpha), add FF for fully opaque
+    if (color.match(/^#[0-9A-Fa-f]{6}$/))
+        return color + 'FF';
+    // If 3 digits (shorthand), expand to 8
+    if (color.match(/^#[0-9A-Fa-f]{3}$/)) {
+        const r = color[1];
+        const g = color[2];
+        const b = color[3];
+        return `#${r}${r}${g}${g}${b}${b}FF`;
+    }
+    // Invalid or unknown format, return white
+    return '#FFFFFFFF';
+}
+/**
+ * Create a Grid3 style XML string with default and category styles
+ * @param includeCategories - Whether to include category-specific styles (default: true)
+ * @returns XML string for Settings0/styles.xml
+ */
+function createDefaultStylesXml(includeCategories = true) {
+    const builder = new fast_xml_parser_1.XMLBuilder({
+        ignoreAttributes: false,
+        format: true,
+        indentBy: '  ',
+    });
+    const styles = { ...exports.DEFAULT_GRID3_STYLES };
+    if (includeCategories) {
+        Object.assign(styles, exports.CATEGORY_STYLES);
+    }
+    const styleArray = Object.entries(styles).map(([key, style]) => ({
+        '@_Key': key,
+        BackColour: style.BackColour,
+        TileColour: style.TileColour,
+        BorderColour: style.BorderColour,
+        FontColour: style.FontColour,
+        FontName: style.FontName,
+        FontSize: style.FontSize?.toString(),
+    }));
+    const stylesData = {
+        StyleData: {
+            '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            Styles: {
+                Style: styleArray,
+            },
+        },
+    };
+    return builder.build(stylesData);
+}
+/**
+ * Create a custom category style
+ * @param categoryName - Name of the category
+ * @param backgroundColor - Background color in hex format
+ * @param fontColor - Font color in hex format (default: white)
+ * @returns Grid3Style object
+ */
+function createCategoryStyle(categoryName, backgroundColor, fontColor = '#FFFFFFFF') {
+    return {
+        BackColour: ensureAlphaChannel(backgroundColor),
+        TileColour: ensureAlphaChannel(backgroundColor),
+        BorderColour: ensureAlphaChannel(darkenColor(backgroundColor, 30)),
+        FontColour: ensureAlphaChannel(fontColor),
+        FontName: 'Arial',
+        FontSize: '16',
+    };
+}
+/**
+ * Darken a hex color by a given amount
+ * @param hexColor - Hex color string
+ * @param amount - Amount to darken (0-255)
+ * @returns Darkened hex color
+ */
+function darkenColor(hexColor, amount) {
+    const normalized = ensureAlphaChannel(hexColor);
+    const hex = normalized.slice(1, 7); // Extract RGB part (skip # and alpha)
+    const num = parseInt(hex, 16);
+    const clamp = (value) => Math.max(0, Math.min(255, value));
+    const r = clamp(((num >> 16) & 0xff) - amount);
+    const g = clamp(((num >> 8) & 0xff) - amount);
+    const b = clamp((num & 0xff) - amount);
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+}

package/dist/processors/gridset/wordlistHelpers.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Grid3 Wordlist Helpers
+ *
+ * This module provides utilities for creating and extracting wordlists
+ * from Grid3 gridsets. Wordlists are Grid3-specific data structures
+ * used for dynamic vocabulary content.
+ *
+ * Note: Wordlists are only supported in Grid3 format. Other AAC formats
+ * do not have equivalent wordlist functionality.
+ */
+/**
+ * Represents a single item in a wordlist
+ */
+export interface WordListItem {
+    /** The text/word/phrase */
+    text: string;
+    /** Optional image reference (e.g., "[WIDGIT]path/to/symbol.emf") */
+    image?: string;
+    /** Part of speech category (e.g., "Noun", "Verb", "Unknown") */
+    partOfSpeech?: string;
+}
+/**
+ * Represents a complete wordlist
+ */
+export interface WordList {
+    /** Array of wordlist items */
+    items: WordListItem[];
+}
+/**
+ * Creates a WordList object from an array of words/phrases or a dictionary
+ *
+ * @param input - Either an array of strings or an object with text/image/partOfSpeech properties
+ * @returns A WordList object ready to be used in Grid3
+ *
+ * @example
+ * // From simple array
+ * const wordlist = createWordlist(['hello', 'goodbye', 'thank you']);
+ *
+ * @example
+ * // From array of objects
+ * const wordlist = createWordlist([
+ *   { text: 'hello', image: '[WIDGIT]greetings/hello.emf', partOfSpeech: 'Interjection' },
+ *   { text: 'goodbye', image: '[WIDGIT]greetings/goodbye.emf', partOfSpeech: 'Interjection' }
+ * ]);
+ */
+export declare function createWordlist(input: string[] | WordListItem[] | Record<string, string | WordListItem>): WordList;
+/**
+ * Converts a WordList object to Grid3 XML format
+ *
+ * @param wordlist - The wordlist to convert
+ * @returns XML string representation
+ * @internal
+ */
+export declare function wordlistToXml(wordlist: WordList): string;
+/**
+ * Extracts all wordlists from a gridset buffer
+ *
+ * @param gridsetBuffer - The gridset file as a Buffer
+ * @returns Map of grid names to their wordlists (if they have any)
+ *
+ * @example
+ * const wordlists = extractWordlists(gridsetBuffer);
+ * wordlists.forEach((wordlist, gridName) => {
+ *   console.log(`Grid "${gridName}" has ${wordlist.items.length} items`);
+ * });
+ */
+export declare function extractWordlists(gridsetBuffer: Buffer): Map<string, WordList>;
+/**
+ * Updates or adds a wordlist to a specific grid in a gridset
+ *
+ * @param gridsetBuffer - The gridset file as a Buffer
+ * @param gridName - The name of the grid to update (e.g., "Greetings")
+ * @param wordlist - The wordlist to add/update
+ * @returns Updated gridset as a Buffer
+ *
+ * @example
+ * const gridsetBuffer = fs.readFileSync('my-gridset.gridset');
+ * const newWordlist = createWordlist(['hello', 'hi', 'hey']);
+ * const updatedGridset = updateWordlist(gridsetBuffer, 'Greetings', newWordlist);
+ * fs.writeFileSync('updated-gridset.gridset', updatedGridset);
+ */
+export declare function updateWordlist(gridsetBuffer: Buffer, gridName: string, wordlist: WordList): Buffer;

package/dist/processors/gridset/wordlistHelpers.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Grid3 Wordlist Helpers
+ *
+ * This module provides utilities for creating and extracting wordlists
+ * from Grid3 gridsets. Wordlists are Grid3-specific data structures
+ * used for dynamic vocabulary content.
+ *
+ * Note: Wordlists are only supported in Grid3 format. Other AAC formats
+ * do not have equivalent wordlist functionality.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWordlist = createWordlist;
+exports.wordlistToXml = wordlistToXml;
+exports.extractWordlists = extractWordlists;
+exports.updateWordlist = updateWordlist;
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const fast_xml_parser_1 = require("fast-xml-parser");
+/**
+ * Creates a WordList object from an array of words/phrases or a dictionary
+ *
+ * @param input - Either an array of strings or an object with text/image/partOfSpeech properties
+ * @returns A WordList object ready to be used in Grid3
+ *
+ * @example
+ * // From simple array
+ * const wordlist = createWordlist(['hello', 'goodbye', 'thank you']);
+ *
+ * @example
+ * // From array of objects
+ * const wordlist = createWordlist([
+ *   { text: 'hello', image: '[WIDGIT]greetings/hello.emf', partOfSpeech: 'Interjection' },
+ *   { text: 'goodbye', image: '[WIDGIT]greetings/goodbye.emf', partOfSpeech: 'Interjection' }
+ * ]);
+ */
+function createWordlist(input) {
+    let items = [];
+    if (Array.isArray(input)) {
+        // Handle array input
+        items = input.map((item) => {
+            if (typeof item === 'string') {
+                return { text: item };
+            }
+            return item;
+        });
+    }
+    else if (typeof input === 'object') {
+        // Handle dictionary/object input
+        items = Object.entries(input).map(([key, value]) => {
+            if (typeof value === 'string') {
+                return { text: value };
+            }
+            return value;
+        });
+    }
+    return { items };
+}
+/**
+ * Converts a WordList object to Grid3 XML format
+ *
+ * @param wordlist - The wordlist to convert
+ * @returns XML string representation
+ * @internal
+ */
+function wordlistToXml(wordlist) {
+    const items = wordlist.items.map((item) => ({
+        WordListItem: {
+            Text: {
+                s: {
+                    '@_Image': item.image || '',
+                    r: item.text,
+                },
+            },
+            Image: item.image || '',
+            PartOfSpeech: item.partOfSpeech || 'Unknown',
+        },
+    }));
+    const wordlistData = {
+        WordList: {
+            Items: {
+                WordListItem: items.length === 1 ? items[0].WordListItem : items.map((i) => i.WordListItem),
+            },
+        },
+    };
+    const builder = new fast_xml_parser_1.XMLBuilder({
+        ignoreAttributes: false,
+        format: false,
+        suppressEmptyNode: false,
+    });
+    return builder.build(wordlistData);
+}
+/**
+ * Extracts all wordlists from a gridset buffer
+ *
+ * @param gridsetBuffer - The gridset file as a Buffer
+ * @returns Map of grid names to their wordlists (if they have any)
+ *
+ * @example
+ * const wordlists = extractWordlists(gridsetBuffer);
+ * wordlists.forEach((wordlist, gridName) => {
+ *   console.log(`Grid "${gridName}" has ${wordlist.items.length} items`);
+ * });
+ */
+function extractWordlists(gridsetBuffer) {
+    const wordlists = new Map();
+    const parser = new fast_xml_parser_1.XMLParser();
+    let zip;
+    try {
+        zip = new adm_zip_1.default(gridsetBuffer);
+    }
+    catch (error) {
+        throw new Error(`Invalid gridset buffer: ${error.message}`);
+    }
+    // Process each grid file
+    zip.getEntries().forEach((entry) => {
+        if (entry.entryName.startsWith('Grids/') && entry.entryName.endsWith('grid.xml')) {
+            try {
+                const xmlContent = entry.getData().toString('utf8');
+                const data = parser.parse(xmlContent);
+                const grid = data.Grid || data.grid;
+                if (!grid || !grid.WordList) {
+                    return;
+                }
+                // Extract grid name from path (e.g., "Grids/MyGrid/grid.xml" -> "MyGrid")
+                const match = entry.entryName.match(/^Grids\/([^/]+)\//);
+                const gridName = match ? match[1] : entry.entryName;
+                // Parse wordlist items
+                const wordlistData = grid.WordList;
+                const itemsContainer = wordlistData.Items || wordlistData.items;
+                if (!itemsContainer) {
+                    return;
+                }
+                const itemArray = Array.isArray(itemsContainer.WordListItem)
+                    ? itemsContainer.WordListItem
+                    : itemsContainer.WordListItem
+                        ? [itemsContainer.WordListItem]
+                        : [];
+                const items = itemArray.map((item) => ({
+                    text: item.Text?.s?.r || item.text?.s?.r || '',
+                    image: item.Image || item.image || undefined,
+                    partOfSpeech: item.PartOfSpeech || item.partOfSpeech || 'Unknown',
+                }));
+                if (items.length > 0) {
+                    wordlists.set(gridName, { items });
+                }
+            }
+            catch (error) {
+                // Skip grids with parsing errors
+                console.warn(`Failed to extract wordlist from ${entry.entryName}:`, error);
+            }
+        }
+    });
+    return wordlists;
+}
+/**
+ * Updates or adds a wordlist to a specific grid in a gridset
+ *
+ * @param gridsetBuffer - The gridset file as a Buffer
+ * @param gridName - The name of the grid to update (e.g., "Greetings")
+ * @param wordlist - The wordlist to add/update
+ * @returns Updated gridset as a Buffer
+ *
+ * @example
+ * const gridsetBuffer = fs.readFileSync('my-gridset.gridset');
+ * const newWordlist = createWordlist(['hello', 'hi', 'hey']);
+ * const updatedGridset = updateWordlist(gridsetBuffer, 'Greetings', newWordlist);
+ * fs.writeFileSync('updated-gridset.gridset', updatedGridset);
+ */
+function updateWordlist(gridsetBuffer, gridName, wordlist) {
+    const parser = new fast_xml_parser_1.XMLParser();
+    const builder = new fast_xml_parser_1.XMLBuilder({
+        ignoreAttributes: false,
+        format: true,
+        indentBy: '  ',
+        suppressEmptyNode: false,
+    });
+    let zip;
+    try {
+        zip = new adm_zip_1.default(gridsetBuffer);
+    }
+    catch (error) {
+        throw new Error(`Invalid gridset buffer: ${error.message}`);
+    }
+    let found = false;
+    // Find and update the grid
+    zip.getEntries().forEach((entry) => {
+        if (entry.entryName.startsWith('Grids/') && entry.entryName.endsWith('grid.xml')) {
+            const match = entry.entryName.match(/^Grids\/([^/]+)\//);
+            const currentGridName = match ? match[1] : null;
+            if (currentGridName === gridName) {
+                try {
+                    const xmlContent = entry.getData().toString('utf8');
+                    const data = parser.parse(xmlContent);
+                    const grid = data.Grid || data.grid;
+                    if (!grid) {
+                        return;
+                    }
+                    // Build the new wordlist XML structure
+                    const items = wordlist.items.map((item) => ({
+                        WordListItem: {
+                            Text: {
+                                s: {
+                                    '@_Image': item.image || '',
+                                    r: item.text,
+                                },
+                            },
+                            Image: item.image || '',
+                            PartOfSpeech: item.partOfSpeech || 'Unknown',
+                        },
+                    }));
+                    grid.WordList = {
+                        Items: {
+                            WordListItem: items.length === 1 ? items[0].WordListItem : items.map((i) => i.WordListItem),
+                        },
+                    };
+                    // Rebuild the XML
+                    const updatedXml = builder.build(data);
+                    zip.updateFile(entry, Buffer.from(updatedXml, 'utf8'));
+                    found = true;
+                }
+                catch (error) {
+                    throw new Error(`Failed to update wordlist in grid "${gridName}": ${error}`);
+                }
+            }
+        }
+    });
+    if (!found) {
+        throw new Error(`Grid "${gridName}" not found in gridset`);
+    }
+    return zip.toBuffer();
+}

package/dist/processors/index.d.ts

@@ -10,5 +10,7 @@ export { AstericsGridProcessor } from './astericsGridProcessor';
 export { getPageTokenImageMap, getAllowedImageEntries, openImage } from './gridset/helpers';
 export { getPageTokenImageMap as getGridsetPageTokenImageMap, getAllowedImageEntries as getGridsetAllowedImageEntries, openImage as openGridsetImage, } from './gridset/helpers';
 export { resolveGrid3CellImage } from './gridset/resolver';
+export { createWordlist, extractWordlists, updateWordlist, wordlistToXml, type WordList, type WordListItem, } from './gridset/wordlistHelpers';
+export { DEFAULT_GRID3_STYLES, CATEGORY_STYLES, ensureAlphaChannel, createDefaultStylesXml, createCategoryStyle, type Grid3Style, } from './gridset/styleHelpers';
 export { getPageTokenImageMap as getSnapPageTokenImageMap, getAllowedImageEntries as getSnapAllowedImageEntries, openImage as openSnapImage, } from './snap/helpers';
 export { getPageTokenImageMap as getTouchChatPageTokenImageMap, getAllowedImageEntries as getTouchChatAllowedImageEntries, openImage as openTouchChatImage, } from './touchchat/helpers';

package/dist/processors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openTouchChatImage = exports.getTouchChatAllowedImageEntries = exports.getTouchChatPageTokenImageMap = exports.openSnapImage = exports.getSnapAllowedImageEntries = exports.getSnapPageTokenImageMap = exports.resolveGrid3CellImage = exports.openGridsetImage = exports.getGridsetAllowedImageEntries = exports.getGridsetPageTokenImageMap = exports.openImage = exports.getAllowedImageEntries = exports.getPageTokenImageMap = exports.AstericsGridProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.OpmlProcessor = exports.ObfProcessor = exports.GridsetProcessor = exports.ExcelProcessor = exports.DotProcessor = exports.ApplePanelsProcessor = void 0;
+exports.openTouchChatImage = exports.getTouchChatAllowedImageEntries = exports.getTouchChatPageTokenImageMap = exports.openSnapImage = exports.getSnapAllowedImageEntries = exports.getSnapPageTokenImageMap = exports.createCategoryStyle = exports.createDefaultStylesXml = exports.ensureAlphaChannel = exports.CATEGORY_STYLES = exports.DEFAULT_GRID3_STYLES = exports.wordlistToXml = exports.updateWordlist = exports.extractWordlists = exports.createWordlist = exports.resolveGrid3CellImage = exports.openGridsetImage = exports.getGridsetAllowedImageEntries = exports.getGridsetPageTokenImageMap = exports.openImage = exports.getAllowedImageEntries = exports.getPageTokenImageMap = exports.AstericsGridProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.OpmlProcessor = exports.ObfProcessor = exports.GridsetProcessor = exports.ExcelProcessor = exports.DotProcessor = exports.ApplePanelsProcessor = void 0;
 var applePanelsProcessor_1 = require("./applePanelsProcessor");
 Object.defineProperty(exports, "ApplePanelsProcessor", { enumerable: true, get: function () { return applePanelsProcessor_1.ApplePanelsProcessor; } });
 var dotProcessor_1 = require("./dotProcessor");
@@ -30,6 +30,19 @@ Object.defineProperty(exports, "getGridsetAllowedImageEntries", { enumerable: tr
 Object.defineProperty(exports, "openGridsetImage", { enumerable: true, get: function () { return helpers_2.openImage; } });
 var resolver_1 = require("./gridset/resolver");
 Object.defineProperty(exports, "resolveGrid3CellImage", { enumerable: true, get: function () { return resolver_1.resolveGrid3CellImage; } });
+// Gridset (Grid 3) wordlist helpers
+var wordlistHelpers_1 = require("./gridset/wordlistHelpers");
+Object.defineProperty(exports, "createWordlist", { enumerable: true, get: function () { return wordlistHelpers_1.createWordlist; } });
+Object.defineProperty(exports, "extractWordlists", { enumerable: true, get: function () { return wordlistHelpers_1.extractWordlists; } });
+Object.defineProperty(exports, "updateWordlist", { enumerable: true, get: function () { return wordlistHelpers_1.updateWordlist; } });
+Object.defineProperty(exports, "wordlistToXml", { enumerable: true, get: function () { return wordlistHelpers_1.wordlistToXml; } });
+// Gridset (Grid 3) style helpers
+var styleHelpers_1 = require("./gridset/styleHelpers");
+Object.defineProperty(exports, "DEFAULT_GRID3_STYLES", { enumerable: true, get: function () { return styleHelpers_1.DEFAULT_GRID3_STYLES; } });
+Object.defineProperty(exports, "CATEGORY_STYLES", { enumerable: true, get: function () { return styleHelpers_1.CATEGORY_STYLES; } });
+Object.defineProperty(exports, "ensureAlphaChannel", { enumerable: true, get: function () { return styleHelpers_1.ensureAlphaChannel; } });
+Object.defineProperty(exports, "createDefaultStylesXml", { enumerable: true, get: function () { return styleHelpers_1.createDefaultStylesXml; } });
+Object.defineProperty(exports, "createCategoryStyle", { enumerable: true, get: function () { return styleHelpers_1.createCategoryStyle; } });
 // Snap helpers (stubs)
 var helpers_3 = require("./snap/helpers");
 Object.defineProperty(exports, "getSnapPageTokenImageMap", { enumerable: true, get: function () { return helpers_3.getPageTokenImageMap; } });