@gmb/bitmark-parser-generator 3.34.0 → 3.36.0

package/dist/esm/BitmarkParserGenerator.js

@@ -1,735 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/* eslint-disable arca/import-ordering */
-import { superenum } from '@ncoderz/superenum';
-import { Ast } from './ast/Ast';
-import { BitmarkStringGenerator } from './generator/bitmark/BitmarkStringGenerator';
-import { JsonObjectGenerator } from './generator/json/JsonObjectGenerator';
-import { BitmarkParserType } from './model/enum/BitmarkParserType';
-import { BitmarkParser } from './parser/bitmark/BitmarkParser';
-import { JsonParser } from './parser/json/JsonParser';
-import { env } from './utils/env/Env';
-import { InfoBuilder } from './info/InfoBuilder';
-import { InfoType } from './model/info/enum/InfoType';
-import { InfoFormat } from './model/info/enum/InfoFormat';
-import { Config } from './config/Config';
-// import { TextFormat, TextFormatType } from './model/enum/TextFormat';
-import { TextGenerator } from './generator/text/TextGenerator';
-import { TextParser } from './parser/text/TextParser';
-/*
- * NOTE:
- *
- * We want to be able to strip out the NodeJS specific functions from the final bundle.
- * Any code between the comments STRIP:START and STRIP:END will be removed.
- *
- * However, the Typescript compiler will remove comments that it does not believe are associated with code.
- * Therefore we have to use some dummy code to prevent it from removing the STRIP stripping comments.
- */
-const STRIP = 0;
-/* STRIP:START */
-STRIP;
-/* eslint-disable arca/import-ordering */
-import * as fs from 'fs-extra';
-import path from 'path';
-import { BitmarkFileGenerator } from './generator/bitmark/BitmarkFileGenerator';
-import { JsonFileGenerator } from './generator/json/JsonFileGenerator';
-import { Breakscape } from './breakscaping/Breakscape';
-import { TextLocation } from './model/enum/TextLocation';
-import { TextFormat } from './model/enum/TextFormat';
-/* STRIP:END */
-STRIP;
-/**
- * Input type enumeration
- */
-const Input = superenum({
-    /**
-     * Input is as a string
-     */
-    string: 'string',
-    /**
-     * Input is as a file path
-     */
-    file: 'file',
-});
-/**
- * Output type enumeration
- */
-const Output = superenum({
-    /**
-     * Output bitmark string
-     */
-    bitmark: 'bitmark',
-    /**
-     * Output JSON as a plain JS object, or a file
-     */
-    json: 'json',
-    /**
-     * Output AST as a plain JS object, or a file
-     */
-    ast: 'ast',
-});
-/**
- * Bitmark tool for manipulating bitmark in all its formats.
- *
- */
-class BitmarkParserGenerator {
-    constructor() {
-        this.ast = new Ast();
-        this.jsonParser = new JsonParser();
-        this.bitmarkParser = new BitmarkParser();
-        this.textParser = new TextParser();
-        this.textGenerator = new TextGenerator();
-        /**
-         * Stringify / prettify a plain JS object to a JSON string, depending on the JSON options
-         *
-         * @param json
-         * @param options
-         * @param forceStringify
-         * @returns
-         */
-        this.jsonStringifyPrettify = (json, options, forceStringify) => {
-            const prettifySpace = options.prettify === true ? 2 : options.prettify || undefined;
-            const stringify = forceStringify || options.stringify === true || prettifySpace !== undefined;
-            if (stringify) {
-                return JSON.stringify(json, null, prettifySpace);
-            }
-            return json;
-        };
-    }
-    /**
-     * Get the version of the bitmark-parser-generator library
-     */
-    version() {
-        return env.appVersion.full;
-    }
-    /**
-     * Get information about the bitmark-parser-generator library
-     */
-    info(options) {
-        const opts = Object.assign({}, options);
-        const builder = new InfoBuilder();
-        let res;
-        const outputString = !opts.outputFormat || opts.outputFormat === InfoFormat.text;
-        const outputJson = opts.outputFormat === InfoFormat.json;
-        const all = opts.type === InfoType.all;
-        const deprecated = opts.type === InfoType.deprecated;
-        const includeNonDeprecated = all || !deprecated;
-        const includeDeprecated = all || deprecated;
-        if (opts.type === InfoType.bit) {
-            const bitConfigs = builder.getSupportedBitConfigs().filter((b) => {
-                if (!opts.bit)
-                    return true;
-                const bitType = Config.getBitType(opts.bit);
-                return bitType === b.bitType;
-            });
-            if (outputString) {
-                res = bitConfigs
-                    .map((b) => b.toString({
-                    includeChains: true,
-                    includeConfigs: true,
-                }))
-                    .join('\n\n--------------\n\n');
-            }
-            else {
-                res = bitConfigs;
-            }
-        }
-        else {
-            // List / List Deprecated
-            const supportedBits = builder
-                .getSupportedBits({
-                includeNonDeprecated,
-                includeDeprecated,
-            })
-                .filter((b) => {
-                if (!opts.bit)
-                    return true;
-                const bitType = Config.getBitType(opts.bit);
-                if (b.name === bitType)
-                    return true;
-            });
-            if (outputString) {
-                res = this.supportedBitsAsString(supportedBits);
-            }
-            else {
-                res = supportedBits;
-            }
-        }
-        if (outputJson) {
-            const prettifySpace = opts.prettify === true ? 2 : opts.prettify || undefined;
-            res = JSON.stringify(res, null, prettifySpace);
-        }
-        return res;
-    }
-    /**
-     * Convert bitmark from bitmark to JSON, or JSON to bitmark.
-     *
-     * Input type is detected automatically and may be:
-     * - string: bitmark, JSON, or AST
-     * - object: JSON or AST
-     * - file: bitmark, JSON, or AST
-     *
-     * Output type is selected automatically based on input type detection:
-     * - input(JSON/AST) ==> output(bitmark)
-     * - input(bitmark)  ==> output(JSON)
-     *
-     * By default, the result is returned as a string for bitmark, or a plain JS object for JSON/AST.
-     *
-     * The options can be used to write the output to a file and to set conversion options or override defaults.
-     *
-     * If both the input and output formats are the same, the input will be validated and rewritten.
-     * This feature be used to upgrade bitmark or JSON to the latest version.
-     *
-     * @param input - bitmark or JSON or AST as a string, JSON or AST as plain JS object, or path to a file containing
-     * bitmark, JSON, or AST.
-     * @param options - the conversion options
-     * @returns Promise that resolves to string if converting to bitmark, a plain JS object if converting to JSON, or
-     * void if writing to a file
-     * @throws Error if any error occurs
-     */
-    convert(input, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let res;
-            const opts = Object.assign({}, options);
-            // const fileOptions = Object.assign({}, opts.fileOptions);
-            // const bitmarkOptions = Object.assign({}, opts.bitmarkOptions);
-            const jsonOptions = Object.assign({}, opts.jsonOptions);
-            const outputFormat = opts.outputFormat;
-            const outputBitmark = outputFormat === Output.bitmark;
-            const outputJson = outputFormat === Output.json;
-            const outputAst = outputFormat === Output.ast;
-            const bitmarkParserType = BitmarkParserType.peggy; // Option is no longer used as only Peggy parser supported
-            let inStr = input;
-            // Check if we are trying to write to a file in the browser
-            if (env.isBrowser && opts.outputFile) {
-                throw new Error('Cannot write to file in browser environment');
-            }
-            // If a file, read the file in
-            if (!opts.inputFormat || opts.inputFormat === Input.file) {
-                if (env.isNode) {
-                    if (fs.existsSync(inStr)) {
-                        inStr = fs.readFileSync(inStr, {
-                            encoding: 'utf8',
-                        });
-                    }
-                }
-            }
-            // Preprocess as AST to see if AST
-            let ast = this.ast.preprocessAst(inStr);
-            const isAst = !!ast;
-            if (!isAst) {
-                // Not AST, so process as JSON to see if we have JSON
-                ast = this.jsonParser.toAst(inStr);
-            }
-            const isJson = !!(ast === null || ast === void 0 ? void 0 : ast.bits);
-            const isBitmark = !isJson && !isAst; // Assume bitmark since not AST or JSON
-            // Helper conversion functions
-            const bitmarkToBitmark = (bitmarkStr) => __awaiter(this, void 0, void 0, function* () {
-                // Validate and prettify
-                yield bitmarkToAst(bitmarkStr);
-                yield astToBitmark(res);
-            });
-            const bitmarkToAst = (bitmarkStr) => __awaiter(this, void 0, void 0, function* () {
-                res = this.bitmarkParser.toAst(bitmarkStr, {
-                    parserType: bitmarkParserType,
-                });
-            });
-            const bitmarkToJson = (bitmarkStr) => __awaiter(this, void 0, void 0, function* () {
-                if (bitmarkParserType === BitmarkParserType.peggy) {
-                    // Convert the bitmark to JSON using the peggy parser (aways true, only peggy parser supported)
-                    // Generate AST from the Bitmark markup
-                    ast = this.bitmarkParser.toAst(bitmarkStr, {
-                        parserType: bitmarkParserType,
-                    });
-                    // Convert the AST to JSON
-                    if (opts.outputFile) {
-                        // Write JSON file
-                        const generator = new JsonFileGenerator(opts.outputFile, opts);
-                        yield generator.generate(ast);
-                    }
-                    else {
-                        // Generate JSON object
-                        const generator = new JsonObjectGenerator(opts);
-                        const json = yield generator.generate(ast);
-                        // Return JSON as object or string depending on prettify/stringify option
-                        res = this.jsonStringifyPrettify(json, jsonOptions);
-                    }
-                }
-            });
-            const astToBitmark = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // Convert the AST to bitmark
-                if (opts.outputFile) {
-                    // Write markup file
-                    const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-                    yield generator.generate(astJson);
-                }
-                else {
-                    // Generate markup string
-                    const generator = new BitmarkStringGenerator(opts);
-                    res = yield generator.generate(astJson);
-                }
-            });
-            const astToAst = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // Return JSON as object or string depending on prettify/stringify option
-                res = this.jsonStringifyPrettify(astJson, jsonOptions);
-            });
-            const astToJson = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // Convert the AST to JSON
-                if (opts.outputFile) {
-                    // Write JSON file
-                    const generator = new JsonFileGenerator(opts.outputFile, opts);
-                    yield generator.generate(astJson);
-                }
-                else {
-                    // Generate JSON object
-                    const generator = new JsonObjectGenerator(opts);
-                    const json = yield generator.generate(astJson);
-                    // Return JSON as object or string depending on prettify/stringify option
-                    res = this.jsonStringifyPrettify(json, jsonOptions);
-                }
-            });
-            const jsonToBitmark = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // We already have the ast from detecting the input type, so use the AST we already have
-                // Convert the JSON to bitmark
-                if (opts.outputFile) {
-                    // Write markup file
-                    const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-                    yield generator.generate(astJson);
-                }
-                else {
-                    // Generate markup string
-                    const generator = new BitmarkStringGenerator(opts);
-                    res = yield generator.generate(astJson);
-                }
-            });
-            const jsonToAst = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // We already have the ast from detecting the input type, so just return the AST we already have
-                // Return JSON as object or string depending on prettify/stringify option
-                res = this.jsonStringifyPrettify(astJson, jsonOptions);
-            });
-            const jsonToJson = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // Validate and prettify
-                yield astToJson(astJson);
-            });
-            // Convert
-            if (isBitmark) {
-                // Input was Bitmark
-                if (outputBitmark) {
-                    // Bitmark ==> Bitmark
-                    yield bitmarkToBitmark(inStr);
-                }
-                else if (outputAst) {
-                    // Bitmark ==> AST
-                    yield bitmarkToAst(inStr);
-                }
-                else {
-                    // Bitmark ==> JSON
-                    yield bitmarkToJson(inStr);
-                }
-            }
-            else if (isAst) {
-                // Input was AST
-                ast = ast;
-                if (outputAst) {
-                    // AST ==> AST
-                    yield astToAst(ast);
-                }
-                else if (outputJson) {
-                    // AST ==> JSON
-                    yield astToJson(ast);
-                }
-                else {
-                    // AST ==> Bitmark
-                    yield astToBitmark(ast);
-                }
-            }
-            else {
-                // Input was JSON
-                ast = ast;
-                if (outputJson) {
-                    // JSON ==> JSON
-                    yield jsonToJson(ast);
-                }
-                else if (outputAst) {
-                    // JSON ==> AST
-                    yield jsonToAst(ast);
-                }
-                else {
-                    // JSON ==> Bitmark
-                    yield jsonToBitmark(ast);
-                }
-            }
-            return res;
-        });
-    }
-    /**
-     * Upgrade bitmark or JSON, upgrading to the latest supported syntax, removing unrecognised data in the process.
-     *
-     * THIS FEATURE SHOULD BE USED WITH CAUTION. IT WILL POTENTIALLY DELETE DATA.
-     *
-     * Input type is detected automatically and may be:
-     * - string: bitmark, JSON
-     * - object: JSON
-     * - file: bitmark, JSON
-     *
-     * Output type is the same as the detected input type
-     *
-     * By default, the result is returned as a string for bitmark, or a plain JS object for JSON.
-     *
-     * The options can be used to write the output to a file and to set conversion options or override defaults.
-     *
-     * If both the input and output formats are the same, the input will be validated and rewritten.
-     *
-     * @param input - bitmark or JSON or AST as a string, JSON or AST as plain JS object, or path to a file containing
-     * bitmark, JSON, or AST.
-     * @param options - the conversion options
-     * @returns Promise that resolves to string if upgrading to bitmark, a plain JS object if converting to JSON, or
-     * void if writing to a file
-     * @throws Error if any error occurs
-     */
-    upgrade(input, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let res;
-            const opts = Object.assign({}, options);
-            // const fileOptions = Object.assign({}, opts.fileOptions);
-            // const bitmarkOptions = Object.assign({}, opts.bitmarkOptions);
-            const jsonOptions = Object.assign({}, opts.jsonOptions);
-            const bitmarkParserType = opts.bitmarkParserType;
-            let inStr = input;
-            // Check if we are trying to write to a file in the browser
-            if (env.isBrowser && opts.outputFile) {
-                throw new Error('Cannot write to file in browser environment');
-            }
-            // If a file, read the file in
-            if (!opts.inputFormat || opts.inputFormat === Input.file) {
-                if (env.isNode) {
-                    if (fs.existsSync(inStr)) {
-                        inStr = fs.readFileSync(inStr, {
-                            encoding: 'utf8',
-                        });
-                    }
-                }
-            }
-            // Process as JSON to see if we have JSON
-            let ast = this.jsonParser.toAst(inStr);
-            const isJson = !!(ast === null || ast === void 0 ? void 0 : ast.bits);
-            const isBitmark = !isJson; // Assume bitmark since not JSON
-            // Helper conversion functions
-            const bitmarkToBitmark = (bitmarkStr) => __awaiter(this, void 0, void 0, function* () {
-                // Validate and upgrade
-                const astJson = this.bitmarkParser.toAst(bitmarkStr, {
-                    parserType: bitmarkParserType,
-                });
-                // Convert the AST to bitmark
-                if (opts.outputFile) {
-                    // Write markup file
-                    const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-                    yield generator.generate(astJson);
-                }
-                else {
-                    // Generate markup string
-                    const generator = new BitmarkStringGenerator(opts);
-                    res = yield generator.generate(astJson);
-                }
-            });
-            const jsonToJson = (astJson) => __awaiter(this, void 0, void 0, function* () {
-                // Validate and upgrade
-                // Convert the AST to JSON
-                if (opts.outputFile) {
-                    // Write JSON file
-                    const generator = new JsonFileGenerator(opts.outputFile, opts);
-                    yield generator.generate(astJson);
-                }
-                else {
-                    // Generate JSON object
-                    const generator = new JsonObjectGenerator(opts);
-                    const json = yield generator.generate(astJson);
-                    // Return JSON as object or string depending on prettify/stringify option
-                    res = this.jsonStringifyPrettify(json, jsonOptions);
-                }
-            });
-            // Validate and Upgrade
-            if (isBitmark) {
-                // Bitmark ==> Bitmark
-                yield bitmarkToBitmark(inStr);
-            }
-            else {
-                // JSON ==> JSON
-                ast = ast;
-                yield jsonToJson(ast);
-            }
-            return res;
-        });
-    }
-    /**
-     * Create a bitmark AST (Abstract Syntax Tree) from bitmark or JSON or AST
-     *
-     * Input type is detected automatically and may be string, object (JSON or AST), or file
-     *
-     * @param input the JSON or bitmark to convert to a bitmark AST
-     * @param options - the create AST options
-     * @returns bitmark AST
-     * @throws Error if any error occurs
-     */
-    createAst(input, options) {
-        let res;
-        let inStr = input;
-        const opts = Object.assign({}, options);
-        // If a file, read the file in
-        if (!opts.inputFormat || opts.inputFormat === Input.file) {
-            if (env.isNode) {
-                if (fs.existsSync(inStr)) {
-                    inStr = fs.readFileSync(inStr, {
-                        encoding: 'utf8',
-                    });
-                }
-            }
-        }
-        // Preprocess as AST to see if AST
-        let ast = this.ast.preprocessAst(inStr);
-        const isAst = !!ast;
-        if (!isAst) {
-            // Not AST, so process as JSON to see if we have JSON
-            ast = this.jsonParser.toAst(inStr);
-        }
-        const isJson = !!(ast === null || ast === void 0 ? void 0 : ast.bits);
-        const isBitmark = !isJson && !isAst; // Assume bitmark since not AST or JSON
-        if (isBitmark) {
-            // Bitmark ==> AST
-            res = this.bitmarkParser.toAst(inStr);
-        }
-        else {
-            // JSON / AST ==> AST
-            res = ast;
-        }
-        return res;
-    }
-    /**
-     * Convert bitmark text from JSON, or JSON to bitmark text.
-     *
-     * Input type is detected automatically and may be:
-     * - string: bitmark text or JSON
-     * - object: JSON
-     * - file: bitmark text or JSON
-     *
-     * Output type is selected automatically based on input type detection:
-     * - input(JSON) ==> output(bitmark text)
-     * - input(bitmark text)  ==> output(JSON)
-     *
-     * By default, the result is returned as a string for bitmark text, or a plain JS object for JSON.
-     *
-     * The options can be used to write the output to a file and to set conversion options or override defaults.
-     *
-     * @param input - bitmark text or JSON as a string, JSON as plain JS object, or path to a file containing
-     * bitmark text or JSON.
-     * @param options - the conversion options
-     * @returns Promise that resolves to string if converting to bitmark text, a plain JS object if converting to JSON, or
-     * void if writing to a file
-     * @throws Error if any error occurs
-     */
-    convertText(input, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            let res;
-            let preRes;
-            const opts = Object.assign({}, options);
-            const fileOptions = Object.assign({}, opts.fileOptions);
-            const jsonOptions = Object.assign({}, opts.jsonOptions);
-            const textFormat = (_a = TextFormat.fromValue(opts.textFormat)) !== null && _a !== void 0 ? _a : TextFormat.bitmarkText;
-            const textLocation = (_b = opts.textLocation) !== null && _b !== void 0 ? _b : TextLocation.body;
-            let inStr = input;
-            // Check if we are trying to write to a file in the browser
-            if (env.isBrowser && opts.outputFile) {
-                throw new Error('Cannot write to file in browser environment');
-            }
-            // If a file, read the file in
-            if (!opts.inputFormat || opts.inputFormat === Input.file) {
-                if (env.isNode) {
-                    if (fs.existsSync(inStr)) {
-                        inStr = fs.readFileSync(inStr, {
-                            encoding: 'utf8',
-                        });
-                    }
-                }
-            }
-            // Preprocess as text AST to see if text AST
-            const ast = this.textParser.preprocessAst(inStr);
-            const isAst = !!ast;
-            if (!isAst) {
-                preRes = this.textParser.toAst(inStr, {
-                    format: textFormat,
-                    location: TextLocation.body,
-                });
-            }
-            else {
-                preRes = yield this.textGenerator.generate(ast, textFormat, textLocation);
-            }
-            if (opts.outputFile) {
-                const output = opts.outputFile.toString();
-                let strRes = preRes;
-                if (!isAst) {
-                    strRes = this.jsonStringifyPrettify(preRes, jsonOptions, true);
-                }
-                // Write JSON to file
-                const flag = fileOptions.append ? 'a' : 'w';
-                fs.ensureDirSync(path.dirname(output));
-                fs.writeFileSync(output, strRes, {
-                    flag,
-                });
-            }
-            else {
-                if (!isAst) {
-                    res = this.jsonStringifyPrettify(preRes, jsonOptions);
-                }
-                else {
-                    res = preRes;
-                }
-            }
-            return res;
-        });
-    }
-    /**
-     * Breakscape bitmark text.
-     *
-     * Input type is detected automatically and may be:
-     * - string: text
-     * - file: path to a file containing text
-     *
-     * By default, the result is returned as a string.
-     * By default, the text is breakscaped as if it was bitmark text in the body.
-     * Use the options to change this behaviour.
-     *
-     * The options can be used to write the output to a file.
-     *
-     * @param input - text, or path to a file containing text.
-     * @param options - the conversion options
-     * @returns breakscaped string, or void if writing to a file
-     * @throws Error if any error occurs
-     */
-    breakscapeText(input, options) {
-        var _a, _b;
-        if (!input)
-            return input;
-        const opts = Object.assign({}, options);
-        const fileOptions = Object.assign({}, opts.fileOptions);
-        const textFormat = (_a = TextFormat.fromValue(opts.textFormat)) !== null && _a !== void 0 ? _a : TextFormat.bitmarkText;
-        const textLocation = (_b = opts.textLocation) !== null && _b !== void 0 ? _b : TextLocation.body;
-        let inStr = input;
-        // Check if we are trying to write to a file in the browser
-        if (env.isBrowser && opts.outputFile) {
-            throw new Error('Cannot write to file in browser environment');
-        }
-        // If a file, read the file in
-        if (!opts.inputFormat || opts.inputFormat === Input.file) {
-            if (env.isNode) {
-                if (fs.existsSync(inStr)) {
-                    inStr = fs.readFileSync(inStr, {
-                        encoding: 'utf8',
-                    });
-                }
-            }
-        }
-        // Do the breakscape
-        const res = Breakscape.breakscape(inStr, {
-            format: textFormat,
-            location: textLocation,
-        });
-        if (opts.outputFile) {
-            const output = opts.outputFile.toString();
-            // Write JSON to file
-            const flag = fileOptions.append ? 'a' : 'w';
-            fs.ensureDirSync(path.dirname(output));
-            fs.writeFileSync(output, res, {
-                flag,
-            });
-        }
-        else {
-            return res;
-        }
-    }
-    /**
-     * Unescape (unbreakscape) bitmark text
-     *
-     * Input type is detected automatically and may be:
-     * - string: text
-     * - file: path to a file containing text
-     *
-     * By default, the result is returned as a string.
-     * By default, the text is unbreakscaped as if it was bitmark text in the body.
-     * Use the options to change this behaviour.
-     *
-     * The options can be used to write the output to a file.
-     *
-     * @param input - text, or path to a file containing text.
-     * @param options - the conversion options
-     * @returns unbreakscaped string, or void if writing to a file
-     * @throws Error if any error occurs
-     */
-    unbreakscapeText(input, options) {
-        var _a, _b;
-        if (!input)
-            return input;
-        const opts = Object.assign({}, options);
-        const fileOptions = Object.assign({}, opts.fileOptions);
-        const textFormat = (_a = TextFormat.fromValue(opts.textFormat)) !== null && _a !== void 0 ? _a : TextFormat.bitmarkText;
-        const textLocation = (_b = opts.textLocation) !== null && _b !== void 0 ? _b : TextLocation.body;
-        let inStr = input;
-        // Check if we are trying to write to a file in the browser
-        if (env.isBrowser && opts.outputFile) {
-            throw new Error('Cannot write to file in browser environment');
-        }
-        // If a file, read the file in
-        if (!opts.inputFormat || opts.inputFormat === Input.file) {
-            if (env.isNode) {
-                if (fs.existsSync(inStr)) {
-                    inStr = fs.readFileSync(inStr, {
-                        encoding: 'utf8',
-                    });
-                }
-            }
-        }
-        // Do the unbreakscape
-        const res = Breakscape.unbreakscape(inStr, {
-            format: textFormat,
-            location: textLocation,
-        });
-        if (opts.outputFile) {
-            const output = opts.outputFile.toString();
-            // Write JSON to file
-            const flag = fileOptions.append ? 'a' : 'w';
-            fs.ensureDirSync(path.dirname(output));
-            fs.writeFileSync(output, res, {
-                flag,
-            });
-        }
-        else {
-            return res;
-        }
-        return;
-    }
-    /**
-     * Get the supported bits as a formatted strings
-     *
-     * @param supportedBits
-     * @returns
-     */
-    supportedBitsAsString(supportedBits) {
-        let res = '';
-        for (const rootBit of supportedBits) {
-            res += `${rootBit.name} (since: ${rootBit.since}`;
-            if (rootBit.deprecated)
-                res += `, deprecated: ${rootBit.deprecated}`;
-            res += ')\n';
-        }
-        return res;
-    }
-}
-export { BitmarkParserGenerator, Input, Output };
-//# sourceMappingURL=BitmarkParserGenerator.js.map