bluera-knowledge 0.13.3 → 0.14.1

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

@@ -1,34 +0,0 @@
-/**
- * @module
- * Encode utility.
- */
-
-export const decodeBase64Url = (str: string): Uint8Array => {
-  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: '/', '-': '+' })[m] ?? m))
-}
-
-export const encodeBase64Url = (buf: ArrayBufferLike): string =>
-  encodeBase64(buf).replace(/\/|\+/g, (m) => ({ '/': '_', '+': '-' })[m] ?? m)
-
-// This approach is written in MDN.
-// btoa does not support utf-8 characters. So we need a little bit hack.
-export const encodeBase64 = (buf: ArrayBufferLike): string => {
-  let binary = ''
-  const bytes = new Uint8Array(buf)
-  for (let i = 0, len = bytes.length; i < len; i++) {
-    binary += String.fromCharCode(bytes[i])
-  }
-  return btoa(binary)
-}
-
-// atob does not support utf-8 characters. So we need a little bit hack.
-export const decodeBase64 = (str: string): Uint8Array => {
-  const binary = atob(str)
-  const bytes = new Uint8Array(new ArrayBuffer(binary.length))
-  const half = binary.length / 2
-  for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
-    bytes[i] = binary.charCodeAt(i)
-    bytes[j] = binary.charCodeAt(j)
-  }
-  return bytes
-}

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

@@ -1,56 +0,0 @@
-/**
- * @module
- * FilePath utility.
- */
-
-type FilePathOptions = {
-  filename: string
-  root?: string
-  defaultDocument?: string
-}
-
-export const getFilePath = (options: FilePathOptions): string | undefined => {
-  let filename = options.filename
-  const defaultDocument = options.defaultDocument || 'index.html'
-
-  if (filename.endsWith('/')) {
-    // /top/ => /top/index.html
-    filename = filename.concat(defaultDocument)
-  } else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) {
-    // /top => /top/index.html
-    filename = filename.concat('/' + defaultDocument)
-  }
-
-  const path = getFilePathWithoutDefaultDocument({
-    root: options.root,
-    filename,
-  })
-
-  return path
-}
-
-export const getFilePathWithoutDefaultDocument = (
-  options: Omit<FilePathOptions, 'defaultDocument'>
-): string | undefined => {
-  let root = options.root || ''
-  let filename = options.filename
-
-  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
-    return
-  }
-
-  // /foo.html => foo.html
-  filename = filename.replace(/^\.?[\/\\]/, '')
-
-  // foo\bar.txt => foo/bar.txt
-  filename = filename.replace(/\\/, '/')
-
-  // assets/ => assets
-  root = root.replace(/\/$/, '')
-
-  // ./assets/foo.html => assets/foo.html
-  let path = root ? root + '/' + filename : filename
-  path = path.replace(/^\.?\//, '')
-
-  return path
-}

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

@@ -1,15 +0,0 @@
-/**
- * @module
- * Handler utility.
- */
-
-import { COMPOSED_HANDLER } from '../hono-base'
-
-export const isMiddleware = (handler: Function) => handler.length > 1
-export const findTargetHandler = (handler: Function): Function => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (handler as any)[COMPOSED_HANDLER]
-    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      findTargetHandler((handler as any)[COMPOSED_HANDLER])
-    : handler
-}

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

@@ -1,182 +0,0 @@
-/**
- * @module
- * HTML utility.
- */
-
-export const HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3,
-} as const
-type HtmlEscapedCallbackOpts = {
-  buffer?: [string]
-  phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase]
-  context: object // An object unique to each JSX tree. This object is used as the WeakMap key.
-}
-export type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string> | undefined
-export type HtmlEscaped = {
-  isEscaped: true
-  callbacks?: HtmlEscapedCallback[]
-}
-export type HtmlEscapedString = string & HtmlEscaped
-
-/**
- * StringBuffer contains string and Promise<string> alternately
- * The length of the array will be odd, the odd numbered element will be a string,
- * and the even numbered element will be a Promise<string>.
- * When concatenating into a single string, it must be processed from the tail.
- * @example
- * [
- *   'framework.',
- *   Promise.resolve('ultra fast'),
- *   'a ',
- *   Promise.resolve('is '),
- *   'Hono',
- * ]
- */
-export type StringBuffer = (string | Promise<string>)[]
-export type StringBufferWithCallbacks = StringBuffer & { callbacks: HtmlEscapedCallback[] }
-
-export const raw = (value: unknown, callbacks?: HtmlEscapedCallback[]): HtmlEscapedString => {
-  const escapedString = new String(value) as HtmlEscapedString
-  escapedString.isEscaped = true
-  escapedString.callbacks = callbacks
-
-  return escapedString
-}
-
-// The `escapeToBuffer` implementation is based on code from the MIT licensed `react-dom` package.
-// https://github.com/facebook/react/blob/main/packages/react-dom-bindings/src/server/escapeTextForBrowser.js
-
-const escapeRe = /[&<>'"]/
-
-export const stringBufferToString = async (
-  buffer: StringBuffer,
-  callbacks: HtmlEscapedCallback[] | undefined
-): Promise<HtmlEscapedString> => {
-  let str = ''
-  callbacks ||= []
-  const resolvedBuffer = await Promise.all(buffer)
-  for (let i = resolvedBuffer.length - 1; ; i--) {
-    str += resolvedBuffer[i]
-    i--
-    if (i < 0) {
-      break
-    }
-
-    let r = resolvedBuffer[i]
-    if (typeof r === 'object') {
-      callbacks.push(...((r as HtmlEscapedString).callbacks || []))
-    }
-
-    const isEscaped = (r as HtmlEscapedString).isEscaped
-    r = await (typeof r === 'object' ? (r as HtmlEscapedString).toString() : r)
-    if (typeof r === 'object') {
-      callbacks.push(...((r as HtmlEscapedString).callbacks || []))
-    }
-
-    if ((r as HtmlEscapedString).isEscaped ?? isEscaped) {
-      str += r
-    } else {
-      const buf = [str]
-      escapeToBuffer(r, buf)
-      str = buf[0]
-    }
-  }
-
-  return raw(str, callbacks)
-}
-
-export const escapeToBuffer = (str: string, buffer: StringBuffer): void => {
-  const match = str.search(escapeRe)
-  if (match === -1) {
-    buffer[0] += str
-    return
-  }
-
-  let escape
-  let index
-  let lastIndex = 0
-
-  for (index = match; index < str.length; index++) {
-    switch (str.charCodeAt(index)) {
-      case 34: // "
-        escape = '&quot;'
-        break
-      case 39: // '
-        escape = '&#39;'
-        break
-      case 38: // &
-        escape = '&amp;'
-        break
-      case 60: // <
-        escape = '&lt;'
-        break
-      case 62: // >
-        escape = '&gt;'
-        break
-      default:
-        continue
-    }
-
-    buffer[0] += str.substring(lastIndex, index) + escape
-    lastIndex = index + 1
-  }
-
-  buffer[0] += str.substring(lastIndex, index)
-}
-
-export const resolveCallbackSync = (str: string | HtmlEscapedString): string => {
-  const callbacks = (str as HtmlEscapedString).callbacks as HtmlEscapedCallback[]
-  if (!callbacks?.length) {
-    return str
-  }
-  const buffer: [string] = [str]
-  const context = {}
-
-  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }))
-
-  return buffer[0]
-}
-
-export const resolveCallback = async (
-  str: string | HtmlEscapedString | Promise<string>,
-  phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase],
-  preserveCallbacks: boolean,
-  context: object,
-  buffer?: [string]
-): Promise<string> => {
-  if (typeof str === 'object' && !(str instanceof String)) {
-    if (!((str as unknown) instanceof Promise)) {
-      str = (str as unknown as string).toString() // HtmlEscapedString object to string
-    }
-    if ((str as string | Promise<string>) instanceof Promise) {
-      str = await (str as unknown as Promise<string>)
-    }
-  }
-
-  const callbacks = (str as HtmlEscapedString).callbacks as HtmlEscapedCallback[]
-  if (!callbacks?.length) {
-    return Promise.resolve(str)
-  }
-  if (buffer) {
-    buffer[0] += str
-  } else {
-    buffer = [str as string]
-  }
-
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) =>
-    Promise.all(
-      res
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        .filter<string>(Boolean as any)
-        .map((str) => resolveCallback(str, phase, false, context, buffer))
-    ).then(() => (buffer as [string])[0])
-  )
-
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks)
-  } else {
-    return resStr
-  }
-}

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

@@ -1,69 +0,0 @@
-/**
- * @module
- * HTTP Status utility.
- */
-
-export type InfoStatusCode = 100 | 101 | 102 | 103
-export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
-export type DeprecatedStatusCode = 305 | 306
-export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308
-export type ClientErrorStatusCode =
-  | 400
-  | 401
-  | 402
-  | 403
-  | 404
-  | 405
-  | 406
-  | 407
-  | 408
-  | 409
-  | 410
-  | 411
-  | 412
-  | 413
-  | 414
-  | 415
-  | 416
-  | 417
-  | 418
-  | 421
-  | 422
-  | 423
-  | 424
-  | 425
-  | 426
-  | 428
-  | 429
-  | 431
-  | 451
-export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511
-
-/**
- * `UnofficialStatusCode` can be used to specify an unofficial status code.
- * @example
- *
- * ```ts
- * app.get('/unknown', (c) => {
- *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
- * })
- * ```
- */
-export type UnofficialStatusCode = -1
-
-/**
- * @deprecated
- * Use `UnofficialStatusCode` instead.
- */
-export type UnOfficalStatusCode = UnofficialStatusCode
-
-/**
- * If you want to use an unofficial status, use `UnofficialStatusCode`.
- */
-export type StatusCode =
-  | InfoStatusCode
-  | SuccessStatusCode
-  | RedirectStatusCode
-  | ClientErrorStatusCode
-  | ServerErrorStatusCode
-  | UnofficialStatusCode

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

@@ -1,113 +0,0 @@
-/**
- * Utils for IP Addresses
- * @module
- */
-
-import type { AddressType } from '../helper/conninfo'
-
-/**
- * Expand IPv6 Address
- * @param ipV6 Shorten IPv6 Address
- * @return expanded IPv6 Address
- */
-export const expandIPv6 = (ipV6: string): string => {
-  const sections = ipV6.split(':')
-  for (let i = 0; i < sections.length; i++) {
-    const node = sections[i]
-    if (node !== '') {
-      sections[i] = node.padStart(4, '0')
-    } else {
-      sections[i + 1] === '' && sections.splice(i + 1, 1)
-      sections[i] = new Array(8 - sections.length + 1).fill('0000').join(':')
-    }
-  }
-  return sections.join(':')
-}
-
-const IPV4_REGEX = /^[0-9]{0,3}\.[0-9]{0,3}\.[0-9]{0,3}\.[0-9]{0,3}$/
-
-/**
- * Distinct Remote Addr
- * @param remoteAddr Remote Addr
- */
-export const distinctRemoteAddr = (remoteAddr: string): AddressType => {
-  if (IPV4_REGEX.test(remoteAddr)) {
-    return 'IPv4'
-  }
-  if (remoteAddr.includes(':')) {
-    // Domain can't include `:`
-    return 'IPv6'
-  }
-}
-
-/**
- * Convert IPv4 to Uint8Array
- * @param ipv4 IPv4 Address
- * @returns BigInt
- */
-export const convertIPv4ToBinary = (ipv4: string): bigint => {
-  const parts = ipv4.split('.')
-  let result = 0n
-  for (let i = 0; i < 4; i++) {
-    result <<= 8n
-    result += BigInt(parts[i])
-  }
-  return result
-}
-
-/**
- * Convert IPv6 to Uint8Array
- * @param ipv6 IPv6 Address
- * @returns BigInt
- */
-export const convertIPv6ToBinary = (ipv6: string): bigint => {
-  const sections = expandIPv6(ipv6).split(':')
-  let result = 0n
-  for (let i = 0; i < 8; i++) {
-    result <<= 16n
-    result += BigInt(parseInt(sections[i], 16))
-  }
-  return result
-}
-
-/**
- * Convert a binary representation of an IPv6 address to a string.
- * @param ipV6 binary IPv6 Address
- * @return normalized IPv6 Address in string
- */
-export const convertIPv6BinaryToString = (ipV6: bigint): string => {
-  const sections = []
-  for (let i = 0; i < 8; i++) {
-    sections.push(((ipV6 >> BigInt(16 * (7 - i))) & 0xffffn).toString(16))
-  }
-
-  let currentZeroStart = -1
-  let maxZeroStart = -1
-  let maxZeroEnd = -1
-  for (let i = 0; i < 8; i++) {
-    if (sections[i] === '0') {
-      if (currentZeroStart === -1) {
-        currentZeroStart = i
-      }
-    } else {
-      if (currentZeroStart > -1) {
-        if (i - currentZeroStart > maxZeroEnd - maxZeroStart) {
-          maxZeroStart = currentZeroStart
-          maxZeroEnd = i
-        }
-        currentZeroStart = -1
-      }
-    }
-  }
-  if (currentZeroStart > -1) {
-    if (8 - currentZeroStart > maxZeroEnd - maxZeroStart) {
-      maxZeroStart = currentZeroStart
-      maxZeroEnd = 8
-    }
-  }
-  if (maxZeroStart !== -1) {
-    sections.splice(maxZeroStart, maxZeroEnd - maxZeroStart, ':')
-  }
-
-  return sections.join(':').replace(/:{2,}/g, '::')
-}

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

@@ -1,7 +0,0 @@
-/**
- * @module
- * JWT utility.
- */
-
-import { decode, sign, verify } from './jwt'
-export const Jwt = { sign, verify, decode }

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

@@ -1,23 +0,0 @@
-/**
- * @module
- * JSON Web Algorithms (JWA)
- * https://datatracker.ietf.org/doc/html/rfc7518
- */
-
-export enum AlgorithmTypes {
-  HS256 = 'HS256',
-  HS384 = 'HS384',
-  HS512 = 'HS512',
-  RS256 = 'RS256',
-  RS384 = 'RS384',
-  RS512 = 'RS512',
-  PS256 = 'PS256',
-  PS384 = 'PS384',
-  PS512 = 'PS512',
-  ES256 = 'ES256',
-  ES384 = 'ES384',
-  ES512 = 'ES512',
-  EdDSA = 'EdDSA',
-}
-
-export type SignatureAlgorithm = keyof typeof AlgorithmTypes