@willwade/aac-processors 0.0.10 → 0.0.11

package/dist/processors/gridset/symbols.js

@@ -0,0 +1,468 @@
+"use strict";
+/**
+ * Grid 3 Symbol Library Resolution
+ *
+ * Grid 3 uses symbol libraries stored as .pix files in the installation directory.
+ * Symbol references in Grid files use the format: [library]/path/to/symbol.png
+ *
+ * Examples:
+ * - [widgit]/food/apple.png
+ * - [tawasl]/above bw.png
+ * - [ssnaps]963.jpg
+ * - [grid3x]/folder/document.png
+ *
+ * This module provides symbol resolution and metadata extraction.
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOCALE = exports.SYMBOL_LIBRARIES = void 0;
+exports.parseSymbolReference = parseSymbolReference;
+exports.isSymbolReference = isSymbolReference;
+exports.getDefaultGrid3Path = getDefaultGrid3Path;
+exports.getSymbolLibrariesDir = getSymbolLibrariesDir;
+exports.getSymbolSearchIndexesDir = getSymbolSearchIndexesDir;
+exports.getAvailableSymbolLibraries = getAvailableSymbolLibraries;
+exports.getSymbolLibraryInfo = getSymbolLibraryInfo;
+exports.resolveSymbolReference = resolveSymbolReference;
+exports.extractSymbolReferences = extractSymbolReferences;
+exports.createSymbolReference = createSymbolReference;
+exports.getSymbolLibraryName = getSymbolLibraryName;
+exports.getSymbolPath = getSymbolPath;
+exports.isKnownSymbolLibrary = isKnownSymbolLibrary;
+exports.getSymbolLibraryDisplayName = getSymbolLibraryDisplayName;
+exports.analyzeSymbolUsage = analyzeSymbolUsage;
+exports.symbolReferenceToFilename = symbolReferenceToFilename;
+exports.getSymbolsDir = getSymbolsDir;
+exports.getSymbolSearchDir = getSymbolSearchDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+/**
+ * Default Grid 3 installation paths by platform
+ */
+const DEFAULT_GRID3_PATHS = {
+    win32: 'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+    darwin: '/Applications/Grid 3.app/Contents/Resources',
+    linux: '/opt/smartbox/grid3',
+};
+/**
+ * Path to Symbols directory within Grid 3 installation
+ * Contains .symbols ZIP archives with actual images
+ */
+const SYMBOLS_SUBDIR = 'Resources\\Symbols';
+/**
+ * Path to symbol search indexes within Grid 3 installation
+ * Contains .pix index files for searching
+ */
+const SYMBOLSEARCH_SUBDIR = 'Locale';
+/**
+ * Known symbol libraries in Grid 3
+ */
+exports.SYMBOL_LIBRARIES = {
+    WIDGIT: 'widgit',
+    TAWASL: 'tawasl',
+    SSNAPS: 'ssnaps',
+    GRID3X: 'grid3x',
+    GRID2X: 'grid2x',
+    BLISSX: 'blissx',
+    EYEGAZ: 'eyegaz',
+    INTERL: 'interl',
+    METACM: 'metacm',
+    MJPCS: 'mjpcs#',
+    PCSHC: 'pcshc#',
+    PCSTL: 'pcstl#',
+    SESENS: 'sesens',
+    SSTIX: 'sstix#',
+    SYMOJI: 'symoji',
+};
+/**
+ * Default locale to use
+ */
+exports.DEFAULT_LOCALE = 'en-GB';
+/**
+ * Parse a symbol reference string
+ * @param reference - Symbol reference like "[widgit]/food/apple.png"
+ * @returns Parsed symbol reference
+ */
+function parseSymbolReference(reference) {
+    const trimmed = reference.trim();
+    // Match pattern: [library]/path or [library]path
+    const match = trimmed.match(/^\[([^\]]+)\](.+)$/);
+    if (!match) {
+        return {
+            library: '',
+            path: trimmed,
+            fullReference: trimmed,
+            isValid: false,
+        };
+    }
+    const [, library, symbolPath] = match;
+    return {
+        library: library.toLowerCase(),
+        path: symbolPath.replace(/^\\+/, '').trim(), // Remove leading slashes
+        fullReference: trimmed,
+        isValid: true,
+    };
+}
+/**
+ * Check if a string is a symbol library reference
+ * @param reference - String to check
+ * @returns True if it's a symbol reference like [widgit]/...
+ */
+function isSymbolReference(reference) {
+    return reference.trim().startsWith('[');
+}
+/**
+ * Get the default Grid 3 installation path for the current platform
+ * @returns Default Grid 3 path or empty string if not found
+ */
+function getDefaultGrid3Path() {
+    const platform = process.platform;
+    const defaultPath = DEFAULT_GRID3_PATHS[platform] || '';
+    if (defaultPath && fs.existsSync(defaultPath)) {
+        return defaultPath;
+    }
+    // Try to find Grid 3 in common locations
+    const commonPaths = [
+        'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        'C:\\Program Files\\Smartbox\\Grid 3',
+        '/Applications/Grid 3.app',
+        '/opt/smartbox/grid3',
+    ];
+    for (const testPath of commonPaths) {
+        if (fs.existsSync(testPath)) {
+            return testPath;
+        }
+    }
+    return '';
+}
+/**
+ * Get the Symbol Libraries directory path
+ * Contains .symbols ZIP archives with actual image files
+ * @param grid3Path - Grid 3 installation path
+ * @returns Path to Symbol Libraries directory (e.g., "C:\...\Grid 3\Resources\Symbols")
+ */
+function getSymbolLibrariesDir(grid3Path) {
+    return path.join(grid3Path, SYMBOLS_SUBDIR);
+}
+/**
+ * Get the symbol search indexes directory path for a given locale
+ * Contains .pix index files for searching symbols
+ * @param grid3Path - Grid 3 installation path
+ * @param locale - Locale code (e.g., 'en-GB')
+ * @returns Path to symbol search indexes directory (e.g., "C:\...\Grid 3\Locale\en-GB\symbolsearch")
+ */
+function getSymbolSearchIndexesDir(grid3Path, locale = exports.DEFAULT_LOCALE) {
+    return path.join(grid3Path, SYMBOLSEARCH_SUBDIR, locale, 'symbolsearch');
+}
+/**
+ * Get all available symbol libraries in the Grid 3 installation
+ * @param options - Resolution options
+ * @returns Array of symbol library information
+ */
+function getAvailableSymbolLibraries(options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return [];
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    if (!fs.existsSync(symbolsDir)) {
+        return [];
+    }
+    const libraries = [];
+    const files = fs.readdirSync(symbolsDir);
+    for (const file of files) {
+        if (file.endsWith('.symbols')) {
+            const fullPath = path.join(symbolsDir, file);
+            const stats = fs.statSync(fullPath);
+            const libraryName = path.basename(file, '.symbols');
+            libraries.push({
+                name: libraryName,
+                pixFile: fullPath, // Reuse this field for the .symbols file path
+                exists: true,
+                size: stats.size,
+                locale: 'global', // .symbols files are not locale-specific
+            });
+        }
+    }
+    return libraries.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if a symbol library exists
+ * @param libraryName - Name of the library (e.g., 'widgit', 'tawasl')
+ * @param options - Resolution options
+ * @returns Symbol library info or undefined if not found
+ */
+function getSymbolLibraryInfo(libraryName, options = {}) {
+    const grid3Path = options.grid3Path || options.symbolDir || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return undefined;
+    }
+    const symbolsDir = getSymbolLibrariesDir(grid3Path);
+    const normalizedLibName = libraryName.toLowerCase();
+    // Try different case variations
+    const variations = [
+        normalizedLibName + '.symbols',
+        normalizedLibName.toUpperCase() + '.symbols',
+        libraryName + '.symbols',
+    ];
+    for (const file of variations) {
+        const fullPath = path.join(symbolsDir, file);
+        if (fs.existsSync(fullPath)) {
+            const stats = fs.statSync(fullPath);
+            return {
+                name: libraryName,
+                pixFile: fullPath,
+                exists: true,
+                size: stats.size,
+                locale: 'global',
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve a symbol reference to extract the actual image data
+ * @param reference - Symbol reference like "[tawasl]/above bw.png"
+ * @param options - Resolution options
+ * @returns Resolution result with image data if found
+ */
+function resolveSymbolReference(reference, options = {}) {
+    const parsed = parseSymbolReference(reference);
+    if (!parsed.isValid) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Invalid symbol reference format',
+        };
+    }
+    const grid3Path = options.grid3Path || getDefaultGrid3Path();
+    if (!grid3Path) {
+        return {
+            reference: parsed,
+            found: false,
+            error: 'Grid 3 installation not found. Please specify grid3Path.',
+        };
+    }
+    const libraryInfo = getSymbolLibraryInfo(parsed.library, { grid3Path });
+    if (!libraryInfo || !libraryInfo.exists) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Symbol library '${parsed.library}' not found at ${libraryInfo?.pixFile || 'unknown'}`,
+        };
+    }
+    try {
+        // .symbols files are ZIP archives
+        const zip = new adm_zip_1.default(libraryInfo.pixFile);
+        // The path in the symbol reference becomes the path within the symbols/ folder
+        // e.g., [tawasl]/above bw.png becomes symbols/above bw.png
+        const symbolPath = `symbols/${parsed.path}`;
+        const entry = zip.getEntry(symbolPath);
+        if (!entry) {
+            // Try without the symbols/ prefix (in case reference already includes it)
+            const altPath = parsed.path.startsWith('symbols/') ? parsed.path : `symbols/${parsed.path}`;
+            const altEntry = zip.getEntry(altPath);
+            if (!altEntry) {
+                return {
+                    reference: parsed,
+                    found: false,
+                    error: `Symbol '${parsed.path}' not found in library '${parsed.library}'`,
+                    path: libraryInfo.pixFile,
+                    libraryInfo,
+                };
+            }
+            // Found with alternate path
+            const data = altEntry.getData();
+            return {
+                reference: parsed,
+                found: true,
+                path: libraryInfo.pixFile,
+                data,
+                libraryInfo,
+            };
+        }
+        // Found the symbol!
+        const data = entry.getData();
+        return {
+            reference: parsed,
+            found: true,
+            path: libraryInfo.pixFile,
+            data,
+            libraryInfo,
+        };
+    }
+    catch (error) {
+        return {
+            reference: parsed,
+            found: false,
+            error: `Failed to extract symbol: ${error.message}`,
+            path: libraryInfo.pixFile,
+            libraryInfo,
+        };
+    }
+}
+/**
+ * Get all symbol references from a gridset
+ * This scans button images for symbol references
+ * @param tree - AAC tree from loaded gridset
+ * @returns Array of unique symbol references
+ */
+function extractSymbolReferences(tree) {
+    const references = new Set();
+    for (const pageId in tree.pages) {
+        const page = tree.pages[pageId];
+        if (page.buttons) {
+            for (const button of page.buttons) {
+                if (button.image && isSymbolReference(String(button.image))) {
+                    references.add(String(button.image));
+                }
+                // Check for symbol library metadata
+                if (button.symbolLibrary) {
+                    const ref = `[${button.symbolLibrary}]${button.symbolPath || ''}`;
+                    references.add(ref);
+                }
+            }
+        }
+    }
+    return Array.from(references).sort();
+}
+/**
+ * Create a symbol reference from library and path
+ * @param library - Library name
+ * @param symbolPath - Path within the library
+ * @returns Formatted symbol reference
+ */
+function createSymbolReference(library, symbolPath) {
+    const normalizedLib = library.toLowerCase().replace(/\[|\]/g, '');
+    const normalizedPath = symbolPath.replace(/^\\+/, '');
+    return `[${normalizedLib}]${normalizedPath}`;
+}
+/**
+ * Get the library name from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Library name or empty string
+ */
+function getSymbolLibraryName(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.library;
+}
+/**
+ * Get the symbol path from a symbol reference
+ * @param reference - Symbol reference
+ * @returns Symbol path or empty string
+ */
+function getSymbolPath(reference) {
+    const parsed = parseSymbolReference(reference);
+    return parsed.path;
+}
+/**
+ * Check if a symbol library is one of the known Grid 3 libraries
+ * @param libraryName - Library name to check
+ * @returns True if it's a known library
+ */
+function isKnownSymbolLibrary(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    return Object.values(exports.SYMBOL_LIBRARIES).includes(normalized);
+}
+/**
+ * Get display name for a symbol library
+ * @param libraryName - Library name
+ * @returns Human-readable display name
+ */
+function getSymbolLibraryDisplayName(libraryName) {
+    const normalized = libraryName.toLowerCase().replace(/\[|\]/g, '');
+    const displayNames = {
+        widgit: 'Widgit Symbols',
+        tawasl: 'Tawasol (Arabic)',
+        ssnaps: 'Smartbox Symbol Snapshots',
+        grid3x: 'Grid 3 Extended',
+        grid2x: 'Grid 2 Extended',
+        blissx: 'Blissymbols',
+        eyegaz: 'Eye Gaze Symbols',
+        interl: 'International Symbols',
+        metacm: 'MetaComm',
+        mjpcs: 'Mayer-Johnson PCS',
+        pcshc: 'PCS High Contrast',
+        pcstl: 'PCS Thin Line',
+        sesens: 'Sensory Software',
+        sstix: 'Smartbox TIX',
+        symoji: 'Symbol Emoji',
+    };
+    return displayNames[normalized] || normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function analyzeSymbolUsage(tree) {
+    const references = extractSymbolReferences(tree);
+    const byLibrary = {};
+    const libraries = new Set();
+    for (const ref of references) {
+        const lib = getSymbolLibraryName(ref);
+        byLibrary[lib] = (byLibrary[lib] || 0) + 1;
+        if (lib) {
+            libraries.add(lib);
+        }
+    }
+    return {
+        totalSymbols: references.length,
+        byLibrary,
+        uniqueReferences: references,
+        librariesUsed: Array.from(libraries).sort(),
+    };
+}
+/**
+ * Convert symbol reference to filename for embedded images
+ * Grid 3 sometimes embeds symbols with special naming
+ * @param reference - Symbol reference
+ * @param cellX - Cell X coordinate
+ * @param cellY - Cell Y coordinate
+ * @returns Generated filename
+ */
+function symbolReferenceToFilename(reference, cellX, cellY) {
+    const parsed = parseSymbolReference(reference);
+    const ext = path.extname(parsed.path) || '.png';
+    // Grid 3 format: {x}-{y}-0-text-0.{ext}
+    return `${cellX}-${cellY}-0-text-0${ext}`;
+}
+// ============================================================================
+// BACKWARD COMPATIBILITY ALIASES
+// ============================================================================
+/**
+ * @deprecated Use getSymbolLibrariesDir() instead - more descriptive name
+ * Get the Symbols directory path (where .symbols ZIP archives are)
+ */
+function getSymbolsDir(grid3Path) {
+    return getSymbolLibrariesDir(grid3Path);
+}
+/**
+ * @deprecated Use getSymbolSearchIndexesDir() instead - more descriptive name
+ * Get the symbol search directory for a given locale (where .pix index files are)
+ */
+function getSymbolSearchDir(grid3Path, locale = exports.DEFAULT_LOCALE) {
+    return getSymbolSearchIndexesDir(grid3Path, locale);
+}

package/dist/processors/gridsetProcessor.js

@@ -14,6 +14,11 @@ const password_1 = require("./gridset/password");
 const crypto_1 = __importDefault(require("crypto"));
 const zlib_1 = __importDefault(require("zlib"));
 const gridsetValidator_1 = require("../validation/gridsetValidator");
+// New imports for enhanced Grid 3 support
+const pluginTypes_1 = require("./gridset/pluginTypes");
+const commands_1 = require("./gridset/commands");
+const symbols_1 = require("./gridset/symbols");
+const resolver_2 = require("./gridset/resolver");
 class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -254,6 +259,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
             fontColor: grid3Style.FontColour,
             fontFamily: grid3Style.FontName,
             fontSize: grid3Style.FontSize ? parseInt(String(grid3Style.FontSize)) : undefined,
+            backgroundShape: grid3Style.BackgroundShape !== undefined
+                ? parseInt(String(grid3Style.BackgroundShape))
+                : undefined,
         };
     }
     // Helper function to get style by ID or return default
@@ -496,11 +504,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             }
                         }
                         const message = label; // Use caption as message
+                        // Detect plugin cell type (Workspace, LiveCell, AutoContent)
+                        const pluginMetadata = (0, pluginTypes_1.detectPluginCellType)(content);
                         // Parse all command types from Grid3 and create semantic actions
                         let semanticAction;
                         let legacyAction = null;
                         // infer action type implicitly from commands; no explicit enum needed
                         let navigationTarget;
+                        let detectedCommands = []; // Store detected command metadata
                         const commands = content.Commands?.Command || content.commands?.command;
                         // Resolve image for this cell using FileMap and coordinate heuristics
                         const imageCandidate = captionAndImage?.Image ||
@@ -520,8 +531,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             y: cellY + 1,
                             dynamicFiles,
                         }, entries) || undefined;
+                        // Check if image is a symbol library reference
+                        let symbolLibraryRef = null;
+                        if (declaredImageName && (0, resolver_2.isSymbolLibraryReference)(declaredImageName)) {
+                            symbolLibraryRef = (0, symbols_1.parseSymbolReference)(declaredImageName);
+                        }
                         if (commands) {
                             const commandArr = Array.isArray(commands) ? commands : [commands];
+                            detectedCommands = commandArr.map((cmd) => (0, commands_1.detectCommand)(cmd));
                             for (const command of commandArr) {
                                 const commandId = command['@_ID'] || command.ID || command.id;
                                 const parameters = command.Parameter || command.parameter;
@@ -911,10 +928,27 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             y: cellY,
                             columnSpan: colSpan,
                             rowSpan: rowSpan,
+                            contentType: pluginMetadata.cellType === pluginTypes_1.Grid3CellType.Regular
+                                ? 'Normal'
+                                : pluginMetadata.cellType === pluginTypes_1.Grid3CellType.Workspace
+                                    ? 'Workspace'
+                                    : pluginMetadata.cellType === pluginTypes_1.Grid3CellType.LiveCell
+                                        ? 'LiveCell'
+                                        : 'AutoContent',
+                            contentSubType: pluginMetadata.subType ||
+                                pluginMetadata.liveCellType ||
+                                pluginMetadata.autoContentType,
+                            symbolLibrary: symbolLibraryRef?.library || undefined,
+                            symbolPath: symbolLibraryRef?.path || undefined,
                             style: {
                                 ...cellStyle,
                                 ...inlineStyle, // Inline styles override referenced styles
                             },
+                            parameters: {
+                                pluginMetadata: pluginMetadata, // Store full plugin metadata for future use
+                                grid3Commands: detectedCommands, // Store detected command metadata
+                                symbolLibraryRef: symbolLibraryRef, // Store full symbol reference
+                            },
                         });
                         // Add button to page
                         page.addButton(button);

package/dist/processors/index.d.ts

@@ -13,7 +13,15 @@ export { resolveGrid3CellImage } from './gridset/resolver';
 export { createWordlist, extractWordlists, updateWordlist, wordlistToXml, type WordList, type WordListItem, } from './gridset/wordlistHelpers';
 export { resolveGridsetPassword, resolveGridsetPasswordFromEnv } from './gridset/password';
 export { getNamedColor, rgbaToHex, channelToHex, clampColorChannel, clampAlpha, toHexColor, darkenColor, normalizeColor, ensureAlphaChannel, } from './gridset/colorUtils';
-export { DEFAULT_GRID3_STYLES, CATEGORY_STYLES, createDefaultStylesXml, createCategoryStyle, } from './gridset/styleHelpers';
+export { DEFAULT_GRID3_STYLES, CATEGORY_STYLES, createDefaultStylesXml, createCategoryStyle, CellBackgroundShape, SHAPE_NAMES, } from './gridset/styleHelpers';
 export { ensureAlphaChannel as ensureAlphaChannelFromStyles } from './gridset/styleHelpers';
+export { detectPluginCellType, type Grid3PluginMetadata, Grid3CellType, WORKSPACE_TYPES, LIVECELL_TYPES, AUTOCONTENT_TYPES, getCellTypeDisplayName, isWorkspaceCell, isLiveCell, isAutoContentCell, isRegularCell, } from './gridset/pluginTypes';
+export { detectCommand, getCommandDefinition, getCommandsByPlugin, getCommandsByCategory, getAllCommandIds, getAllPluginIds, extractCommandParameters, GRID3_COMMANDS, type Grid3CommandDefinition, type CommandParameter, type ExtractedParameters, Grid3CommandCategory, } from './gridset/commands';
+export * from './gridset/index';
+export { parseSymbolReference, isSymbolReference, resolveSymbolReference, getAvailableSymbolLibraries, getSymbolLibraryInfo, extractSymbolReferences, analyzeSymbolUsage, createSymbolReference, getSymbolLibraryName, getSymbolPath, isKnownSymbolLibrary, getSymbolLibraryDisplayName, getDefaultGrid3Path, getSymbolLibrariesDir, getSymbolSearchIndexesDir, symbolReferenceToFilename, SYMBOL_LIBRARIES, } from './gridset/symbols';
+export { isSymbolLibraryReference, parseImageSymbolReference } from './gridset/resolver';
+export { getSymbolsDir, getSymbolSearchDir } from './gridset/symbols';
+export { extractButtonImage, extractSymbolLibraryImage, convertToAstericsImage, analyzeSymbolExtraction, suggestExtractionStrategy, exportSymbolReferencesToCsv, createSymbolManifest, } from './gridset/symbolExtractor';
+export { parsePixFile, loadSearchIndexes, searchSymbols, searchSymbolsWithReferences, getSymbolFilename, getSymbolDisplayName, getAllSearchTerms, getSearchSuggestions, countLibrarySymbols, getSymbolSearchStats, } from './gridset/symbolSearch';
 export { getPageTokenImageMap as getSnapPageTokenImageMap, getAllowedImageEntries as getSnapAllowedImageEntries, openImage as openSnapImage, findSnapPackages, findSnapPackagePath, findSnapUsers, findSnapUserVocabularies, findSnapUserHistory, isSnapInstalled, readSnapUsage, readSnapUsageForUser, type SnapPackagePath, type SnapUserInfo, type SnapUsageEntry, } from './snap/helpers';
 export { getPageTokenImageMap as getTouchChatPageTokenImageMap, getAllowedImageEntries as getTouchChatAllowedImageEntries, openImage as openTouchChatImage, } from './touchchat/helpers';