cline 1.0.1 → 1.0.3

package/node_modules/b4a/index.js

@@ -0,0 +1,188 @@
+function isBuffer(value) {
+  return Buffer.isBuffer(value) || value instanceof Uint8Array
+}
+
+function isEncoding(encoding) {
+  return Buffer.isEncoding(encoding)
+}
+
+function alloc(size, fill, encoding) {
+  return Buffer.alloc(size, fill, encoding)
+}
+
+function allocUnsafe(size) {
+  return Buffer.allocUnsafe(size)
+}
+
+function allocUnsafeSlow(size) {
+  return Buffer.allocUnsafeSlow(size)
+}
+
+function byteLength(string, encoding) {
+  return Buffer.byteLength(string, encoding)
+}
+
+function compare(a, b) {
+  return Buffer.compare(a, b)
+}
+
+function concat(buffers, totalLength) {
+  return Buffer.concat(buffers, totalLength)
+}
+
+function copy(source, target, targetStart, start, end) {
+  return toBuffer(source).copy(target, targetStart, start, end)
+}
+
+function equals(a, b) {
+  return toBuffer(a).equals(b)
+}
+
+function fill(buffer, value, offset, end, encoding) {
+  return toBuffer(buffer).fill(value, offset, end, encoding)
+}
+
+function from(value, encodingOrOffset, length) {
+  return Buffer.from(value, encodingOrOffset, length)
+}
+
+function includes(buffer, value, byteOffset, encoding) {
+  return toBuffer(buffer).includes(value, byteOffset, encoding)
+}
+
+function indexOf(buffer, value, byfeOffset, encoding) {
+  return toBuffer(buffer).indexOf(value, byfeOffset, encoding)
+}
+
+function lastIndexOf(buffer, value, byteOffset, encoding) {
+  return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding)
+}
+
+function swap16(buffer) {
+  return toBuffer(buffer).swap16()
+}
+
+function swap32(buffer) {
+  return toBuffer(buffer).swap32()
+}
+
+function swap64(buffer) {
+  return toBuffer(buffer).swap64()
+}
+
+function toBuffer(buffer) {
+  if (Buffer.isBuffer(buffer)) return buffer
+  return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}
+
+function toString(buffer, encoding, start, end) {
+  return toBuffer(buffer).toString(encoding, start, end)
+}
+
+function write(buffer, string, offset, length, encoding) {
+  return toBuffer(buffer).write(string, offset, length, encoding)
+}
+
+function readDoubleBE(buffer, offset) {
+  return toBuffer(buffer).readDoubleBE(offset)
+}
+
+function readDoubleLE(buffer, offset) {
+  return toBuffer(buffer).readDoubleLE(offset)
+}
+
+function readFloatBE(buffer, offset) {
+  return toBuffer(buffer).readFloatBE(offset)
+}
+
+function readFloatLE(buffer, offset) {
+  return toBuffer(buffer).readFloatLE(offset)
+}
+
+function readInt32BE(buffer, offset) {
+  return toBuffer(buffer).readInt32BE(offset)
+}
+
+function readInt32LE(buffer, offset) {
+  return toBuffer(buffer).readInt32LE(offset)
+}
+
+function readUInt32BE(buffer, offset) {
+  return toBuffer(buffer).readUInt32BE(offset)
+}
+
+function readUInt32LE(buffer, offset) {
+  return toBuffer(buffer).readUInt32LE(offset)
+}
+
+function writeDoubleBE(buffer, value, offset) {
+  return toBuffer(buffer).writeDoubleBE(value, offset)
+}
+
+function writeDoubleLE(buffer, value, offset) {
+  return toBuffer(buffer).writeDoubleLE(value, offset)
+}
+
+function writeFloatBE(buffer, value, offset) {
+  return toBuffer(buffer).writeFloatBE(value, offset)
+}
+
+function writeFloatLE(buffer, value, offset) {
+  return toBuffer(buffer).writeFloatLE(value, offset)
+}
+
+function writeInt32BE(buffer, value, offset) {
+  return toBuffer(buffer).writeInt32BE(value, offset)
+}
+
+function writeInt32LE(buffer, value, offset) {
+  return toBuffer(buffer).writeInt32LE(value, offset)
+}
+
+function writeUInt32BE(buffer, value, offset) {
+  return toBuffer(buffer).writeUInt32BE(value, offset)
+}
+
+function writeUInt32LE(buffer, value, offset) {
+  return toBuffer(buffer).writeUInt32LE(value, offset)
+}
+
+module.exports = {
+  isBuffer,
+  isEncoding,
+  alloc,
+  allocUnsafe,
+  allocUnsafeSlow,
+  byteLength,
+  compare,
+  concat,
+  copy,
+  equals,
+  fill,
+  from,
+  includes,
+  indexOf,
+  lastIndexOf,
+  swap16,
+  swap32,
+  swap64,
+  toBuffer,
+  toString,
+  write,
+  readDoubleBE,
+  readDoubleLE,
+  readFloatBE,
+  readFloatLE,
+  readInt32BE,
+  readInt32LE,
+  readUInt32BE,
+  readUInt32LE,
+  writeDoubleBE,
+  writeDoubleLE,
+  writeFloatBE,
+  writeFloatLE,
+  writeInt32BE,
+  writeInt32LE,
+  writeUInt32BE,
+  writeUInt32LE
+}

package/node_modules/b4a/lib/ascii.js

@@ -0,0 +1,31 @@
+function byteLength(string) {
+  return string.length
+}
+
+function toString(buffer) {
+  const len = buffer.byteLength
+
+  let result = ''
+
+  for (let i = 0; i < len; i++) {
+    result += String.fromCharCode(buffer[i])
+  }
+
+  return result
+}
+
+function write(buffer, string) {
+  const len = buffer.byteLength
+
+  for (let i = 0; i < len; i++) {
+    buffer[i] = string.charCodeAt(i)
+  }
+
+  return len
+}
+
+module.exports = {
+  byteLength,
+  toString,
+  write
+}

package/node_modules/b4a/lib/base64.js

@@ -0,0 +1,65 @@
+const alphabet =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+const codes = new Uint8Array(256)
+
+for (let i = 0; i < alphabet.length; i++) {
+  codes[alphabet.charCodeAt(i)] = i
+}
+
+codes[/* - */ 0x2d] = 62
+codes[/* _ */ 0x5f] = 63
+
+function byteLength(string) {
+  let len = string.length
+
+  if (string.charCodeAt(len - 1) === 0x3d) len--
+  if (len > 1 && string.charCodeAt(len - 1) === 0x3d) len--
+
+  return (len * 3) >>> 2
+}
+
+function toString(buffer) {
+  const len = buffer.byteLength
+
+  let result = ''
+
+  for (let i = 0; i < len; i += 3) {
+    result +=
+      alphabet[buffer[i] >> 2] +
+      alphabet[((buffer[i] & 3) << 4) | (buffer[i + 1] >> 4)] +
+      alphabet[((buffer[i + 1] & 15) << 2) | (buffer[i + 2] >> 6)] +
+      alphabet[buffer[i + 2] & 63]
+  }
+
+  if (len % 3 === 2) {
+    result = result.substring(0, result.length - 1) + '='
+  } else if (len % 3 === 1) {
+    result = result.substring(0, result.length - 2) + '=='
+  }
+
+  return result
+}
+
+function write(buffer, string) {
+  const len = buffer.byteLength
+
+  for (let i = 0, j = 0; j < len; i += 4) {
+    const a = codes[string.charCodeAt(i)]
+    const b = codes[string.charCodeAt(i + 1)]
+    const c = codes[string.charCodeAt(i + 2)]
+    const d = codes[string.charCodeAt(i + 3)]
+
+    buffer[j++] = (a << 2) | (b >> 4)
+    buffer[j++] = ((b & 15) << 4) | (c >> 2)
+    buffer[j++] = ((c & 3) << 6) | (d & 63)
+  }
+
+  return len
+}
+
+module.exports = {
+  byteLength,
+  toString,
+  write
+}

package/node_modules/b4a/lib/hex.js

@@ -0,0 +1,51 @@
+function byteLength(string) {
+  return string.length >>> 1
+}
+
+function toString(buffer) {
+  const len = buffer.byteLength
+
+  buffer = new DataView(buffer.buffer, buffer.byteOffset, len)
+
+  let result = ''
+  let i = 0
+
+  for (let n = len - (len % 4); i < n; i += 4) {
+    result += buffer.getUint32(i).toString(16).padStart(8, '0')
+  }
+
+  for (; i < len; i++) {
+    result += buffer.getUint8(i).toString(16).padStart(2, '0')
+  }
+
+  return result
+}
+
+function write(buffer, string) {
+  const len = buffer.byteLength
+
+  for (let i = 0; i < len; i++) {
+    const a = hexValue(string.charCodeAt(i * 2))
+    const b = hexValue(string.charCodeAt(i * 2 + 1))
+
+    if (a === undefined || b === undefined) {
+      return buffer.subarray(0, i)
+    }
+
+    buffer[i] = (a << 4) | b
+  }
+
+  return len
+}
+
+module.exports = {
+  byteLength,
+  toString,
+  write
+}
+
+function hexValue(char) {
+  if (char >= 0x30 && char <= 0x39) return char - 0x30
+  if (char >= 0x41 && char <= 0x46) return char - 0x41 + 10
+  if (char >= 0x61 && char <= 0x66) return char - 0x61 + 10
+}

package/node_modules/b4a/lib/utf16le.js

@@ -0,0 +1,40 @@
+function byteLength(string) {
+  return string.length * 2
+}
+
+function toString(buffer) {
+  const len = buffer.byteLength
+
+  let result = ''
+
+  for (let i = 0; i < len - 1; i += 2) {
+    result += String.fromCharCode(buffer[i] + buffer[i + 1] * 256)
+  }
+
+  return result
+}
+
+function write(buffer, string) {
+  const len = buffer.byteLength
+
+  let units = len
+
+  for (let i = 0; i < string.length; ++i) {
+    if ((units -= 2) < 0) break
+
+    const c = string.charCodeAt(i)
+    const hi = c >> 8
+    const lo = c % 256
+
+    buffer[i * 2] = lo
+    buffer[i * 2 + 1] = hi
+  }
+
+  return len
+}
+
+module.exports = {
+  byteLength,
+  toString,
+  write
+}

package/node_modules/b4a/lib/utf8.js

@@ -0,0 +1,141 @@
+function byteLength(string) {
+  let length = 0
+
+  for (let i = 0, n = string.length; i < n; i++) {
+    const code = string.charCodeAt(i)
+
+    if (code >= 0xd800 && code <= 0xdbff && i + 1 < n) {
+      const code = string.charCodeAt(i + 1)
+
+      if (code >= 0xdc00 && code <= 0xdfff) {
+        length += 4
+        i++
+        continue
+      }
+    }
+
+    if (code <= 0x7f) length += 1
+    else if (code <= 0x7ff) length += 2
+    else length += 3
+  }
+
+  return length
+}
+
+let toString
+
+if (typeof TextDecoder !== 'undefined') {
+  const decoder = new TextDecoder()
+
+  toString = function toString(buffer) {
+    return decoder.decode(buffer)
+  }
+} else {
+  toString = function toString(buffer) {
+    const len = buffer.byteLength
+
+    let output = ''
+    let i = 0
+
+    while (i < len) {
+      let byte = buffer[i]
+
+      if (byte <= 0x7f) {
+        output += String.fromCharCode(byte)
+        i++
+        continue
+      }
+
+      let bytesNeeded = 0
+      let codePoint = 0
+
+      if (byte <= 0xdf) {
+        bytesNeeded = 1
+        codePoint = byte & 0x1f
+      } else if (byte <= 0xef) {
+        bytesNeeded = 2
+        codePoint = byte & 0x0f
+      } else if (byte <= 0xf4) {
+        bytesNeeded = 3
+        codePoint = byte & 0x07
+      }
+
+      if (len - i - bytesNeeded > 0) {
+        let k = 0
+
+        while (k < bytesNeeded) {
+          byte = buffer[i + k + 1]
+          codePoint = (codePoint << 6) | (byte & 0x3f)
+          k += 1
+        }
+      } else {
+        codePoint = 0xfffd
+        bytesNeeded = len - i
+      }
+
+      output += String.fromCodePoint(codePoint)
+      i += bytesNeeded + 1
+    }
+
+    return output
+  }
+}
+
+let write
+
+if (typeof TextEncoder !== 'undefined') {
+  const encoder = new TextEncoder()
+
+  write = function write(buffer, string) {
+    return encoder.encodeInto(string, buffer).written
+  }
+} else {
+  write = function write(buffer, string) {
+    const len = buffer.byteLength
+
+    let i = 0
+    let j = 0
+
+    while (i < string.length) {
+      const code = string.codePointAt(i)
+
+      if (code <= 0x7f) {
+        buffer[j++] = code
+        i++
+        continue
+      }
+
+      let count = 0
+      let bits = 0
+
+      if (code <= 0x7ff) {
+        count = 6
+        bits = 0xc0
+      } else if (code <= 0xffff) {
+        count = 12
+        bits = 0xe0
+      } else if (code <= 0x1fffff) {
+        count = 18
+        bits = 0xf0
+      }
+
+      buffer[j++] = bits | (code >> count)
+      count -= 6
+
+      while (count >= 0) {
+        buffer[j++] = 0x80 | ((code >> count) & 0x3f)
+        count -= 6
+      }
+
+      i += code >= 0x10000 ? 2 : 1
+    }
+
+    return len
+  }
+}
+
+module.exports = {
+  byteLength,
+  toString,
+  write
+}

package/node_modules/b4a/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "b4a",
+  "version": "1.7.3",
+  "description": "Bridging the gap between buffers and typed arrays",
+  "exports": {
+    "./package": "./package.json",
+    ".": {
+      "react-native": "./react-native.js",
+      "browser": "./browser.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "react-native.js",
+    "lib"
+  ],
+  "scripts": {
+    "test": "npm run lint && npm run test:bare && npm run test:node",
+    "test:bare": "bare test.mjs",
+    "test:node": "node test.mjs",
+    "lint": "prettier . --check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holepunchto/b4a.git"
+  },
+  "author": "Holepunch",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/holepunchto/b4a/issues"
+  },
+  "homepage": "https://github.com/holepunchto/b4a#readme",
+  "devDependencies": {
+    "brittle": "^3.5.2",
+    "nanobench": "^3.0.0",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^1.0.0"
+  },
+  "peerDependencies": {
+    "react-native-b4a": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native-b4a": {
+      "optional": true
+    }
+  }
+}

package/node_modules/b4a/react-native.js

@@ -0,0 +1,5 @@
+try {
+  module.exports = require('react-native-b4a')
+} catch {
+  module.exports = require('./browser')
+}