### Install easygettext with npm

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Install easygettext as a development dependency using npm.

```bash
npm install --save-dev easygettext
```

--------------------------------

### Install easygettext with yarn

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Install easygettext as a development dependency using yarn.

```bash
yarn add --dev easygettext
```

--------------------------------

### HTML token extraction examples

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Demonstrates various ways to mark strings for translation in HTML using the 'translate' attribute and directives like 'i18n' and 'get-text'. Supports context, comments, and plurals.

```html
<div translate>Hello World</div>
```

```html
<div translate translate-context="According to...">Hello World</div>
```

```html
<div translate translate-comment="My comment...">Hello World</div>
```

```html
<div translate translate-plural="Hello worlds">Hello World</div>
```

```html
<div placeholder="{{ 'Hello World' | translate }}"></div>
```

```html
<div placeholder="{{ scopeVariable || ('Hello World' | translate) }}"></div>
```

```html
<get-text>Hello World</get-text>
```

```html
<i18n>Hello World</i18n>
```

```html
<translate>Hello World</translate>
```

```html
<!--  The following becomes 'Broken strings are joined'  --> 
<span ng-bind="{{ 'Broken ' 
 + 'strings ' + 
 'are ' + 
 'joined' |translate}}"></span>
```

```html
 <span ng-bind="'Bed n\' ' + ' breakfast' |translate"></span>
```

```html
 <!-- JavaScript expressions are parsed and compiled -->
<span ng-bind="true ? 'Always' : 'Never' |i18n "></span>
```

```html
<!--  By supplying the  --filterPrefix '::' parameter  -->  
<span>{{:: 'Something …' |translate}}</span>
```

```html
<!--  The default delimiters '{{' and '}}' must be changed to empty strings to handle these examples  -->
<span ng-bind=":: 'Something …' |translate"></span>
```

```html
<div placeholder="'Hello World' | translate"></div>
```

--------------------------------

### Javascript gettext token extraction examples

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Demonstrates the usage of $gettext, $pgettext, and $ngettext for extracting translatable strings from Javascript code. Supports concatenated and template string literals.

```javascript
const myVar = $gettext("My fantastic msgid")
```

```javascript
const myConcatVar = $gettext(
  "My"
  + "fantastic"
  + "msgid"
)
```

```javascript
const myTempVar = $gettext(
  `My
  fantastic
  msgid`
)
```

```javascript
const myContextualizedVar = $pgettext("some context", "Some other string")
```

```javascript
const myPluralVar = $ngettext(...)
```

--------------------------------

### Supported HTML translation token formats

Source: https://context7.com/polyconseil/easygettext/llms.txt

Examples of various HTML attributes, tags, and interpolation patterns recognized by the extraction tool.

```html
<!-- Attribute-based translation -->
<div translate>Hello World</div>
<div i18n>Hello World</div>

<!-- With translation context -->
<div translate translate-context="Greeting for user">Hello World</div>

<!-- With translator comment -->
<div translate translate-comment="Shown on homepage">Hello World</div>

<!-- Plural form -->
<div translate translate-plural="Hello Worlds">Hello World</div>

<!-- Filter-based translation in interpolation -->
<div placeholder="{{ 'Hello World' | translate }}"></div>
<div title="{{ 'Tooltip text' | i18n }}"></div>

<!-- With fallback expression -->
<div placeholder="{{ scopeVariable || ('Hello World' | translate) }}"></div>

<!-- Tag-based translation -->
<get-text>Hello World</get-text>
<i18n>Hello World</i18n>
<translate>Hello World</translate>

<!-- Concatenated strings -->
<span ng-bind="{{ 'Hello ' + 'World' | translate }}"></span>

<!-- Conditional expressions (all branches extracted) -->
<span ng-bind="isDay ? 'Good morning' : 'Good evening' | translate"></span>

<!-- AngularJS one-time binding with :: prefix -->
<span>{{:: 'Bind once text' | translate }}</span>
<span ng-bind=":: 'Bind once' | translate"></span>

<!-- HTML entity quotes -->
<div attr="{{ &quot;Quoted text&quot; | translate }}">Content</div>

<!-- Escaped quotes in strings -->
<span ng-bind="'It\'s working' | translate"></span>
```

--------------------------------

### AngularJS HTML Translation Examples

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

These HTML snippets demonstrate different ways translations can be embedded in AngularJS templates, including interpolation and filter usage. The extraction tool needs to be run twice to cover all cases.

```html
<input placeholder="{{:: 'Insert name …' |translate }}">
<input placeholder="{{ 'Insert name …' |translate }}">
```

```html
<a href="#" ng-bind=":: 'Link text' |translate"></a>
<a href="#" ng-bind="'Link text' |translate"></a>
<a href="#">{{::'Link text' |translate}}</a>
<a href="#">{{'Link text' |translate}}</a>
```

--------------------------------

### AngularJS Translation Extraction (Interpolation)

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

For AngularJS, extract translations using specific start and end delimiters for interpolation, and optionally a filter prefix. This command targets interpolation within `{{ }}`.

```bash
--startDelimiter '{{' --endDelimiter '}}' --filterPrefix '::'
```

--------------------------------

### AngularJS Translation Extraction (Direct)

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

This command extracts translations from AngularJS templates without specific delimiters, useful for cases where translations are directly bound or filtered. It uses empty start and end delimiters.

```bash
--output ${html_b} --startDelimiter '' --endDelimiter '' --filterPrefix '::'
```

--------------------------------

### Run Jest Tests

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Execute the project's tests using the Jest testing framework. This command is typically run from the project's root directory.

```bash
npm test
```

--------------------------------

### preprocessTemplate()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Preprocesses template content from various formats like Pug, Jade, or Vue into standard HTML for extraction.

```APIDOC
## preprocessTemplate()

### Description
Preprocess template content from Pug/Jade or Vue files into HTML for extraction.

### Parameters
- **content** (string) - Required - The template source code.
- **type** (string) - Required - The format type (e.g., 'html', 'pug', 'vue').

### Response
- **string|array** - Returns the processed HTML string or an array of strings if multiple templates are found.
```

--------------------------------

### Parser options for gettext-extract

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Available options for the --parser flag: auto, acorn, or babel.

```bash
--parser auto|acorn|babel
```

--------------------------------

### Extract gettext tokens from HTML, Pug, Vue, and JS files

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Invoke the gettext-extract tool on various file types to generate a POT dictionary template. The --output argument specifies the output file.

```bash
gettext-extract --output dictionary.pot foo.html bar.pug component.vue sourcefile.js
```

--------------------------------

### Extract Gettext from Multiple Files via npm Script

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

This npm script demonstrates extracting gettext strings from all `.vue` files within a specified directory using `gettext-extract` and the `find` command. Adapt the file pattern and directory for other file types.

```json
{
  //...
  "scripts": {
    // This is for VueJS files, please adapt for HTML or Jade/Pug templates
    "extract-gettext-cli": "gettext-extract --attribute v-translate --output dictionary.pot $(find scripts/src/components -type f -name '*.vue')"
  }
}
```

--------------------------------

### Programmatic Extraction with Extractor Class

Source: https://context7.com/polyconseil/easygettext/llms.txt

Instantiate the `Extractor` class to programmatically parse files and generate POT output. Configure options like line numbers, attributes, filters, and delimiters.

```javascript
const { Extractor } = require('easygettext/src/extract.js');

// Create extractor with options
const extractor = new Extractor({
  lineNumbers: true,
  attributes: ['translate', 'i18n', 'v-translate'],
  filters: ['translate', 'i18n'],
  startDelimiter: '{{',
  endDelimiter: '}}',
  filterPrefix: '::',
  removeHTMLWhitespaces: false,
});

// Parse HTML content
extractor.parse('greeting.html', '<div translate>Hello world</div>');

// Parse HTML with context and comments
extractor.parse('greeting.html', "\
  <div translate translate-context=\"Greeting\" translate-comment=\"Main greeting\">
    Hello world
  </div>");

// Parse HTML with plurals
extractor.parse('items.html', "\
  <span translate translate-plural=\"There are {{ count }} items\">
    There is one item
  </span>");

// Extract from JavaScript code
extractor.parseJavascript('app.js', "\
  const greeting = this.$gettext(\"Hello there!\");
  const contextual = this.$pgettext(\"menu\", \"Home\");
  const plural = this.$ngettext(\"%{ n } item\", \"%{ n } items\", count);
  const contextualPlural = this.$npgettext(\"cart\", \"%{ n } item\", \"%{ n } items\", count);
");

// Extract from Vue component (handles both template and script)
extractor.extract('Component.vue', 'vue', "\
  <template>
    <h1 v-translate>Welcome</h1>
    <p>{{ $gettext('Click here') }}</p>
  </template>
  <script>
    export default {
      computed: {
        message() {
          return this.$gettext('Hello from script');
        }
      }
    }
  </script>
");

// Generate POT output
const potContent = extractor.toString();
console.log(potContent);
// Output:
// msgid ""
// msgstr ""
// \"Content-Type: text/plain; charset=utf-8\\n\"
// \"Content-Transfer-Encoding: 8bit\\n\"
// \"Generated-By: easygettext\\n\"
// \"Project-Id-Version: \\n\"
// 
// #: greeting.html:2
// msgid \"Hello world\"
// msgstr ""

```

--------------------------------

### Test CLI with Attributes

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

This command tests the CLI tool by specifying attributes for extraction and an output file. It's useful for verifying the functionality of the extraction process with custom attributes.

```bash
./src/extract-cli.js --attribute v-translate --attribute v-i18n ~/output.html
```

--------------------------------

### preprocessScript()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Extracts and preprocesses script content from Vue single-file components.

```APIDOC
## preprocessScript()

### Description
Extract and preprocess script content from Vue single-file components.

### Parameters
- **component** (string) - Required - The full Vue component source code.
- **type** (string) - Required - The file type (e.g., 'vue').

### Response
- **array** - An array of objects containing 'content' (the script code) and 'lang' (the language, e.g., 'js' or 'ts').
```

--------------------------------

### Compile PO Files to JSON

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Use `gettext-compile` to convert one or more PO files into a sanitized JSON output file. This is useful for integrating translations into applications.

```bash
gettext-compile --output translations.json fr.po en.po de.po
```

--------------------------------

### Extract Translation Tokens with gettext-extract

Source: https://context7.com/polyconseil/easygettext/llms.txt

Use `gettext-extract` to generate POT files from source code. Specify custom attributes, parsers, delimiters, or filters as needed.

```bash
gettext-extract --output dictionary.pot foo.html bar.pug component.vue sourcefile.js
```

```bash
gettext-extract --attribute v-translate --output dictionary.pot src/*.vue
```

```bash
gettext-extract --attribute v-translate --attribute v-i18n --output dictionary.pot src/*.vue
```

```bash
gettext-extract --parser babel --output dictionary.pot src/*.js
```

```bash
gettext-extract --startDelimiter '[#' --endDelimiter '#]' --output dictionary.pot templates/*.html
```

```bash
gettext-extract --removeHTMLWhitespaces --output dictionary.pot templates/*.html
```

```bash
gettext-extract --filterPrefix '::' --output dictionary.pot templates/*.html
```

```bash
gettext-extract --attribute v-translate --output dictionary.pot $(find src/components -type f -name '*.vue')
```

--------------------------------

### CLI usage for gettext-extract

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Command-line interface options for gettext-extract, including attribute, prefix, output file, and parser.

```bash
gettext-extract [--attribute EXTRA-ATTRIBUTE] [--filterPrefix FILTER-PREFIX] [--output OUTFILE] [--parser auto|acorn|babel] <FILES>
```

--------------------------------

### Compile PO Files to JSON with gettext-compile

Source: https://context7.com/polyconseil/easygettext/llms.txt

Use `gettext-compile` to convert PO files into a JSON format for JavaScript applications. Multiple PO files can be combined into a single JSON output.

```bash
gettext-compile --output translations.json fr.po en.po de.po
```

```bash
gettext-compile fr.po en.po
```

--------------------------------

### Preprocess template content with preprocessTemplate()

Source: https://context7.com/polyconseil/easygettext/llms.txt

This function preprocesses template content from various formats (HTML, Pug, Vue) into HTML. It's used for extracting translatable strings from templates. Specify the source language using the second argument.

```javascript
const { preprocessTemplate } = require('easygettext/src/extract.js');

// HTML passthrough
const html = preprocessTemplate('<h1>hello</h1>', 'html');
console.log(html);  // '<h1>hello</h1>'

// Pug/Jade to HTML
const pug = preprocessTemplate('h1 hello', 'pug');
console.log(pug);   // '<h1>hello</h1>'

// Vue template extraction
const vue = preprocessTemplate('<template><h1>hello</h1></template>', 'vue');
console.log(vue);   // '<h1>hello</h1>'

// Vue with Pug template
const vuePug = preprocessTemplate("<template lang='pug'>h1 hello</template>", 'vue');
console.log(vuePug); // '<h1>hello</h1>'

// Vue with multiple templates (NativeScript)
const multiVue = preprocessTemplate(`
  <template web><h1>Web</h1></template>
  <template native><Label text="Native"/></template>
`, 'vue');
console.log(multiVue); // ['<h1>Web</h1>', '<Label text="Native"/>']
```

--------------------------------

### Extract gettext tokens from Javascript files

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Invoke gettext-extract on Javascript files to extract translatable strings using predefined tokens.

```bash
gettext-extract somefile.js
```

--------------------------------

### Custom attribute and delimiters for gettext-extract

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Customize the attribute used for translation tokens and change the start/end delimiters for template strings.

```bash
gettext-extract --attribute v-translate --output dictionary.pot foo.html bar.jade
```

```bash
gettext-extract --attribute v-translate --attribute v-i18n --output dictionary.pot foo.html bar.jade
```

```bash
gettext-extract --startDelimiter '[#' --endDelimiter '#]' --output dictionary.pot foo.html bar.jade
```

--------------------------------

### Use Babel parser for advanced JS features

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Set the --parser babel option to enable parsing of advanced JavaScript features like optional-chaining and nullish coalescing.

```bash
gettext-extract --parser babel --output dictionary.pot foo.html
```

--------------------------------

### Convert PO content to JSON with compile.po2json()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Use this function to transform PO file content into a JSON dictionary. This is useful for integrating translations into JavaScript applications. It handles basic messages, context-specific messages, and plural forms.

```javascript
const { po2json } = require('easygettext/src/compile.js');

const poContent = `
msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Language: fr\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"

msgid "Hello, you!"
msgstr "Salut, toi!"

msgctxt "In spanish"
msgid "Hello, you!"
msgstr "Hola ustedes!"

msgid "(1 attempt)"
msgid_plural "({{ remaining }} attempts)"
msgstr[0] "(1 tentative)"
msgstr[1] "({{ remaining }} tentatives)"
`;

const result = po2json(poContent);
console.log(JSON.stringify(result, null, 2));
```

--------------------------------

### Bash Script for AngularJS Extraction and Merging

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

This Bash script orchestrates the extraction of gettext strings from HTML files using two different configurations and JavaScript files. It then merges these into a single POT file using `msgcat` and cleans up temporary files.

```bash
#!/usr/bin/env bash

input_files="$(find ./src/ -iname \*.html)"
workdir=$(mktemp -d "${TMPDIR:-/tmp/}$(basename $0).XXXXXXXXXXXX") || exit 1

html_a=${workdir}/messages-html-interpolate.pot
html_b=${workdir}/messages-html.pot

./dist/extract-cli.js --output ${html_a} --startDelimiter '{{' --endDelimiter '}}' --filterPrefix '::' ${input_files}
./dist/extract-cli.js --output ${html_b} --startDelimiter '' --endDelimiter '' --filterPrefix '::' ${input_files}

# Extract gettext “messages” from JavaScript files here, into ${es_a} …
es_a=${workdir}/ecmascript.pot
# [...] > ${es_a}

# Merge the different catalog templates with `msgcat`:  
merged_pot=${workdir}/merged.pot
msgcat ${html_a} ${html_b} ${es_a} > ${merged_pot}

# Cleanup, in case `msgcat` gave merge-conflicts in catalog header.
header=${workdir}/header.pot
sed -e '/^$/q' < ${html_a} > ${header}

body=${workdir}/body.pot
sed '1,/^$/d' < ${merged_pot} > ${body}

cat ${header} ${body} > ${output_file}

# Remove temporary directory with working files.
rm -r ${workdir}
```

--------------------------------

### compile.po2json()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Converts raw PO file content into a structured JSON dictionary suitable for JavaScript applications.

```APIDOC
## compile.po2json()

### Description
Converts PO file content to a JSON dictionary structure for use in JavaScript applications.

### Parameters
- **poContent** (string) - Required - The raw string content of a .po file.

### Response
- **headers** (object) - Contains PO file metadata like Language and Plural-Forms.
- **messages** (object) - A dictionary mapping msgid to translations, handling contexts and plurals.
```

--------------------------------

### Extract from Vue Component

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Use `gettext-extract` to extract translatable strings from Vue.js components. Ensure the component uses the specified template syntax for translatable content.

```bash
gettext-extract MyComponent.vue
```

```html
<template>
        <h1>{{ greeting_message }}</h1>
        <p>{{ number_of_people_here }}</p>

        <h2 v-translate> Some text to be translated
    </template>

    <script>
        export default {
            name: "greetings",
            computed: {
                greeting_message() {
                    return this.$gettext("Hello there!")
                },
                number_of_people_here(nb_folks) {
                    return this.$ngettext("There is ${ n } person here.", "There are ${ n } persons here.", nb_folks)
                }
            }
        }
    </script>
```

--------------------------------

### Extracting Translation Tokens from HTML Fragments

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Demonstrates how JavaScript expressions within HTML translate filters are parsed to extract translatable strings. This is useful for frameworks like AngularJS.

```html
<span ng-bind="isNight ? 'Moon' + 'shine' : 'Day' + 'light' |translate"></span>
<span ng-bind="isC ? 'C' + (isD ? 'D' : 'd') : 'c' + (isE ? 'E' : 'e') |i18n "></span>
```

--------------------------------

### Extract script content from Vue components with preprocessScript()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Extracts and preprocesses script content from Vue single-file components. It supports both JavaScript and TypeScript, identifying the language automatically. This is crucial for extracting translatable strings from component logic.

```javascript
const { preprocessScript } = require('easygettext/src/extract.js');

// Extract JavaScript from Vue component
const vueComponent = `
<template>
  <h1>{{ message }}</h1>
</template>
<script>
export default {
  computed: {
    message() {
      return this.$gettext('Hello');
    }
  }
}
</script>
`;

const scripts = preprocessScript(vueComponent, 'vue');
scripts.forEach(({ content, lang }) => {
  console.log(`Language: ${lang}`);
  console.log(content);
});

// TypeScript Vue component
const tsComponent = `
<template><h1>Test</h1></template>
<script lang="ts">
type Message = string;
export default {
  computed: {
    message(): Message {
      return this.$gettext('Hello');
    }
  }
}
</script>
`;

const tsScripts = preprocessScript(tsComponent, 'vue');
console.log(tsScripts[0].lang);  // 'ts'
```

--------------------------------

### Extracted Translation Strings

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Shows the resulting strings extracted from the HTML fragments after parsing. These strings are then used for runtime translation lookup.

```text
Moonshine
Daylight
CD
Cd
cE
ce
```

--------------------------------

### compile.sanitizePoData()

Source: https://context7.com/polyconseil/easygettext/llms.txt

Filters PO items to remove fuzzy, obsolete, and empty translations from the dataset.

```APIDOC
## compile.sanitizePoData()

### Description
Filter PO items to remove fuzzy, obsolete, and empty translations.

### Parameters
- **poItems** (array) - Required - An array of PO item objects containing msgid, msgstr, flags, and obsolete status.

### Response
- **object** - A cleaned dictionary of translations.
```

--------------------------------

### Filter PO items with compile.sanitizePoData()

Source: https://context7.com/polyconseil/easygettext/llms.txt

This utility function filters an array of PO items, removing fuzzy, obsolete, and empty translations. It's useful for cleaning up translation data before use. Ensure the input is an array of objects with expected keys like msgid, msgstr, and flags.

```javascript
const { sanitizePoData } = require('easygettext/src/compile.js');

const poItems = [
  { msgid: 'Hello', msgstr: ['Bonjour'], msgctxt: null, flags: {}, obsolete: false },
  { msgid: 'Goodbye', msgstr: ['Au revoir'], msgctxt: 'formal', flags: {}, obsolete: false },
  { msgid: 'Fuzzy text', msgstr: ['Texte flou'], flags: { fuzzy: true }, obsolete: false },
  { msgid: 'Old text', msgstr: ['Vieux texte'], flags: {}, obsolete: true },
  { msgid: 'Empty', msgstr: [], flags: {}, obsolete: false },
];

const sanitized = sanitizePoData(poItems);
console.log(JSON.stringify(sanitized, null, 2));
```

--------------------------------

### Remove HTML whitespaces during extraction

Source: https://github.com/polyconseil/easygettext/blob/master/README.md

Use the --removeHTMLWhitespaces flag to remove optional HTML whitespaces inside tags before extracting gettext tokens.

```bash
gettext-extract --removeHTMLWhitespaces --output dictionary.pot foo.html
```

--------------------------------

### Extract translation strings from JavaScript

Source: https://context7.com/polyconseil/easygettext/llms.txt

Use the extractStringsFromJavascript function to parse translation calls from JS/TS code. Supports both acorn and babel parsers for different syntax requirements.

```javascript
const { extractStringsFromJavascript } = require('easygettext/src/javascript-extract.js');

const jsCode = `
export default {
  computed: {
    greeting() {
      return this.$gettext("Hello there!");
    },
    contextual() {
      return this.$pgettext("menu", "Home");
    },
    plural(n) {
      return this.$ngettext("%{ n } item", "%{ n } items", n);
    },
    contextualPlural(n) {
      return this.$npgettext("cart", "%{ n } item", "%{ n } items", n);
    }
  }
}
`;

// Using acorn parser (default)
const strings = extractStringsFromJavascript('component.vue', jsCode, 'acorn');
strings.forEach(str => {
  console.log(`msgid: "${str.msgid}"`);
  console.log(`context: ${str.msgctxt}`);
  console.log(`file: ${str.reference.file}:${str.reference.line}`);
  console.log('---');
});

// Using babel parser for modern syntax (optional chaining, nullish coalescing)
const modernCode = `
const message = obj?.nested?.$gettext('Optional chaining works');
const fallback = value ?? $gettext('Nullish coalescing');
`;
const modernStrings = extractStringsFromJavascript('modern.js', modernCode, 'babel');
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.