open-index/open-npm huggingface dataset:
npm package: @istree/11ty
Description: 11ty tools
Author: GEON JU
Latest version: 1.0.11

## Usage

### Apply Filters
```js
function eleventy(config) {
    const filters = require('@istree/11ty');
    filters.init(config);
}
```

same as
```js
function eleventy(config) {
    const filters = require('@istree/11ty');
    for(let key in filters) {
        config.addFilter(key, filters[key]);
    }
}
module.exports = eleventy;
```

### slice
latest 10 posts
```liquid
{% assign latest10Posts = collections['blog'] | reverse | slice : '0', '10' %}
```

### keys
```liquid
{% assign tagList = collections | keys | sort %}
```

### concat
```liquid
{% for tag in tagList %}
    {% assign aHref = '/tags/' | concat : tag, '/' %}
    <a href="{{ aHref }}" rel="permalink">{{ tag }}</a></br>
{% endfor %}
```

### filter
Apply condition to collections
```liquid
{% assign pageList = collections['11ty']
| filter: 'data.type', '==', 'docs'
| filter: 'fileSlug', '!=', '11ty'
| sortByProp : 'data.title'
%}
```

### normalize
```json
{
  "permalink": "/posts/{{ page.fileSlug | normalize }}/"
}
```

### removeHyphen
```liquid
{{ page.fileSlug | removeHyphen}}
```

### dateTime
```liquid
{{ page.date | dateTime: '/y/M/d/' }}
```

### sort
```liquid
{% assign tagList = collections | keys | sort %}
```

### sortByProp
```liquid
{% assign postList = collections[tag] | sortByProp : 'data.title' %}
```

### groupBy
post by year
```liquid
{% assign postsByYearList = collections['blog'] | groupBy: 'date', 'dateTime', 'y' | reverse %}
```

nested loop
```liquid
{% for postsByYear in postsByYearList %}
    <h1>{{postsByYear.name}}</h1>
    {% assign postsByMonth = postsByYear.values | groupBy: 'date', 'dateTime', 'M' | reverse %}
    {% for postsEachMonth in postsByMonth %}
        <h2>{{ postsEachMonth.name }}</h2>
        {% for post in postsEachMonth.values %}
            <a href="{{ post.url }}" rel="permalink">{{ post.fileSlug }}</a><br/>
        {% endfor %}
    {% endfor %}
{% endfor %}
```

### groupByExt
post by year
```liquid
{% assign postsByYearGroup = collections['blog']
| groupByExt: "['date', 'dateTime', 'y' ]", "['reverse']" | eachName: "['concat', ' Year']"
| groupByExt: "['date', 'dateTime', 'M' ]", "['reverse']" | eachName: "['concat', ' Month']"
| eachValues: "['reverse']"
%}
```

nested loop
```liquid
{% for postsByYear in postsByYearGroup %}
    <h1>{{ postsByYear.name }}</h1>
    {% for postsByMonth in postsByYear.values %}
        <h2>{{ postsByMonth.name }}</h2>
        {% for post in postsByMonth.values %}
            <a href="{{ post.url }}" rel="permalink">{{ post.fileSlug }}</a><br/>
        {% endfor %}
    {% endfor %}
{% endfor %}
```

### defaultTitle
```json
{
    "eleventyComputed": {
        "title": "{{ title | defaultTitle : page.fileSlug }}"
    }
}
```

### defaultPageTitle
```liquid
{{ post | defaultPageTitle }}
```

### print
equal to console.log
```liquid
{% assign posts = 'any string' | print: 'apple', 'car' %}
```
npm package: @istvan.xyz/phc-format
Description: An implementation of the PHC format.
Author: István Antal
Latest version: 0.0.4

Spec: https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md

Originally ported to TypeScript from: https://github.com/simonepri/phc-format

## Usage

This package provides a tiny serializer/deserializer for PHC strings that works in modern Node.js and Deno. It ships ESM and CJS builds and avoids Node-only APIs.

Exports:

-   serialize(opts): string
-   deserialize(phcString): { id, version?, params?, salt?, hash? }

Binary fields and cross-runtime behavior:

-   The `salt` and `hash` fields are returned as Uint8Array-compatible instances.
-   In Node.js, they will be Buffer instances for compatibility. In Deno and browsers, they are plain Uint8Array.
-   When serializing, pass `Uint8Array` (or `Buffer` on Node) and the library will base64-encode appropriately without padding.

### Node.js

ESM:

import { serialize, deserialize } from '@istvan.xyz/phc-format';

CommonJS:

const { serialize, deserialize } = require('@istvan.xyz/phc-format');

### Deno

Import via npm specifier:

import { serialize, deserialize } from 'npm:@istvan.xyz/phc-format';

### Examples

// Serialize
const out = serialize({
id: 'argon2i',
params: { m: 120, t: 5000, p: 2 },
salt: new Uint8Array([1,2,3]),
});

// Deserialize
const obj = deserialize('$argon2i$m=120,t=5000,p=2');
// obj.salt / obj.hash are Buffer (Node) or Uint8Array (Deno)

### Notes

-   The library targets Node >= 18.17. Deno is supported via the ESM build and generic APIs (no Node Buffer import required at compile-time).
-   Base64 encoding/decoding omits trailing '=' padding to match PHC examples; decoding accepts unpadded input.