@poe-platform/safe-bash 0.1.439 → 0.1.440

package/dist/safe-bash/portable.js

@@ -7205,6 +7205,57 @@ async function matchesPattern(pattern, value2, work) {
     reservation?.release();
   }
 }
+async function compilePatternBoundaries(pattern, work) {
+  work.signal.throwIfAborted();
+  const { patternTokens } = await tokens(pattern, work);
+  return async (value2, shortest = false, suffix2 = false) => {
+    let rowReservation;
+    let resultReservation;
+    try {
+      const rowSize = patternTokens.length + 1;
+      const resultSize = value2.length + 1;
+      const initialized = stringCheckpoint(work, rowSize + resultSize);
+      if (initialized) await initialized;
+      rowReservation = work.allocation?.reserve(64 + rowSize * 8, 0);
+      resultReservation = work.allocation?.reserve(64 + resultSize * 8, 0);
+      const row = new Float64Array(rowSize).fill(-1);
+      const ends = new Float64Array(resultSize).fill(-1);
+      let position = value2.length;
+      while (true) {
+        const advanced = stringCheckpoint(work);
+        if (advanced) await advanced;
+        const point = position < value2.length ? value2.codePointAt(position) : void 0;
+        let diagonal = row[patternTokens.length];
+        row[patternTokens.length] = !suffix2 || position === value2.length ? position : -1;
+        for (let index = patternTokens.length - 1; index >= 0; index--) {
+          const pending = stringCheckpoint(work);
+          if (pending) await pending;
+          const previous = row[index];
+          const token = patternTokens[index];
+          if (token.kind === "star") {
+            const skip = row[index + 1];
+            const consume = point === void 0 ? -1 : previous;
+            row[index] = skip < 0 ? consume : consume < 0 ? skip : shortest ? Math.min(skip, consume) : Math.max(skip, consume);
+          } else {
+            const accepts = point !== void 0 && (token.kind === "any" || (token.kind === "literal" ? token.value.codePointAt(0) === point : token.expression.test(String.fromCodePoint(point))));
+            row[index] = accepts ? diagonal : -1;
+          }
+          diagonal = previous;
+        }
+        ends[position] = row[0];
+        if (position === 0) break;
+        position = previousCodePointOffset(value2, position);
+      }
+      work.signal.throwIfAborted();
+      return ends;
+    } catch (error) {
+      resultReservation?.release();
+      throw error;
+    } finally {
+      rowReservation?.release();
+    }
+  };
+}
 async function matchTokens(patternTokens, value2, work, start, end) {
   work.signal.throwIfAborted();
   let position = start;
@@ -16786,19 +16837,17 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       scratch.reserve(patternUnits * 2, 0);
       const pattern = patternFields.join("");
       const size = (await scanString(text3, work)).count;
-      const matches3 = await compilePattern(pattern, work);
-      const match = async (start, end, length) => {
-        const pending = stringCheckpoint(work, length + 1);
-        if (pending) await pending;
-        return matches3(text3, start, end);
-      };
+      const boundaries = await compilePatternBoundaries(pattern, work);
       const operator = part.operator;
       if (!operator.startsWith("/")) {
         const longest = operator.length === 2;
         const prefix3 = operator.startsWith("#");
+        const ends2 = await boundaries(text3, !longest && prefix3, !prefix3);
         let boundary = longest === prefix3 ? text3.length : 0;
         for (let length = longest ? size : 0; longest ? length >= 0 : length <= size; length += longest ? -1 : 1) {
-          if (await match(prefix3 ? 0 : boundary, prefix3 ? boundary : text3.length, length)) {
+          const pending = stringCheckpoint(work);
+          if (pending) await pending;
+          if (ends2[prefix3 ? 0 : boundary] === (prefix3 ? boundary : text3.length)) {
             const start = prefix3 ? boundary : 0;
             const end = prefix3 ? text3.length : boundary;
             scratch.reserve((end - start) * 2, 0);
@@ -16841,49 +16890,49 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         retained?.release();
         retained = next;
       };
+      const ends = await boundaries(text3, false, operator === "/%");
       let position = 0;
-      let positionIndex = 0;
-      while (positionIndex <= size) {
+      while (position <= text3.length) {
         let found = false;
-        for (let start = position, startIndex2 = positionIndex; startIndex2 <= size; startIndex2++, start = nextCodePointOffset(text3, start)) {
+        for (let start = position; start <= text3.length; start = nextCodePointOffset(text3, start)) {
           if (operator === "/#" && start !== 0) break;
-          for (let end = text3.length, endIndex = size; endIndex >= startIndex2; endIndex--, end = previousCodePointOffset(text3, end)) {
-            if (operator === "/%" && end !== text3.length) break;
-            if (!await match(start, end, endIndex - startIndex2)) continue;
-            await append(text3, position, start);
-            for (const replacement of replacements) {
-              if (replacement.quoted) await append(replacement.value);
-              else {
-                let fragment = 0;
-                for (let cursor = 0; cursor < replacement.value.length; cursor++) {
-                  const pending = stringCheckpoint(work);
-                  if (pending) await pending;
-                  if (replacement.value[cursor] !== "&") continue;
-                  await append(replacement.value, fragment, cursor);
-                  await append(text3, start, end);
-                  fragment = cursor + 1;
-                }
-                await append(replacement.value, fragment);
+          const pending = stringCheckpoint(work);
+          if (pending) await pending;
+          const end = ends[start];
+          if (end < 0) {
+            if (start === text3.length) break;
+            continue;
+          }
+          await append(text3, position, start);
+          for (const replacement of replacements) {
+            if (replacement.quoted) await append(replacement.value);
+            else {
+              let fragment = 0;
+              for (let cursor = 0; cursor < replacement.value.length; cursor++) {
+                const pending2 = stringCheckpoint(work);
+                if (pending2) await pending2;
+                if (replacement.value[cursor] !== "&") continue;
+                await append(replacement.value, fragment, cursor);
+                await append(text3, start, end);
+                fragment = cursor + 1;
               }
+              await append(replacement.value, fragment);
             }
-            position = end;
-            positionIndex = endIndex;
-            found = true;
-            if (operator !== "//" || end === text3.length) {
-              await append(text3, end);
-              return result2;
-            }
-            if (end === start) {
-              position = nextCodePointOffset(text3, end);
-              positionIndex++;
-              await append(text3, end, position);
-            }
-            break;
           }
-          if (found) break;
+          position = end;
+          found = true;
+          if (operator !== "//" || end === text3.length) {
+            await append(text3, end);
+            return result2;
+          }
+          if (end === start) {
+            position = nextCodePointOffset(text3, end);
+            await append(text3, end, position);
+          }
+          break;
         }
         if (!found) {
-          if (positionIndex === 0) return text3;
+          if (position === 0) return text3;
           await append(text3, position);
           break;
         }
@@ -24391,40 +24440,117 @@ async function* rawValues(sources2, budget, slurp) {
     yield buffer;
   }
 }
-function stringify(value2, budget, pretty = false, maxBytes = budget.limits.maxValueBytes, limitName = "maxValueBytes") {
+function* quotedFragments(value2, budget) {
+  yield { text: '"', bytes: 1 };
+  let offset = 0;
+  while (offset < value2.length) {
+    const start = offset;
+    const limit = Math.min(start + 32, value2.length);
+    budget.step(limit - start);
+    let bytes3 = 0;
+    while (offset < limit) {
+      const code = value2.charCodeAt(offset);
+      if (code >= 55296 && code <= 56319 && offset + 1 === limit && limit < value2.length) break;
+      if (code >= 55296 && code <= 56319 && offset + 1 < limit) {
+        const next = value2.charCodeAt(offset + 1);
+        if (next >= 56320 && next <= 57343) {
+          bytes3 += 4;
+          offset += 2;
+          continue;
+        }
+      }
+      if (code === 34 || code === 92 || code === 8 || code === 9 || code === 10 || code === 12 || code === 13) bytes3 += 2;
+      else if (code < 32 || code >= 55296 && code <= 57343) bytes3 += 6;
+      else bytes3 += code < 128 ? 1 : code < 2048 ? 2 : 3;
+      offset++;
+    }
+    yield { value: value2, start, end: offset, bytes: bytes3, quoted: true };
+  }
+  yield { text: '"', bytes: 1 };
+}
+function renderJsonFragment(fragment, budget) {
+  if ("text" in fragment) return fragment.text;
+  budget.step(fragment.end - fragment.start);
+  const text3 = fragment.value.slice(fragment.start, fragment.end);
+  return fragment.quoted ? JSON.stringify(text3).slice(1, -1) : text3;
+}
+function* jsonFragments(value2, budget, pretty = false, depth = 0) {
+  budget.step();
+  if (depth > budget.limits.maxDepth) throw new JqLimitError("maxDepth");
+  if (typeof value2 === "string") {
+    yield* quotedFragments(value2, budget);
+    return;
+  }
+  if (value2 === null || typeof value2 !== "object" || isNumber(value2)) {
+    const text3 = scalarJson(value2, budget);
+    for (let start = 0; start < text3.length; start += 32) {
+      const end = Math.min(start + 32, text3.length);
+      budget.step(end - start);
+      yield { value: text3, start, end, bytes: end - start, quoted: false };
+    }
+    return;
+  }
+  if (depth + 1 > budget.limits.maxDepth) throw new JqLimitError("maxDepth");
+  const array2 = Array.isArray(value2);
+  if (array2) budget.collection(value2.length);
+  yield { text: array2 ? "[" : "{", bytes: 1 };
+  let count2 = 0;
+  const keys = array2 ? value2.keys() : objectKeyIterator(value2);
+  for (const key of keys) {
+    budget.step();
+    budget.collection(count2 + 1);
+    if (count2++) yield { text: ",", bytes: 1 };
+    if (pretty) {
+      const bytes3 = 1 + 2 * (depth + 1);
+      budget.step(bytes3);
+      yield { text: `
+${"  ".repeat(depth + 1)}`, bytes: bytes3 };
+    }
+    if (!array2) {
+      yield* quotedFragments(String(key), budget);
+      yield { text: pretty ? ": " : ":", bytes: pretty ? 2 : 1 };
+    }
+    yield* jsonFragments(value2[key], budget, pretty, depth + 1);
+  }
+  if (pretty && count2) {
+    const bytes3 = 1 + 2 * depth;
+    budget.step(bytes3);
+    yield { text: `
+${"  ".repeat(depth)}`, bytes: bytes3 };
+  }
+  yield { text: array2 ? "]" : "}", bytes: 1 };
+}
+async function measureValue(value2, budget, depth = 0, maxBytes = budget.limits.maxValueBytes) {
+  await budget.tick(0);
+  let bytes3 = 0;
+  for (const fragment of jsonFragments(value2, budget, false, depth)) {
+    await budget.tick(0);
+    bytes3 += fragment.bytes;
+    if (bytes3 > maxBytes) throw new JqLimitError("maxValueBytes");
+  }
+  return bytes3;
+}
+async function stringify(value2, budget, pretty = false, maxBytes = budget.limits.maxValueBytes, limitName = "maxValueBytes", asStringValue = false) {
+  await budget.tick(0);
   const parts2 = [];
   let bytes3 = 0;
-  const append = (text3) => {
-    bytes3 += import_buffer.Buffer.byteLength(text3);
+  let units = 0;
+  let stringBytes = 2;
+  for (const fragment of jsonFragments(value2, budget, pretty)) {
+    await budget.tick(0);
+    bytes3 += fragment.bytes;
     if (bytes3 > maxBytes) throw new JqLimitError(limitName);
-    parts2.push(text3);
-  };
-  const visit = (current, depth) => {
-    budget.step();
-    if (depth > budget.limits.maxDepth) throw new JqLimitError("maxDepth");
-    if (current === null || typeof current !== "object" || isNumber(current)) {
-      append(scalarJson(current, budget));
-      return;
+    const text3 = renderJsonFragment(fragment, budget);
+    if (asStringValue) {
+      for (const encoded2 of quotedFragments(text3, budget)) stringBytes += encoded2.bytes;
+      stringBytes -= 2;
+      if (stringBytes > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
     }
-    const keys = Array.isArray(current) ? Object.keys(current) : objectKeys(current);
-    const array2 = Array.isArray(current);
-    append(array2 ? "[" : "{");
-    for (let index = 0; index < keys.length; index++) {
-      if (index) append(",");
-      if (pretty) append(`
-${"  ".repeat(depth + 1)}`);
-      const key = keys[index];
-      if (!array2) {
-        append(JSON.stringify(key));
-        append(pretty ? ": " : ":");
-      }
-      visit(current[key], depth + 1);
-    }
-    if (pretty && keys.length) append(`
-${"  ".repeat(depth)}`);
-    append(array2 ? "]" : "}");
-  };
-  visit(value2, 0);
+    budget.step();
+    units += text3.length;
+    parts2.push(text3);
+  }
+  await budget.tick(units);
   return parts2.join("");
 }
 
@@ -24501,8 +24627,19 @@ function type(value2) {
   return value2 === null ? "null" : isNumber(value2) ? "number" : Array.isArray(value2) ? "array" : typeof value2;
 }
 function describe(value2, budget) {
-  const bytes3 = import_buffer.Buffer.from(stringify(value2, budget));
-  const text3 = bytes3.length < 15 ? bytes3.toString() : `${bytes3.subarray(0, 11).toString()}...`;
+  const parts2 = [];
+  let length = 0;
+  for (const fragment of jsonFragments(value2, budget)) {
+    const text4 = renderJsonFragment(fragment, budget);
+    budget.step(text4.length);
+    const bytes4 = import_buffer.Buffer.from(text4);
+    const retained = Math.min(15 - length, bytes4.length);
+    parts2.push(bytes4.subarray(0, retained));
+    length += retained;
+    if (length === 15) break;
+  }
+  const bytes3 = import_buffer.Buffer.concat(parts2, length);
+  const text3 = length < 15 ? bytes3.toString() : `${bytes3.subarray(0, 11).toString()}...`;
   return `${type(value2)} (${text3})`;
 }
 async function stringCompare(left, right, budget) {
@@ -24598,15 +24735,24 @@ function equal(left, right, budget) {
   }
   return false;
 }
-function entries(value2, budget) {
+async function* entries(value2, budget) {
+  budget.signal.throwIfAborted();
   if (Array.isArray(value2)) {
     budget.collection(value2.length);
-    return value2.map((item, index) => [index, item]);
+    for (let index = 0; index < value2.length; index++) {
+      await budget.tick(2);
+      yield [index, value2[index]];
+    }
+    return;
   }
   if (isObject(value2)) {
-    const keys = objectKeys(value2);
-    budget.collection(keys.length);
-    return keys.map((key) => [key, value2[key]]);
+    let count2 = 0;
+    for (const key of objectKeyIterator(value2)) {
+      await budget.tick(2);
+      budget.collection(++count2);
+      yield [key, value2[key]];
+    }
+    return;
   }
   throw new JqError(`Cannot iterate over ${describe(value2, budget)}`);
 }
@@ -24845,7 +24991,7 @@ var Interpreter = class _Interpreter {
             }
         return;
       case "iterate":
-        for await (const base of this.run(ast.base, input3)) for (const [, value2] of entries(base, this.budget)) {
+        for await (const base of this.run(ast.base, input3)) for await (const [, value2] of entries(base, this.budget)) {
           await this.budget.tick();
           yield value2;
         }
@@ -24981,7 +25127,7 @@ var Interpreter = class _Interpreter {
     for await (const path of this.paths(ast.base, input3)) {
       let base = input3;
       for (const component of path) base = indexValue(base, component);
-      for (const [key] of entries(base, this.budget)) {
+      for await (const [key] of entries(base, this.budget)) {
         await this.budget.tick();
         yield [...path, key];
       }
@@ -25102,24 +25248,66 @@ var Interpreter = class _Interpreter {
       if (input3 === null) yield 0;
       else if (isNumber(input3)) yield Math.abs(numberValue(input3));
       else if (typeof input3 === "string") {
+        await budget.tick(input3.length);
         let length = 0;
-        for (const ignoredEntry of input3) length++;
+        for (let offset = 0; offset < input3.length; length++) {
+          if (length % 32 === 0) await budget.tick(0);
+          offset += input3.codePointAt(offset) > 65535 ? 2 : 1;
+        }
         yield length;
       } else if (Array.isArray(input3)) yield input3.length;
-      else if (isObject(input3)) yield objectKeys(input3).length;
-      else throw new JqError("boolean has no length");
+      else if (isObject(input3)) {
+        let length = 0;
+        for (const key of objectKeyIterator(input3)) {
+          await budget.tick();
+          void key;
+          length++;
+        }
+        yield length;
+      } else throw new JqError("boolean has no length");
       return;
     }
     if (name2 === "keys" || name2 === "keys_unsorted") {
-      if (Array.isArray(input3)) yield input3.map((_, index) => index);
-      else if (isObject(input3)) yield name2 === "keys" ? await sortedKeys(input3, budget) : objectKeys(input3);
-      else throw new JqError("keys requires an object or array");
+      let result2;
+      if (Array.isArray(input3)) {
+        budget.collection(input3.length);
+        await budget.tick(input3.length);
+        result2 = [];
+        let bytes3 = 2;
+        if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+        for (let index = 0; index < input3.length; index++) {
+          await budget.tick();
+          bytes3 += String(index).length + (index ? 1 : 0);
+          if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+          result2.push(index);
+        }
+      } else if (isObject(input3)) {
+        let bytes3 = 2;
+        let count2 = 0;
+        if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+        for (const key of objectKeyIterator(input3)) {
+          await budget.tick();
+          budget.collection(++count2);
+          const separator = count2 > 1 ? 1 : 0;
+          bytes3 += separator + await measureValue(key, budget, 1, budget.limits.maxValueBytes - bytes3 - separator);
+        }
+        if (name2 === "keys") result2 = await sortedKeys(input3, budget);
+        else {
+          result2 = [];
+          for (const key of objectKeyIterator(input3)) {
+            await budget.tick();
+            budget.collection(result2.length + 1);
+            result2.push(key);
+          }
+        }
+      } else throw new JqError("keys requires an object or array");
+      yield result2;
       return;
     }
     if (name2 === "map" || name2 === "map_values") {
       const result2 = name2 === "map_values" && isObject(input3) ? object() : [];
       let bytes3 = 2;
-      for (const [key, value2] of entries(input3, budget)) for await (const mapped of this.run(args[0], value2)) {
+      for await (const [key, value2] of entries(input3, budget)) for await (const mapped of this.run(args[0], value2)) {
         bytes3 += budget.value(mapped) + 1 + (Array.isArray(result2) ? 0 : import_buffer.Buffer.byteLength(JSON.stringify(String(key))) + 1);
         if (bytes3 - 1 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
         if (Array.isArray(result2)) {
@@ -25161,7 +25349,7 @@ var Interpreter = class _Interpreter {
           if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
           result2 += text3;
         };
-        for (const [, item] of entries(input3, budget)) {
+        for await (const [, item] of entries(input3, budget)) {
           await budget.tick();
           if (!first && separator !== null) {
             if (typeof separator !== "string") await binary("+", result2, separator, budget);
@@ -25170,7 +25358,7 @@ var Interpreter = class _Interpreter {
           }
           first = false;
           if (isObject(item) || Array.isArray(item)) await binary("+", result2, item, budget);
-          const text3 = item === null ? "" : typeof item === "string" ? item : stringify(item, budget);
+          const text3 = item === null ? "" : typeof item === "string" ? item : await stringify(item, budget);
           append(text3, budget.value(text3));
         }
         budget.value(result2);
@@ -25228,9 +25416,10 @@ var Interpreter = class _Interpreter {
       return;
     }
     if (name2 === "tostring" || name2 === "tojson") {
-      const result2 = typeof input3 === "string" && name2 === "tostring" ? input3 : stringify(input3, budget);
-      budget.text(result2);
-      yield result2;
+      if (typeof input3 === "string" && name2 === "tostring") {
+        await measureValue(input3, budget);
+        yield input3;
+      } else yield await stringify(input3, budget, false, budget.limits.maxValueBytes, "maxValueBytes", true);
       return;
     }
     if (name2 === "tonumber" || name2 === "fromjson") {
@@ -25251,7 +25440,24 @@ var Interpreter = class _Interpreter {
       return;
     }
     if (name2 === "to_entries") {
-      yield entries(input3, budget).map(([key, value2]) => copyObject({ key, value: value2 }));
+      if (Array.isArray(input3)) await budget.tick(input3.length);
+      const result2 = [];
+      let bytes3 = 2;
+      if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+      for await (const [key, value2] of entries(input3, budget)) {
+        budget.collection(result2.length + 1);
+        budget.collection(2);
+        const overhead = 17 + (result2.length ? 1 : 0);
+        const keyBytes3 = await measureValue(key, budget, 2, budget.limits.maxValueBytes - bytes3 - overhead);
+        const valueBytes = await measureValue(value2, budget, 2, budget.limits.maxValueBytes - bytes3 - overhead - keyBytes3);
+        await budget.tick(4);
+        bytes3 += overhead + keyBytes3 + valueBytes;
+        const entry = object();
+        put(entry, "key", key);
+        put(entry, "value", value2);
+        result2.push(entry);
+      }
+      yield result2;
       return;
     }
     if (name2 === "from_entries" || name2 === "with_entries") {
@@ -25259,7 +25465,7 @@ var Interpreter = class _Interpreter {
       if (name2 === "with_entries") {
         values = [];
         let bytes3 = 2;
-        for (const [key, value2] of entries(input3, budget)) for await (const mapped of this.run(args[0], copyObject({ key, value: value2 }))) {
+        for await (const [key, value2] of entries(input3, budget)) for await (const mapped of this.run(args[0], copyObject({ key, value: value2 }))) {
           budget.collection(values.length + 1);
           bytes3 += budget.value(mapped) + (values.length ? 1 : 0);
           if (bytes3 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
@@ -25267,7 +25473,7 @@ var Interpreter = class _Interpreter {
         }
       }
       const result2 = object();
-      for (const [, entry] of entries(values, budget)) {
+      for await (const [, entry] of entries(values, budget)) {
         await budget.tick();
         if (!isObject(entry)) throw new JqError(`Cannot index ${type(entry)} with string "key"`);
         const key = ["key", "Key", "name", "Name"].find((candidate) => Object.hasOwn(entry, candidate) && truth2(entry[candidate]));
@@ -25295,12 +25501,19 @@ var Interpreter = class _Interpreter {
       return;
     }
     if (!Array.isArray(input3)) {
-      if (name2 === "unique") entries(input3, budget);
+      if (name2 === "unique" && !isObject(input3)) throw new JqError(`Cannot iterate over ${describe(input3, budget)}`);
       if (name2 === "sort") throw new JqError(`${describe(input3, budget)} cannot be sorted, as it is not an array`);
       throw new JqError(`${name2} requires an array`);
     }
     if (name2 === "reverse") {
-      yield [...input3].reverse();
+      await budget.tick(input3.length);
+      await measureValue(input3, budget);
+      const result2 = [];
+      for (let index = input3.length - 1; index >= 0; index--) {
+        await budget.tick(0);
+        result2.push(input3[index]);
+      }
+      yield result2;
       return;
     }
     if (name2 === "add") {
@@ -25901,7 +26114,7 @@ async function execute3(context2, limits) {
           if (++budget.results > limits.maxResults) throw new JqLimitError("maxResults");
           const remaining = limits.maxOutputBytes - budget.outputBytes;
           const suffix2 = options3.joinOutput ? "" : "\n";
-          const text3 = options3.raw && typeof result2 === "string" ? result2 : stringify(result2, budget, !options3.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
+          const text3 = options3.raw && typeof result2 === "string" ? result2 : await stringify(result2, budget, !options3.compact, Math.max(0, remaining - suffix2.length), "maxOutputBytes");
           const bytes3 = import_buffer.Buffer.from(`${text3}${suffix2}`);
           if (bytes3.byteLength > remaining) throw new JqLimitError("maxOutputBytes");
           budget.outputBytes += bytes3.byteLength;