@tianshu-ai/tianshu 0.3.0

package/plugins/web-search/node_modules/@vitest/spy/dist/index.js

@@ -0,0 +1,191 @@
+import * as tinyspy from 'tinyspy';
+
+const mocks = new Set();
+function isMockFunction(fn) {
+	return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction;
+}
+function spyOn(obj, method, accessType) {
+	const dictionary = {
+		get: "getter",
+		set: "setter"
+	};
+	const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+	let state;
+	const descriptor = getDescriptor(obj, method);
+	const fn = descriptor && descriptor[accessType || "value"];
+	// inherit implementations if it was already mocked
+	if (isMockFunction(fn)) {
+		state = fn.mock._state();
+	}
+	try {
+		const stub = tinyspy.internalSpyOn(obj, objMethod);
+		const spy = enhanceSpy(stub);
+		if (state) {
+			spy.mock._state(state);
+		}
+		return spy;
+	} catch (error) {
+		if (error instanceof TypeError && Symbol.toStringTag && obj[Symbol.toStringTag] === "Module" && (error.message.includes("Cannot redefine property") || error.message.includes("Cannot replace module namespace") || error.message.includes("can't redefine non-configurable property"))) {
+			throw new TypeError(`Cannot spy on export "${String(objMethod)}". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/browser/#limitations`, { cause: error });
+		}
+		throw error;
+	}
+}
+let callOrder = 0;
+function enhanceSpy(spy) {
+	const stub = spy;
+	let implementation;
+	let onceImplementations = [];
+	let implementationChangedTemporarily = false;
+	let instances = [];
+	let contexts = [];
+	let invocations = [];
+	const state = tinyspy.getInternalState(spy);
+	const mockContext = {
+		get calls() {
+			return state.calls;
+		},
+		get contexts() {
+			return contexts;
+		},
+		get instances() {
+			return instances;
+		},
+		get invocationCallOrder() {
+			return invocations;
+		},
+		get results() {
+			return state.results.map(([callType, value]) => {
+				const type = callType === "error" ? "throw" : "return";
+				return {
+					type,
+					value
+				};
+			});
+		},
+		get settledResults() {
+			return state.resolves.map(([callType, value]) => {
+				const type = callType === "error" ? "rejected" : "fulfilled";
+				return {
+					type,
+					value
+				};
+			});
+		},
+		get lastCall() {
+			return state.calls[state.calls.length - 1];
+		},
+		_state(state) {
+			if (state) {
+				implementation = state.implementation;
+				onceImplementations = state.onceImplementations;
+				implementationChangedTemporarily = state.implementationChangedTemporarily;
+			}
+			return {
+				implementation,
+				onceImplementations,
+				implementationChangedTemporarily
+			};
+		}
+	};
+	function mockCall(...args) {
+		instances.push(this);
+		contexts.push(this);
+		invocations.push(++callOrder);
+		const impl = implementationChangedTemporarily ? implementation : onceImplementations.shift() || implementation || state.getOriginal() || (() => {});
+		return impl.apply(this, args);
+	}
+	let name = stub.name;
+	stub.getMockName = () => name || "vi.fn()";
+	stub.mockName = (n) => {
+		name = n;
+		return stub;
+	};
+	stub.mockClear = () => {
+		state.reset();
+		instances = [];
+		contexts = [];
+		invocations = [];
+		return stub;
+	};
+	stub.mockReset = () => {
+		stub.mockClear();
+		implementation = undefined;
+		onceImplementations = [];
+		return stub;
+	};
+	stub.mockRestore = () => {
+		stub.mockReset();
+		state.restore();
+		return stub;
+	};
+	if (Symbol.dispose) {
+		stub[Symbol.dispose] = () => stub.mockRestore();
+	}
+	stub.getMockImplementation = () => implementationChangedTemporarily ? implementation : onceImplementations.at(0) || implementation;
+	stub.mockImplementation = (fn) => {
+		implementation = fn;
+		state.willCall(mockCall);
+		return stub;
+	};
+	stub.mockImplementationOnce = (fn) => {
+		onceImplementations.push(fn);
+		return stub;
+	};
+	function withImplementation(fn, cb) {
+		const originalImplementation = implementation;
+		implementation = fn;
+		state.willCall(mockCall);
+		implementationChangedTemporarily = true;
+		const reset = () => {
+			implementation = originalImplementation;
+			implementationChangedTemporarily = false;
+		};
+		const result = cb();
+		if (typeof result === "object" && result && typeof result.then === "function") {
+			return result.then(() => {
+				reset();
+				return stub;
+			});
+		}
+		reset();
+		return stub;
+	}
+	stub.withImplementation = withImplementation;
+	stub.mockReturnThis = () => stub.mockImplementation(function() {
+		return this;
+	});
+	stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+	stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+	stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+	stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+	stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+	stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
+	Object.defineProperty(stub, "mock", { get: () => mockContext });
+	state.willCall(mockCall);
+	mocks.add(stub);
+	return stub;
+}
+function fn(implementation) {
+	const enhancedSpy = enhanceSpy(tinyspy.internalSpyOn({ spy: implementation || function() {} }, "spy"));
+	if (implementation) {
+		enhancedSpy.mockImplementation(implementation);
+	}
+	return enhancedSpy;
+}
+function getDescriptor(obj, method) {
+	const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+	if (objDescriptor) {
+		return objDescriptor;
+	}
+	let currentProto = Object.getPrototypeOf(obj);
+	while (currentProto !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+		if (descriptor) {
+			return descriptor;
+		}
+		currentProto = Object.getPrototypeOf(currentProto);
+	}
+}
+
+export { fn, isMockFunction, mocks, spyOn };

package/plugins/web-search/node_modules/@vitest/spy/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@vitest/spy",
+  "type": "module",
+  "version": "3.2.6",
+  "description": "Lightweight Jest compatible spy implementation",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/spy#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/spy"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "tinyspy": "^4.0.3"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}

package/plugins/web-search/node_modules/@vitest/utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-Present Vitest Team
+
+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/plugins/web-search/node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js

@@ -0,0 +1,158 @@
+import { plugins, format as format$1 } from '@vitest/pretty-format';
+import * as loupe from 'loupe';
+
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength,...options } = {}) {
+	const MAX_LENGTH = maxLength ?? 1e4;
+	let result;
+	try {
+		result = format$1(object, {
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	} catch {
+		result = format$1(object, {
+			callToJSON: false,
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	}
+	// Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
+	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+		maxLength,
+		...options
+	}) : result;
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function format(...args) {
+	if (typeof args[0] !== "string") {
+		const objects = [];
+		for (let i = 0; i < args.length; i++) {
+			objects.push(inspect(args[i], {
+				depth: 0,
+				colors: false
+			}));
+		}
+		return objects.join(" ");
+	}
+	const len = args.length;
+	let i = 1;
+	const template = args[0];
+	let str = String(template).replace(formatRegExp, (x) => {
+		if (x === "%%") {
+			return "%";
+		}
+		if (i >= len) {
+			return x;
+		}
+		switch (x) {
+			case "%s": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				if (typeof value === "number" && value === 0 && 1 / value < 0) {
+					return "-0";
+				}
+				if (typeof value === "object" && value !== null) {
+					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+						return value.toString();
+					}
+					return inspect(value, {
+						depth: 0,
+						colors: false
+					});
+				}
+				return String(value);
+			}
+			case "%d": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				return Number(value).toString();
+			}
+			case "%i": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				return Number.parseInt(String(value)).toString();
+			}
+			case "%f": return Number.parseFloat(String(args[i++])).toString();
+			case "%o": return inspect(args[i++], {
+				showHidden: true,
+				showProxy: true
+			});
+			case "%O": return inspect(args[i++]);
+			case "%c": {
+				i++;
+				return "";
+			}
+			case "%j": try {
+				return JSON.stringify(args[i++]);
+			} catch (err) {
+				const m = err.message;
+				if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) {
+					return "[Circular]";
+				}
+				throw err;
+			}
+			default: return x;
+		}
+	});
+	for (let x = args[i]; i < len; x = args[++i]) {
+		if (x === null || typeof x !== "object") {
+			str += ` ${x}`;
+		} else {
+			str += ` ${inspect(x)}`;
+		}
+	}
+	return str;
+}
+function inspect(obj, options = {}) {
+	if (options.truncate === 0) {
+		options.truncate = Number.POSITIVE_INFINITY;
+	}
+	return loupe.inspect(obj, options);
+}
+function objDisplay(obj, options = {}) {
+	if (typeof options.truncate === "undefined") {
+		options.truncate = 40;
+	}
+	const str = inspect(obj, options);
+	const type = Object.prototype.toString.call(obj);
+	if (options.truncate && str.length >= options.truncate) {
+		if (type === "[object Function]") {
+			const fn = obj;
+			return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+		} else if (type === "[object Array]") {
+			return `[ Array(${obj.length}) ]`;
+		} else if (type === "[object Object]") {
+			const keys = Object.keys(obj);
+			const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
+			return `{ Object (${kstr}) }`;
+		} else {
+			return str;
+		}
+	}
+	return str;
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { format as f, getDefaultExportFromCjs as g, inspect as i, objDisplay as o, stringify as s };

package/plugins/web-search/node_modules/@vitest/utils/dist/diff.d.ts

@@ -0,0 +1,104 @@
+import { D as DiffOptions } from './types.d-BCElaP-c.js';
+export { a as DiffOptionsColor, S as SerializedDiffOptions } from './types.d-BCElaP-c.js';
+import '@vitest/pretty-format';
+
+/**
+* Diff Match and Patch
+* Copyright 2018 The diff-match-patch Authors.
+* https://github.com/google/diff-match-patch
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* @fileoverview Computes the difference between two texts to create a patch.
+* Applies the patch onto another text, allowing for errors.
+* @author fraser@google.com (Neil Fraser)
+*/
+/**
+* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
+*
+* 1. Delete anything not needed to use diff_cleanupSemantic method
+* 2. Convert from prototype properties to var declarations
+* 3. Convert Diff to class from constructor and prototype
+* 4. Add type annotations for arguments and return values
+* 5. Add exports
+*/
+/**
+* The data structure representing a diff is an array of tuples:
+* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+*/
+declare const DIFF_DELETE = -1;
+declare const DIFF_INSERT = 1;
+declare const DIFF_EQUAL = 0;
+/**
+* Class representing one diff tuple.
+* Attempts to look like a two-element array (which is what this used to be).
+* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
+* @param {string} text Text to be deleted, inserted, or retained.
+* @constructor
+*/
+declare class Diff {
+	0: number;
+	1: string;
+	constructor(op: number, text: string);
+}
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+// Compare two arrays of strings line-by-line. Format as comparison lines.
+declare function diffLinesUnified(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): string;
+// Given two pairs of arrays of strings:
+// Compare the pair of comparison arrays line-by-line.
+// Format the corresponding lines in the pair of displayable arrays.
+declare function diffLinesUnified2(aLinesDisplay: Array<string>, bLinesDisplay: Array<string>, aLinesCompare: Array<string>, bLinesCompare: Array<string>, options?: DiffOptions): string;
+// Compare two arrays of strings line-by-line.
+declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): [Array<Diff>, boolean];
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+// Compare two strings character-by-character.
+// Format as comparison lines in which changed substrings have inverse colors.
+declare function diffStringsUnified(a: string, b: string, options?: DiffOptions): string;
+// Compare two strings character-by-character.
+// Optionally clean up small common substrings, also known as chaff.
+declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?: DiffOptions): [Array<Diff>, boolean];
+
+// Generate a string that will highlight the difference between two values
+// with green and red. (similar to how github does code diffing)
+/**
+* @param a Expected value
+* @param b Received value
+* @param options Diff options
+* @returns {string | null} a string diff
+*/
+declare function diff(a: any, b: any, options?: DiffOptions): string | undefined;
+declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions): string | undefined;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<WeakKey>, expectedReplaced?: WeakSet<WeakKey>): {
+	replacedActual: any
+	replacedExpected: any
+};
+type PrintLabel = (string: string) => string;
+declare function getLabelPrinter(...strings: Array<string>): PrintLabel;
+
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };