@nocobase/plugin-ai 2.1.0-beta.16 → 2.1.0-beta.19

package/dist/node_modules/jsonrepair/lib/esm/streaming/stack.js

@@ -0,0 +1,44 @@
+export let Caret = /*#__PURE__*/function (Caret) {
+  Caret["beforeValue"] = "beforeValue";
+  Caret["afterValue"] = "afterValue";
+  Caret["beforeKey"] = "beforeKey";
+  return Caret;
+}({});
+export let StackType = /*#__PURE__*/function (StackType) {
+  StackType["root"] = "root";
+  StackType["object"] = "object";
+  StackType["array"] = "array";
+  StackType["ndJson"] = "ndJson";
+  StackType["functionCall"] = "dataType";
+  return StackType;
+}({});
+export function createStack() {
+  const stack = [StackType.root];
+  let caret = Caret.beforeValue;
+  return {
+    get type() {
+      return last(stack);
+    },
+    get caret() {
+      return caret;
+    },
+    pop() {
+      stack.pop();
+      caret = Caret.afterValue;
+      return true;
+    },
+    push(type, newCaret) {
+      stack.push(type);
+      caret = newCaret;
+      return true;
+    },
+    update(newCaret) {
+      caret = newCaret;
+      return true;
+    }
+  };
+}
+function last(array) {
+  return array[array.length - 1];
+}
+//# sourceMappingURL=stack.js.map

package/dist/node_modules/jsonrepair/lib/esm/streaming/stream.js

@@ -0,0 +1,31 @@
+import { Transform } from 'node:stream';
+import { jsonrepairCore } from './core.js';
+export function jsonrepairTransform(options) {
+  const repair = jsonrepairCore({
+    onData: chunk => transform.push(chunk),
+    bufferSize: options?.bufferSize,
+    chunkSize: options?.chunkSize
+  });
+  const transform = new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        repair.transform(chunk.toString());
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    },
+    flush(callback) {
+      try {
+        repair.flush();
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        callback();
+      }
+    }
+  });
+  return transform;
+}
+//# sourceMappingURL=stream.js.map

package/dist/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js

@@ -0,0 +1,7 @@
+export class JSONRepairError extends Error {
+  constructor(message, position) {
+    super(`${message} at position ${position}`);
+    this.position = position;
+  }
+}
+//# sourceMappingURL=JSONRepairError.js.map

package/dist/node_modules/jsonrepair/lib/esm/utils/stringUtils.js

@@ -0,0 +1,147 @@
+const codeSpace = 0x20; // " "
+const codeNewline = 0xa; // "\n"
+const codeTab = 0x9; // "\t"
+const codeReturn = 0xd; // "\r"
+const codeNonBreakingSpace = 0xa0;
+const codeEnQuad = 0x2000;
+const codeHairSpace = 0x200a;
+const codeNarrowNoBreakSpace = 0x202f;
+const codeMediumMathematicalSpace = 0x205f;
+const codeIdeographicSpace = 0x3000;
+export function isHex(char) {
+  return /^[0-9A-Fa-f]$/.test(char);
+}
+export function isDigit(char) {
+  return char >= '0' && char <= '9';
+}
+export function isValidStringCharacter(char) {
+  // note that the valid range is between \u{0020} and \u{10ffff},
+  // but in JavaScript it is not possible to create a code point larger than
+  // \u{10ffff}, so there is no need to test for that here.
+  return char >= '\u0020';
+}
+export function isDelimiter(char) {
+  return ',:[]/{}()\n+'.includes(char);
+}
+export function isFunctionNameCharStart(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$';
+}
+export function isFunctionNameChar(char) {
+  return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$' || char >= '0' && char <= '9';
+}
+
+// matches "https://" and other schemas
+export const regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
+
+// matches all valid URL characters EXCEPT "[", "]", and ",", since that are important JSON delimiters
+export const regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
+export function isUnquotedStringDelimiter(char) {
+  return ',[]/{}\n+'.includes(char);
+}
+export function isStartOfValue(char) {
+  return isQuote(char) || regexStartOfValue.test(char);
+}
+
+// alpha, number, minus, or opening bracket or brace
+const regexStartOfValue = /^[[{\w-]$/;
+export function isControlCharacter(char) {
+  return char === '\n' || char === '\r' || char === '\t' || char === '\b' || char === '\f';
+}
+/**
+ * Check if the given character is a whitespace character like space, tab, or
+ * newline
+ */
+export function isWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a whitespace character like space or tab,
+ * but NOT a newline
+ */
+export function isWhitespaceExceptNewline(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeSpace || code === codeTab || code === codeReturn;
+}
+
+/**
+ * Check if the given character is a special whitespace character, some
+ * unicode variant
+ */
+export function isSpecialWhitespace(text, index) {
+  const code = text.charCodeAt(index);
+  return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
+}
+
+/**
+ * Test whether the given character is a quote or double quote character.
+ * Also tests for special variants of quotes.
+ */
+export function isQuote(char) {
+  // the first check double quotes, since that occurs most often
+  return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Also tests for special variants of double quotes.
+ */
+export function isDoubleQuoteLike(char) {
+  return char === '"' || char === '\u201c' || char === '\u201d';
+}
+
+/**
+ * Test whether the given character is a double quote character.
+ * Does NOT test for special variants of double quotes.
+ */
+export function isDoubleQuote(char) {
+  return char === '"';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Also tests for special variants of single quotes.
+ */
+export function isSingleQuoteLike(char) {
+  return char === "'" || char === '\u2018' || char === '\u2019' || char === '\u0060' || char === '\u00b4';
+}
+
+/**
+ * Test whether the given character is a single quote character.
+ * Does NOT test for special variants of single quotes.
+ */
+export function isSingleQuote(char) {
+  return char === "'";
+}
+
+/**
+ * Strip last occurrence of textToStrip from text
+ */
+export function stripLastOccurrence(text, textToStrip) {
+  let stripRemainingText = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const index = text.lastIndexOf(textToStrip);
+  return index !== -1 ? text.substring(0, index) + (stripRemainingText ? '' : text.substring(index + 1)) : text;
+}
+export function insertBeforeLastWhitespace(text, textToInsert) {
+  let index = text.length;
+  if (!isWhitespace(text, index - 1)) {
+    // no trailing whitespaces
+    return text + textToInsert;
+  }
+  while (isWhitespace(text, index - 1)) {
+    index--;
+  }
+  return text.substring(0, index) + textToInsert + text.substring(index);
+}
+export function removeAtIndex(text, start, count) {
+  return text.substring(0, start) + text.substring(start + count);
+}
+
+/**
+ * Test whether a string ends with a newline or comma character and optional whitespace
+ */
+export function endsWithCommaOrNewline(text) {
+  return /[,\n][ \t\r]*$/.test(text);
+}
+//# sourceMappingURL=stringUtils.js.map

package/dist/node_modules/jsonrepair/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export { jsonrepair } from './regular/jsonrepair.js';
+export { JSONRepairError } from './utils/JSONRepairError.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/regular/jsonrepair.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Repair a string containing an invalid JSON document.
+ * For example changes JavaScript notation into JSON notation.
+ *
+ * Example:
+ *
+ *     try {
+ *       const json = "{name: 'John'}"
+ *       const repaired = jsonrepair(json)
+ *       console.log(repaired)
+ *       // '{"name": "John"}'
+ *     } catch (err) {
+ *       console.error(err)
+ *     }
+ *
+ */
+export declare function jsonrepair(text: string): string;
+//# sourceMappingURL=jsonrepair.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/stream.d.ts

@@ -0,0 +1,2 @@
+export { type JsonRepairTransformOptions, jsonrepairTransform } from './streaming/stream.js';
+//# sourceMappingURL=stream.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/streaming/buffer/InputBuffer.d.ts

@@ -0,0 +1,14 @@
+export interface InputBuffer {
+    push: (chunk: string) => void;
+    flush: (position: number) => void;
+    charAt: (index: number) => string;
+    charCodeAt: (index: number) => number;
+    substring: (start: number, end: number) => string;
+    length: () => number;
+    currentLength: () => number;
+    currentBufferSize: () => number;
+    isEnd: (index: number) => boolean;
+    close: () => void;
+}
+export declare function createInputBuffer(): InputBuffer;
+//# sourceMappingURL=InputBuffer.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/streaming/buffer/OutputBuffer.d.ts

@@ -0,0 +1,18 @@
+export interface OutputBuffer {
+    push: (text: string) => void;
+    unshift: (text: string) => void;
+    remove: (start: number, end?: number) => void;
+    insertAt: (index: number, text: string) => void;
+    length: () => number;
+    flush: () => void;
+    stripLastOccurrence: (textToStrip: string, stripRemainingText?: boolean) => void;
+    insertBeforeLastWhitespace: (textToInsert: string) => void;
+    endsWithIgnoringWhitespace: (char: string) => boolean;
+}
+export interface OutputBufferOptions {
+    write: (chunk: string) => void;
+    chunkSize: number;
+    bufferSize: number;
+}
+export declare function createOutputBuffer({ write, chunkSize, bufferSize }: OutputBufferOptions): OutputBuffer;
+//# sourceMappingURL=OutputBuffer.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/streaming/core.d.ts

@@ -0,0 +1,11 @@
+export interface JsonRepairCoreOptions {
+    onData: (chunk: string) => void;
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export interface JsonRepairCore {
+    transform: (chunk: string) => void;
+    flush: () => void;
+}
+export declare function jsonrepairCore({ onData, bufferSize, chunkSize }: JsonRepairCoreOptions): JsonRepairCore;
+//# sourceMappingURL=core.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/streaming/stack.d.ts

@@ -0,0 +1,20 @@
+export declare enum Caret {
+    beforeValue = "beforeValue",
+    afterValue = "afterValue",
+    beforeKey = "beforeKey"
+}
+export declare enum StackType {
+    root = "root",
+    object = "object",
+    array = "array",
+    ndJson = "ndJson",
+    functionCall = "dataType"
+}
+export declare function createStack(): {
+    readonly type: StackType;
+    readonly caret: Caret;
+    pop(): true;
+    push(type: StackType, newCaret: Caret): true;
+    update(newCaret: Caret): true;
+};
+//# sourceMappingURL=stack.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/streaming/stream.d.ts

@@ -0,0 +1,7 @@
+import { Transform } from 'node:stream';
+export interface JsonRepairTransformOptions {
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export declare function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform;
+//# sourceMappingURL=stream.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/utils/JSONRepairError.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONRepairError extends Error {
+    position: number;
+    constructor(message: string, position: number);
+}
+//# sourceMappingURL=JSONRepairError.d.ts.map

package/dist/node_modules/jsonrepair/lib/types/utils/stringUtils.d.ts

@@ -0,0 +1,65 @@
+export declare function isHex(char: string): boolean;
+export declare function isDigit(char: string): boolean;
+export declare function isValidStringCharacter(char: string): boolean;
+export declare function isDelimiter(char: string): boolean;
+export declare function isFunctionNameCharStart(char: string): boolean;
+export declare function isFunctionNameChar(char: string): boolean;
+export declare const regexUrlStart: RegExp;
+export declare const regexUrlChar: RegExp;
+export declare function isUnquotedStringDelimiter(char: string): boolean;
+export declare function isStartOfValue(char: string): boolean;
+export declare function isControlCharacter(char: string): char is "\n" | "\r" | "\t" | "\b" | "\f";
+export interface Text {
+    charCodeAt: (index: number) => number;
+}
+/**
+ * Check if the given character is a whitespace character like space, tab, or
+ * newline
+ */
+export declare function isWhitespace(text: Text, index: number): boolean;
+/**
+ * Check if the given character is a whitespace character like space or tab,
+ * but NOT a newline
+ */
+export declare function isWhitespaceExceptNewline(text: Text, index: number): boolean;
+/**
+ * Check if the given character is a special whitespace character, some
+ * unicode variant
+ */
+export declare function isSpecialWhitespace(text: Text, index: number): boolean;
+/**
+ * Test whether the given character is a quote or double quote character.
+ * Also tests for special variants of quotes.
+ */
+export declare function isQuote(char: string): boolean;
+/**
+ * Test whether the given character is a double quote character.
+ * Also tests for special variants of double quotes.
+ */
+export declare function isDoubleQuoteLike(char: string): boolean;
+/**
+ * Test whether the given character is a double quote character.
+ * Does NOT test for special variants of double quotes.
+ */
+export declare function isDoubleQuote(char: string): boolean;
+/**
+ * Test whether the given character is a single quote character.
+ * Also tests for special variants of single quotes.
+ */
+export declare function isSingleQuoteLike(char: string): boolean;
+/**
+ * Test whether the given character is a single quote character.
+ * Does NOT test for special variants of single quotes.
+ */
+export declare function isSingleQuote(char: string): boolean;
+/**
+ * Strip last occurrence of textToStrip from text
+ */
+export declare function stripLastOccurrence(text: string, textToStrip: string, stripRemainingText?: boolean): string;
+export declare function insertBeforeLastWhitespace(text: string, textToInsert: string): string;
+export declare function removeAtIndex(text: string, start: number, count: number): string;
+/**
+ * Test whether a string ends with a newline or comma character and optional whitespace
+ */
+export declare function endsWithCommaOrNewline(text: string): boolean;
+//# sourceMappingURL=stringUtils.d.ts.map