1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 |
x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 x1 |
/**
* Helper functions for working with
* {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array | Uint8Array}
* byte slices.
*
* ```ts
* import { concat, indexOfNeedle, endsWith } from "@std/bytes";
* import { assertEquals } from "@std/assert";
*
* const a = new Uint8Array([0, 1, 2]);
* const b = new Uint8Array([3, 4, 5]);
*
* const c = concat([a, b]);
*
* assertEquals(c, new Uint8Array([0, 1, 2, 3, 4, 5]));
*
* assertEquals(indexOfNeedle(c, new Uint8Array([2, 3])), 2);
*
* assertEquals(endsWith(c, b), true);
* ```
*
* @module
*/
import { concat as _function_concat } from "jsr:@std/[email protected]"
/**
* Concatenate an array of byte slices into a single slice.
*
* @param buffers Array of byte slices to concatenate.
* @return A new byte slice containing all the input slices concatenated.
*
* @example Basic usage
* ```ts
* import { concat } from "@std/bytes/concat";
* import { assertEquals } from "@std/assert";
*
* const a = new Uint8Array([0, 1, 2]);
* const b = new Uint8Array([3, 4, 5]);
*
* assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
* ```
*/
const concat = _function_concat as typeof _function_concat
export { concat }
import { copy as _function_copy } from "jsr:@std/[email protected]"
/**
* Copy bytes from the source array to the destination array and returns the
* number of bytes copied.
*
* If the source array is larger than what the `dst` array can hold, only the
* amount of bytes that fit in the `dst` array are copied.
*
* @param src Source array to copy from.
* @param dst Destination array to copy to.
* @param offset Offset in the destination array to start copying to. Defaults
* to 0.
* @return Number of bytes copied.
*
* @example Basic usage
* ```ts
* import { copy } from "@std/bytes/copy";
* import { assertEquals } from "@std/assert";
*
* const src = new Uint8Array([9, 8, 7]);
* const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
*
* assertEquals(copy(src, dst), 3);
* assertEquals(dst, new Uint8Array([9, 8, 7, 3, 4, 5]));
* ```
*
* @example Copy with offset
* ```ts
* import { copy } from "@std/bytes/copy";
* import { assertEquals } from "@std/assert";
*
* const src = new Uint8Array([1, 1, 1, 1]);
* const dst = new Uint8Array([0, 0, 0, 0]);
*
* assertEquals(copy(src, dst, 1), 3);
* assertEquals(dst, new Uint8Array([0, 1, 1, 1]));
* ```
* Defining an offset will start copying at the specified index in the
* destination array.
*/
const copy = _function_copy as typeof _function_copy
export { copy }
import { endsWith as _function_endsWith } from "jsr:@std/[email protected]"
/**
* Returns `true` if the suffix array appears at the end of the source array,
* `false` otherwise.
*
* The complexity of this function is `O(suffix.length)`.
*
* @param source Source array to check.
* @param suffix Suffix array to check for.
* @return `true` if the suffix array appears at the end of the source array,
* `false` otherwise.
*
* @example Basic usage
* ```ts
* import { endsWith } from "@std/bytes/ends-with";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const suffix = new Uint8Array([1, 2, 3]);
*
* assertEquals(endsWith(source, suffix), true);
* ```
*/
const endsWith = _function_endsWith as typeof _function_endsWith
export { endsWith }
import { equals as _function_equals } from "jsr:@std/[email protected]"
/**
* Check whether byte slices are equal to each other.
*
* @param a First array to check equality.
* @param b Second array to check equality.
* @return `true` if the arrays are equal, `false` otherwise.
*
* @example Basic usage
* ```ts
* import { equals } from "@std/bytes/equals";
* import { assertEquals } from "@std/assert";
*
* const a = new Uint8Array([1, 2, 3]);
* const b = new Uint8Array([1, 2, 3]);
* const c = new Uint8Array([4, 5, 6]);
*
* assertEquals(equals(a, b), true);
* assertEquals(equals(a, c), false);
* ```
*/
const equals = _function_equals as typeof _function_equals
export { equals }
import { includesNeedle as _function_includesNeedle } from "jsr:@std/[email protected]"
/**
* Determines whether the source array contains the needle array.
*
* The complexity of this function is `O(source.length * needle.length)`.
*
* @param source Source array to check.
* @param needle Needle array to check for.
* @param start Start index in the source array to begin the search. Defaults to
* 0.
* @return `true` if the source array contains the needle array, `false`
* otherwise.
*
* @example Basic usage
* ```ts
* import { includesNeedle } from "@std/bytes/includes-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
*
* assertEquals(includesNeedle(source, needle), true);
* ```
*
* @example Start index
* ```ts
* import { includesNeedle } from "@std/bytes/includes-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
*
* assertEquals(includesNeedle(source, needle, 3), true);
* assertEquals(includesNeedle(source, needle, 6), false);
* ```
* The search will start at the specified index in the source array.
*/
const includesNeedle = _function_includesNeedle as typeof _function_includesNeedle
export { includesNeedle }
import { indexOfNeedle as _function_indexOfNeedle } from "jsr:@std/[email protected]"
/**
* Returns the index of the first occurrence of the needle array in the source
* array, or -1 if it is not present.
*
* A start index can be specified as the third argument that begins the search
* at that given index. The start index defaults to the start of the array.
*
* The complexity of this function is `O(source.length * needle.length)`.
*
* @param source Source array to check.
* @param needle Needle array to check for.
* @param start Start index in the source array to begin the search. Defaults to
* 0.
* @return Index of the first occurrence of the needle array in the source
* array, or -1 if it is not present.
*
* @example Basic usage
* ```ts
* import { indexOfNeedle } from "@std/bytes/index-of-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
* const notNeedle = new Uint8Array([5, 0]);
*
* assertEquals(indexOfNeedle(source, needle), 1);
* assertEquals(indexOfNeedle(source, notNeedle), -1);
* ```
*
* @example Start index
* ```ts
* import { indexOfNeedle } from "@std/bytes/index-of-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
*
* assertEquals(indexOfNeedle(source, needle, 2), 3);
* assertEquals(indexOfNeedle(source, needle, 6), -1);
* ```
* Defining a start index will begin the search at the specified index in the
* source array.
*/
const indexOfNeedle = _function_indexOfNeedle as typeof _function_indexOfNeedle
export { indexOfNeedle }
import { lastIndexOfNeedle as _function_lastIndexOfNeedle } from "jsr:@std/[email protected]"
/**
* Returns the index of the last occurrence of the needle array in the source
* array, or -1 if it is not present.
*
* The complexity of this function is `O(source.length * needle.length)`.
*
* @param source Source array to check.
* @param needle Needle array to check for.
* @param start Start index in the source array to begin the search. Defaults to
* `source.length - 1`.
* @return Index of the last occurrence of the needle array in the source
* array, or -1 if it is not present.
*
* @example Basic usage
* ```ts
* import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
* const notNeedle = new Uint8Array([5, 0]);
*
* assertEquals(lastIndexOfNeedle(source, needle), 5);
* assertEquals(lastIndexOfNeedle(source, notNeedle), -1);
* ```
*
* @example Start index
* ```ts
* import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const needle = new Uint8Array([1, 2]);
*
* assertEquals(lastIndexOfNeedle(source, needle, 2), 1);
* assertEquals(lastIndexOfNeedle(source, needle, 6), 5);
* ```
* Defining a start index will begin the search at the specified index in the
* source array.
*/
const lastIndexOfNeedle = _function_lastIndexOfNeedle as typeof _function_lastIndexOfNeedle
export { lastIndexOfNeedle }
import { repeat as _function_repeat } from "jsr:@std/[email protected]"
/**
* Returns a new byte slice composed of `count` repetitions of the `source`
* array.
*
* @param source Source array to repeat.
* @param count Number of times to repeat the source array.
* @return A new byte slice composed of `count` repetitions of the `source`
* array.
*
* @example Basic usage
* ```ts
* import { repeat } from "@std/bytes/repeat";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2]);
*
* assertEquals(repeat(source, 3), new Uint8Array([0, 1, 2, 0, 1, 2, 0, 1, 2]));
* ```
*
* @example Zero count
* ```ts
* import { repeat } from "@std/bytes/repeat";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2]);
*
* assertEquals(repeat(source, 0), new Uint8Array());
* ```
*/
const repeat = _function_repeat as typeof _function_repeat
export { repeat }
import { startsWith as _function_startsWith } from "jsr:@std/[email protected]"
/**
* Returns `true` if the prefix array appears at the start of the source array,
* `false` otherwise.
*
* The complexity of this function is `O(prefix.length)`.
*
* @param source Source array to check.
* @param prefix Prefix array to check for.
* @return `true` if the prefix array appears at the start of the source array,
* `false` otherwise.
*
* @example Basic usage
* ```ts
* import { startsWith } from "@std/bytes/starts-with";
* import { assertEquals } from "@std/assert";
*
* const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
* const prefix = new Uint8Array([0, 1, 2]);
*
* assertEquals(startsWith(source, prefix), true);
* ```
*/
const startsWith = _function_startsWith as typeof _function_startsWith
export { startsWith }
|