Prototxt Parser

Common errors

• TypeError: prototxtParser.parse is not a function

  cause The `parse` function is accessed directly as a named export, but it's actually a method of the default (or namespace) export `prototxtParser`.
  fix Ensure you are calling it as `prototxtParser.parse(yourString)`. If using ESM, make sure to `import * as prototxtParser from 'prototxt-parser';` or for CJS, `const prototxtParser = require('prototxt-parser');`.

• Module not found: Can't resolve 'prototxt-parser'

  cause The package `prototxt-parser` has not been installed or is not correctly listed in your project's dependencies, or there's a module resolution issue in your bundler/runtime.
  fix Run `npm install prototxt-parser` or `yarn add prototxt-parser` to add it to your project. Verify your bundler (e.g., Webpack, Rollup) or Node.js environment is configured to resolve modules from `node_modules`.

• Error: Expected a Protobuf field assignment (like 'key: value' or 'key { ... }') but got something else

  cause The input string is not a valid `.prototxt` format, or contains syntax that the `parsimmon`-based parser does not expect (e.g., missing colons, malformed blocks, unexpected characters).
  fix Carefully review the input string against the `.prototxt` syntax rules, especially for Caffe. Use a `.prototxt` linter if available, or compare against known working examples. The error message from `parsimmon` is usually quite specific about the unexpected token or position.

Warnings

• gotcha The library is specifically designed for `.prototxt` format as used by Caffe. It may not fully support all variations or advanced features of Google's Protocol Buffers text format, which can be more general. If your `.prototxt` deviates significantly from Caffe's conventions, parsing might fail or produce unexpected results.
  Fix: Validate the `.prototxt` against known Caffe syntax conventions. If encountering issues, manually inspect the `.prototxt` structure or refer to Caffe's documentation for expected format. Consider alternative parsers if your Protobuf text format is non-standard.
• gotcha The development activity on the GitHub repository has been minimal since its last update approximately 4 years ago (as of 2026), and the latest release is version 0.1.5. While functional for its intended purpose, expect slow or non-existent updates for new features, bug fixes, or compatibility with newer JavaScript environments or parsing standards.
  Fix: Be aware that maintaining this package might require manual patches or forks for critical issues. Thorough testing of the parser's output for your specific `.prototxt` files is recommended, especially in production environments. Consider contributing if you need new features or bug fixes.
• gotcha The `rawgit.com` CDN mentioned in the original README for browser usage has been deprecated and is no longer actively maintained since 2018. Relying on such deprecated services poses a security risk and can lead to broken deployments.
  Fix: Avoid using `rawgit.com`. For browser usage, consider bundling the library using tools like Webpack or Rollup, or serve it from a reliable CDN like `unpkg.com` if available and maintained for the specific version.

Install

• npm install prototxt-parser npm
• yarn add prototxt-parser yarn
• pnpm add prototxt-parser pnpm

Imports

• prototxtParser
  wrong:

  import prototxtParser from 'prototxt-parser'; // Not a default export
  import { parse } from 'prototxt-parser'; // The main 'parse' function is a member of the 'prototxtParser' object

  correct:

  import * as prototxtParser from 'prototxt-parser';

  The library exports a namespace object, so `import * as` is the correct pattern for TypeScript and modern ESM. The primary parsing function is accessed as `prototxtParser.parse()`.
• prototxtParser

  const prototxtParser = require('prototxt-parser');

  For CommonJS environments (e.g., older Node.js projects), `require` imports the entire module object, consistent with the `* as` import pattern in ESM.
• prototxtParser.parse
  wrong:

  parse(prototxtString); // 'parse' is not a top-level export

  correct:

  prototxtParser.parse(prototxtString);

  The core parsing functionality is exposed as a method on the `prototxtParser` object. Ensure the object itself is correctly imported first.

Quickstart

This quickstart demonstrates how to asynchronously fetch a `.prototxt` file from a URL and then parse its content into a JavaScript object using `prototxt-parser`. It includes error handling and logs the structured output.

import * as prototxtParser from 'prototxt-parser';

async function fetchPrototxt(uri: string): Promise<string> {
  try {
    const response = await fetch(new Request(uri));
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return await response.text();
  } catch (error) {
    console.error(`Failed to fetch prototxt from ${uri}:`, error);
    throw error;
  }
}

// Example .prototxt for a SqueezeNet model
const uri = "https://raw.githubusercontent.com/DeepScale/SqueezeNet/master/SqueezeNet_v1.1/deploy.prototxt";

(async () => {
  try {
    const prototxtString = await fetchPrototxt(uri);
    const parsedProto = prototxtParser.parse(prototxtString);
    console.log('Successfully parsed .prototxt:');
    console.log(JSON.stringify(parsedProto, null, 2));
    // You can now access properties, e.g., console.log(parsedProto.name);
  } catch (error) {
    console.error('An error occurred during parsing:', error);
  }
})();