@jsonstudio/rcc 0.89.611 → 0.89.682

package/node_modules/json-schema-traverse/spec/index.spec.js

@@ -1,171 +0,0 @@
-'use strict';
-
-var traverse = require('../index');
-var assert = require('assert');
-
-describe('json-schema-traverse', function() {
-  var calls;
-
-  beforeEach(function() {
-    calls = [];
-  });
-
-  it('should traverse all keywords containing schemas recursively', function() {
-    var schema = require('./fixtures/schema').schema;
-    var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-    traverse(schema, {cb: callback});
-    assert.deepStrictEqual(calls, expectedCalls);
-  });
-
-  describe('Legacy v0.3.1 API', function() {
-    it('should traverse all keywords containing schemas recursively', function() {
-      var schema = require('./fixtures/schema').schema;
-      var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-      traverse(schema, callback);
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should work when an options object is provided', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var schema = require('./fixtures/schema').schema;
-      var expectedCalls = require('./fixtures/schema').expectedCalls;
-
-      traverse(schema, {}, callback);
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-
-  describe('allKeys option', function() {
-    var schema = {
-      someObject: {
-        minimum: 1,
-        maximum: 2
-      }
-    };
-
-    it('should traverse objects with allKeys: true option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined],
-        [schema.someObject, '/someObject', schema, '', 'someObject', schema, undefined]
-      ];
-
-      traverse(schema, {allKeys: true, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT traverse objects with allKeys: false option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined]
-      ];
-
-      traverse(schema, {allKeys: false, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT traverse objects without allKeys option', function() {
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema, '', schema, undefined, undefined, undefined, undefined]
-      ];
-
-      traverse(schema, {cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-
-    it('should NOT travers objects in standard keywords which value is not a schema', function() {
-      var schema2 = {
-        const: {foo: 'bar'},
-        enum: ['a', 'b'],
-        required: ['foo'],
-        another: {
-
-        },
-        patternProperties: {}, // will not traverse - no properties
-        dependencies: true, // will not traverse - invalid
-        properties: {
-          smaller: {
-            type: 'number'
-          },
-          larger: {
-            type: 'number',
-            minimum: {$data: '1/smaller'}
-          }
-        }
-      };
-
-      // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
-      var expectedCalls = [
-        [schema2, '', schema2, undefined, undefined, undefined, undefined],
-        [schema2.another, '/another', schema2, '', 'another', schema2, undefined],
-        [schema2.properties.smaller, '/properties/smaller', schema2, '', 'properties', schema2, 'smaller'],
-        [schema2.properties.larger, '/properties/larger', schema2, '', 'properties', schema2, 'larger'],
-      ];
-
-      traverse(schema2, {allKeys: true, cb: callback});
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-  describe('pre and post', function() {
-    var schema = {
-      type: 'object',
-      properties: {
-        name: {type: 'string'},
-        age: {type: 'number'}
-      }
-    };
-
-    it('should traverse schema in pre-order', function() {
-      traverse(schema, {cb: {pre}});
-      var expectedCalls = [
-        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
-        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should traverse schema in post-order', function() {
-      traverse(schema, {cb: {post}});
-      var expectedCalls = [
-        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-
-    it('should traverse schema in pre- and post-order at the same time', function() {
-      traverse(schema, {cb: {pre, post}});
-      var expectedCalls = [
-        ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
-        ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
-        ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
-        ['post', schema, '', schema, undefined, undefined, undefined, undefined],
-      ];
-      assert.deepStrictEqual(calls, expectedCalls);
-    });
-  });
-
-  function callback() {
-    calls.push(Array.prototype.slice.call(arguments));
-  }
-
-  function pre() {
-    calls.push(['pre'].concat(Array.prototype.slice.call(arguments)));
-  }
-
-  function post() {
-    calls.push(['post'].concat(Array.prototype.slice.call(arguments)));
-  }
-});

package/node_modules/require-from-string/index.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var Module = require('module');
-var path = require('path');
-
-module.exports = function requireFromString(code, filename, opts) {
-	if (typeof filename === 'object') {
-		opts = filename;
-		filename = undefined;
-	}
-
-	opts = opts || {};
-	filename = filename || '';
-
-	opts.appendPaths = opts.appendPaths || [];
-	opts.prependPaths = opts.prependPaths || [];
-
-	if (typeof code !== 'string') {
-		throw new Error('code must be a string, not ' + typeof code);
-	}
-
-	var paths = Module._nodeModulePaths(path.dirname(filename));
-
-	var parent = module.parent;
-	var m = new Module(filename, parent);
-	m.filename = filename;
-	m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
-	m._compile(code, filename);
-
-	var exports = m.exports;
-	parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
-
-	return exports;
-};

package/node_modules/require-from-string/license

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Vsevolod Strukchinsky <floatdrop@gmail.com> (github.com/floatdrop)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/node_modules/require-from-string/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "require-from-string",
-  "version": "2.0.2",
-  "description": "Require module from string",
-  "license": "MIT",
-  "repository": "floatdrop/require-from-string",
-  "author": {
-    "name": "Vsevolod Strukchinsky",
-    "email": "floatdrop@gmail.com",
-    "url": "github.com/floatdrop"
-  },
-  "engines": {
-    "node": ">=0.10.0"
-  },
-  "scripts": {
-    "test": "mocha"
-  },
-  "files": [
-    "index.js"
-  ],
-  "keywords": [
-    ""
-  ],
-  "dependencies": {},
-  "devDependencies": {
-    "mocha": "*"
-  }
-}

package/node_modules/require-from-string/readme.md

@@ -1,56 +0,0 @@
-# require-from-string [![Build Status](https://travis-ci.org/floatdrop/require-from-string.svg?branch=master)](https://travis-ci.org/floatdrop/require-from-string)
-
-Load module from string in Node.
-
-## Install
-
-```
-$ npm install --save require-from-string
-```
-
-
-## Usage
-
-```js
-var requireFromString = require('require-from-string');
-
-requireFromString('module.exports = 1');
-//=> 1
-```
-
-
-## API
-
-### requireFromString(code, [filename], [options])
-
-#### code
-
-*Required*  
-Type: `string`
-
-Module code.
-
-#### filename
-Type: `string`  
-Default: `''`
-
-Optional filename.
-
-
-#### options
-Type: `object`
-
-##### appendPaths
-Type: `Array`
-
-List of `paths`, that will be appended to module `paths`. Useful, when you want
-to be able require modules from these paths.
-
-##### prependPaths
-Type: `Array`
-
-Same as `appendPaths`, but paths will be prepended.
-
-## License
-
-MIT © [Vsevolod Strukchinsky](http://github.com/floatdrop)

package/node_modules/tiktoken/README.md

@@ -1,325 +0,0 @@
-# ⏳ tiktoken
-
-tiktoken is a [BPE](https://en.wikipedia.org/wiki/Byte_pair_encoding) tokeniser for use with
-OpenAI's models, forked from the original tiktoken library to provide JS/WASM bindings for NodeJS and other JS runtimes.
-
-This repository contains the following packages:
-
-- `tiktoken` (formally hosted at `@dqbd/tiktoken`): WASM bindings for the original Python library, providing full 1-to-1 feature parity.
-- `js-tiktoken`: Pure JavaScript port of the original library with the core functionality, suitable for environments where WASM is not well supported or not desired (such as edge runtimes). 
-
-Documentation for `js-tiktoken` can be found in [here](https://github.com/dqbd/tiktoken/blob/main/js/README.md). Documentation for the `tiktoken` can be found here below.
-
-The WASM version of `tiktoken` can be installed from NPM:
-
-```
-npm install tiktoken
-```
-
-## Usage
-
-Basic usage follows, which includes all the OpenAI encoders and ranks:
-
-```typescript
-import assert from "node:assert";
-import { get_encoding, encoding_for_model } from "tiktoken";
-
-const enc = get_encoding("gpt2");
-assert(
-  new TextDecoder().decode(enc.decode(enc.encode("hello world"))) ===
-    "hello world"
-);
-
-// To get the tokeniser corresponding to a specific model in the OpenAI API:
-const enc = encoding_for_model("text-davinci-003");
-
-// Extend existing encoding with custom special tokens
-const enc = encoding_for_model("gpt2", {
-  "<|im_start|>": 100264,
-  "<|im_end|>": 100265,
-});
-
-// don't forget to free the encoder after it is not used
-enc.free();
-```
-
-In constrained environments (eg. Edge Runtime, Cloudflare Workers), where you don't want to load all the encoders at once, you can use the lightweight WASM binary via `tiktoken/lite`.
-
-```typescript
-const { Tiktoken } = require("tiktoken/lite");
-const cl100k_base = require("tiktoken/encoders/cl100k_base.json");
-
-const encoding = new Tiktoken(
-  cl100k_base.bpe_ranks,
-  cl100k_base.special_tokens,
-  cl100k_base.pat_str
-);
-const tokens = encoding.encode("hello world");
-encoding.free();
-```
-
-If you want to fetch the latest ranks, use the `load` function:
-
-```typescript
-const { Tiktoken } = require("tiktoken/lite");
-const { load } = require("tiktoken/load");
-const registry = require("tiktoken/registry.json");
-const models = require("tiktoken/model_to_encoding.json");
-
-async function main() {
-  const model = await load(registry[models["gpt-3.5-turbo"]]);
-  const encoder = new Tiktoken(
-    model.bpe_ranks,
-    model.special_tokens,
-    model.pat_str
-  );
-  const tokens = encoder.encode("hello world");
-  encoder.free();
-}
-
-main();
-```
-
-If desired, you can create a Tiktoken instance directly with custom ranks, special tokens and regex pattern:
-
-```typescript
-import { Tiktoken } from "../pkg";
-import { readFileSync } from "fs";
-
-const encoder = new Tiktoken(
-  readFileSync("./ranks/gpt2.tiktoken").toString("utf-8"),
-  { "<|endoftext|>": 50256, "<|im_start|>": 100264, "<|im_end|>": 100265 },
-  "'s|'t|'re|'ve|'m|'ll|'d| ?\\p{L}+| ?\\p{N}+| ?[^\\s\\p{L}\\p{N}]+|\\s+(?!\\S)|\\s+"
-);
-```
-
-Finally, you can a custom `init` function to override the WASM initialization logic for non-Node environments. This is useful if you are using a bundler that does not support WASM ESM integration.
-
-```typescript
-import { get_encoding, init } from "tiktoken/init";
-
-async function main() {
-  const wasm = "..."; // fetch the WASM binary somehow
-  await init((imports) => WebAssembly.instantiate(wasm, imports));
-
-  const encoding = get_encoding("cl100k_base");
-  const tokens = encoding.encode("hello world");
-  encoding.free();
-}
-
-main();
-```
-
-## Compatibility
-
-As this is a WASM library, there might be some issues with specific runtimes. If you encounter any issues, please open an issue.
-
-| Runtime                      | Status | Notes                                                                                      |
-| ---------------------------- | ------ | ------------------------------------------------------------------------------------------ |
-| Node.js                      | ✅     |                                                                                            |
-| Bun                          | ✅     |                                                                                            |
-| Vite                         | ✅     | See [here](#vite) for notes                                                                |
-| Next.js                      | ✅     | See [here](#nextjs) for notes                                                              |
-| Create React App (via Craco) | ✅     | See [here](#create-react-app) for notes                                                    |
-| Vercel Edge Runtime          | ✅     | See [here](#vercel-edge-runtime) for notes                                                 |
-| Cloudflare Workers           | ✅     | See [here](#cloudflare-workers) for notes                                                  |
-| Electron                     | ✅     | See [here](#electron) for notes                                                            |
-| Deno                         | ❌     | Currently unsupported (see [dqbd/tiktoken#22](https://github.com/dqbd/tiktoken/issues/22)) |
-| Svelte + Cloudflare Workers  | ❌     | Currently unsupported (see [dqbd/tiktoken#37](https://github.com/dqbd/tiktoken/issues/37)) |
-
-For unsupported runtimes, consider using [`js-tiktoken`](https://www.npmjs.com/package/js-tiktoken), which is a pure JS implementation of the tokeniser.
-
-### [Vite](#vite)
-
-If you are using Vite, you will need to add both the `vite-plugin-wasm` and `vite-plugin-top-level-await`. Add the following to your `vite.config.js`:
-
-```js
-import wasm from "vite-plugin-wasm";
-import topLevelAwait from "vite-plugin-top-level-await";
-import { defineConfig } from "vite";
-
-export default defineConfig({
-  plugins: [wasm(), topLevelAwait()],
-});
-```
-
-### [Next.js](#nextjs)
-
-Both API routes and `/pages` are supported with the following `next.config.js` configuration.
-
-```typescript
-// next.config.json
-const config = {
-  webpack(config, { isServer, dev }) {
-    config.experiments = {
-      asyncWebAssembly: true,
-      layers: true,
-    };
-
-    return config;
-  },
-};
-```
-
-Usage in pages:
-
-```tsx
-import { get_encoding } from "tiktoken";
-import { useState } from "react";
-
-const encoding = get_encoding("cl100k_base");
-
-export default function Home() {
-  const [input, setInput] = useState("hello world");
-  const tokens = encoding.encode(input);
-
-  return (
-    <div>
-      <input
-        type="text"
-        value={input}
-        onChange={(e) => setInput(e.target.value)}
-      />
-      <div>{tokens.toString()}</div>
-    </div>
-  );
-}
-```
-
-Usage in API routes:
-
-```typescript
-import { get_encoding } from "tiktoken";
-import { NextApiRequest, NextApiResponse } from "next";
-
-export default function handler(req: NextApiRequest, res: NextApiResponse) {
-  const encoding = get_encoding("cl100k_base");
-  const tokens = encoding.encode("hello world");
-  encoding.free();
-  return res.status(200).json({ tokens });
-}
-```
-
-### [Create React App](#create-react-app)
-
-By default, the Webpack configugration found in Create React App does not support WASM ESM modules. To add support, please do the following:
-
-1. Swap `react-scripts` with `craco`, using the guide found here: https://craco.js.org/docs/getting-started/.
-2. Add the following to `craco.config.js`:
-
-```js
-module.exports = {
-  webpack: {
-    configure: (config) => {
-      config.experiments = {
-        asyncWebAssembly: true,
-        layers: true,
-      };
-
-      // turn off static file serving of WASM files
-      // we need to let Webpack handle WASM import
-      config.module.rules
-        .find((i) => "oneOf" in i)
-        .oneOf.find((i) => i.type === "asset/resource")
-        .exclude.push(/\.wasm$/);
-
-      return config;
-    },
-  },
-};
-```
-
-### [Vercel Edge Runtime](#vercel-edge-runtime)
-
-Vercel Edge Runtime does support WASM modules by adding a `?module` suffix. Initialize the encoder with the following snippet:
-
-```typescript
-// @ts-expect-error
-import wasm from "tiktoken/lite/tiktoken_bg.wasm?module";
-import model from "tiktoken/encoders/cl100k_base.json";
-import { init, Tiktoken } from "tiktoken/lite/init";
-
-export const config = { runtime: "edge" };
-
-export default async function (req: Request) {
-  await init((imports) => WebAssembly.instantiate(wasm, imports));
-
-  const encoding = new Tiktoken(
-    model.bpe_ranks,
-    model.special_tokens,
-    model.pat_str
-  );
-
-  const tokens = encoding.encode("hello world");
-  encoding.free();
-
-  return new Response(`${tokens}`);
-}
-```
-
-### [Cloudflare Workers](#cloudflare-workers)
-
-Similar to Vercel Edge Runtime, Cloudflare Workers must import the WASM binary file manually and use the `tiktoken/lite` version to fit the 1 MB limit. However, users need to point directly at the WASM binary via a relative path (including `./node_modules/`).
-
-Add the following rule to the `wrangler.toml` to upload WASM during build:
-
-```toml
-[[rules]]
-globs = ["**/*.wasm"]
-type = "CompiledWasm"
-```
-
-Initialize the encoder with the following snippet:
-
-```javascript
-import { init, Tiktoken } from "tiktoken/lite/init";
-import wasm from "./node_modules/tiktoken/lite/tiktoken_bg.wasm";
-import model from "tiktoken/encoders/cl100k_base.json";
-
-export default {
-  async fetch() {
-    await init((imports) => WebAssembly.instantiate(wasm, imports));
-    const encoder = new Tiktoken(
-      model.bpe_ranks,
-      model.special_tokens,
-      model.pat_str
-    );
-    const tokens = encoder.encode("test");
-    encoder.free();
-    return new Response(`${tokens}`);
-  },
-};
-```
-
-### [Electron](#electron)
-
-To use tiktoken in your Electron main process, you need to make sure the WASM binary gets copied into your application package.
-
-Assuming a setup with [Electron Forge](https://www.electronforge.io) and [`@electron-forge/plugin-webpack`](https://www.npmjs.com/package/@electron-forge/plugin-webpack), add the following to your `webpack.main.config.js`:
-
-```javascript
-const CopyPlugin = require("copy-webpack-plugin");
-
-module.exports = {
-  // ...
-  plugins: [
-    new CopyPlugin({
-      patterns: [
-        { from: "./node_modules/tiktoken/tiktoken_bg.wasm" },
-      ],
-    }),
-  ],
-};
-```
-
-## Development
-
-To build the `tiktoken` library, make sure to have:
-- Rust and [`wasm-pack`](https://github.com/rustwasm/wasm-pack) installed.
-- Node.js 18+ is required to build the JS bindings and fetch the latest encoder ranks via `fetch`.
-
-Install all the dev-dependencies with `yarn install` and build both WASM binary and JS bindings with `yarn build`.
-
-## Acknowledgements
-
-- https://github.com/zurawiki/tiktoken-rs