@git.zone/tsbundle 2.6.3 → 2.7.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tsbundle',
-    version: '2.6.3',
+    version: '2.7.0',
     description: 'a multi-bundler tool supporting esbuild, rolldown, and rspack for painless bundling of web projects'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxvQkFBb0I7SUFDMUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFHQUFxRztDQUNuSCxDQUFBIn0=

package/dist_ts/interfaces/index.d.ts

@@ -11,3 +11,20 @@ export interface IEnvTransportOptions {
     mode: 'test' | 'production';
     argv: ICliOptions;
 }
+export type TOutputMode = 'bundle' | 'base64ts';
+export type TBundler = 'esbuild' | 'rolldown' | 'rspack';
+export interface IBundleConfig {
+    from: string;
+    to: string;
+    outputMode?: TOutputMode;
+    bundler?: TBundler;
+    production?: boolean;
+    includeFiles?: string[];
+}
+export interface ITsbundleConfig {
+    bundles: IBundleConfig[];
+}
+export interface IBase64File {
+    path: string;
+    contentBase64: string;
+}

package/dist_ts/mod_custom/index.d.ts

@@ -0,0 +1,33 @@
+export declare class CustomBundleHandler {
+    private cwd;
+    private config;
+    constructor(cwd?: string);
+    /**
+     * Load configuration from npmextra.json
+     */
+    loadConfig(): Promise<boolean>;
+    /**
+     * Process all configured bundles
+     */
+    processAllBundles(): Promise<void>;
+    /**
+     * Process a single bundle configuration
+     */
+    private processSingleBundle;
+    /**
+     * Handle base64ts output mode
+     */
+    private handleBase64TsOutput;
+    /**
+     * Handle standard bundle output mode
+     */
+    private handleBundleOutput;
+    /**
+     * Copy files matching a pattern to the output directory
+     */
+    private copyIncludedFiles;
+}
+/**
+ * Run the custom bundle command
+ */
+export declare function runCustomBundles(): Promise<void>;

package/dist_ts/mod_custom/index.js

@@ -0,0 +1,167 @@
+import * as plugins from './plugins.js';
+import * as paths from '../paths.js';
+import * as interfaces from '../interfaces/index.js';
+import { TsBundle } from '../tsbundle.class.tsbundle.js';
+import { HtmlHandler } from '../mod_html/index.js';
+import { Base64TsOutput } from '../mod_output/index.js';
+const TEMP_DIR = '.nogit/tsbundle-temp';
+export class CustomBundleHandler {
+    cwd;
+    config;
+    constructor(cwd = paths.cwd) {
+        this.cwd = cwd;
+    }
+    /**
+     * Load configuration from npmextra.json
+     */
+    async loadConfig() {
+        const npmextraInstance = new plugins.npmextra.Npmextra(this.cwd);
+        this.config = npmextraInstance.dataFor('@git.zone/tsbundle', {
+            bundles: [],
+        });
+        if (!this.config.bundles || this.config.bundles.length === 0) {
+            console.log('No bundle configuration found.');
+            console.log('Run `tsbundle init` to create one.');
+            return false;
+        }
+        console.log(`Found ${this.config.bundles.length} bundle configuration(s)`);
+        return true;
+    }
+    /**
+     * Process all configured bundles
+     */
+    async processAllBundles() {
+        for (let i = 0; i < this.config.bundles.length; i++) {
+            const bundleConfig = this.config.bundles[i];
+            console.log(`\nProcessing bundle ${i + 1}/${this.config.bundles.length}: ${bundleConfig.from} -> ${bundleConfig.to}`);
+            await this.processSingleBundle(bundleConfig);
+        }
+    }
+    /**
+     * Process a single bundle configuration
+     */
+    async processSingleBundle(bundleConfig) {
+        const outputMode = bundleConfig.outputMode || 'bundle';
+        const bundler = bundleConfig.bundler || 'esbuild';
+        // Determine temp output path
+        const tempDir = plugins.path.join(this.cwd, TEMP_DIR);
+        const tempBundlePath = plugins.path.join(tempDir, `bundle-${Date.now()}.js`);
+        // Ensure temp directory exists
+        await plugins.fs.directory(tempDir).create();
+        // Build the bundle to temp location
+        const tsbundle = new TsBundle();
+        await tsbundle.build(this.cwd, bundleConfig.from, tempBundlePath, {
+            bundler,
+            production: bundleConfig.production || false,
+        });
+        if (outputMode === 'base64ts') {
+            await this.handleBase64TsOutput(bundleConfig, tempBundlePath);
+        }
+        else {
+            await this.handleBundleOutput(bundleConfig, tempBundlePath);
+        }
+        // Clean up temp file
+        const tempFileExists = await plugins.fs.file(tempBundlePath).exists();
+        if (tempFileExists) {
+            await plugins.fs.file(tempBundlePath).delete();
+        }
+    }
+    /**
+     * Handle base64ts output mode
+     */
+    async handleBase64TsOutput(bundleConfig, tempBundlePath) {
+        const base64Output = new Base64TsOutput(this.cwd);
+        // Add the bundle itself
+        const bundleContent = await plugins.fs.file(tempBundlePath).read();
+        base64Output.addFile('bundle.js', bundleContent);
+        // Add included files
+        if (bundleConfig.includeFiles && bundleConfig.includeFiles.length > 0) {
+            for (const pattern of bundleConfig.includeFiles) {
+                await base64Output.addFilesFromGlob(pattern);
+            }
+        }
+        // Write the TypeScript output
+        await base64Output.writeToFile(bundleConfig.to);
+    }
+    /**
+     * Handle standard bundle output mode
+     */
+    async handleBundleOutput(bundleConfig, tempBundlePath) {
+        // Move bundle to final destination
+        const toPath = plugins.smartpath.transform.toAbsolute(bundleConfig.to, this.cwd);
+        const toDir = plugins.path.dirname(toPath);
+        await plugins.fs.directory(toDir).create();
+        const bundleContent = await plugins.fs.file(tempBundlePath).read();
+        await plugins.fs.file(toPath).write(bundleContent);
+        console.log(`Bundle written to: ${bundleConfig.to}`);
+        // Process included files (copy them)
+        if (bundleConfig.includeFiles && bundleConfig.includeFiles.length > 0) {
+            const htmlHandler = new HtmlHandler();
+            const outputDir = plugins.path.dirname(toPath);
+            for (const pattern of bundleConfig.includeFiles) {
+                await this.copyIncludedFiles(pattern, outputDir);
+            }
+        }
+    }
+    /**
+     * Copy files matching a pattern to the output directory
+     */
+    async copyIncludedFiles(pattern, outputDir) {
+        const absolutePattern = plugins.smartpath.transform.toAbsolute(pattern, this.cwd);
+        const patternDir = plugins.path.dirname(absolutePattern);
+        const patternBase = plugins.path.basename(absolutePattern);
+        const isGlobPattern = patternBase.includes('*');
+        if (isGlobPattern) {
+            const dirPath = patternDir.replace(/\/\*\*$/, '');
+            const dirExists = await plugins.fs.directory(dirPath).exists();
+            if (!dirExists) {
+                console.log(`Directory does not exist: ${dirPath}`);
+                return;
+            }
+            const isRecursive = pattern.includes('**');
+            let entries;
+            if (isRecursive) {
+                entries = await plugins.fs.directory(dirPath).recursive().list();
+            }
+            else {
+                entries = await plugins.fs.directory(dirPath).list();
+            }
+            const filePattern = patternBase.replace('*', '.*');
+            const regex = new RegExp(filePattern);
+            for (const entry of entries) {
+                if (!entry.isDirectory && regex.test(entry.name)) {
+                    const fullPath = plugins.path.join(dirPath, entry.path);
+                    const relativePath = plugins.path.relative(this.cwd, fullPath);
+                    const destPath = plugins.path.join(outputDir, plugins.path.basename(entry.path));
+                    await plugins.fs.directory(plugins.path.dirname(destPath)).create();
+                    await plugins.fs.file(fullPath).copy(destPath);
+                    console.log(`Copied: ${relativePath} -> ${destPath}`);
+                }
+            }
+        }
+        else {
+            const fileExists = await plugins.fs.file(absolutePattern).exists();
+            if (!fileExists) {
+                console.log(`File does not exist: ${absolutePattern}`);
+                return;
+            }
+            const fileName = plugins.path.basename(absolutePattern);
+            const destPath = plugins.path.join(outputDir, fileName);
+            await plugins.fs.file(absolutePattern).copy(destPath);
+            console.log(`Copied: ${pattern} -> ${destPath}`);
+        }
+    }
+}
+/**
+ * Run the custom bundle command
+ */
+export async function runCustomBundles() {
+    const handler = new CustomBundleHandler();
+    const hasConfig = await handler.loadConfig();
+    if (!hasConfig) {
+        return;
+    }
+    await handler.processAllBundles();
+    console.log('\nCustom bundle processing complete!');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/mod_custom/index.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_custom/plugins.d.ts

@@ -0,0 +1 @@
+export * from '../plugins.js';

package/dist_ts/mod_custom/plugins.js

@@ -0,0 +1,2 @@
+export * from '../plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9jdXN0b20vcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyJ9

package/dist_ts/mod_init/index.d.ts

@@ -0,0 +1,33 @@
+export declare class InitHandler {
+    private cwd;
+    private npmextraPath;
+    constructor(cwd?: string);
+    /**
+     * Load existing npmextra.json or create empty config
+     */
+    private loadExistingConfig;
+    /**
+     * Save config to npmextra.json
+     */
+    private saveConfig;
+    /**
+     * Run the interactive init wizard
+     */
+    runWizard(): Promise<void>;
+    /**
+     * Configure a single bundle interactively
+     */
+    private configureSingleBundle;
+    /**
+     * Configure a bundle manually with optional pre-filled values
+     */
+    private configureManualBundle;
+    /**
+     * Configure files to include
+     */
+    private configureIncludeFiles;
+}
+/**
+ * Run the init command
+ */
+export declare function runInit(): Promise<void>;

package/dist_ts/mod_init/index.js

@@ -0,0 +1,336 @@
+import * as plugins from './plugins.js';
+import * as paths from '../paths.js';
+import * as interfaces from '../interfaces/index.js';
+// Preset configurations
+const PRESETS = {
+    element: {
+        description: 'Web component / element bundle',
+        config: {
+            from: './ts_web/index.ts',
+            to: './dist_bundle/bundle.js',
+            outputMode: 'bundle',
+            bundler: 'esbuild',
+        },
+    },
+    website: {
+        description: 'Full website with HTML and assets',
+        config: {
+            from: './ts_web/index.ts',
+            to: './dist_serve/bundle.js',
+            outputMode: 'bundle',
+            bundler: 'esbuild',
+            includeFiles: ['./html/**/*.html', './assets/**/*'],
+        },
+    },
+    npm: {
+        description: 'NPM package bundle (from ts/)',
+        config: {
+            from: './ts/index.ts',
+            to: './dist_bundle/bundle.js',
+            outputMode: 'bundle',
+            bundler: 'esbuild',
+        },
+    },
+};
+export class InitHandler {
+    cwd;
+    npmextraPath;
+    constructor(cwd = paths.cwd) {
+        this.cwd = cwd;
+        this.npmextraPath = plugins.path.join(this.cwd, 'npmextra.json');
+    }
+    /**
+     * Load existing npmextra.json or create empty config
+     */
+    async loadExistingConfig() {
+        const fileExists = await plugins.fs.file(this.npmextraPath).exists();
+        if (fileExists) {
+            const content = (await plugins.fs.file(this.npmextraPath).encoding('utf8').read());
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return {};
+            }
+        }
+        return {};
+    }
+    /**
+     * Save config to npmextra.json
+     */
+    async saveConfig(config) {
+        const content = JSON.stringify(config, null, 2);
+        await plugins.fs.file(this.npmextraPath).encoding('utf8').write(content);
+        console.log(`\n✅ Configuration saved to npmextra.json`);
+    }
+    /**
+     * Run the interactive init wizard
+     */
+    async runWizard() {
+        console.log('\n🚀 tsbundle configuration wizard\n');
+        console.log('This wizard will help you configure bundle settings in npmextra.json.\n');
+        const npmextraJson = await this.loadExistingConfig();
+        if (!npmextraJson['@git.zone/tsbundle']) {
+            npmextraJson['@git.zone/tsbundle'] = { bundles: [] };
+        }
+        const existingBundles = npmextraJson['@git.zone/tsbundle'].bundles || [];
+        if (existingBundles.length > 0) {
+            console.log(`Found ${existingBundles.length} existing bundle configuration(s):\n`);
+            existingBundles.forEach((bundle, i) => {
+                console.log(`  ${i + 1}. ${bundle.from} → ${bundle.to} (${bundle.outputMode || 'bundle'})`);
+            });
+            console.log('');
+        }
+        let addMore = true;
+        while (addMore) {
+            const bundle = await this.configureSingleBundle();
+            if (bundle) {
+                npmextraJson['@git.zone/tsbundle'].bundles.push(bundle);
+                console.log(`\n✅ Bundle configuration added!`);
+            }
+            const continueInteract = new plugins.smartinteract.SmartInteract();
+            continueInteract.addQuestions([
+                {
+                    type: 'confirm',
+                    name: 'addAnother',
+                    message: 'Would you like to add another bundle configuration?',
+                    default: false,
+                },
+            ]);
+            const answers = await continueInteract.runQueue();
+            addMore = answers.getAnswerFor('addAnother');
+        }
+        await this.saveConfig(npmextraJson);
+        console.log('\n📋 Final configuration:\n');
+        const bundles = npmextraJson['@git.zone/tsbundle'].bundles;
+        bundles.forEach((bundle, i) => {
+            console.log(`  Bundle ${i + 1}:`);
+            console.log(`    From: ${bundle.from}`);
+            console.log(`    To: ${bundle.to}`);
+            console.log(`    Mode: ${bundle.outputMode || 'bundle'}`);
+            console.log(`    Bundler: ${bundle.bundler || 'esbuild'}`);
+            if (bundle.includeFiles && bundle.includeFiles.length > 0) {
+                console.log(`    Include: ${bundle.includeFiles.join(', ')}`);
+            }
+            console.log('');
+        });
+        console.log('Run `tsbundle` to build your bundles.\n');
+    }
+    /**
+     * Configure a single bundle interactively
+     */
+    async configureSingleBundle() {
+        // First, ask for preset or custom
+        const presetInteract = new plugins.smartinteract.SmartInteract();
+        presetInteract.addQuestions([
+            {
+                type: 'list',
+                name: 'preset',
+                message: 'Choose a configuration:',
+                choices: [
+                    { name: 'element - Web component / element bundle', value: 'element' },
+                    { name: 'website - Full website with HTML and assets', value: 'website' },
+                    { name: 'npm - NPM package bundle (from ts/)', value: 'npm' },
+                    { name: 'custom - Configure manually', value: 'custom' },
+                ],
+                default: 'element',
+            },
+        ]);
+        const presetAnswers = await presetInteract.runQueue();
+        const selectedPreset = presetAnswers.getAnswerFor('preset');
+        // If custom, go to full manual configuration
+        if (selectedPreset === 'custom') {
+            return this.configureManualBundle();
+        }
+        // Show preset config and ask if user wants to use it or customize
+        const preset = PRESETS[selectedPreset];
+        console.log(`\n📦 ${preset.description}:`);
+        console.log(`    From: ${preset.config.from}`);
+        console.log(`    To: ${preset.config.to}`);
+        console.log(`    Mode: ${preset.config.outputMode}`);
+        console.log(`    Bundler: ${preset.config.bundler}`);
+        if (preset.config.includeFiles && preset.config.includeFiles.length > 0) {
+            console.log(`    Include: ${preset.config.includeFiles.join(', ')}`);
+        }
+        const confirmInteract = new plugins.smartinteract.SmartInteract();
+        confirmInteract.addQuestions([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'Use this configuration?',
+                choices: [
+                    { name: 'Yes, use as-is', value: 'use' },
+                    { name: 'Customize it', value: 'customize' },
+                ],
+                default: 'use',
+            },
+        ]);
+        const confirmAnswers = await confirmInteract.runQueue();
+        const action = confirmAnswers.getAnswerFor('action');
+        if (action === 'use') {
+            // Return the preset config directly
+            return { ...preset.config };
+        }
+        // Customize: pre-fill with preset values
+        return this.configureManualBundle(preset.config);
+    }
+    /**
+     * Configure a bundle manually with optional pre-filled values
+     */
+    async configureManualBundle(prefill) {
+        const interact = new plugins.smartinteract.SmartInteract();
+        // Basic configuration questions
+        interact.addQuestions([
+            {
+                type: 'input',
+                name: 'from',
+                message: 'Entry point TypeScript file:',
+                default: prefill?.from || './ts_web/index.ts',
+            },
+            {
+                type: 'input',
+                name: 'to',
+                message: 'Output file path:',
+                default: prefill?.to || './dist_bundle/bundle.js',
+            },
+            {
+                type: 'list',
+                name: 'outputMode',
+                message: 'Output mode:',
+                choices: [
+                    { name: 'bundle - Standard JavaScript bundle file', value: 'bundle' },
+                    {
+                        name: 'base64ts - TypeScript file with base64-encoded content (for Deno compile)',
+                        value: 'base64ts',
+                    },
+                ],
+                default: prefill?.outputMode || 'bundle',
+            },
+            {
+                type: 'list',
+                name: 'bundler',
+                message: 'Bundler to use:',
+                choices: [
+                    { name: 'esbuild (fastest, recommended)', value: 'esbuild' },
+                    { name: 'rolldown (Rust-based, Rollup compatible)', value: 'rolldown' },
+                    { name: 'rspack (Webpack compatible)', value: 'rspack' },
+                ],
+                default: prefill?.bundler || 'esbuild',
+            },
+            {
+                type: 'confirm',
+                name: 'production',
+                message: 'Enable production mode (minification)?',
+                default: prefill?.production || false,
+            },
+            {
+                type: 'confirm',
+                name: 'hasIncludeFiles',
+                message: 'Include additional files (HTML, assets)?',
+                default: prefill?.includeFiles && prefill.includeFiles.length > 0 ? true : false,
+            },
+        ]);
+        const answers = await interact.runQueue();
+        const bundle = {
+            from: answers.getAnswerFor('from'),
+            to: answers.getAnswerFor('to'),
+            outputMode: answers.getAnswerFor('outputMode'),
+            bundler: answers.getAnswerFor('bundler'),
+            production: answers.getAnswerFor('production'),
+        };
+        // Update default output path based on mode
+        if (bundle.outputMode === 'base64ts' && bundle.to === './dist_bundle/bundle.js') {
+            const suggestInteract = new plugins.smartinteract.SmartInteract();
+            suggestInteract.addQuestions([
+                {
+                    type: 'input',
+                    name: 'to',
+                    message: 'For base64ts mode, suggest a .ts output path:',
+                    default: './ts/embedded-bundle.ts',
+                },
+            ]);
+            const suggestAnswers = await suggestInteract.runQueue();
+            bundle.to = suggestAnswers.getAnswerFor('to');
+        }
+        // Handle include files
+        if (answers.getAnswerFor('hasIncludeFiles')) {
+            bundle.includeFiles = await this.configureIncludeFiles(prefill?.includeFiles);
+        }
+        return bundle;
+    }
+    /**
+     * Configure files to include
+     */
+    async configureIncludeFiles(prefill) {
+        const includeFiles = [];
+        let addMore = true;
+        // If we have prefilled values, show them first
+        if (prefill && prefill.length > 0) {
+            console.log('\nPre-configured include patterns:');
+            prefill.forEach((p) => console.log(`  - ${p}`));
+            const keepInteract = new plugins.smartinteract.SmartInteract();
+            keepInteract.addQuestions([
+                {
+                    type: 'confirm',
+                    name: 'keepPrefill',
+                    message: 'Keep these patterns?',
+                    default: true,
+                },
+            ]);
+            const keepAnswers = await keepInteract.runQueue();
+            if (keepAnswers.getAnswerFor('keepPrefill')) {
+                includeFiles.push(...prefill);
+            }
+        }
+        console.log('\nAdd files or glob patterns to include (e.g., ./html/index.html, ./assets/**/*):\n');
+        // Ask if user wants to add more patterns
+        const addInteract = new plugins.smartinteract.SmartInteract();
+        addInteract.addQuestions([
+            {
+                type: 'confirm',
+                name: 'addPatterns',
+                message: includeFiles.length > 0 ? 'Add more patterns?' : 'Add include patterns?',
+                default: includeFiles.length === 0,
+            },
+        ]);
+        const addAnswers = await addInteract.runQueue();
+        addMore = addAnswers.getAnswerFor('addPatterns');
+        while (addMore) {
+            const fileInteract = new plugins.smartinteract.SmartInteract();
+            fileInteract.addQuestions([
+                {
+                    type: 'input',
+                    name: 'pattern',
+                    message: 'File or glob pattern:',
+                    default: includeFiles.length === 0 ? './html/index.html' : '',
+                },
+            ]);
+            const fileAnswers = await fileInteract.runQueue();
+            const pattern = fileAnswers.getAnswerFor('pattern');
+            if (pattern && pattern.trim()) {
+                includeFiles.push(pattern.trim());
+                console.log(`  Added: ${pattern}`);
+            }
+            const continueInteract = new plugins.smartinteract.SmartInteract();
+            continueInteract.addQuestions([
+                {
+                    type: 'confirm',
+                    name: 'addMore',
+                    message: 'Add another file/pattern?',
+                    default: false,
+                },
+            ]);
+            const continueAnswers = await continueInteract.runQueue();
+            addMore = continueAnswers.getAnswerFor('addMore');
+        }
+        return includeFiles;
+    }
+}
+/**
+ * Run the init command
+ */
+export async function runInit() {
+    const handler = new InitHandler();
+    await handler.runWizard();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/mod_init/index.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_init/plugins.d.ts

@@ -0,0 +1,3 @@
+export * from '../plugins.js';
+import * as smartinteract from '@push.rocks/smartinteract';
+export { smartinteract };

package/dist_ts/mod_init/plugins.js

@@ -0,0 +1,4 @@
+export * from '../plugins.js';
+import * as smartinteract from '@push.rocks/smartinteract';
+export { smartinteract };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9pbml0L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFFOUIsT0FBTyxLQUFLLGFBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsYUFBYSxFQUFFLENBQUMifQ==