bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/utils/basic-auth.ts

@@ -0,0 +1,26 @@
+import { decodeBase64 } from './encode'
+
+const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/
+const USER_PASS_REGEXP = /^([^:]*):(.*)$/
+const utf8Decoder = new TextDecoder()
+
+export type Auth = (req: Request) => { username: string; password: string } | undefined
+
+export const auth: Auth = (req: Request) => {
+  const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '')
+  if (!match) {
+    return undefined
+  }
+
+  let userPass = undefined
+  // If an invalid string is passed to atob(), it throws a `DOMException`.
+  try {
+    userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode(decodeBase64(match[1])))
+  } catch {} // Do nothing
+
+  if (!userPass) {
+    return undefined
+  }
+
+  return { username: userPass[1], password: userPass[2] }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/body.ts

@@ -0,0 +1,225 @@
+/**
+ * @module
+ * Body utility.
+ */
+
+import { HonoRequest } from '../request'
+
+type BodyDataValueDot = { [x: string]: string | File | BodyDataValueDot } & {}
+type BodyDataValueDotAll = {
+  [x: string]: string | File | (string | File)[] | BodyDataValueDotAll
+} & {}
+type SimplifyBodyData<T> = {
+  [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K]
+    ? string | File | (string | File)[] | BodyDataValueDotAll
+    : string | File | BodyDataValueDot extends T[K]
+    ? string | File | BodyDataValueDot
+    : string | File | (string | File)[] extends T[K]
+    ? string | File | (string | File)[]
+    : string | File
+} & {}
+
+type BodyDataValueComponent<T> =
+  | string
+  | File
+  | (T extends { all: false }
+      ? never // explicitly set to false
+      : T extends { all: true } | { all: boolean }
+      ? (string | File)[] // use all option
+      : never) // without options
+type BodyDataValueObject<T> = { [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T> }
+type BodyDataValue<T> =
+  | BodyDataValueComponent<T>
+  | (T extends { dot: false }
+      ? never // explicitly set to false
+      : T extends { dot: true } | { dot: boolean }
+      ? BodyDataValueObject<T> // use dot option
+      : never) // without options
+export type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<
+  Record<string, BodyDataValue<T>>
+>
+
+export type ParseBodyOptions = {
+  /**
+   * Determines whether all fields with multiple values should be parsed as arrays.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('file', 'aaa')
+   * data.append('file', 'bbb')
+   * data.append('message', 'hello')
+   *
+   * If all is false:
+   * parseBody should return { file: 'bbb', message: 'hello' }
+   *
+   * If all is true:
+   * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
+   */
+  all: boolean
+  /**
+   * Determines whether all fields with dot notation should be parsed as nested objects.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('obj.key1', 'value1')
+   * data.append('obj.key2', 'value2')
+   *
+   * If dot is false:
+   * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
+   *
+   * If dot is true:
+   * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
+   */
+  dot: boolean
+}
+
+/**
+ * Parses the body of a request based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {HonoRequest | Request} request - The request object to parse.
+ * @param {Partial<ParseBodyOptions>} [options] - Options for parsing the body.
+ * @returns {Promise<T>} The parsed body data.
+ */
+interface ParseBody {
+  <Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(
+    request: HonoRequest | Request,
+    options?: Options
+  ): Promise<T>
+  <T extends BodyData>(
+    request: HonoRequest | Request,
+    options?: Partial<ParseBodyOptions>
+  ): Promise<T>
+}
+export const parseBody: ParseBody = async (
+  request: HonoRequest | Request,
+  options = Object.create(null)
+) => {
+  const { all = false, dot = false } = options
+
+  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers
+  const contentType = headers.get('Content-Type')
+
+  if (
+    contentType?.startsWith('multipart/form-data') ||
+    contentType?.startsWith('application/x-www-form-urlencoded')
+  ) {
+    return parseFormData(request, { all, dot })
+  }
+
+  return {}
+}
+
+/**
+ * Parses form data from a request.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {HonoRequest | Request} request - The request object containing form data.
+ * @param {ParseBodyOptions} options - Options for parsing the form data.
+ * @returns {Promise<T>} The parsed body data.
+ */
+async function parseFormData<T extends BodyData>(
+  request: HonoRequest | Request,
+  options: ParseBodyOptions
+): Promise<T> {
+  const formData = await (request as Request).formData()
+
+  if (formData) {
+    return convertFormDataToBodyData<T>(formData, options)
+  }
+
+  return {} as T
+}
+
+/**
+ * Converts form data to body data based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {FormData} formData - The form data to convert.
+ * @param {ParseBodyOptions} options - Options for parsing the form data.
+ * @returns {T} The converted body data.
+ */
+function convertFormDataToBodyData<T extends BodyData = BodyData>(
+  formData: FormData,
+  options: ParseBodyOptions
+): T {
+  const form: BodyData = Object.create(null)
+
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith('[]')
+
+    if (!shouldParseAllValues) {
+      form[key] = value
+    } else {
+      handleParsingAllValues(form, key, value)
+    }
+  })
+
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes('.')
+
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value)
+        delete form[key]
+      }
+    })
+  }
+
+  return form as T
+}
+
+/**
+ * Handles parsing all values for a given key, supporting multiple values as arrays.
+ *
+ * @param {BodyData} form - The form data object.
+ * @param {string} key - The key to parse.
+ * @param {FormDataEntryValue} value - The value to assign.
+ */
+const handleParsingAllValues = (
+  form: BodyData<{ all: true }>,
+  key: string,
+  value: FormDataEntryValue
+): void => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key])) {
+      ;(form[key] as (string | File)[]).push(value)
+    } else {
+      form[key] = [form[key] as string | File, value]
+    }
+  } else {
+    form[key] = value
+  }
+}
+
+/**
+ * Handles parsing nested values using dot notation keys.
+ *
+ * @param {BodyData} form - The form data object.
+ * @param {string} key - The dot notation key.
+ * @param {BodyDataValue} value - The value to assign.
+ */
+const handleParsingNestedValues = (
+  form: BodyData,
+  key: string,
+  value: BodyDataValue<Partial<ParseBodyOptions>>
+): void => {
+  let nestedForm = form
+  const keys = key.split('.')
+
+  keys.forEach((key, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key] = value
+    } else {
+      if (
+        !nestedForm[key] ||
+        typeof nestedForm[key] !== 'object' ||
+        Array.isArray(nestedForm[key]) ||
+        nestedForm[key] instanceof File
+      ) {
+        nestedForm[key] = Object.create(null)
+      }
+      nestedForm = nestedForm[key] as unknown as BodyData
+    }
+  })
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/buffer.ts

@@ -0,0 +1,65 @@
+/**
+ * @module
+ * Buffer utility.
+ */
+
+import { sha256 } from './crypto'
+
+export const equal = (a: ArrayBuffer, b: ArrayBuffer): boolean => {
+  if (a === b) {
+    return true
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false
+  }
+
+  const va = new DataView(a)
+  const vb = new DataView(b)
+
+  let i = va.byteLength
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const timingSafeEqual = async (
+  a: string | object | boolean,
+  b: string | object | boolean,
+  hashFunction?: Function
+): Promise<boolean> => {
+  if (!hashFunction) {
+    hashFunction = sha256
+  }
+
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)])
+
+  if (!sa || !sb) {
+    return false
+  }
+
+  return sa === sb && a === b
+}
+
+export const bufferToString = (buffer: ArrayBuffer): string => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder('utf-8')
+    return enc.decode(buffer)
+  }
+  return buffer
+}
+
+export const bufferToFormData = (
+  arrayBuffer: ArrayBuffer,
+  contentType: string
+): Promise<FormData> => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      'Content-Type': contentType,
+    },
+  })
+  return response.formData()
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/color.ts

@@ -0,0 +1,26 @@
+/**
+ * @module
+ * Color utility.
+ */
+
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export function getColorEnabled(): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { process, Deno } = globalThis as any
+
+  const isNoColor =
+    typeof Deno?.noColor === 'boolean'
+      ? (Deno.noColor as boolean)
+      : typeof process !== 'undefined'
+      ? // eslint-disable-next-line no-unsafe-optional-chaining
+        'NO_COLOR' in process?.env
+      : false
+
+  return !isNoColor
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/concurrent.ts

@@ -0,0 +1,55 @@
+/**
+ * @module
+ * Concurrent utility.
+ */
+
+const DEFAULT_CONCURRENCY = 1024
+
+export interface Pool {
+  run<T>(fn: () => T): Promise<T>
+}
+
+export const createPool = ({
+  concurrency,
+  interval,
+}: {
+  concurrency?: number
+  interval?: number
+} = {}): Pool => {
+  concurrency ||= DEFAULT_CONCURRENCY
+
+  if (concurrency === Infinity) {
+    // unlimited
+    return {
+      run: async (fn) => fn(),
+    }
+  }
+
+  const pool: Set<{}> = new Set()
+  const run = async <T>(
+    fn: () => T,
+    promise?: Promise<T>,
+    resolve?: (result: T) => void
+  ): Promise<T> => {
+    if (pool.size >= (concurrency as number)) {
+      promise ||= new Promise<T>((r) => (resolve = r))
+      setTimeout(() => run(fn, promise, resolve))
+      return promise
+    }
+    const marker = {}
+    pool.add(marker)
+    const result = await fn()
+    if (interval) {
+      setTimeout(() => pool.delete(marker), interval)
+    } else {
+      pool.delete(marker)
+    }
+    if (resolve) {
+      resolve(result)
+      return promise as Promise<T>
+    } else {
+      return result
+    }
+  }
+  return { run }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/cookie.ts

@@ -0,0 +1,230 @@
+/**
+ * @module
+ * Cookie utility.
+ */
+
+import { decodeURIComponent_ } from './url'
+
+export type Cookie = Record<string, string>
+export type SignedCookie = Record<string, string | false>
+
+type PartitionCookieConstraint =
+  | { partition: true; secure: true }
+  | { partition?: boolean; secure?: boolean } // reset to default
+type SecureCookieConstraint = { secure: true }
+type HostCookieConstraint = { secure: true; path: '/'; domain?: undefined }
+
+export type CookieOptions = {
+  domain?: string
+  expires?: Date
+  httpOnly?: boolean
+  maxAge?: number
+  path?: string
+  secure?: boolean
+  signingSecret?: string
+  sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none'
+  partitioned?: boolean
+  prefix?: CookiePrefixOptions
+} & PartitionCookieConstraint
+export type CookiePrefixOptions = 'host' | 'secure'
+
+export type CookieConstraint<Name> = Name extends `__Secure-${string}`
+  ? CookieOptions & SecureCookieConstraint
+  : Name extends `__Host-${string}`
+  ? CookieOptions & HostCookieConstraint
+  : CookieOptions
+
+const algorithm = { name: 'HMAC', hash: 'SHA-256' }
+
+const getCryptoKey = async (secret: string | BufferSource): Promise<CryptoKey> => {
+  const secretBuf = typeof secret === 'string' ? new TextEncoder().encode(secret) : secret
+  return await crypto.subtle.importKey('raw', secretBuf, algorithm, false, ['sign', 'verify'])
+}
+
+const makeSignature = async (value: string, secret: string | BufferSource): Promise<string> => {
+  const key = await getCryptoKey(secret)
+  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value))
+  // the returned base64 encoded signature will always be 44 characters long and end with one or two equal signs
+  return btoa(String.fromCharCode(...new Uint8Array(signature)))
+}
+
+const verifySignature = async (
+  base64Signature: string,
+  value: string,
+  secret: CryptoKey
+): Promise<boolean> => {
+  try {
+    const signatureBinStr = atob(base64Signature)
+    const signature = new Uint8Array(signatureBinStr.length)
+    for (let i = 0, len = signatureBinStr.length; i < len; i++) {
+      signature[i] = signatureBinStr.charCodeAt(i)
+    }
+    return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value))
+  } catch (e) {
+    return false
+  }
+}
+
+// all alphanumeric chars and all of _!#$%&'*.^`|~+-
+// (see: https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.1)
+const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/
+
+// all ASCII chars 32-126 except 34, 59, and 92 (i.e. space to tilde but not double quote, semicolon, or backslash)
+// (see: https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.1)
+//
+// note: the spec also prohibits comma and space, but we allow both since they are very common in the real world
+// (see: https://github.com/golang/go/issues/7243)
+const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/
+
+export const parse = (cookie: string, name?: string): Cookie => {
+  const pairs = cookie.trim().split(';')
+  return pairs.reduce((parsedCookie, pairStr) => {
+    pairStr = pairStr.trim()
+    const valueStartPos = pairStr.indexOf('=')
+    if (valueStartPos === -1) {
+      return parsedCookie
+    }
+
+    const cookieName = pairStr.substring(0, valueStartPos).trim()
+    if ((name && name !== cookieName) || !validCookieNameRegEx.test(cookieName)) {
+      return parsedCookie
+    }
+
+    let cookieValue = pairStr.substring(valueStartPos + 1).trim()
+    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
+      cookieValue = cookieValue.slice(1, -1)
+    }
+    if (validCookieValueRegEx.test(cookieValue)) {
+      parsedCookie[cookieName] = decodeURIComponent_(cookieValue)
+    }
+
+    return parsedCookie
+  }, {} as Cookie)
+}
+
+export const parseSigned = async (
+  cookie: string,
+  secret: string | BufferSource,
+  name?: string
+): Promise<SignedCookie> => {
+  const parsedCookie: SignedCookie = {}
+  const secretKey = await getCryptoKey(secret)
+
+  for (const [key, value] of Object.entries(parse(cookie, name))) {
+    const signatureStartPos = value.lastIndexOf('.')
+    if (signatureStartPos < 1) {
+      continue
+    }
+
+    const signedValue = value.substring(0, signatureStartPos)
+    const signature = value.substring(signatureStartPos + 1)
+    if (signature.length !== 44 || !signature.endsWith('=')) {
+      continue
+    }
+
+    const isVerified = await verifySignature(signature, signedValue, secretKey)
+    parsedCookie[key] = isVerified ? signedValue : false
+  }
+
+  return parsedCookie
+}
+
+const _serialize = (name: string, value: string, opt: CookieOptions = {}): string => {
+  let cookie = `${name}=${value}`
+
+  if (name.startsWith('__Secure-') && !opt.secure) {
+    // FIXME: replace link to RFC
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.3.1
+    throw new Error('__Secure- Cookie must have Secure attributes')
+  }
+
+  if (name.startsWith('__Host-')) {
+    // FIXME: replace link to RFC
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.3.2
+    if (!opt.secure) {
+      throw new Error('__Host- Cookie must have Secure attributes')
+    }
+
+    if (opt.path !== '/') {
+      throw new Error('__Host- Cookie must have Path attributes with "/"')
+    }
+
+    if (opt.domain) {
+      throw new Error('__Host- Cookie must not have Domain attributes')
+    }
+  }
+
+  if (opt && typeof opt.maxAge === 'number' && opt.maxAge >= 0) {
+    if (opt.maxAge > 34560000) {
+      // FIXME: replace link to RFC
+      // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.2.2
+      throw new Error(
+        'Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.'
+      )
+    }
+    cookie += `; Max-Age=${Math.floor(opt.maxAge)}`
+  }
+
+  if (opt.domain && opt.prefix !== 'host') {
+    cookie += `; Domain=${opt.domain}`
+  }
+
+  if (opt.path) {
+    cookie += `; Path=${opt.path}`
+  }
+
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 34560000_000) {
+      // FIXME: replace link to RFC
+      // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.2.1
+      throw new Error(
+        'Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.'
+      )
+    }
+    cookie += `; Expires=${opt.expires.toUTCString()}`
+  }
+
+  if (opt.httpOnly) {
+    cookie += '; HttpOnly'
+  }
+
+  if (opt.secure) {
+    cookie += '; Secure'
+  }
+
+  if (opt.sameSite) {
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`
+  }
+
+  if (opt.partitioned) {
+    // FIXME: replace link to RFC
+    // https://www.ietf.org/archive/id/draft-cutler-httpbis-partitioned-cookies-01.html#section-2.3
+    if (!opt.secure) {
+      throw new Error('Partitioned Cookie must have Secure attributes')
+    }
+    cookie += '; Partitioned'
+  }
+
+  return cookie
+}
+
+export const serialize = <Name extends string>(
+  name: Name,
+  value: string,
+  opt?: CookieConstraint<Name>
+): string => {
+  value = encodeURIComponent(value)
+  return _serialize(name, value, opt)
+}
+
+export const serializeSigned = async (
+  name: string,
+  value: string,
+  secret: string | BufferSource,
+  opt: CookieOptions = {}
+): Promise<string> => {
+  const signature = await makeSignature(value, secret)
+  value = `${value}.${signature}`
+  value = encodeURIComponent(value)
+  return _serialize(name, value, opt)
+}

package/tests/fixtures/corpus/oss-repos/hono/src/utils/crypto.ts

@@ -0,0 +1,65 @@
+/**
+ * @module
+ * Crypto utility.
+ */
+
+type Algorithm = {
+  name: string
+  alias: string
+}
+
+type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream
+
+export const sha256 = async (data: Data): Promise<string | null> => {
+  const algorithm: Algorithm = { name: 'SHA-256', alias: 'sha256' }
+  const hash = await createHash(data, algorithm)
+  return hash
+}
+
+export const sha1 = async (data: Data): Promise<string | null> => {
+  const algorithm: Algorithm = { name: 'SHA-1', alias: 'sha1' }
+  const hash = await createHash(data, algorithm)
+  return hash
+}
+
+export const md5 = async (data: Data): Promise<string | null> => {
+  const algorithm: Algorithm = { name: 'MD5', alias: 'md5' }
+  const hash = await createHash(data, algorithm)
+  return hash
+}
+
+export const createHash = async (data: Data, algorithm: Algorithm): Promise<string | null> => {
+  let sourceBuffer: ArrayBufferView | ArrayBuffer
+
+  if (data instanceof ReadableStream) {
+    let body = ''
+    const reader = data.getReader()
+    await reader?.read().then(async (chuck) => {
+      const value = await createHash(chuck.value || '', algorithm)
+      body += value
+    })
+    return body
+  }
+  if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) {
+    sourceBuffer = data
+  } else {
+    if (typeof data === 'object') {
+      data = JSON.stringify(data)
+    }
+    sourceBuffer = new TextEncoder().encode(String(data))
+  }
+
+  if (crypto && crypto.subtle) {
+    const buffer = await crypto.subtle.digest(
+      {
+        name: algorithm.name,
+      },
+      sourceBuffer as ArrayBuffer
+    )
+    const hash = Array.prototype.map
+      .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+      .join('')
+    return hash
+  }
+  return null
+}