bluera-knowledge 0.9.21

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

@@ -0,0 +1,34 @@
+/**
+ * @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

@@ -0,0 +1,56 @@
+/**
+ * @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

@@ -0,0 +1,15 @@
+/**
+ * @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

@@ -0,0 +1,182 @@
+/**
+ * @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

@@ -0,0 +1,69 @@
+/**
+ * @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

@@ -0,0 +1,113 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * @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

@@ -0,0 +1,23 @@
+/**
+ * @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