open-index/open-npm huggingface dataset:
npm package: @lincy/uniapp-ui-resolver
Description: uniapp ui resolver
Author: lincenying
Latest version: 1.2.1

# @lincy/uniapp-ui-resolver

uniapp ui组件库 按需自动导入

目前支持:

TuniaoUI [https://vue3.tuniaokj.com/zh-CN/guide/intro.html]

Wot Design Uni [https://wot-design-uni.cn/guide/introduction.html]

Usage

```bash
pnpm i -D @uni-helper/vite-plugin-uni-components @lincy/uniapp-ui-resolver
```

### TuniaoUI 使用示例
```ts
import Components from '@uni-helper/vite-plugin-uni-components'
import { TuNiaoResolver } from '@lincy/uniapp-ui-resolver'

export default {
    plugins: [
        Components({
            include: [
                /\.[tj]sx?$/, // .ts, .tsx, .js, .jsx
                /\.vue$/,
                /\.vue\?vue/, // .vue
                /\.md$/, // .md
            ],
            extensions: ['vue', 'tsx', 'jsx'],
            resolvers: [
                TuNiaoResolver(),
            ],
            dts: 'src/z-components.d.ts',
            directoryAsNamespace: true,
        }),
    ]
}
```

### Wot Design Uni 使用示例
```ts
import Components from '@uni-helper/vite-plugin-uni-components'
import { wotDesignResolver } from '@lincy/uniapp-ui-resolver'

export default {
    plugins: [
        Components({
            include: [
                /\.[tj]sx?$/, // .ts, .tsx, .js, .jsx
                /\.vue$/,
                /\.vue\?vue/, // .vue
                /\.md$/, // .md
            ],
            extensions: ['vue', 'tsx', 'jsx'],
            resolvers: [
                wotDesignResolver(),
            ],
            dts: 'src/z-components.d.ts',
            directoryAsNamespace: true,
        }),
    ]
}
```

License

MIT
npm package: @lincy/useragent_parser
Description: This is the VCL & JS implementation of the [ua-parser](https://github.com/tobie/ua-parser)
Author: Jake Champion
Latest version: 1.6.4

# User Agent parser in VCL & JS

This is the VCL & JS implementation of the [ua-parser](https://github.com/tobie/ua-parser)

# Usage

## Updating

  `uap-core` definitions are, by default, compiled and included in the package. Updating `uap-core` is done every day via a GitHub Action.

# Example in VCL

For a request which was the user-agent Chrome 71.1:
```vcl
import ua_parser;

sub vcl_recv {
  call useragent_parser;
  # req.http.useragent_parser_family = "chrome";
  # req.http.useragent_parser_major = "71";
  # req.http.useragent_parser_minor = "1";
  # req.http.useragent_parser_patch = "0";
}
```

# Example in JS

```js
const useragent = require('@lincy/useragent_parser');

console.log(useragent(request.headers['user-agent']))
/*
  {
    family: 'chrome',
    major: 71,
    minor: 1,
    patch: 0
  }
*/
```
npm package: @linda9/vue-dt
Description: DevTools for Vue.js
Author: webfansplz
Latest version: 1.0.1

<p align="center">
  <a href="https://github.com/vuejs/devtools">
    <img src="https://raw.githubusercontent.com/vuejs/devtools/main/docs/public/logo.svg" alt="Vue DevTools - Unleash Vue Developer Experience" width="200">
  </a>
  <br>
  <h1 align="center">Vue DevTools</h1>
  <p align="center">Unleash Vue Developer Experience</p>
</p>

> Note: this repository is for Vue Devtools v7 (previously known as Vue Devtools Next). The now legacy v6 version has been moved to [vuejs/devtools-v6](https://github.com/vuejs/devtools-v6).

## Getting Started

- [Chrome Extension](https://chromewebstore.google.com/detail/vuejs-devtools/nhdogjmejiglipccpnnnanhbledajbpd)
- [Install as Vite plugin](https://devtools.vuejs.org/guide/vite-plugin)
- [Standalone App](https://devtools.vuejs.org/guide/standalone)

For more details, check out the documentation at [devtools.vuejs.org](https://devtools.vuejs.org).

## Sponsors

<p align="center">
  <a href="https://github.com/sponsors/webfansplz">
    <img src="https://cdn.jsdelivr.net/gh/webfansplz/sponsors/sponsors.wide.svg" />
  </a>
</p>

## Contribution

Please make sure to read the [Contributing Guide](https://devtools.vuejs.org/help/contributing) before making a pull request.

Thank you to all the people who already contributed to Vue DevTools!

<!-- <a href="https://github.com/vuejs/devtools/graphs/contributors">
 <img src="https://contrib.rocks/image?repo=vuejs/devtools" />
</a> -->

## License

[MIT](./LICENSE)
npm package: @lindas/barnard59-core
Description: Core component of Barnard59 Linked Data pipelines
Author: Zazuko GmbH
Latest version: 7.0.3

# barnard59-core

The core component of Barnard59 Linked Data pipelines to create and run pipelines.

## Usage

The package exports multiple functions which can be imported like this:

```
import { createPipeline, run } from 'barnard59-core' 
```

### createPipeline(ptr, { basePath, context, logger, variables })

Creates a new `Pipeline` object based on the definition given as graph pointer in `ptr`.
The function accepts the following arguments:

- `ptr`: A graph pointer to the pipeline definition.
- `basePath`: Optional an alternative base path given as string, which is used by the code loaders.
- `context`: Additional optional properties which will be merged into the loader context.
- `logger`: An optional alternative `winston` logger instance that should be used.
  See `defaultLogger()` if you want to create a logger based on the default logger settings.
- `variables`: Additional optional variables which will be merged into the pipeline variables. 

### defaultLoaderRegistry()

Creates an instance of a loader registry that contains all default loaders.
The function can be used to create custom registry instances based on the defaults.

### defaultLogger({ console, errorFilename, filename, level })

The function accepts the following arguments:

- `console` (default: `true`)
- `errorFilename` (default: `null`)
- `filename`: (default: `null`)
- `level`: (default: `error`)

### async run(pipeline, { end = false, resume = false } = {})

Wait for a pipeline to finish.
Optional calls `.end()` or `.resume()` on the stream of the pipeline to trigger processing.

The function accepts the following arguments:

- `pipeline`: The pipeline as Pipeline object.
- `end`: An optional flag, if `true` calls `.end()` on the stream of the pipeline. (default = `false`)
- `resume`: An optional flag, if `true` calls `.resume()` on the stream of the pipeline. (default = `false`)
npm package: @lindas/barnard59-csvw
Description: Simplifies handling CSVW mapping documents in barnard59 pipelines
Author: Zazuko GmbH
Latest version: 3.0.2

#  barnard59-csvw

Simplifies handling CSVW mapping documents in barnard59 pipelines

## Install

```
npm install barnard59-csvw --save
```

## Exported steps

### `fetch`

A step to automate loading CSVW mapping documents and the source CSV, by following the `csvw:url` property. The URL can be local filesystem path or remote URL.

| Argument | Type | Description |
| -- | -- | -- |
| `csvw` | `string` | Local path or URL of the mapping to load |

### Example: Loading CSVW from filesystem

```turtle
@prefix p: <https://pipeline.described.at/> .
@prefix code: <https://code.described.at/> .

<#CsvwStep> a p:Step;
  code:implementedBy [ a code:EcmaScriptModule;
    code:link <node:barnard59-csvw/fetch.js#default>
  ];
  code:arguments [
    code:name "csvw";
    code:value "file:/test/mappings/remote.csvw.json"
  ].
```
npm package: @lindas/barnard59-env
Description: [RDF/JS Environment](https://npm.im/@rdfjs/environment) for [barnard59](https://npm.im/barnard59).
Author: Zazuko GmbH
Latest version: 2.0.2

#  barnard59-env

[RDF/JS Environment](https://npm.im/@rdfjs/environment) for [barnard59](https://npm.im/barnard59).

This is an extension of [@zazuko/env-node](https://npm.im/@zazuko/env-node) that adds namespaces commonly used
by pipelines to `env.ns`.
npm package: @lindas/barnard59-ftp
Description: FTP support for Linked Data pipelines
Author: Zazuko GmbH
Latest version: 3.0.2

# barnard59-ftp

[![Build Status](https://travis-ci.org/zazuko/barnard59-ftp.svg?branch=master)](https://travis-ci.org/zazuko/barnard59-ftp)

FTP support for Linked Data pipelines.

## Examples

### list

The pipeline defined in `examples/list.ttl` lists all files in the root directory of the FTP server running on `localhost` port 8020 using the user/password `test/1234`.
To run a server with that configuration, just use the following command:

```bash
node examples/server.js
```

The pipeline can be started like this:

```bash
./node_modules/.bin/barnard59 run --format=text/turtle --pipeline=http://example.org/pipeline#pipeline --verbose examples/list.ttl
```

## Operations

This package provides operations to make single requests to an FTP server. The
following options are common to all the operations.

Common options:
- `protocol` (*string*): "ftp" (default) or "sftp"
- `host` (*string*): Hostname or IP address of the server (default "localhost")
- `port` (*integer*): Port number of the server (default 21 for FTP, 22 for SFTP)
- `user` (*string*): Username for authentication
- `password` (*string*): Password for password-based authentication
- `privateKey` (*mixed*): (SFTP-only) Buffer or string that contains a private
  key for either key-based or hostbased user authentication (OpenSSH format).
- `passphrase` (*string*): (SFTP-only) For an encrypted private key, this is
  the passphrase used to decrypt it.

### list

List files in a given remote directory. Returns a stream of file names.

Options:
- `pathname` (*string*): Path of the directory to list
- All the common options defined above

### read

Read the content of a remote file at a given path. Returns a stream of
string data.

Options:
- `filename` (*string*): Path of the file to read
- All the common options defined above

### move

Move a remote file from one path to another.

Options:
- `source` (*string*): Source path
- `target` (*string*): Target path
- All the common options defined above
npm package: @lindas/barnard59-graph-store
Description: SPARQL Graph Store Protocol support for Linked Data pipelines
Author: Zazuko GmbH
Latest version: 7.0.2

# barnard59-graph-store

[SPARQL Graph Store Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/) support for Linked Data pipelines.

This package provides operations to read and write from a SPARQL Graph Store.

## Operations

The operation names match the HTTP methods in lower case.

### get ({ endpoint, graph, user, password })

This operation reads a named graph from the given SPARQL Graph Store.
A `Readable` stream of RDF/JS `Quad` objects is returned.
The following options are supported:

- `endpoint`: The URL of the Graph Store endpoint as a string.
- `graph`: The named graph which should be read as a string or RDF/JS Term.
  The default graph will be read if an empty string is given or the option is not given at all.
- `user`: User for basic authentication.
- `password`: Password for basic authentication.

### post ({ endpoint, user, password, maxQuadsPerRequest })

This operation appends quads to the given SPARQL Graph store.
A `Writable` stream of RDF/JS `Quad` objects is returned.
The following options are supported:

- `endpoint`: The URL of the graph store endpoint as a string.
- `user`: User for basic authentication.
- `password`: Password for basic authentication.
- `maxQuadsPerRequest`: The maximum number of quads per request until a new request is made.
  (default: 500000)

### put ({ endpoint, user, password, maxQuadsPerRequest })

This operation appends quads to the given SPARQL Graph store.
A `Writable` stream of RDF/JS `Quad` objects is returned.
The following options are supported:

- `endpoint`: The URL of the graph store endpoint as a string.
- `user`: User for basic authentication.
- `password`: Password for basic authentication.
- `maxQuadsPerRequest`: The maximum number of quads per request until a new request is made.
  (default: 500000)

## Examples

See the [barnard59-examples](https://github.com/zazuko/barnard59-examples/) repository for working example pipelines.
npm package: @lindas/barnard59-rdf
Description: RDF support for Linked Data pipelines
Author: Zazuko GmbH
Latest version: 4.0.3

# barnard59-rdf

This package provides operations for RDF/JS `Quad` and `Dataset` streams for Barnard59 Linked Data pipelines.
The `manifest.ttl` file contains a full list of all operations included in this package. 

## Operations

### `fs/parse`

Reads a file where the input chunk is its path and outputs quad stream of its contents. The appropriate parser is automatically selected by the [rdf-utils-fs](https://npm.im/rdf-utils-fs) package.

### `mapMatch`

TBD

### `members/toTarget`

TBD

### `members/fromSource`

TBD

### `metadata/append`

TBD

### `metadata/voidStats`

TBD

### `setGraph`

TBD
npm package: @lindas/barnard59-sparql
Description: SPARQL support for Barnard59 Linked Data pipelines
Author: Zazuko GmbH
Latest version: 3.0.3

# barnard59-sparql

SPARQL support for Barnard59 Linked Data pipelines.
This package exports operations to run SPARQL queries on endpoints that support the [SPARQL Protocol](https://www.w3.org/TR/sparql11-protocol/).

## Operations

### construct

Runs a construct or describe query and parses the response into RDF/JS Quad stream.

- `endpoint`: URL of the SPARQL endpoint as a string.
- `query`: The SPARQL construct or describe query as a string.
- `user`: User for basic authentication.
- `password`: Password for basic authentication.
- `operation`: The HTTP operation to use ('get' | 'postUrlencoded' | 'postDirect').

### select

Runs a select query and returns each row of the results as single chunk object.
The chunk object contains key-value pairs for each variable of the select query. 

- `endpoint`: URL of the SPARQL endpoint as a string.
- `query`: The SPARQL select query as a string.
- `user`: User for basic authentication.
- `password`: Password for basic authentication.
- `operation`: The HTTP operation to use ('get' | 'postUrlencoded' | 'postDirect').
npm package: @lindas/barnard59-validation
Description: ![CI status](https://github.com/zazuko/barnard59-pipeline-validation/workflows/Node.js%20CI/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/zazuko/barnard59-pipeline-validation/badge.svg?branch=main)](https://coveralls.io/github/zazuko/b
Author: Zazuko GmbH
Latest version: 1.0.2

# barnard59-pipeline-validation
![CI status](https://github.com/zazuko/barnard59-pipeline-validation/workflows/Node.js%20CI/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/zazuko/barnard59-pipeline-validation/badge.svg?branch=main)](https://coveralls.io/github/zazuko/barnard59-pipeline-validation?branch=main)
[![npm version](https://badge.fury.io/js/barnard59-pipeline-validation.svg)](https://www.npmjs.com/package/barnard59-pipeline-validation)

### Pipeline validation

Pipeline validation enables you to verify the consistency of your RDF pipelines. It ensures that all pipeline steps are consistent, and can be executed one after another.
It is a programmatic reflection of [principles behind barnard59](https://github.com/zazuko/barnard59/wiki/Validation)

This script will help you understand what is wrong with your pipeline. Documentation behind [barnard59](https://github.com/zazuko/barnard59) will guide you how to build a valid one.

## Usage

Install globally:
`npm install -g barnard59-pipeline-validation`

CLI help:
`barnard59-validate -h`

Validating a pipeline definition:
`barnard59-validate ./sample-pipelines/fetch-json-to-ntriples.ttl`

### Available Options

* Validating a single pipeline by its IRI:  
    `barnard59-validate your-pipeline-file -p your-pipeline-iri`  
    For an example, try:  
    `barnard59-validate ./sample-pipelines/fetch-json-to-ntriples.json -p http://example.org/pipeline/utc`
* Exclude warnings from output:  
    `barnard59-validate your-pipeline-file --quiet`  
    For an example, try:  
    `barnard59-validate ./sample-pipelines/fetch-json-to-ntriples.json -q`
* Show successful validation checks:  
    `barnard59-validate your-pipeline-file --verbose`  
    For an example, try:  
    `barnard59-validate ./sample-pipelines/fetch-json-to-ntriples.json -v`
* Produce an error exit status on warnings (you might want the warnings to show in CI without failing the CI or vice versa):  
    `barnard59-validate your-pipeline-file --strict`  
    For an example, try:  
    `barnard59-validate ./sample-pipelines/fetch-json-to-ntriples.json -s`
* To return error messages in JSON, don't output to a TTY:  
    `barnard59-validate your-pipeline-file | jq`  

### Rules

A JSON summary of all rules is written to [`./rules.json`](./rules.json) whenever the tests are run, it can also be generated by running `npm run generate-rules`.
npm package: @lindas/clownface
Description: Simple but powerful graph traversing library
Author: Thomas Bergwinkl
Latest version: 2.0.4

# lindas-clownface

[![Build Status](https://github.com/SwissFederalArchives/lindas-clownface/workflows/CI/badge.svg)](https://github.com/SwissFederalArchives/lindas-clownface/actions)
[![NPM Version](https://img.shields.io/npm/v/lindas-clownface.svg?style=flat)](https://npm.im/lindas-clownface)

Clownface is a graph traversal library inspired by [Gremlin](https://tinkerpop.apache.org/gremlin.html) which allows to query any [RDF dataset](https://rdf.js.org/dataset-spec/) in a concise and readable way.

Clownface greatly simplifies interacting with RDF data in JavaScript.

# Quick start

The recommended way is to use clownface with and RDF/JS environment.
It also requires [`DataFactory`](https://rdf.js.org/data-model-spec/#datafactory-interface) and [`DatasetFactory`](https://rdf.js.org/dataset-spec/#datasetfactory-interface), for example those provided by [`@rdfjs/data-model`](https://npm.im/@rdfjs/data-model) and [`@rdfjs/dataset`](https://npm.im/@rdfjs/dataset) packages respectively, as well as [`@rdfjs/namespace`](https://npm.im/@rdfjs/namespace).

```shell
npm install lindas-clownface @rdfjs/environment @rdfjs/data-model @rdfjs/dataset @rdfjs/namespace
````

```js
import Environment from '@rdfjs/environment/Environment.js'
import NamespaceFactory from '@rdfjs/namespace/Factory.js'
import DatasetFactory from '@rdfjs/dataset/Factory.js'
import DataFactory from '@rdfjs/data-model/Factory.js'
import ClownfaceFactory from 'lindas-clownface/Factory.js'

const $rdf = new Environment([
  NamespaceFactory,
  DatasetFactory,
  DataFactory,
  ClownfaceFactory
])

const graph = $rdf.clownface()
```

Alternatively, if you already use [@zazuko/env](https://npm.im/@zazuko/env), it comes bundled with clownface and its dependencies.

```js
import $rdf from '@zazuko/env'

const graph = $rdf.clownface()
```

# Learn more

If you are new to RDF and JavaScript, consider our [Getting Started](https://zazuko.com/get-started/developers/#traverse-an-rdf-graph) guide that also covers Clownface basics.

For API documentation and examples, see https://swissfederalarchives.github.io/lindas-clownface/.
npm package: @lindas/env
Description: RDF/JS Environment
Author: Zazuko GmbH
Latest version: 3.0.5

# Zazuko's [RDF/JS Environment](https://github.com/rdfjs-base/environment)

Like `rdf-ext`, with some additional features.

```js
import env from '@zazuko/env'

// bind namespace to create named nodes
const tbbt = env.namespace('https://tbbt.tv/')

// use clownface for easy graph manipulation
const sheldonCooper = env.clownface()
  .namedNode(tbbt.sheldon)
  // use common vocabularies out-of-the box  
  .addOut(env.ns.rdf.type, env.ns.schema.Person)
  .addOut(env.ns.schema.knows, tbbt.leonard)
```

## Browser usage

The main export includes `rdf-dataset-ext` package to extend the dataset's functionality. 
This package may cause issues in the browser, so you can import `@zazuko/env/web.js` instead.

## Additional features

### Dataset

#### Static util functions

The dataset factory implemented by the main module environment provides some static utility functions
from the [rdf-dataset-ext](httos://npm.im/rdf-dataset-ext) package.

```ts
import { Stream, DatasetCore } from '@rdfjs/types'
import env from '@zazuko/env'

let stream: Stream

// shorthand for creating a dataset from a stream
const dataset: DatasetCore = await env.dataset.fromStream(stream)

// stream any DatasetCore
const streamFromCoreDataset: Stream = env.dataset.toStream(dataset)

// convert any DatasetCore to a canonical form
const canonicalQuads = env.dataset.toCanonical(dataset)
```

#### `rdf-ext` functionality

The provided `DatasetCore` implementation provides additional methods, matching the `rdf-ext` interface.

#### Serializing

It also includes a `serialize` method to easily get a string representation for supported formats.
Serializers are not added out of the box and the need to be imported first

```js
import rdf from '@zazuko/env'
import formats from '@rdfjs/formats'

rdf.formats.import(formats)

const dataset = rdf.dataset()

// create some data

const turtle = await dataset.serialize({ format: 'text/turtle' })
```

#### Extending environments

This package adds the ability to create environments on top of existing ones. To do that, pass the parent environment to the constructor options.

```js
import env from '@zazuko/env';
import Environment from '@zazuko/env/Environment.js';
import MyFactory from './my-factory.js';

const myEnv = new Environment([MyFactory], { parent: env });
```

The `myEnv` will have all the factories from `env` and `MyFactory`.