@gmb/bitmark-parser-generator 3.38.0 → 4.0.1

package/dist/index.js

@@ -1463,12 +1463,12 @@ var StringUtils = class {
         subLength = width;
         rangeStartNext = rangeStart + width;
       }
-      subString = str.substr(rangeStart, subLength);
+      subString = str.slice(rangeStart, rangeStart + subLength);
       rangeStart = rangeStartNext;
       result.push(subString.trim());
     }
     if (rangeStart < len) {
-      subString = str.substr(rangeStart);
+      subString = str.slice(rangeStart);
       result.push(subString);
     }
     return result;
@@ -1480,6 +1480,7 @@ var StringUtils = class {
    * @returns the camelCase version of the string
    */
   kebabToCamel(str) {
+    if (!str) return str;
     return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
   }
 };
@@ -1635,13 +1636,13 @@ var ObjectUtils = class {
    * @param path the path to the property to set as a dotted string or array or a mix of both
    * @returns the value of the property, or undefined if the property does not exist
    */
-  getViaPath(obj, path4) {
+  getViaPath(obj, path5) {
     if (!obj) return void 0;
-    if (!path4) return void 0;
-    if (!Array.isArray(path4)) path4 = [path4];
-    path4 = path4.flatMap((p) => p.split("."));
+    if (!path5) return void 0;
+    if (!Array.isArray(path5)) path5 = [path5];
+    path5 = path5.flatMap((p) => p.split("."));
     let node = obj;
-    for (const key of path4) {
+    for (const key of path5) {
       if (node == null) return void 0;
       node = node[key];
     }
@@ -1657,14 +1658,14 @@ var ObjectUtils = class {
    * @param create - if true, create plain objects in the path if they do not exist
    * @returns true if the value was set, false if the value was not set
    */
-  setViaPath(obj, path4, value, create) {
+  setViaPath(obj, path5, value, create) {
     if (!obj) return false;
-    if (!path4) return false;
-    if (!Array.isArray(path4)) path4 = [path4];
-    path4 = path4.flatMap((p) => p.split("."));
+    if (!path5) return false;
+    if (!Array.isArray(path5)) path5 = [path5];
+    path5 = path5.flatMap((p) => p.split("."));
     let node = obj;
-    for (let i = 0; i < path4.length - 1; i++) {
-      const key = path4[i];
+    for (let i = 0; i < path5.length - 1; i++) {
+      const key = path5[i];
       if (node[key] == void 0) {
         if (create) {
           node[key] = {};
@@ -1674,7 +1675,7 @@ var ObjectUtils = class {
       }
       node = node[key];
     }
-    node[path4[path4.length - 1]] = value;
+    node[path5[path5.length - 1]] = value;
     return true;
   }
   /**
@@ -1721,19 +1722,19 @@ var ObjectUtils = class {
    * @param path
    * @returns
    */
-  flatMapPath(obj, path4) {
+  flatMapPath(obj, path5) {
     if (!obj) return [];
-    if (!path4) return [];
-    if (!Array.isArray(path4)) path4 = [path4];
+    if (!path5) return [];
+    if (!Array.isArray(path5)) path5 = [path5];
     const node = obj;
-    const key = path4.shift();
+    const key = path5.shift();
     if (key == null) return node;
     const data = node[key];
     if (!data) return [];
     if (Array.isArray(data)) {
-      return data.flatMap((d) => this.flatMapPath(d, path4.slice()));
+      return data.flatMap((d) => this.flatMapPath(d, path5.slice()));
     } else {
-      return [this.flatMapPath(data, path4)].flat();
+      return [this.flatMapPath(data, path5)].flat();
     }
   }
   // testFlatMapPath() {
@@ -8879,7 +8880,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "3.38.0",
+  "version": "4.0.1",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -20645,8 +20646,10 @@ var NodeValidator = class {
     if (!valid) {
       if (resource.type) {
         ret = {
-          type: resource.type
-          // __typeAlias: resource.type,
+          type: resource.type,
+          __typeAlias: resource.type,
+          __configKey: resource.__configKey,
+          __invalid: true
         };
       }
     }
@@ -24124,14 +24127,14 @@ var Builder = class extends BaseBuilder {
    * @param path path for the value
    * @param value the value to push down
    */
-  pushDownTree(_context, body, bodyBitTypes, cardNode, cardNodePath, path4, value) {
+  pushDownTree(_context, body, bodyBitTypes, cardNode, cardNodePath, path5, value) {
     if (value === void 0) return;
     if (cardNode && cardNodePath) {
       if (!Array.isArray(cardNodePath)) cardNodePath = [cardNodePath];
       const data = objectUtils.flatMapPath(cardNode, cardNodePath);
       for (const d of data) {
-        if (d[path4] == null) {
-          d[path4] = value;
+        if (d[path5] == null) {
+          d[path5] = value;
         }
       }
     }
@@ -24145,8 +24148,8 @@ var Builder = class extends BaseBuilder {
               if (part) {
                 if (bodyBitTypes.indexOf(part.type) !== -1) {
                   const data = part;
-                  if (data[path4] == null) {
-                    data[path4] = value;
+                  if (data[path5] == null) {
+                    data[path5] = value;
                   }
                 }
               }
@@ -24339,13 +24342,14 @@ var StringWriter = class {
   }
   writeLine(value) {
     if (!this._buffer) return this;
+    let line;
     if (value != null) {
-      this._buffer.push(value + this.endOfLineString);
-      this.lastWrite = value + this.endOfLineString;
+      line = value + this.endOfLineString;
     } else {
-      this._buffer.push(this.endOfLineString);
-      this.lastWrite = this.endOfLineString;
+      line = this.endOfLineString;
     }
+    this._buffer.push(line);
+    this.lastWrite = line;
     return this;
   }
   writeLines(values, delimiter) {
@@ -26633,6 +26637,7 @@ var JsonGenerator = class extends AstWalkerGenerator {
     this.resetState();
     this.writer.openSync();
     this.walkAndWrite(ast);
+    this.write(JSON.stringify(this.json, null, this.jsonPrettifySpace));
     this.writer.closeSync();
   }
   resetState() {
@@ -31187,7 +31192,8 @@ function buildResources(context, resourceTypeAttachment, resources) {
   const countsMax = resourcesConfig.getCountsMax();
   if (resources) {
     for (const r of resources.reverse()) {
-      const configKey = resourceTypeToConfigKey(r.__typeAlias);
+      if (r.__invalid) continue;
+      const configKey = r.__configKey;
       let countMin = countsMin.get(configKey) ?? 0;
       let countMax = countsMax.get(configKey) ?? 0;
       countMin = Math.max(0, countMin - 1);
@@ -31208,7 +31214,7 @@ function buildResources(context, resourceTypeAttachment, resources) {
     context.addWarning(warningMsg);
   } else if (filteredResources.length === 0 && resourceTypeAttachment) {
     context.addWarning(
-      `Resource type [&${resourceTypeAttachment}] is specified in the bit header, but no such a resource is present`
+      `Resource type [&${resourceTypeAttachment}] is specified in the bit header, but no such resource is present`
     );
   }
   if (excessResources.length > 0) {
@@ -35059,8 +35065,8 @@ var BitmarkParser = class {
 };
 
 // src/BitmarkParserGenerator.ts
-import path3 from "path";
-import fs5 from "fs-extra";
+import path4 from "path";
+import fs6 from "fs-extra";
 
 // src/ast/writer/FileWriter.ts
 import path from "path";
@@ -35148,13 +35154,13 @@ var FileWriter = class extends StreamWriter {
    * @param path - path of file to write
    * @param options - options for file writing
    */
-  constructor(path4, options) {
+  constructor(path5, options) {
     super();
     __publicField(this, "_path");
     __publicField(this, "_append");
     __publicField(this, "_encoding");
     const opts = Object.assign({}, options);
-    this._path = path4;
+    this._path = path5;
     this._append = !!opts.append;
     this._encoding = opts.encoding ?? "utf8";
   }
@@ -35202,6 +35208,118 @@ var FileWriter = class extends StreamWriter {
 
 // src/generator/bitmark/BitmarkFileGenerator.ts
 import "fs-extra";
+
+// src/ast/writer/SyncFileWriter.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import os2 from "os";
+var SyncFileWriter = class {
+  /**
+   * Create a writer to write to a file.
+   *
+   * @param path - path of file to write
+   * @param options - options for file writing
+   */
+  constructor(path5, options) {
+    __publicField(this, "_path");
+    __publicField(this, "_append");
+    __publicField(this, "_encoding");
+    __publicField(this, "_open");
+    __publicField(this, "endOfLineString", os2.EOL);
+    __publicField(this, "lastWrite", "");
+    const opts = Object.assign({}, options);
+    this._path = path5;
+    this._append = !!opts.append;
+    this._encoding = opts.encoding ?? "utf8";
+    this._open = false;
+  }
+  get isSync() {
+    return true;
+  }
+  get path() {
+    return this._path;
+  }
+  get append() {
+    return this._append;
+  }
+  get encoding() {
+    return this._encoding;
+  }
+  async open() {
+    this.openSync();
+    return Promise.resolve();
+  }
+  async close() {
+    try {
+      this.closeSync();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+    return Promise.resolve();
+  }
+  openSync() {
+    const flag = this._append ? "a" : "w";
+    fs2.ensureDirSync(path2.dirname(this._path.toString()));
+    fs2.writeFileSync(this._path, "", {
+      flag,
+      encoding: this._encoding
+    });
+    this._open = true;
+  }
+  closeSync() {
+    this._open = false;
+  }
+  writeLine(value) {
+    if (!this._open) return this;
+    let line;
+    if (value != null) {
+      line = value + this.endOfLineString;
+    } else {
+      line = this.endOfLineString;
+    }
+    fs2.appendFileSync(this._path, line, {
+      encoding: this._encoding
+    });
+    this.lastWrite = line;
+    return this;
+  }
+  writeLines(values, delimiter) {
+    if (!this._open) return this;
+    if (!values) return this;
+    let str = "";
+    for (let i = 0, len = values.length; i < len; i++) {
+      const value = values[i];
+      str += value;
+      if (delimiter && i < len - 1) {
+        str += delimiter;
+      }
+      str += this.endOfLineString;
+    }
+    fs2.appendFileSync(this._path, str, {
+      encoding: this._encoding
+    });
+    this.lastWrite = str;
+    return this;
+  }
+  write(value) {
+    if (!this._open) return this;
+    if (value == null) return this;
+    if (value) this.lastWrite = value;
+    fs2.appendFileSync(this._path, value, {
+      encoding: this._encoding
+    });
+    return this;
+  }
+  writeWhiteSpace() {
+    this.write(" ");
+    return this;
+  }
+  getLastWrite() {
+    return this.lastWrite;
+  }
+};
+
+// src/generator/bitmark/BitmarkFileGenerator.ts
 var BitmarkFileGenerator = class {
   /**
    * Generate bitmark markup from a bitmark AST as a file
@@ -35209,9 +35327,11 @@ var BitmarkFileGenerator = class {
    * @param path - path of file to generate
    * @param options - bitmark generation options
    */
-  constructor(path4, options) {
+  constructor(path5, options) {
     __publicField(this, "generator");
-    const writer = new FileWriter(path4, options?.fileOptions);
+    __publicField(this, "async");
+    this.async = options?.async ?? false;
+    const writer = this.async ? new FileWriter(path5, options?.fileOptions) : new SyncFileWriter(path5, options?.fileOptions);
     this.generator = new BitmarkGenerator(writer, options);
   }
   /**
@@ -35228,7 +35348,10 @@ var BitmarkFileGenerator = class {
    * @param ast bitmark AST
    */
   generateSync(_ast) {
-    throw new Error("Sync operation not supported");
+    if (this.async) {
+      throw new Error("Sync operation not supported");
+    }
+    this.generator.generateSync(_ast);
   }
 };
 
@@ -35243,9 +35366,11 @@ var JsonFileGenerator = class {
    * @param fileOptions - file options
    * @param bitmarkOptions - bitmark generation options
    */
-  constructor(path4, options) {
+  constructor(path5, options) {
     __publicField(this, "generator");
-    const writer = new FileWriter(path4, options?.fileOptions);
+    __publicField(this, "async");
+    this.async = options?.async ?? false;
+    const writer = this.async ? new FileWriter(path5, options?.fileOptions) : new SyncFileWriter(path5, options?.fileOptions);
     this.generator = new JsonGenerator(writer, options);
   }
   /**
@@ -35262,19 +35387,22 @@ var JsonFileGenerator = class {
    * @param ast bitmark AST
    */
   generateSync(_ast) {
-    throw new Error("Sync operation not supported");
+    if (this.async) {
+      throw new Error("Sync operation not supported");
+    }
+    this.generator.generateSync(_ast);
   }
 };
 
 // src/info/ConfigBuilder.ts
-import path2 from "path";
-import fs4 from "fs-extra";
+import path3 from "path";
+import fs5 from "fs-extra";
 var ConfigBuilder = class {
-  async build(options) {
+  build(options) {
     const opts = Object.assign({}, options);
-    await this.buildFlat(opts);
+    this.buildFlat(opts);
   }
-  async buildFlat(options) {
+  buildFlat(options) {
     const opts = Object.assign({}, options);
     const bitConfigs = [];
     for (const bt of BitType.values()) {
@@ -35283,9 +35411,8 @@ var ConfigBuilder = class {
       if (bitConfig) bitConfigs.push(bitConfig);
     }
     const outputFolder = opts.outputDir ?? "assets/config";
-    const outputFolderBits = path2.join(outputFolder, "bits_flat");
-    fs4.ensureDirSync(outputFolderBits);
-    const fileWrites = [];
+    const outputFolderBits = path3.join(outputFolder, "bits_flat");
+    fs5.ensureDirSync(outputFolderBits);
     for (const b of bitConfigs) {
       const inherits = [];
       const tags2 = [];
@@ -35418,11 +35545,10 @@ var ConfigBuilder = class {
         resourceAttachmentAllowed: b.resourceAttachmentAllowed ?? true,
         tags: tags2
       };
-      const output = path2.join(outputFolderBits, `${b.bitType}.jsonc`);
+      const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);
-      fileWrites.push(fs4.writeFile(output, str));
+      fs5.writeFileSync(output, str);
     }
-    await Promise.all(fileWrites);
   }
 };
 
@@ -35534,11 +35660,10 @@ var BitmarkParserGenerator = class {
   /**
    * Generate the new configuration for the bitmark parser.
    */
-  async generateConfig(options) {
+  generateConfig(options) {
     const opts = Object.assign({}, options);
     const builder3 = new ConfigBuilder();
-    await builder3.build(opts);
-    return void 0;
+    builder3.build(opts);
   }
   /**
    * Convert bitmark from bitmark to JSON, or JSON to bitmark.
@@ -35562,11 +35687,11 @@ var BitmarkParserGenerator = class {
    * @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
+   * @returns A 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
    */
-  async convert(input, options) {
+  convert(input, options) {
     let res;
     const opts = Object.assign({}, options);
     const jsonOptions = Object.assign({}, opts.jsonOptions);
@@ -35581,8 +35706,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35595,92 +35720,92 @@ var BitmarkParserGenerator = class {
     }
     const isJson = !!ast?.bits;
     const isBitmark = !isJson && !isAst;
-    const bitmarkToBitmark = async (bitmarkStr) => {
-      await bitmarkToAst(bitmarkStr);
-      await astToBitmark(res);
+    const bitmarkToBitmark = (bitmarkStr) => {
+      bitmarkToAst(bitmarkStr);
+      astToBitmark(res);
     };
-    const bitmarkToAst = async (bitmarkStr) => {
+    const bitmarkToAst = (bitmarkStr) => {
       res = this.bitmarkParser.toAst(bitmarkStr, {
         parserType: bitmarkParserType
       });
     };
-    const bitmarkToJson = async (bitmarkStr) => {
+    const bitmarkToJson = (bitmarkStr) => {
       if (bitmarkParserType === BitmarkParserType.peggy) {
         ast = this.bitmarkParser.toAst(bitmarkStr, {
           parserType: bitmarkParserType
         });
         if (opts.outputFile) {
           const generator = new JsonFileGenerator(opts.outputFile, opts);
-          await generator.generate(ast);
+          generator.generateSync(ast);
         } else {
           const generator = new JsonObjectGenerator(opts);
-          const json = await generator.generate(ast);
+          const json = generator.generateSync(ast);
           res = this.jsonStringifyPrettify(json, jsonOptions);
         }
       }
     };
-    const astToBitmark = async (astJson) => {
+    const astToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-        await generator.generate(astJson);
+        generator.generateSync(astJson);
       } else {
         const generator = new BitmarkStringGenerator(opts);
-        res = await generator.generate(astJson);
+        res = generator.generateSync(astJson);
       }
     };
-    const astToAst = async (astJson) => {
+    const astToAst = (astJson) => {
       res = this.jsonStringifyPrettify(astJson, jsonOptions);
     };
-    const astToJson = async (astJson) => {
+    const astToJson = (astJson) => {
       if (opts.outputFile) {
         const generator = new JsonFileGenerator(opts.outputFile, opts);
-        await generator.generate(astJson);
+        generator.generateSync(astJson);
       } else {
         const generator = new JsonObjectGenerator(opts);
-        const json = await generator.generate(astJson);
+        const json = generator.generateSync(astJson);
         res = this.jsonStringifyPrettify(json, jsonOptions);
       }
     };
-    const jsonToBitmark = async (astJson) => {
+    const jsonToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-        await generator.generate(astJson);
+        generator.generateSync(astJson);
       } else {
         const generator = new BitmarkStringGenerator(opts);
-        res = await generator.generate(astJson);
+        res = generator.generateSync(astJson);
       }
     };
-    const jsonToAst = async (astJson) => {
+    const jsonToAst = (astJson) => {
       res = this.jsonStringifyPrettify(astJson, jsonOptions);
     };
-    const jsonToJson = async (astJson) => {
-      await astToJson(astJson);
+    const jsonToJson = (astJson) => {
+      astToJson(astJson);
     };
     if (isBitmark) {
       if (outputBitmark) {
-        await bitmarkToBitmark(inStr);
+        bitmarkToBitmark(inStr);
       } else if (outputAst) {
-        await bitmarkToAst(inStr);
+        bitmarkToAst(inStr);
       } else {
-        await bitmarkToJson(inStr);
+        bitmarkToJson(inStr);
       }
     } else if (isAst) {
       ast = ast;
       if (outputAst) {
-        await astToAst(ast);
+        astToAst(ast);
       } else if (outputJson) {
-        await astToJson(ast);
+        astToJson(ast);
       } else {
-        await astToBitmark(ast);
+        astToBitmark(ast);
       }
     } else {
       ast = ast;
       if (outputJson) {
-        await jsonToJson(ast);
+        jsonToJson(ast);
       } else if (outputAst) {
-        await jsonToAst(ast);
+        jsonToAst(ast);
       } else {
-        await jsonToBitmark(ast);
+        jsonToBitmark(ast);
       }
     }
     return res;
@@ -35710,7 +35835,7 @@ var BitmarkParserGenerator = class {
    * void if writing to a file
    * @throws Error if any error occurs
    */
-  async upgrade(input, options) {
+  upgrade(input, options) {
     let res;
     const opts = Object.assign({}, options);
     const jsonOptions = Object.assign({}, opts.jsonOptions);
@@ -35721,8 +35846,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35731,33 +35856,33 @@ var BitmarkParserGenerator = class {
     let ast = this.jsonParser.toAst(inStr);
     const isJson = !!ast?.bits;
     const isBitmark = !isJson;
-    const bitmarkToBitmark = async (bitmarkStr) => {
+    const bitmarkToBitmark = (bitmarkStr) => {
       const astJson = this.bitmarkParser.toAst(bitmarkStr, {
         parserType: bitmarkParserType
       });
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
-        await generator.generate(astJson);
+        generator.generateSync(astJson);
       } else {
         const generator = new BitmarkStringGenerator(opts);
-        res = await generator.generate(astJson);
+        res = generator.generateSync(astJson);
       }
     };
-    const jsonToJson = async (astJson) => {
+    const jsonToJson = (astJson) => {
       if (opts.outputFile) {
         const generator = new JsonFileGenerator(opts.outputFile, opts);
-        await generator.generate(astJson);
+        generator.generateSync(astJson);
       } else {
         const generator = new JsonObjectGenerator(opts);
-        const json = await generator.generate(astJson);
+        const json = generator.generateSync(astJson);
         res = this.jsonStringifyPrettify(json, jsonOptions);
       }
     };
     if (isBitmark) {
-      await bitmarkToBitmark(inStr);
+      bitmarkToBitmark(inStr);
     } else {
       ast = ast;
-      await jsonToJson(ast);
+      jsonToJson(ast);
     }
     return res;
   }
@@ -35777,8 +35902,8 @@ var BitmarkParserGenerator = class {
     const opts = Object.assign({}, options);
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35821,7 +35946,7 @@ var BitmarkParserGenerator = class {
    * void if writing to a file
    * @throws Error if any error occurs
    */
-  async convertText(input, options) {
+  convertText(input, options) {
     let res;
     let preRes;
     const opts = Object.assign({}, options);
@@ -35835,8 +35960,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35850,7 +35975,7 @@ var BitmarkParserGenerator = class {
         location: TextLocation.body
       });
     } else {
-      preRes = await this.textGenerator.generate(ast, textFormat, textLocation);
+      preRes = this.textGenerator.generateSync(ast, textFormat, textLocation);
     }
     if (opts.outputFile) {
       const output = opts.outputFile.toString();
@@ -35859,8 +35984,8 @@ var BitmarkParserGenerator = class {
         strRes = this.jsonStringifyPrettify(preRes, jsonOptions, true);
       }
       const flag = fileOptions.append ? "a" : "w";
-      fs5.ensureDirSync(path3.dirname(output));
-      fs5.writeFileSync(output, strRes, {
+      fs6.ensureDirSync(path4.dirname(output));
+      fs6.writeFileSync(output, strRes, {
         flag
       });
     } else {
@@ -35902,8 +36027,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35916,8 +36041,8 @@ var BitmarkParserGenerator = class {
     if (opts.outputFile) {
       const output = opts.outputFile.toString();
       const flag = fileOptions.append ? "a" : "w";
-      fs5.ensureDirSync(path3.dirname(output));
-      fs5.writeFileSync(output, res, {
+      fs6.ensureDirSync(path4.dirname(output));
+      fs6.writeFileSync(output, res, {
         flag
       });
     } else {
@@ -35954,8 +36079,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (fs5.existsSync(inStr)) {
-          inStr = fs5.readFileSync(inStr, {
+        if (fs6.existsSync(inStr)) {
+          inStr = fs6.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -35968,8 +36093,8 @@ var BitmarkParserGenerator = class {
     if (opts.outputFile) {
       const output = opts.outputFile.toString();
       const flag = fileOptions.append ? "a" : "w";
-      fs5.ensureDirSync(path3.dirname(output));
-      fs5.writeFileSync(output, res, {
+      fs6.ensureDirSync(path4.dirname(output));
+      fs6.writeFileSync(output, res, {
         flag
       });
     } else {