Complete src/CompletionTypedArrays.res 1:17
posCursor:[1:17] posNoWhite:[1:16] Found expr:[1:3->1:17]
Pexp_field [1:3->1:16] _:[4:0->1:17]
Completable: Cpath Value[bigInt64Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[bigInt64Array].""
ContextPath Value[bigInt64Array]
Path bigInt64Array
ContextPath Value[bigInt64Array]->
ContextPath Value[bigInt64Array]
Path bigInt64Array
CPPipe pathFromEnv:Stdlib.BigInt64Array found:false
Path Stdlib.BigInt64Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->BigInt64Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(bigIntArray)` ignores the provided bigIntArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->BigInt64Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 1, "character": 16}, "end": {"line": 1, "character": 17}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 5:18
posCursor:[5:18] posNoWhite:[5:17] Found expr:[5:3->5:18]
Pexp_field [5:3->5:17] _:[8:0->5:18]
Completable: Cpath Value[bigUint64Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[bigUint64Array].""
ContextPath Value[bigUint64Array]
Path bigUint64Array
ContextPath Value[bigUint64Array]->
ContextPath Value[bigUint64Array]
Path bigUint64Array
CPPipe pathFromEnv:Stdlib.BigUint64Array found:false
Path Stdlib.BigUint64Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->BigUint64Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(bigUintArray)` ignores the provided bigUintArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->BigUint64Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 5, "character": 17}, "end": {"line": 5, "character": 18}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 9:16
posCursor:[9:16] posNoWhite:[9:15] Found expr:[9:3->9:16]
Pexp_field [9:3->9:15] _:[12:0->9:16]
Completable: Cpath Value[float32Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[float32Array].""
ContextPath Value[float32Array]
Path float32Array
ContextPath Value[float32Array]->
ContextPath Value[float32Array]
Path float32Array
CPPipe pathFromEnv:Stdlib.Float32Array found:false
Path Stdlib.Float32Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Float32Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(floatArray)` ignores the provided floatArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Float32Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 9, "character": 15}, "end": {"line": 9, "character": 16}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 13:16
posCursor:[13:16] posNoWhite:[13:15] Found expr:[13:3->13:16]
Pexp_field [13:3->13:15] _:[16:0->13:16]
Completable: Cpath Value[float64Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[float64Array].""
ContextPath Value[float64Array]
Path float64Array
ContextPath Value[float64Array]->
ContextPath Value[float64Array]
Path float64Array
CPPipe pathFromEnv:Stdlib.Float64Array found:false
Path Stdlib.Float64Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Float64Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(floatArray)` ignores the provided floatArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Float64Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 13, "character": 15}, "end": {"line": 13, "character": 16}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 17:14
posCursor:[17:14] posNoWhite:[17:13] Found expr:[17:3->17:14]
Pexp_field [17:3->17:13] _:[20:0->17:14]
Completable: Cpath Value[int16Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[int16Array].""
ContextPath Value[int16Array]
Path int16Array
ContextPath Value[int16Array]->
ContextPath Value[int16Array]
Path int16Array
CPPipe pathFromEnv:Stdlib.Int16Array found:false
Path Stdlib.Int16Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Int16Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(intArray)` ignores the provided intArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Int16Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 17, "character": 13}, "end": {"line": 17, "character": 14}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 21:14
posCursor:[21:14] posNoWhite:[21:13] Found expr:[21:3->21:14]
Pexp_field [21:3->21:13] _:[24:0->21:14]
Completable: Cpath Value[int32Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[int32Array].""
ContextPath Value[int32Array]
Path int32Array
ContextPath Value[int32Array]->
ContextPath Value[int32Array]
Path int32Array
CPPipe pathFromEnv:Stdlib.Int32Array found:false
Path Stdlib.Int32Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Int32Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(intArray)` ignores the provided intArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Int32Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 21, "character": 13}, "end": {"line": 21, "character": 14}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 25:13
posCursor:[25:13] posNoWhite:[25:12] Found expr:[25:3->25:13]
Pexp_field [25:3->25:12] _:[28:0->25:13]
Completable: Cpath Value[int8Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[int8Array].""
ContextPath Value[int8Array]
Path int8Array
ContextPath Value[int8Array]->
ContextPath Value[int8Array]
Path int8Array
CPPipe pathFromEnv:Stdlib.Int8Array found:false
Path Stdlib.Int8Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Int8Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(intArray)` ignores the provided intArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Int8Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 25, "character": 12}, "end": {"line": 25, "character": 13}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 29:15
posCursor:[29:15] posNoWhite:[29:14] Found expr:[29:3->29:15]
Pexp_field [29:3->29:14] _:[32:0->29:15]
Completable: Cpath Value[uint16Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[uint16Array].""
ContextPath Value[uint16Array]
Path uint16Array
ContextPath Value[uint16Array]->
ContextPath Value[uint16Array]
Path uint16Array
CPPipe pathFromEnv:Stdlib.Uint16Array found:false
Path Stdlib.Uint16Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Uint16Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(uintArray)` ignores the provided uintArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Uint16Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 29, "character": 14}, "end": {"line": 29, "character": 15}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 33:15
posCursor:[33:15] posNoWhite:[33:14] Found expr:[33:3->33:15]
Pexp_field [33:3->33:14] _:[36:0->33:15]
Completable: Cpath Value[uint32Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[uint32Array].""
ContextPath Value[uint32Array]
Path uint32Array
ContextPath Value[uint32Array]->
ContextPath Value[uint32Array]
Path uint32Array
CPPipe pathFromEnv:Stdlib.Uint32Array found:false
Path Stdlib.Uint32Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Uint32Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(uintArray)` ignores the provided uintArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Uint32Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 33, "character": 14}, "end": {"line": 33, "character": 15}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 37:14
posCursor:[37:14] posNoWhite:[37:13] Found expr:[37:3->37:14]
Pexp_field [37:3->37:13] _:[40:0->37:14]
Completable: Cpath Value[uint8Array].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[uint8Array].""
ContextPath Value[uint8Array]
Path uint8Array
ContextPath Value[uint8Array]->
ContextPath Value[uint8Array]
Path uint8Array
CPPipe pathFromEnv:Stdlib.Uint8Array found:false
Path Stdlib.Uint8Array.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Uint8Array.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(uintArray)` ignores the provided uintArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Uint8Array.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 37, "character": 13}, "end": {"line": 37, "character": 14}},
      "newText": ""
      }]
  }]

Complete src/CompletionTypedArrays.res 41:21
posCursor:[41:21] posNoWhite:[41:20] Found expr:[41:3->41:21]
Pexp_field [41:3->41:20] _:[44:0->41:21]
Completable: Cpath Value[uint8ClampedArray].""
Package opens Stdlib.place holder Pervasives.JsxModules.place holder
Resolved opens 1 Stdlib
ContextPath Value[uint8ClampedArray].""
ContextPath Value[uint8ClampedArray]
Path uint8ClampedArray
ContextPath Value[uint8ClampedArray]->
ContextPath Value[uint8ClampedArray]
Path uint8ClampedArray
CPPipe pathFromEnv:Stdlib.Uint8ClampedArray found:false
Path Stdlib.Uint8ClampedArray.
Path Stdlib.TypedArray.
Path 
[{
    "label": "->Uint8ClampedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(uintArray)` ignores the provided uintArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->Uint8ClampedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndexWithIndex(typedArray, predicate)` is the indexed variant of `findLastIndex`.\n"},
    "sortText": "findLastIndexWithIndex",
    "insertText": "->TypedArray.findLastIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOf(typedArray, value)` returns the last index of `value`, or `-1` if not found.\n\nSee [`TypedArray.prototype.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) on MDN.\n"},
    "sortText": "lastIndexOf",
    "insertText": "->TypedArray.lastIndexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLastWithIndex(typedArray, predicate)` is the indexed variant of `findLast`.\n"},
    "sortText": "findLastWithIndex",
    "insertText": "->TypedArray.findLastWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLast",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findLast(typedArray, predicate)` returns the last element that satisfies `predicate`.\n\nSee [`TypedArray.prototype.findLast`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast) on MDN.\n"},
    "sortText": "findLast",
    "insertText": "->TypedArray.findLast",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filter",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filter(typedArray, predicate)` returns a new typed array containing only elements that satisfy `predicate`.\n\nSee [`TypedArray.prototype.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) on MDN.\n"},
    "sortText": "filter",
    "insertText": "->TypedArray.filter",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteLength",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteLength(typedArray)` returns the length in bytes of the view.\n\nSee [`TypedArray.prototype.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.byteLength(view) == 8\n```\n"},
    "sortText": "byteLength",
    "insertText": "->TypedArray.byteLength",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.ignore",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n  `ignore(typedArray)` ignores the provided typedArray and returns unit.\n\n  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)\n  without having to store or process it further.\n"},
    "sortText": "ignore",
    "insertText": "->TypedArray.ignore",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRightWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRightWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduceRight`.\n"},
    "sortText": "reduceRightWithIndex",
    "insertText": "->TypedArray.reduceRightWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceRight",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceRight(typedArray, reducer, initial)` is like `reduce` but processes the elements from right to left.\n\nSee [`TypedArray.prototype.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) on MDN.\n"},
    "sortText": "reduceRight",
    "insertText": "->TypedArray.reduceRight",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.joinWith",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, string) => string",
    "documentation": {"kind": "markdown", "value": "\n`joinWith(typedArray, separator)` returns a string formed by the elements joined with `separator`.\n\nSee [`TypedArray.prototype.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.joinWith(view, \"-\") == \"1-2-3\"\n```\n"},
    "sortText": "joinWith",
    "insertText": "->TypedArray.joinWith",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.buffer",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => ArrayBuffer.t",
    "documentation": {"kind": "markdown", "value": "\n`buffer(typedArray)` returns the underlying `ArrayBuffer` backing this view.\n\nSee [`TypedArray.prototype.buffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) on MDN.\n"},
    "sortText": "buffer",
    "insertText": "->TypedArray.buffer",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduce",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduce(typedArray, reducer, initial)` combines the elements from left to right using `reducer`.\n\nSee [`TypedArray.prototype.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) on MDN.\n"},
    "sortText": "reduce",
    "insertText": "->TypedArray.reduce",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEachWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEachWithIndex(typedArray, f)` runs `f` for every element, also providing the index.\n"},
    "sortText": "forEachWithIndex",
    "insertText": "->TypedArray.forEachWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copy",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copy(typedArray)` produces a shallow copy of the typed array.\n"},
    "sortText": "copy",
    "insertText": "->TypedArray.copy",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.someWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`someWithIndex(typedArray, predicate)` behaves like `some`, but `predicate` also receives the element index.\n"},
    "sortText": "someWithIndex",
    "insertText": "->TypedArray.someWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndexWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndexWithIndex(typedArray, predicate)` is the indexed variant of `findIndex`.\n"},
    "sortText": "findIndexWithIndex",
    "insertText": "->TypedArray.findIndexWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sliceToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`sliceToEnd(typedArray, ~start)` returns the elements from `start` through the end in a new typed array.\n"},
    "sortText": "sliceToEnd",
    "insertText": "->TypedArray.sliceToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.slice",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`slice(typedArray, ~start, ~end)` returns a new typed array containing the elements in `[start, end)`.\n\nSee [`TypedArray.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) on MDN.\n"},
    "sortText": "slice",
    "insertText": "->TypedArray.slice",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findLastIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findLastIndex(typedArray, predicate)` returns the index of the last matching element, or `-1` if none do.\n\nSee [`TypedArray.prototype.findLastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex) on MDN.\n"},
    "sortText": "findLastIndex",
    "insertText": "->TypedArray.findLastIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.includes",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => bool",
    "documentation": {"kind": "markdown", "value": "\n`includes(typedArray, value)` returns `true` if `value` occurs in the typed array.\n\nSee [`TypedArray.prototype.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.includes(view, 2) == true\nTypedArray.includes(view, 10) == false\n```\n"},
    "sortText": "includes",
    "insertText": "->TypedArray.includes",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, 'a, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`fillToEnd(typedArray, value, ~start)` fills from `start` through the end with `value`.\n\nBeware this will *mutate* the typed array.\n"},
    "sortText": "fillToEnd",
    "insertText": "->TypedArray.fillToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fillAll",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fillAll(typedArray, value)` fills every element with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet _ = TypedArray.fillAll(view, 9)\nTypedArray.toString(view) == \"9,9,9\"\n```\n"},
    "sortText": "fillAll",
    "insertText": "->TypedArray.fillAll",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.find",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`find(typedArray, predicate)` returns the first element that satisfies `predicate`, or `None` if nothing matches.\n\nSee [`TypedArray.prototype.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) on MDN.\n"},
    "sortText": "find",
    "insertText": "->TypedArray.find",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarrayToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~start: int) => t<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`subarrayToEnd(typedArray, ~start)` returns a new view from `start` to the end of the buffer.\n"},
    "sortText": "subarrayToEnd",
    "insertText": "->TypedArray.subarrayToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.set",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => unit",
    "documentation": {"kind": "markdown", "value": "\n`set(typedArray, index, item)` sets the provided `item` at `index` of `typedArray`.\n\nBeware this will *mutate* the array.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2])\nTypedArray.set(view, 1, 5)\nTypedArray.get(view, 1) == Some(5)\n```\n"},
    "sortText": "set",
    "insertText": "->TypedArray.set",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toLocaleString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toLocaleString(typedArray)` concatenates the elements using locale-aware formatting.\n\nSee [`TypedArray.prototype.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) on MDN.\n"},
    "sortText": "toLocaleString",
    "insertText": "->TypedArray.toLocaleString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.lastIndexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`lastIndexOfFrom(typedArray, value, fromIndex)` searches backwards starting at `fromIndex`.\n"},
    "sortText": "lastIndexOfFrom",
    "insertText": "->TypedArray.lastIndexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => int",
    "documentation": {"kind": "markdown", "value": "\n`findIndex(typedArray, predicate)` returns the index of the first element that satisfies `predicate`, or `-1` if none do.\n\nSee [`TypedArray.prototype.findIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) on MDN.\n"},
    "sortText": "findIndex",
    "insertText": "->TypedArray.findIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.filterWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`filterWithIndex(typedArray, predicate)` behaves like `filter` but also passes the index to `predicate`.\n"},
    "sortText": "filterWithIndex",
    "insertText": "->TypedArray.filterWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.sort",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => unit",
    "documentation": {"kind": "markdown", "value": "\n`sort(typedArray, comparator)` sorts the values in place using `comparator`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) on MDN.\n"},
    "sortText": "sort",
    "insertText": "->TypedArray.sort",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.mapWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`mapWithIndex(typedArray, f)` behaves like `map`, but `f` also receives the index.\n"},
    "sortText": "mapWithIndex",
    "insertText": "->TypedArray.mapWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.every",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`every(typedArray, predicate)` returns `true` if `predicate` returns `true` for every element.\n\nSee [`TypedArray.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) on MDN.\n"},
    "sortText": "every",
    "insertText": "->TypedArray.every",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.length",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`length(typedArray)` returns the number of elements.\n\nSee [`TypedArray.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.length(view) == 3\n```\n"},
    "sortText": "length",
    "insertText": "->TypedArray.length",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOf",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOf(typedArray, value)` returns the first index of `value`, or `-1` when not found.\n\nSee [`TypedArray.prototype.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) on MDN.\n"},
    "sortText": "indexOf",
    "insertText": "->TypedArray.indexOf",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithinToEnd",
    "kind": 12,
    "tags": [1],
    "detail": "(t<'a>, ~target: int, ~start: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "Deprecated: \n\n\n`copyWithinToEnd(typedArray, ~target, ~start)` copies values from `start` through the end of the view into the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithinToEnd(view, ~target=0, ~start=2)\nTypedArray.toString(view) == \"3,4,3,4\"\n```\n"},
    "sortText": "copyWithinToEnd",
    "insertText": "->TypedArray.copyWithinToEnd",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.some",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`some(typedArray, predicate)` returns `true` if `predicate` returns `true` for at least one element.\n\nSee [`TypedArray.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) on MDN.\n"},
    "sortText": "some",
    "insertText": "->TypedArray.some",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reduceWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('b, 'a, int) => 'b, 'b) => 'b",
    "documentation": {"kind": "markdown", "value": "\n`reduceWithIndex(typedArray, reducer, initial)` is the indexed variant of `reduce`.\n"},
    "sortText": "reduceWithIndex",
    "insertText": "->TypedArray.reduceWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.map",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => 'b) => t<'b>",
    "documentation": {"kind": "markdown", "value": "\n`map(typedArray, f)` returns a new typed array whose elements are produced by applying `f` to each element.\n\nSee [`TypedArray.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) on MDN.\n"},
    "sortText": "map",
    "insertText": "->TypedArray.map",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toSorted",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, 'a) => Ordering.t) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toSorted(typedArray, comparator)` returns a new typed array containing the sorted values, leaving the original untouched.\n\nSee [`TypedArray.prototype.toSorted`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([3, 1, 2])\nlet sorted = TypedArray.toSorted(view, Int.compare)\nTypedArray.toString(sorted) == \"1,2,3\"\nTypedArray.toString(view) == \"3,1,2\"\n```\n"},
    "sortText": "toSorted",
    "insertText": "->TypedArray.toSorted",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyAllWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyAllWithin(typedArray, ~target)` copies values starting at index `0` over the positions beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([10, 20, 30])\nlet _ = TypedArray.copyAllWithin(view, ~target=1)\nTypedArray.toString(view) == \"10,10,20\"\n```\n"},
    "sortText": "copyAllWithin",
    "insertText": "->TypedArray.copyAllWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.subarray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`subarray(typedArray, ~start, ~end)` returns a new view referencing the same buffer over `[start, end)`.\n\nSee [`TypedArray.prototype.subarray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) on MDN.\n"},
    "sortText": "subarray",
    "insertText": "->TypedArray.subarray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArray",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArray(target, source)` copies the values from `source` into `target`, mutating it.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0])\nTypedArray.setArray(view, [1, 2])\nTypedArray.toString(view) == \"1,2\"\n```\n"},
    "sortText": "setArray",
    "insertText": "->TypedArray.setArray",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.get",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`get(typedArray, index)` returns the element at `index` of `typedArray`.\nReturns `None` if the index does not exist in the typed array. Equivalent to doing `typedArray[index]` in JavaScript.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nTypedArray.get(view, 0) == Some(1)\nTypedArray.get(view, 10) == None\n```\n"},
    "sortText": "get",
    "insertText": "->TypedArray.get",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.with",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, int, 'a) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`with(typedArray, index, value)` returns a new typed array where the element at `index` is replaced with `value`.\n\nSee [`TypedArray.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet updated = TypedArray.with(view, 1, 10)\nTypedArray.toString(updated) == \"1,10,3\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "with",
    "insertText": "->TypedArray.with",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toReversed",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`toReversed(typedArray)` returns a new typed array with the elements in reverse order, leaving the original untouched.\n\nSee [`TypedArray.prototype.toReversed`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3])\nlet reversed = TypedArray.toReversed(view)\nTypedArray.toString(reversed) == \"3,2,1\"\nTypedArray.toString(view) == \"1,2,3\"\n```\n"},
    "sortText": "toReversed",
    "insertText": "->TypedArray.toReversed",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.copyWithin",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ~target: int, ~start: int, ~end: int=?) => array<'a>",
    "documentation": {"kind": "markdown", "value": "\n`copyWithin(typedArray, ~target, ~start, ~end)` copies the section `[start, end)` onto the range beginning at `target`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.copyWithin(view, ~target=1, ~start=2, ~end=4)\nTypedArray.toString(view) == \"1,3,4,4\"\n```\n"},
    "sortText": "copyWithin",
    "insertText": "->TypedArray.copyWithin",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.everyWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => bool",
    "documentation": {"kind": "markdown", "value": "\n`everyWithIndex(typedArray, checker)` is like `every` but provides the element index to `checker`.\n"},
    "sortText": "everyWithIndex",
    "insertText": "->TypedArray.everyWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.toString",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => string",
    "documentation": {"kind": "markdown", "value": "\n`toString(typedArray)` returns a comma-separated string of the elements.\n\nSee [`TypedArray.prototype.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) on MDN.\n\n## Examples\n\n```rescript\nInt32Array.fromArray([1, 2])->TypedArray.toString == \"1,2\"\n```\n"},
    "sortText": "toString",
    "insertText": "->TypedArray.toString",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.setArrayFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, array<'a>, int) => unit",
    "documentation": {"kind": "markdown", "value": "\n`setArrayFrom(target, source, index)` copies `source` into `target` starting at `index`.\n\nSee [`TypedArray.prototype.set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([0, 0, 0])\nTypedArray.setArrayFrom(view, [5, 6], 1)\nTypedArray.toString(view) == \"0,5,6\"\n```\n"},
    "sortText": "setArrayFrom",
    "insertText": "->TypedArray.setArrayFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.forEach",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a => unit) => unit",
    "documentation": {"kind": "markdown", "value": "\n`forEach(typedArray, f)` runs `f` for every element in order.\n\nSee [`TypedArray.prototype.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) on MDN.\n"},
    "sortText": "forEach",
    "insertText": "->TypedArray.forEach",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.findWithIndex",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, ('a, int) => bool) => option<'a>",
    "documentation": {"kind": "markdown", "value": "\n`findWithIndex(typedArray, predicate)` behaves like `find`, but `predicate` also receives the index.\n"},
    "sortText": "findWithIndex",
    "insertText": "->TypedArray.findWithIndex",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.fill",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, ~start: int, ~end: int=?) => t<'a>",
    "documentation": {"kind": "markdown", "value": "\n`fill(typedArray, value, ~start, ~end)` fills the half-open interval `[start, end)` with `value`.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) on MDN.\n\n## Examples\n\n```rescript\nlet view = Int32Array.fromArray([1, 2, 3, 4])\nlet _ = TypedArray.fill(view, 0, ~start=1, ~end=3)\nTypedArray.toString(view) == \"1,0,0,4\"\n```\n"},
    "sortText": "fill",
    "insertText": "->TypedArray.fill",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.indexOfFrom",
    "kind": 12,
    "tags": [],
    "detail": "(t<'a>, 'a, int) => int",
    "documentation": {"kind": "markdown", "value": "\n`indexOfFrom(typedArray, value, fromIndex)` searches for `value` starting at `fromIndex`.\n"},
    "sortText": "indexOfFrom",
    "insertText": "->TypedArray.indexOfFrom",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.reverse",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => unit",
    "documentation": {"kind": "markdown", "value": "\n`reverse(typedArray)` reverses the elements of the view in place.\n\nBeware this will *mutate* the typed array.\n\nSee [`TypedArray.prototype.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) on MDN.\n"},
    "sortText": "reverse",
    "insertText": "->TypedArray.reverse",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }, {
    "label": "->TypedArray.byteOffset",
    "kind": 12,
    "tags": [],
    "detail": "t<'a> => int",
    "documentation": {"kind": "markdown", "value": "\n`byteOffset(typedArray)` returns the offset in bytes from the start of the buffer.\n\nSee [`TypedArray.prototype.byteOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) on MDN.\n"},
    "sortText": "byteOffset",
    "insertText": "->TypedArray.byteOffset",
    "additionalTextEdits": [{
      "range": {"start": {"line": 41, "character": 20}, "end": {"line": 41, "character": 21}},
      "newText": ""
      }]
  }]

