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

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

@@ -0,0 +1,3 @@
+// Node.js streaming API
+export { jsonrepairTransform } from './streaming/stream.js';
+//# sourceMappingURL=stream.js.map

package/dist/node_modules/jsonrepair/lib/esm/streaming/buffer/InputBuffer.js

@@ -0,0 +1,69 @@
+export function createInputBuffer() {
+  let buffer = '';
+  let offset = 0;
+  let currentLength = 0;
+  let closed = false;
+  function ensure(index) {
+    if (index < offset) {
+      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`);
+    }
+    if (index >= currentLength) {
+      if (!closed) {
+        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`);
+      }
+    }
+  }
+  function push(chunk) {
+    buffer += chunk;
+    currentLength += chunk.length;
+  }
+  function flush(position) {
+    if (position > currentLength) {
+      return;
+    }
+    buffer = buffer.substring(position - offset);
+    offset = position;
+  }
+  function charAt(index) {
+    ensure(index);
+    return buffer.charAt(index - offset);
+  }
+  function charCodeAt(index) {
+    ensure(index);
+    return buffer.charCodeAt(index - offset);
+  }
+  function substring(start, end) {
+    ensure(end - 1); // -1 because end is excluded
+    ensure(start);
+    return buffer.slice(start - offset, end - offset);
+  }
+  function length() {
+    if (!closed) {
+      throw new Error('Cannot get length: input is not yet closed');
+    }
+    return currentLength;
+  }
+  function isEnd(index) {
+    if (!closed) {
+      ensure(index);
+    }
+    return index >= currentLength;
+  }
+  function close() {
+    closed = true;
+  }
+  return {
+    push,
+    flush,
+    charAt,
+    charCodeAt,
+    substring,
+    length,
+    currentLength: () => currentLength,
+    currentBufferSize: () => buffer.length,
+    isEnd,
+    close
+  };
+}
+const indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size';
+//# sourceMappingURL=InputBuffer.js.map

package/dist/node_modules/jsonrepair/lib/esm/streaming/buffer/OutputBuffer.js

@@ -0,0 +1,111 @@
+import { isWhitespace } from '../../utils/stringUtils.js';
+export function createOutputBuffer(_ref) {
+  let {
+    write,
+    chunkSize,
+    bufferSize
+  } = _ref;
+  let buffer = '';
+  let offset = 0;
+  function flushChunks() {
+    let minSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : bufferSize;
+    while (buffer.length >= minSize + chunkSize) {
+      const chunk = buffer.substring(0, chunkSize);
+      write(chunk);
+      offset += chunkSize;
+      buffer = buffer.substring(chunkSize);
+    }
+  }
+  function flush() {
+    flushChunks(0);
+    if (buffer.length > 0) {
+      write(buffer);
+      offset += buffer.length;
+      buffer = '';
+    }
+  }
+  function push(text) {
+    buffer += text;
+    flushChunks();
+  }
+  function unshift(text) {
+    if (offset > 0) {
+      throw new Error(`Cannot unshift: ${flushedMessage}`);
+    }
+    buffer = text + buffer;
+    flushChunks();
+  }
+  function remove(start, end) {
+    if (start < offset) {
+      throw new Error(`Cannot remove: ${flushedMessage}`);
+    }
+    if (end !== undefined) {
+      buffer = buffer.substring(0, start - offset) + buffer.substring(end - offset);
+    } else {
+      buffer = buffer.substring(0, start - offset);
+    }
+  }
+  function insertAt(index, text) {
+    if (index < offset) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, index - offset) + text + buffer.substring(index - offset);
+  }
+  function length() {
+    return offset + buffer.length;
+  }
+  function stripLastOccurrence(textToStrip) {
+    let stripRemainingText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const bufferIndex = buffer.lastIndexOf(textToStrip);
+    if (bufferIndex !== -1) {
+      if (stripRemainingText) {
+        buffer = buffer.substring(0, bufferIndex);
+      } else {
+        buffer = buffer.substring(0, bufferIndex) + buffer.substring(bufferIndex + textToStrip.length);
+      }
+    }
+  }
+  function insertBeforeLastWhitespace(textToInsert) {
+    let bufferIndex = buffer.length; // index relative to the start of the buffer, not taking `offset` into account
+
+    if (!isWhitespace(buffer, bufferIndex - 1)) {
+      // no trailing whitespaces
+      push(textToInsert);
+      return;
+    }
+    while (isWhitespace(buffer, bufferIndex - 1)) {
+      bufferIndex--;
+    }
+    if (bufferIndex <= 0) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, bufferIndex) + textToInsert + buffer.substring(bufferIndex);
+    flushChunks();
+  }
+  function endsWithIgnoringWhitespace(char) {
+    let i = buffer.length - 1;
+    while (i > 0) {
+      if (char === buffer.charAt(i)) {
+        return true;
+      }
+      if (!isWhitespace(buffer, i)) {
+        return false;
+      }
+      i--;
+    }
+    return false;
+  }
+  return {
+    push,
+    unshift,
+    remove,
+    insertAt,
+    length,
+    flush,
+    stripLastOccurrence,
+    insertBeforeLastWhitespace,
+    endsWithIgnoringWhitespace
+  };
+}
+const flushedMessage = 'start of the output is already flushed from the buffer';
+//# sourceMappingURL=OutputBuffer.js.map