@banbolee/dsh-fish-shell 0.7.0 → 0.8.1

package/node_modules/@deepseek-ai/cosmokit/lib/types/types.d.ts

@@ -0,0 +1,42 @@
+type GlobalConstructorNames = keyof {
+    [K in keyof typeof globalThis as typeof globalThis[K] extends abstract new (...args: any) => any ? K : never]: K;
+};
+/** Create a predicate for a global constructor name. */
+export declare function is<K extends GlobalConstructorNames>(type: K): (value: any) => value is InstanceType<typeof globalThis[K]>;
+/** Test whether a value matches a global constructor name. */
+export declare function is<K extends GlobalConstructorNames>(type: K, value: any): value is InstanceType<typeof globalThis[K]>;
+declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
+declare function isArrayBufferSource(value: any): value is Binary.Source;
+/** Binary source detection and base64/hex conversion helpers. */
+export declare namespace Binary {
+    type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>;
+    const is: typeof isArrayBufferLike;
+    const isSource: typeof isArrayBufferSource;
+    function fromSource<T extends ArrayBufferLike>(source: Source<T>): T;
+    function toBase64(source: Source): string;
+    function fromBase64(source: string): ArrayBuffer | Uint8Array<ArrayBuffer>;
+    function toHex(source: Source): string;
+    function fromHex(source: string): ArrayBuffer;
+}
+/** Decode a base64 string into binary data. */
+export declare const base64ToArrayBuffer: typeof Binary.fromBase64;
+/** Encode binary data as base64. */
+export declare const arrayBufferToBase64: typeof Binary.toBase64;
+/** Decode a hex string into binary data. */
+export declare const hexToArrayBuffer: typeof Binary.fromHex;
+/** Encode binary data as hex. */
+export declare const arrayBufferToHex: typeof Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes. */
+export declare function clone<T>(source: T): T;
+/**
+ * Compare values recursively, treating two volatile references as equal regardless of value.
+ * Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+ * compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+ * @param a - first value.
+ * @param b - second value.
+ * @param strict - whether to require strict data equality outside volatile references.
+ * @returns whether the values compare equal.
+ */
+export declare function deepEqual(a: any, b: any, strict?: boolean): boolean;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@deepseek-ai/cosmokit/lib/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAGA,KAAK,sBAAsB,GAAG,MAAM;KACjC,CAAC,IAAI,MAAM,OAAO,UAAU,IAAI,OAAO,UAAU,CAAC,CAAC,CAAC,SAAS,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC;CACjH,CAAA;AAED,wDAAwD;AACxD,wBAAgB,EAAE,CAAC,CAAC,SAAS,sBAAsB,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,KAAK,IAAI,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;AAC1H,8DAA8D;AAC9D,wBAAgB,EAAE,CAAC,CAAC,SAAS,sBAAsB,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;AAQtH,iBAAS,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,eAAe,CAE/D;AAED,iBAAS,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,CAE/D;AAED,iEAAiE;AACjE,yBAAiB,MAAM,CAAC;IACtB,KAAY,MAAM,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,IAAI,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;IAEjF,MAAM,EAAE,0BAAoB,CAAA;IAC5B,MAAM,QAAQ,4BAAsB,CAAA;IAE3C,SAAgB,UAAU,CAAC,CAAC,SAAS,eAAe,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAO1E;IAED,SAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,UAWtC;IAED,SAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,yCAGxC;IAED,SAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,UAInC;IAED,SAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,eAQrC;CACF;AAED,+CAA+C;AAC/C,eAAO,MAAM,mBAAmB,0BAAoB,CAAA;AACpD,oCAAoC;AACpC,eAAO,MAAM,mBAAmB,wBAAkB,CAAA;AAClD,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB,uBAAiB,CAAA;AAC9C,iCAAiC;AACjC,eAAO,MAAM,gBAAgB,qBAAe,CAAA;AAE5C,uEAAuE;AACvE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAAA;AA8BtC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAyCnE"}

package/node_modules/@deepseek-ai/cosmokit/lib/types/volatile.d.ts

@@ -0,0 +1,40 @@
+/** Shared config references used by schema validators and plugin runtimes. */
+/** Recursively readonly data returned by a volatile config reference. */
+export type VolatileSnapshot<T> = T extends object ? {
+    readonly [K in keyof T]: VolatileSnapshot<T[K]>;
+} : T;
+/** A stable reference; keep the reference, or capture its value for one operation only. */
+export interface Volatile<T> {
+    /** @returns the current immutable snapshot, including undefined for an absent value. */
+    get(): VolatileSnapshot<T>;
+}
+/**
+ * Create a detached reference containing an immutable copy of the supplied data.
+ * @param value - validated config data; class instances and functions are unsupported.
+ * @returns a reference whose value is updated only by its owning runtime.
+ */
+export declare function createVolatile<T>(value: T): Volatile<T>;
+/**
+ * Identify references across ESM/CJS copies of the shared library.
+ * @param value - a parsed config value.
+ * @returns whether the value implements the shared reference protocol.
+ */
+export declare function isVolatile(value: unknown): value is Volatile<unknown>;
+/**
+ * Collect config references without descending into their snapshots or opaque objects.
+ * @internal
+ * @param value - parsed config; cyclic ordinary fields are visited once per path.
+ * @returns references and their object-key paths, including an empty path for a root reference.
+ */
+export declare function volatileEntries(value: unknown): {
+    path: string[];
+    ref: Volatile<unknown>;
+}[];
+/**
+ * Commit an already validated immutable snapshot from another reference.
+ * @internal
+ * @param target - the owning plugin's stable reference.
+ * @param source - a newly parsed candidate reference.
+ */
+export declare function updateVolatile(target: Volatile<unknown>, source: Volatile<unknown>): void;
+//# sourceMappingURL=volatile.d.ts.map

package/node_modules/@deepseek-ai/cosmokit/lib/types/volatile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volatile.d.ts","sourceRoot":"","sources":["../../src/volatile.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAI9E,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,CAAC,CAAA;AAE5G,2FAA2F;AAC3F,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,wFAAwF;IACxF,GAAG,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAA;CAC3B;AAsBD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAMvD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAAC,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CAc5F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAEzF"}

package/node_modules/@deepseek-ai/cosmokit/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@deepseek-ai/cosmokit",
+  "description": "A collection of common utilities",
+  "version": "1.8.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "vendor/cosmokit"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/**/*.d.ts.map",
+    "src"
+  ],
+  "author": "Shigma <shigma10826@gmail.com>",
+  "license": "MIT"
+}

package/node_modules/@deepseek-ai/cosmokit/src/array.ts

@@ -0,0 +1,42 @@
+import { isNullable } from './misc.ts'
+
+/** Return true when every item in `array2` is present in `array1`. */
+export function contain(array1: readonly any[], array2: readonly any[]) {
+  return array2.every(item => array1.includes(item))
+}
+
+/** Return items that appear in both arrays. */
+export function intersection<T>(array1: readonly T[], array2: readonly T[]) {
+  return array1.filter(item => array2.includes(item))
+}
+
+/** Return items from `array1` that do not appear in `array2`. */
+export function difference<S>(array1: readonly S[], array2: readonly any[]) {
+  return array1.filter(item => !array2.includes(item))
+}
+
+/** Return the set-union of two arrays while preserving first occurrence order. */
+export function union<T>(array1: readonly T[], array2: readonly T[]) {
+  return Array.from(new Set([...array1, ...array2]))
+}
+
+/** Remove duplicate values while preserving first occurrence order. */
+export function deduplicate<T>(array: readonly T[]) {
+  return [...new Set(array)]
+}
+
+/** Remove one item from an array and report whether it was found. */
+export function remove<T>(list: T[], item: T) {
+  const index = list?.indexOf(item)
+  if (index >= 0) {
+    list.splice(index, 1)
+    return true
+  } else {
+    return false
+  }
+}
+
+/** Normalize nullish, scalar, or array input to an array. */
+export function makeArray<T>(source: null | undefined | T | T[]) {
+  return Array.isArray(source) ? source : isNullable(source) ? [] : [source]
+}

package/node_modules/@deepseek-ai/cosmokit/src/index.ts

@@ -0,0 +1,12 @@
+/** Array set and normalization helpers. */
+export * from './array.ts'
+/** Runtime type, binary, clone, and equality helpers. */
+export * from './types.ts'
+/** Shared utility types and object helpers. */
+export * from './misc.ts'
+/** String case, path, and property formatting helpers. */
+export * from './string.ts'
+/** Time constants, parsing, and formatting helpers. */
+export * from './time.ts'
+/** Immutable config references shared by schema validators and runtimes. */
+export * from './volatile.ts'

package/node_modules/@deepseek-ai/cosmokit/src/misc.ts

@@ -0,0 +1,78 @@
+/** String/symbol keyed dictionary type. */
+export type Dict<T = any, K extends string | symbol = string> = { [key in K]: T }
+/** Safely read `T[K]`, returning `never` when `K` is not a key of `T`. */
+export type Get<T extends {}, K> = K extends keyof T ? T[K] : never
+/** Conditional extraction helper with a configurable return type. */
+export type Extract<S, T, U = S> = S extends T ? U : never
+/** Accept a value or an array, unless the value is already an array type. */
+export type MaybeArray<T> = [T] extends [unknown[]] ? T : T | T[]
+/** Wrap a value in `Promise`, preserving the resolved type of existing promises. */
+export type Promisify<T> = Promise<T extends Promise<infer S> ? S : T>
+/** Accept a value or promise unless the value type is already promise-like. */
+export type Awaitable<T> = [T] extends [Promise<unknown>] ? T : T | Promise<T>
+/** Convert a union type to an intersection type. */
+export type Intersect<U> = (U extends any ? (arg: U) => void : never) extends ((arg: infer I) => void) ? I : never
+
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+export function noop(): any {}
+
+/** Return true when a value is `null` or `undefined`. */
+export function isNullable(value: any): value is null | undefined | void {
+  return value === null || value === undefined
+}
+
+/** Return true when a value is neither `null` nor `undefined`. */
+export function isNonNullable<T>(value: T): value is NonNullable<T> {
+  return !isNullable(value)
+}
+
+/** Return true for non-array object values. */
+export function isPlainObject(data: any) {
+  return data && typeof data === 'object' && !Array.isArray(data)
+}
+
+/** Filter object entries with a key type guard. */
+export function filterKeys<T, K extends string, U extends K>(object: Dict<T, K>, filter: (key: K, value: T) => key is U): Dict<T, U>
+/** Filter object entries with a boolean predicate. */
+export function filterKeys<T, K extends string>(object: Dict<T, K>, filter: (key: K, value: T) => boolean): Dict<T, K>
+/** Filter object entries and return a new object. */
+export function filterKeys(object: {}, filter: (key: string, value: any) => boolean) {
+  return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)))
+}
+
+/** Map object values while preserving the original key set. */
+export function mapValues<U, T, K extends string>(object: Dict<T, K>, transform: (value: T, key: K) => U) {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, (transform as any)(value, key)])) as Dict<U, K>
+}
+
+/** Alias for `mapValues`. */
+export { mapValues as valueMap }
+
+/** Pick selected keys from an object, optionally including `undefined` values. */
+export function pick<T extends object, K extends keyof T>(source: T, keys?: Iterable<K>, forced?: boolean) {
+  if (!keys) return { ...source }
+  const result = {} as Pick<T, K>
+  for (const key of keys) {
+    if (forced || source[key] !== undefined) result[key] = source[key]
+  }
+  return result
+}
+
+/** Omit selected keys from a shallow object copy. */
+export function omit<T, K extends keyof T>(source: T, keys?: Iterable<K>) {
+  if (!keys) return { ...source }
+  const result = { ...source } as Omit<T, K>
+  for (const key of keys) {
+    Reflect.deleteProperty(result, key)
+  }
+  return result
+}
+
+/** Define a non-enumerable writable property with a typed key. */
+export function defineProperty<T, K extends keyof T>(object: T, key: K, value: T[K]): T
+/** Define a non-enumerable writable property with an arbitrary key. */
+export function defineProperty<T, K extends keyof any>(object: T, key: K, value: any): T
+/** Define a non-enumerable writable property and return the object. */
+export function defineProperty<T, K extends keyof any>(object: T, key: K, value: any) {
+  return Object.defineProperty(object, key, { writable: true, value, enumerable: false })
+}

package/node_modules/@deepseek-ai/cosmokit/src/string.ts

@@ -0,0 +1,113 @@
+/** Uppercase the first character of a string. */
+export function capitalize(source: string) {
+  return source.charAt(0).toUpperCase() + source.slice(1)
+}
+
+/** Lowercase the first character of a string. */
+export function uncapitalize(source: string) {
+  return source.charAt(0).toLowerCase() + source.slice(1)
+}
+
+/** Convert dash or underscore delimited text to camelCase. */
+export function camelCase(source: string) {
+  return source.replace(/[_-][a-z]/g, str => str.slice(1).toUpperCase())
+}
+
+const enum State {
+  DELIM,
+  UPPER,
+  LOWER,
+}
+
+function tokenize(source: string, delimiters: number[], delimiter: number) {
+  const output: number[] = []
+  let state = State.DELIM
+  for (let i = 0; i < source.length; i++) {
+    const code = source.charCodeAt(i)
+    if (code >= 65 && code <= 90) {
+      if (state === State.UPPER) {
+        const next = source.charCodeAt(i + 1)
+        if (next >= 97 && next <= 122) {
+          output.push(delimiter)
+        }
+        output.push(code + 32)
+      } else {
+        if (state !== State.DELIM) {
+          output.push(delimiter)
+        }
+        output.push(code + 32)
+      }
+      state = State.UPPER
+    } else if (code >= 97 && code <= 122) {
+      output.push(code)
+      state = State.LOWER
+    } else if (delimiters.includes(code)) {
+      if (state !== State.DELIM) {
+        output.push(delimiter)
+      }
+      state = State.DELIM
+    } else {
+      output.push(code)
+    }
+  }
+  return String.fromCharCode(...output)
+}
+
+/** Convert text to dash-delimited parameter case. */
+export function paramCase(source: string) {
+  return tokenize(source, [45, 95], 45)
+}
+
+/** Convert text to underscore-delimited snake case. */
+export function snakeCase(source: string) {
+  return tokenize(source, [45, 95], 95)
+}
+
+/** Runtime alias for `camelCase`. */
+export const camelize = camelCase
+/** Runtime alias for `paramCase`. */
+export const hyphenate = paramCase
+
+namespace Letter {
+  /* eslint-disable @typescript-eslint/member-delimiter-style */
+  interface LowerToUpper {
+    a: 'A', b: 'B', c: 'C', d: 'D', e: 'E', f: 'F', g: 'G', h: 'H', i: 'I', j: 'J', k: 'K', l: 'L', m: 'M',
+    n: 'N', o: 'O', p: 'P', q: 'Q', r: 'R', s: 'S', t: 'T', u: 'U', v: 'V', w: 'W', x: 'X', y: 'Y', z: 'Z',
+  }
+
+  interface UpperToLower {
+    A: 'a', B: 'b', C: 'c', D: 'd', E: 'e', F: 'f', G: 'g', H: 'h', I: 'i', J: 'j', K: 'k', L: 'l', M: 'm',
+    N: 'n', O: 'o', P: 'p', Q: 'q', R: 'r', S: 's', T: 't', U: 'u', V: 'v', W: 'w', X: 'x', Y: 'y', Z: 'z',
+  }
+  /* eslint-enable @typescript-eslint/member-delimiter-style */
+
+  export type Upper = keyof UpperToLower
+  export type Lower = keyof LowerToUpper
+
+  export type ToUpper<S extends string> = S extends Lower ? LowerToUpper[S] : S
+  export type ToLower<S extends string, P extends string = ''> = S extends Upper ? `${P}${UpperToLower[S]}` : S
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+/** Type-level conversion from dash-delimited text to camelCase. */
+export type camelize<S extends string> = S extends `${infer L}-${infer M}${infer R}` ? `${L}${Letter.ToUpper<M>}${camelize<R>}` : S
+/** Type-level conversion from camelCase text to dash-delimited text. */
+export type hyphenate<S extends string> = S extends `${infer L}${infer R}` ? `${Letter.ToLower<L, '-'>}${hyphenate<R>}` : S
+/* eslint-enable @typescript-eslint/naming-convention */
+
+/** Format a property key as a JavaScript member access suffix. */
+export function formatProperty(key: keyof any) {
+  if (typeof key !== 'string') return `[${key.toString()}]`
+  return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`
+}
+
+/** Remove one trailing slash from a path string. */
+export function trimSlash(source: string) {
+  return source.replace(/\/$/, '')
+}
+
+/** Ensure a path starts with `/` and has no trailing slash. */
+export function sanitize(source: string) {
+  if (!source.startsWith('/')) source = '/' + source
+  return trimSlash(source)
+}

package/node_modules/@deepseek-ai/cosmokit/src/time.ts

@@ -0,0 +1,92 @@
+/** Time constants plus parsing and formatting helpers. */
+export namespace Time {
+  export const millisecond = 1
+  export const second = 1000
+  export const minute = second * 60
+  export const hour = minute * 60
+  export const day = hour * 24
+  export const week = day * 7
+
+  let timezoneOffset = new Date().getTimezoneOffset()
+
+  export function setTimezoneOffset(offset: number) {
+    timezoneOffset = offset
+  }
+
+  export function getTimezoneOffset() {
+    return timezoneOffset
+  }
+
+  export function getDateNumber(date: number | Date = new Date(), offset?: number) {
+    if (typeof date === 'number') date = new Date(date)
+    if (offset === undefined) offset = timezoneOffset
+    return Math.floor((date.valueOf() / minute - offset) / 1440)
+  }
+
+  export function fromDateNumber(value: number, offset?: number) {
+    const date = new Date(value * day)
+    if (offset === undefined) offset = timezoneOffset
+    return new Date(+date + offset * minute)
+  }
+
+  const numeric = /\d+(?:\.\d+)?/.source
+  const timeRegExp = new RegExp(`^${[
+    'w(?:eek(?:s)?)?',
+    'd(?:ay(?:s)?)?',
+    'h(?:our(?:s)?)?',
+    'm(?:in(?:ute)?(?:s)?)?',
+    's(?:ec(?:ond)?(?:s)?)?',
+  ].map(unit => `(${numeric}${unit})?`).join('')}$`)
+
+  export function parseTime(source: string) {
+    const capture = timeRegExp.exec(source)
+    if (!capture) return 0
+    return (parseFloat(capture[1]) * week || 0)
+      + (parseFloat(capture[2]) * day || 0)
+      + (parseFloat(capture[3]) * hour || 0)
+      + (parseFloat(capture[4]) * minute || 0)
+      + (parseFloat(capture[5]) * second || 0)
+  }
+
+  export function parseDate(date: string) {
+    const parsed = parseTime(date)
+    if (parsed) {
+      date = Date.now() + parsed as any
+    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${new Date().toLocaleDateString()}-${date}`
+    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${new Date().getFullYear()}-${date}`
+    }
+    return date ? new Date(date) : new Date()
+  }
+
+  export function format(ms: number) {
+    const abs = Math.abs(ms)
+    if (abs >= day - hour / 2) {
+      return Math.round(ms / day) + 'd'
+    } else if (abs >= hour - minute / 2) {
+      return Math.round(ms / hour) + 'h'
+    } else if (abs >= minute - second / 2) {
+      return Math.round(ms / minute) + 'm'
+    } else if (abs >= second) {
+      return Math.round(ms / second) + 's'
+    }
+    return ms + 'ms'
+  }
+
+  export function toDigits(source: number, length = 2) {
+    return source.toString().padStart(length, '0')
+  }
+
+  export function template(template: string, time = new Date()) {
+    return template
+      .replace('yyyy', time.getFullYear().toString())
+      .replace('yy', time.getFullYear().toString().slice(2))
+      .replace('MM', toDigits(time.getMonth() + 1))
+      .replace('dd', toDigits(time.getDate()))
+      .replace('hh', toDigits(time.getHours()))
+      .replace('mm', toDigits(time.getMinutes()))
+      .replace('ss', toDigits(time.getSeconds()))
+      .replace('SSS', toDigits(time.getMilliseconds(), 3))
+  }
+}

package/node_modules/@deepseek-ai/cosmokit/src/types.ts

@@ -0,0 +1,168 @@
+import { isNullable } from './misc.ts'
+import { isVolatile } from './volatile.ts'
+
+type GlobalConstructorNames = keyof {
+  [K in keyof typeof globalThis as typeof globalThis[K] extends abstract new (...args: any) => any ? K : never]: K
+}
+
+/** Create a predicate for a global constructor name. */
+export function is<K extends GlobalConstructorNames>(type: K): (value: any) => value is InstanceType<typeof globalThis[K]>
+/** Test whether a value matches a global constructor name. */
+export function is<K extends GlobalConstructorNames>(type: K, value: any): value is InstanceType<typeof globalThis[K]>
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+export function is<K extends GlobalConstructorNames>(type: K, value?: any): any {
+  if (arguments.length === 1) return (value: any) => is(type, value)
+  return type in globalThis && value instanceof (globalThis[type] as any)
+    || Object.prototype.toString.call(value).slice(8, -1) === type
+}
+
+function isArrayBufferLike(value: any): value is ArrayBufferLike {
+  return is('ArrayBuffer', value) || is('SharedArrayBuffer', value)
+}
+
+function isArrayBufferSource(value: any): value is Binary.Source {
+  return isArrayBufferLike(value) || ArrayBuffer.isView(value)
+}
+
+/** Binary source detection and base64/hex conversion helpers. */
+export namespace Binary {
+  export type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>
+
+  export const is = isArrayBufferLike
+  export const isSource = isArrayBufferSource
+
+  export function fromSource<T extends ArrayBufferLike>(source: Source<T>): T {
+    if (ArrayBuffer.isView(source)) {
+      // https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer#answer-31394257
+      return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength) as T
+    } else {
+      return source
+    }
+  }
+
+  export function toBase64(source: Source) {
+    source = fromSource(source)
+    if (typeof Buffer !== 'undefined') {
+      return Buffer.from(source).toString('base64')
+    }
+    let binary = ''
+    const bytes = new Uint8Array(source)
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i])
+    }
+    return btoa(binary)
+  }
+
+  export function fromBase64(source: string) {
+    if (typeof Buffer !== 'undefined') return fromSource(Buffer.from(source, 'base64'))
+    return Uint8Array.from(atob(source), c => c.charCodeAt(0))
+  }
+
+  export function toHex(source: Source) {
+    source = fromSource(source)
+    if (typeof Buffer !== 'undefined') return Buffer.from(source).toString('hex')
+    return Array.from(new Uint8Array(source), byte => byte.toString(16).padStart(2, '0')).join('')
+  }
+
+  export function fromHex(source: string) {
+    if (typeof Buffer !== 'undefined') return fromSource(Buffer.from(source, 'hex'))
+    const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1)
+    const buffer: number[] = []
+    for (let i = 0; i < hex.length; i += 2) {
+      buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16))
+    }
+    return Uint8Array.from(buffer).buffer
+  }
+}
+
+/** Decode a base64 string into binary data. */
+export const base64ToArrayBuffer = Binary.fromBase64
+/** Encode binary data as base64. */
+export const arrayBufferToBase64 = Binary.toBase64
+/** Decode a hex string into binary data. */
+export const hexToArrayBuffer = Binary.fromHex
+/** Encode binary data as hex. */
+export const arrayBufferToHex = Binary.toHex
+
+/** Deep-clone common JavaScript values while preserving prototypes. */
+export function clone<T>(source: T): T
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+export function clone(source: any, refs = new Map<any, any>()) {
+  if (!source || typeof source !== 'object') return source
+  if (is('Date', source)) return new Date(source.valueOf())
+  if (is('RegExp', source)) return new RegExp(source.source, source.flags)
+  if (isArrayBufferLike(source)) return source.slice(0)
+  if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength)
+  const cached = refs.get(source)
+  if (cached) return cached
+  if (Array.isArray(source)) {
+    const result: any[] = []
+    refs.set(source, result)
+    source.forEach((value, index) => {
+      result[index] = Reflect.apply(clone, null, [value, refs])
+    })
+    return result
+  }
+  const result = Object.create(Object.getPrototypeOf(source))
+  refs.set(source, result)
+  for (const key of Reflect.ownKeys(source)) {
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) }
+    if ('value' in descriptor) {
+      descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs])
+    }
+    Reflect.defineProperty(result, key, descriptor)
+  }
+  return result
+}
+
+/**
+ * Compare values recursively, treating two volatile references as equal regardless of value.
+ * Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+ * compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+ * @param a - first value.
+ * @param b - second value.
+ * @param strict - whether to require strict data equality outside volatile references.
+ * @returns whether the values compare equal.
+ */
+export function deepEqual(a: any, b: any, strict?: boolean): boolean {
+  const ancestors = new Set<object>()
+  function compare(a: any, b: any): boolean {
+    if (a === b) return true
+    if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b)
+    if (!strict && isNullable(a) && isNullable(b)) return true
+    if (typeof a !== typeof b || typeof a !== 'object' || !a || !b) return false
+    if (ancestors.has(a)) return false
+
+    function check<T>(test: (x: any) => x is T, then: (a: T, b: T) => boolean) {
+      return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : undefined
+    }
+
+    ancestors.add(a)
+    try {
+      return check(Array.isArray, (a, b) => {
+        if (a.length !== b.length) return false
+        for (let index = 0; index < a.length; index++) {
+          if (!compare(a[index], b[index])) return false
+        }
+        return true
+      })
+        ?? check(is('Date'), (a, b) => a.valueOf() === b.valueOf())
+        ?? check(is('URL'), (a, b) => a.href === b.href)
+        ?? check(is('RegExp'), (a, b) => a.source === b.source && a.flags === b.flags)
+        ?? check(isArrayBufferLike, (a, b) => {
+          if (a.byteLength !== b.byteLength) return false
+          const viewA = new Uint8Array(a)
+          const viewB = new Uint8Array(b)
+          for (let i = 0; i < viewA.length; i++) {
+            if (viewA[i] !== viewB[i]) return false
+          }
+          return true
+        })
+        ?? ((!strict || [a, b].every(value => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null))
+          && Object.keys({ ...a, ...b }).every(key => compare(a[key], b[key])))
+    } finally {
+      ancestors.delete(a)
+    }
+  }
+  return compare(a, b)
+}