open-index/open-npm huggingface dataset:
npm package: @khulnasoft/httpql
Description: Parser for the HTTPQL language
Author: KhulnaSoft Lab.
Latest version: 0.2.1

# HTTPQL

[<img alt="github" src="https://img.shields.io/badge/github-khulnasoft/httpql-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/khulnasoft-lab/httpql)
[<img alt="crates.io" src="https://img.shields.io/npm/v/@khulnasoft/httpql?style=for-the-badge" height="20">](https://www.npmjs.com/package/@khulnasoft/httpql)

This is the JS parser for the [HTTPQL language](https://docs.khulnasoft.com/internals/httpql.html).

```typescript
import { deserialize, serialize } from "@khulnasoft/httpql";

const parsed = deserialize('req.ext.cont:"HELLO"');
console.log(parsed);
const result = serialize(parsed);
console.log(result);
```
npm package: @khulnasoft/l10nify
Description: Localization workflow for Browserify
Author: Md Sulaiman
Latest version: 0.4.0

# l10nify

Localization workflow for Browserify

## How does this work?

This is a Browserify-based workflow for localizing client side applications. It is built for use cases where you can and want to ship one bundle per locale. Strings are defined by calling a pseudo-global function (i.e. `__(string, args..)`) in the default language in your code (similar to GNU gettext or similar). Strings are stored in `.po` files.

## Installation

Install from npm:

```
npm install @khulnasoft/l10nify
```

This installs two things:

- a Browserify transform for localizing strings at bundle time. It is references as `@khulnasoft/l10nify`
- a `extract-strings` command that you can use to generate PO files from your JavaScript code.

## Usage

### Defining strings in client side code

In your code, use the `__(string, args...)` function (`__` is the default, but you can use anything) to declare strings in your default language (which defaults to `en` but can be anything you want it to):

```js
const HappyBirthdayComponent = (props) => {
  return (
    <h1>{__('Happy birthday, %s!', props.name)}</h1>
  )
}
```

### Extract strings from your code

Next, you can extract these strings from your code into `.po` files using the `extract-strings` command:

```
$(npm bin)/extract-strings **/*.js
```

This will extract the strings from all matching files and print a `.po` file to stdout. Use the standard `gettext` tools like `msgmerge` and `msgcat` to combine the output with existing `.po` files.

Refer to `extract-strings --help` for a full list of options

#### Why not just use `xgettext`

While `xgettext` works perfectly fine on ES5 code, it will choke on ES6+ syntax and also does not support parsing JSX, which `l10nify` supports.

### Apply the transform at bundle time

Apply the transform to your Browserify setup passing the target `locale`. In development, you can omit this parameter to make the transform return the default locale, i.e. the strings you defined in code.

```js
var browserify = require('browserify')

var b = browserify()
b.add('app.js')
b.transform('@khulnasoft/l10nify', { locale: 'fr' })
b.bundle(function (err, src) {
  // consume bundle
})
```

#### Options

The following options can be passed to the transform:

##### `locale`

`locale` specifies the locale which you want to return when bundling. It defaults to `en` or `process.env.LOCALE` when set.

##### `defaultLocale`

`defaultLocale` specifies the default locale that is used to define strings in code. It defaults to `en` or `process.env.DEFAULT_LOCALE` when set.

##### `source`

`source` specifies the directory in which the `<LOCALE>.po` files are stored. It defaults to `./locales` or `process.env.SOURCE` when set.

##### `global`

`global` defines the global function identifier that is used for defining strings in code. It defaults to `__` or `process.env.GLOBAL` when set.

## License

Copyright 2020 Md Sulaiman - `l10nify` is available under the MIT License
npm package: @khulnasoft/lambda-node-opentelemetry
Description: OpenTelemetry auto tracer for Node.JS based AWS Lambda functions
Latest version: 0.3.2

# Lambda Opentelemetry for Node.JS
[![Documentation][docs_badge]][docs]
[![Latest Release][release_badge]][release]
[![License][license_badge]][license]

> Don't install this package - add it via the `kengine:tracing` tag


The `@khulnasoft/lambda-node-opentelemetry` package instruments your Node.js AWS Lambda functions with OpenTelemetry and automatically sends tracing data to Kengine. This is the most powerful and flexible way to instrument your serverless functions.

![Trace Timeline](trace-timeline.png)

### Automatic Installation

Once you've connected your AWS account to Kengine, add the `kengine:tracing` tag to any of your Node.js AWS Lambda functions and it will be automatically instrumented with OpenTelemetry.

## License

&copy; Kengine Limited, 2023

Distributed under MIT License (`The MIT License`).

See [LICENSE](LICENSE) for more information.

<!-- Badges -->

[docs]: https://kengine.khulnasoft.com/docs/
[docs_badge]: https://img.shields.io/badge/docs-reference-blue.svg?style=flat-square
[release]: https://github.com/khulnasoft/lambda-node-opentelemetry/releases/latest
[release_badge]: https://img.shields.io/github/release/kengine/lambda-node-opentelemetry.svg?style=flat-square&ghcache=unused
[license]: https://opensource.org/licenses/MIT
[license_badge]: https://img.shields.io/github/license/kengine/lambda-node-opentelemetry.svg?color=blue&style=flat-square&ghcache=unused