@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/string_and_binary/chunks.js

@@ -0,0 +1,561 @@
+function isTextBlob(blob) {
+  return blob.type === "text/plain";
+}
+import { LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+import { arrayBufferToBase64Single, readString } from "./convert.js";
+import { wrapByDefault } from "../common/utils.js";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+function* pickPiece(leftData, minimumChunkSize) {
+  let buffer = "";
+  L1: do {
+    const curLine = leftData.shift();
+    if (typeof curLine === "undefined") {
+      yield buffer;
+      break L1;
+    }
+    if (curLine.startsWith("```") || curLine.startsWith(" ```") || curLine.startsWith("  ```") || curLine.startsWith("   ```")) {
+      yield buffer;
+      buffer = curLine + (leftData.length != 0 ? "\n" : "");
+      L2: do {
+        const curPx = leftData.shift();
+        if (typeof curPx === "undefined") {
+          break L2;
+        }
+        buffer += curPx + (leftData.length != 0 ? "\n" : "");
+      } while (leftData.length > 0 && !(leftData[0].startsWith("```") || leftData[0].startsWith(" ```") || leftData[0].startsWith("  ```") || leftData[0].startsWith("   ```")));
+      const isLooksLikeBASE64 = buffer.endsWith("=");
+      const maybeUneditable = buffer.length > 2048;
+      const endOfCodeBlock = leftData.shift();
+      if (typeof endOfCodeBlock !== "undefined") {
+        buffer += endOfCodeBlock;
+        buffer += leftData.length != 0 ? "\n" : "";
+      }
+      if (!isLooksLikeBASE64 && !maybeUneditable) {
+        const splitExpr = /(.*?[;,:<])/g;
+        const sx = buffer.split(splitExpr).filter((e) => e != "");
+        for (const v of sx) {
+          yield v;
+        }
+      } else {
+        yield buffer;
+      }
+      buffer = "";
+    } else {
+      buffer += curLine + (leftData.length != 0 ? "\n" : "");
+      if (buffer.length >= minimumChunkSize || leftData.length == 0 || leftData[0] == "#" || buffer[0] == "#") {
+        yield buffer;
+        buffer = "";
+      }
+    }
+  } while (leftData.length > 0);
+}
+const charNewLine = "\n".charCodeAt(0);
+const segmenter = "Segmenter" in Intl ? wrapByDefault(
+  // @ts-ignore We have checked Intl existence above.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return
+  () => new Intl.Segmenter(compatGlobal.navigator.language, { granularity: "sentence" }),
+  (err) => {
+    Logger(`Failed to create Intl.Segmenter: ${err.message}`, LOG_LEVEL_VERBOSE);
+    return void 0;
+  }
+) : void 0;
+function* splitStringWithinLength(text, pieceSize) {
+  let leftData = text;
+  do {
+    const splitSize = pieceSize;
+    const piece = leftData.substring(0, splitSize);
+    leftData = leftData.substring(splitSize);
+    yield piece;
+  } while (leftData != "");
+}
+function* splitTextInSegment(text, pieceSize, minimumChunkSize) {
+  const segments = segmenter.segment(text);
+  let prev = "";
+  let buf = "";
+  for (const seg of segments) {
+    const buffer = seg.segment;
+    if (prev == buffer || buf.length < minimumChunkSize) {
+      buf += buffer;
+      prev = buffer;
+    } else {
+      prev = buffer;
+      if (buf.length > 0) {
+        yield* splitStringWithinLength(buf, pieceSize);
+      }
+      buf = buffer;
+    }
+  }
+  if (buf.length > 0) {
+    yield* splitStringWithinLength(buf, pieceSize);
+  }
+}
+function* splitInNewLine(texts) {
+  for (const text of texts) {
+    let start = -1;
+    let end = -1;
+    do {
+      end = text.indexOf("\n", start);
+      if (end == -1) {
+        yield text.substring(start);
+        break;
+      }
+      while (text[end] == "\n") {
+        end++;
+      }
+      yield text.substring(start, end);
+      start = end;
+    } while (end != -1);
+  }
+  return;
+}
+function splitPiecesTextV2(dataSrc, pieceSize, minimumChunkSize) {
+  const dataListAllArray = typeof dataSrc == "string" ? [dataSrc] : dataSrc;
+  const dataListAll = splitInNewLine(dataListAllArray);
+  let inCodeBlock = 0;
+  let flush = false;
+  let flushBefore = false;
+  return function* () {
+    const buf = [];
+    for (const line of dataListAll) {
+      if (line.startsWith("````")) {
+        if (inCodeBlock == 0) {
+          inCodeBlock = 4;
+          flushBefore = true;
+        } else if (inCodeBlock == 4) {
+          inCodeBlock = 0;
+          flush = true;
+        }
+      } else if (line.startsWith("```")) {
+        if (inCodeBlock == 0) {
+          inCodeBlock = 3;
+          flushBefore = true;
+        } else if (inCodeBlock == 3) {
+          inCodeBlock = 0;
+          flush = true;
+        }
+      }
+      if (flushBefore) {
+        if (buf.length > 0) {
+          yield* splitTextInSegment(buf.join(""), pieceSize, minimumChunkSize);
+          buf.length = 0;
+        }
+        flushBefore = false;
+      }
+      buf.push(line);
+      if (flush) {
+        if (buf.length > 0) {
+          yield* splitStringWithinLength(buf.join(""), pieceSize);
+          buf.length = 0;
+        }
+        flush = false;
+      }
+    }
+    if (buf.length > 0) {
+      if (inCodeBlock == 0) {
+        yield* splitTextInSegment(buf.join(""), pieceSize, minimumChunkSize);
+      } else {
+        yield* splitStringWithinLength(buf.join(""), pieceSize);
+      }
+    }
+  };
+}
+function binaryTextSplit(data, pieceSize, minimumChunkSize) {
+  return function* pieces() {
+    yield* splitStringWithinLength(data, pieceSize);
+  };
+}
+function splitPiecesText(dataSrc, pieceSize, plainSplit, minimumChunkSize, useSegmenter) {
+  if (!useSegmenter || !segmenter) {
+    return splitPiecesTextV1(dataSrc, pieceSize, plainSplit, minimumChunkSize);
+  }
+  if (!plainSplit) {
+    return binaryTextSplit(dataSrc, pieceSize, minimumChunkSize);
+  }
+  return splitPiecesTextV2(dataSrc, pieceSize, minimumChunkSize);
+}
+function splitPiecesTextV1(dataSrc, pieceSize, plainSplit, minimumChunkSize) {
+  const dataList = typeof dataSrc == "string" ? [dataSrc] : dataSrc;
+  return function* pieces() {
+    for (const data of dataList) {
+      if (plainSplit) {
+        const leftData = data.split("\n");
+        const f = pickPiece(leftData, minimumChunkSize);
+        for (const piece of f) {
+          let buffer = piece;
+          do {
+            let ps = pieceSize;
+            if (buffer.charCodeAt(ps - 1) != buffer.codePointAt(ps - 1)) {
+              ps++;
+            }
+            yield buffer.substring(0, ps);
+            buffer = buffer.substring(ps);
+          } while (buffer != "");
+        }
+      } else {
+        let leftData = data;
+        do {
+          const splitSize = pieceSize;
+          const piece = leftData.substring(0, splitSize);
+          leftData = leftData.substring(splitSize);
+          yield piece;
+        } while (leftData != "");
+      }
+    }
+  };
+}
+function* splitByDelimiterWithMinLength(sources, delimiter, minimumChunkLength = 25, splitThreshold) {
+  let buf = "";
+  let last = false;
+  const dl = delimiter.length;
+  for (const source of sources) {
+    const max = source.length;
+    if (splitThreshold && max > splitThreshold) {
+      yield buf + source;
+      last = false;
+      buf = "";
+      continue;
+    }
+    let i = -1;
+    let prev = 0;
+    L1: do {
+      i = source.indexOf(delimiter, prev);
+      if (i == -1) break L1;
+      buf += source.slice(prev, i) + delimiter;
+      if (buf.length > minimumChunkLength) {
+        yield buf;
+        buf = "";
+        last = false;
+      } else {
+        last = true;
+      }
+      prev = i + dl;
+    } while (i < max);
+    if (prev != i || prev == -1 && i == -1) {
+      buf += source.slice(prev);
+      last = true;
+    }
+  }
+  if (last) {
+    yield buf;
+  }
+}
+function* chunkStringGenerator(source, maxLength) {
+  const strLen = source.length;
+  if (strLen > maxLength) {
+    let from = 0;
+    do {
+      let end = from + maxLength;
+      if (end > strLen) {
+        yield source.substring(from);
+        break;
+      }
+      while (source.charCodeAt(end - 1) != source.codePointAt(end - 1)) {
+        end++;
+      }
+      yield source.substring(from, end);
+      from = end;
+    } while (from < strLen);
+  } else {
+    yield source;
+  }
+}
+function* chunkStringGeneratorFromGenerator(sources, maxLength) {
+  for (const source of sources) {
+    yield* chunkStringGenerator(source, maxLength);
+  }
+}
+function* stringGenerator(sources) {
+  for (const str of sources) {
+    yield str;
+  }
+}
+async function collectGenAll(strGen) {
+  const ret = [];
+  for await (const str of strGen) {
+    ret.push(str);
+  }
+  return ret;
+}
+async function concatGeneratedAll(strGen) {
+  return (await collectGenAll(strGen)).join("");
+}
+const MAX_ITEMS = 100;
+async function splitPieces2V2(dataSrc, pieceSize, plainSplit, minimumChunkSize, filename, useSegmenter) {
+  if (dataSrc.size == 0) {
+    return function* noItems() {
+      return;
+    };
+  }
+  if (isTextBlob(dataSrc)) {
+    const text = await dataSrc.text();
+    if (!plainSplit) {
+      const gen2 = chunkStringGenerator(text, pieceSize);
+      return function* pieces() {
+        yield* gen2;
+      };
+    }
+    const textLen = text.length;
+    let xMinimumChunkSize = minimumChunkSize;
+    while (textLen / xMinimumChunkSize > MAX_ITEMS) {
+      xMinimumChunkSize += minimumChunkSize;
+    }
+    const org = stringGenerator([text]);
+    const gen1 = splitByDelimiterWithMinLength(org, "\n", xMinimumChunkSize);
+    const gen = chunkStringGeneratorFromGenerator(gen1, pieceSize);
+    return function* pieces() {
+      yield* gen;
+    };
+  }
+  let canBeSmall = false;
+  let delimiter = 0;
+  if (filename && filename.endsWith(".pdf")) {
+    delimiter = "/".charCodeAt(0);
+  } else if (filename && filename.endsWith(".json")) {
+    canBeSmall = true;
+    delimiter = ",".charCodeAt(0);
+  }
+  const clampMin = canBeSmall ? 100 : 1e5;
+  const clampMax = 1e8;
+  const clampedSize = Math.max(clampMin, Math.min(clampMax, dataSrc.size));
+  let step = 1;
+  let w = clampedSize;
+  while (w > 10) {
+    w /= 12.5;
+    step++;
+  }
+  minimumChunkSize = Math.floor(10 ** (step - 1));
+  return async function* piecesBlob() {
+    const size = dataSrc.size;
+    let i = 0;
+    const buf = new Uint8Array(await dataSrc.arrayBuffer());
+    do {
+      const findStart = i + minimumChunkSize;
+      const defaultSplitEnd = i + pieceSize;
+      let splitEnd;
+      let i1 = buf.indexOf(delimiter, findStart);
+      if (i1 == -1) {
+        i1 = buf.indexOf(charNewLine, findStart);
+      }
+      if (i1 == -1) {
+        splitEnd = defaultSplitEnd;
+      } else {
+        splitEnd = i1 < defaultSplitEnd ? i1 : defaultSplitEnd;
+      }
+      yield await arrayBufferToBase64Single(buf.slice(i, splitEnd));
+      i = splitEnd;
+    } while (i < size);
+  };
+}
+async function splitPieces2(dataSrc, pieceSize, plainSplit, minimumChunkSize, filename, useSegmenter) {
+  if (isTextBlob(dataSrc)) {
+    return splitPiecesText(await dataSrc.text(), pieceSize, plainSplit, minimumChunkSize, useSegmenter ?? false);
+  }
+  let delimiter = 0;
+  let canBeSmall = false;
+  if (filename && filename.endsWith(".pdf")) {
+    delimiter = "/".charCodeAt(0);
+  } else if (filename && filename.endsWith(".json")) {
+    canBeSmall = true;
+    delimiter = ",".charCodeAt(0);
+  }
+  const clampMin = canBeSmall ? 100 : 1e5;
+  const clampMax = 1e8;
+  const clampedSize = Math.max(clampMin, Math.min(clampMax, dataSrc.size));
+  let step = 1;
+  let w = clampedSize;
+  while (w > 10) {
+    w /= 12.5;
+    step++;
+  }
+  minimumChunkSize = Math.floor(10 ** (step - 1));
+  return async function* piecesBlob() {
+    const size = dataSrc.size;
+    let i = 0;
+    do {
+      let splitSize = pieceSize;
+      const currentData = new Uint8Array(await dataSrc.slice(i, i + pieceSize).arrayBuffer());
+      let nextIdx = currentData.indexOf(delimiter, minimumChunkSize);
+      splitSize = nextIdx == -1 ? pieceSize : Math.min(pieceSize, nextIdx);
+      if (nextIdx == -1) nextIdx = currentData.indexOf(charNewLine, minimumChunkSize);
+      const piece = currentData.slice(0, splitSize);
+      i += piece.length;
+      const b64 = await arrayBufferToBase64Single(piece);
+      yield b64;
+    } while (i < size);
+  };
+}
+async function splitPiecesRabinKarp(dataSrc, absoluteMaxPieceSize, doPlainSplit, minimumChunkSize, _filename, _useSegmenter) {
+  let plainSplit = doPlainSplit || isTextBlob(dataSrc);
+  const dataSize = dataSrc.size;
+  let chunkUnitPlain = 64;
+  const MAX_CHUNK_COUNT = 500;
+  if (plainSplit) {
+    const isDataSizeTooLargeForPlainSplit = dataSize >= 4 * 1024 * 1024;
+    if (isDataSizeTooLargeForPlainSplit) {
+      plainSplit = false;
+    } else {
+      let estimatedChunkCount;
+      do {
+        estimatedChunkCount = dataSize / (chunkUnitPlain * 4);
+        if (estimatedChunkCount > MAX_CHUNK_COUNT) {
+          chunkUnitPlain += 32;
+        }
+      } while (estimatedChunkCount > MAX_CHUNK_COUNT);
+    }
+  }
+  const chunkUnitBinary = 256 * 1024;
+  const fixedAvgChunkSize = plainSplit ? chunkUnitPlain * 4 : chunkUnitBinary * 4;
+  const fixedMaxChunkSize = plainSplit ? chunkUnitPlain * 16 : chunkUnitBinary * 16;
+  const fixedMinChunkSize = plainSplit ? chunkUnitPlain * 2 : chunkUnitBinary;
+  const rkAbsoluteMaxPieceSizeFloor = 30 * 1024;
+  const effectiveAbsoluteMaxPieceSize = Math.max(absoluteMaxPieceSize, rkAbsoluteMaxPieceSizeFloor);
+  const maxChunkSize = Math.min(fixedMaxChunkSize, effectiveAbsoluteMaxPieceSize);
+  const minChunkSize = Math.min(Math.max(fixedMinChunkSize, minimumChunkSize), maxChunkSize);
+  const avgChunkSize = Math.min(Math.max(fixedAvgChunkSize, minChunkSize), maxChunkSize);
+  const windowSize = 48;
+  const hashModulus = avgChunkSize;
+  const boundaryPattern = 1;
+  const PRIME = 31;
+  let P_pow_w = 1;
+  for (let i = 0; i < windowSize - 1; i++) {
+    P_pow_w = Math.imul(P_pow_w, PRIME);
+  }
+  const buffer = new Uint8Array(await dataSrc.arrayBuffer());
+  let pos = 0;
+  let hash = 0;
+  let start = 0;
+  const isText = isTextBlob(dataSrc);
+  const length = buffer.length;
+  return async function* piecesBlob() {
+    while (pos < length) {
+      const byte = buffer[pos];
+      if (pos >= start + windowSize) {
+        const oldByte = buffer[pos - windowSize];
+        const oldByteTerm = Math.imul(oldByte, P_pow_w);
+        hash = hash - oldByteTerm | 0;
+        hash = Math.imul(hash, PRIME);
+        hash = hash + byte | 0;
+      } else {
+        hash = Math.imul(hash, PRIME);
+        hash = hash + byte | 0;
+      }
+      const currentChunkSize = pos - start + 1;
+      let isBoundaryCandidate = false;
+      if (currentChunkSize >= minChunkSize) {
+        if ((hash >>> 0) % hashModulus === boundaryPattern) {
+          isBoundaryCandidate = true;
+        }
+      }
+      if (currentChunkSize >= maxChunkSize) {
+        isBoundaryCandidate = true;
+      }
+      if (isBoundaryCandidate) {
+        let isSafeBoundary = true;
+        if (isText) {
+          if (pos + 1 < length && (buffer[pos + 1] & 192) === 128) {
+            isSafeBoundary = false;
+          }
+        }
+        if (isSafeBoundary) {
+          if (isText) {
+            yield Promise.resolve(readString(buffer.subarray(start, pos + 1)));
+          } else {
+            yield await arrayBufferToBase64Single(buffer.subarray(start, pos + 1));
+          }
+          start = pos + 1;
+        }
+      }
+      pos++;
+    }
+    if (start < length) {
+      if (isText) {
+        yield Promise.resolve(readString(buffer.subarray(start, length)));
+      } else {
+        yield await arrayBufferToBase64Single(buffer.subarray(start, length));
+      }
+    }
+  };
+}
+async function splitPiecesRabinKarpOld(dataSrc, absoluteMaxPieceSize, doPlainSplit, minimumChunkSize, _filename, _useSegmenter) {
+  const plainSplit = doPlainSplit || isTextBlob(dataSrc);
+  const minPieceSize = plainSplit ? 128 : 1024 * 4;
+  const splitPieceCount = plainSplit ? 20 : 12;
+  const avgChunkSize = Math.max(minPieceSize, Math.floor(dataSrc.size / splitPieceCount));
+  const maxChunkSize = Math.min(absoluteMaxPieceSize, avgChunkSize * 5);
+  const minChunkSize = Math.min(Math.max(Math.floor(avgChunkSize / 4), minimumChunkSize), maxChunkSize);
+  const windowSize = 48;
+  const hashModulus = avgChunkSize;
+  const boundaryPattern = 1;
+  const PRIME = 31;
+  let P_pow_w = 1;
+  for (let i = 0; i < windowSize - 1; i++) {
+    P_pow_w = Math.imul(P_pow_w, PRIME);
+  }
+  const buffer = new Uint8Array(await dataSrc.arrayBuffer());
+  let pos = 0;
+  let hash = 0;
+  let start = 0;
+  const isText = isTextBlob(dataSrc);
+  const length = buffer.length;
+  return async function* piecesBlob() {
+    while (pos < length) {
+      const byte = buffer[pos];
+      if (pos >= start + windowSize) {
+        const oldByte = buffer[pos - windowSize];
+        const oldByteTerm = Math.imul(oldByte, P_pow_w);
+        hash = hash - oldByteTerm | 0;
+        hash = Math.imul(hash, PRIME);
+        hash = hash + byte | 0;
+      } else {
+        hash = Math.imul(hash, PRIME);
+        hash = hash + byte | 0;
+      }
+      const currentChunkSize = pos - start + 1;
+      let isBoundaryCandidate = false;
+      if (currentChunkSize >= minChunkSize) {
+        if ((hash >>> 0) % hashModulus === boundaryPattern) {
+          isBoundaryCandidate = true;
+        }
+      }
+      if (currentChunkSize >= maxChunkSize) {
+        isBoundaryCandidate = true;
+      }
+      if (isBoundaryCandidate) {
+        let isSafeBoundary = true;
+        if (isText) {
+          if (pos + 1 < length && (buffer[pos + 1] & 192) === 128) {
+            isSafeBoundary = false;
+          }
+        }
+        if (isSafeBoundary) {
+          if (isText) {
+            yield Promise.resolve(readString(buffer.subarray(start, pos + 1)));
+          } else {
+            yield await arrayBufferToBase64Single(buffer.subarray(start, pos + 1));
+          }
+          start = pos + 1;
+        }
+      }
+      pos++;
+    }
+    if (start < length) {
+      if (isText) {
+        yield Promise.resolve(readString(buffer.subarray(start, length)));
+      } else {
+        yield await arrayBufferToBase64Single(buffer.subarray(start, length));
+      }
+    }
+  };
+}
+export {
+  binaryTextSplit,
+  collectGenAll,
+  concatGeneratedAll,
+  splitPieces2,
+  splitPieces2V2,
+  splitPiecesRabinKarp,
+  splitPiecesRabinKarpOld,
+  splitPiecesText,
+  splitPiecesTextV1,
+  splitPiecesTextV2
+};

package/dist/string_and_binary/convert.d.ts

@@ -0,0 +1,8 @@
+import { arrayBufferToBase64, base64ToArrayBuffer, base64ToArrayBufferInternalBrowser, readString, writeString, tryConvertBase64ToArrayBuffer } from "octagonal-wheels/binary";
+export { arrayBufferToBase64, base64ToArrayBuffer, base64ToArrayBufferInternalBrowser, readString, writeString, tryConvertBase64ToArrayBuffer, };
+export declare function arrayBufferToBase64Single(buffer: Uint8Array<ArrayBuffer> | ArrayBuffer): Promise<string>;
+export { uint8ArrayToHexString, hexStringToUint8Array } from "octagonal-wheels/binary/hex";
+export { encodeBinaryEach, decodeToArrayBuffer } from "octagonal-wheels/binary/encodedUTF16";
+export { decodeBinary, encodeBinary } from "octagonal-wheels/binary";
+export { escapeStringToHTML } from "octagonal-wheels/string";
+export declare function versionNumberString2Number(version: string): number;

package/dist/string_and_binary/convert.js

@@ -0,0 +1,46 @@
+import {
+  arrayBufferToBase64,
+  base64ToArrayBuffer,
+  base64ToArrayBufferInternalBrowser,
+  arrayBufferToBase64Single as arrayBufferToBase64SingleInternal,
+  readString,
+  writeString,
+  tryConvertBase64ToArrayBuffer
+} from "octagonal-wheels/binary";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+async function arrayBufferToBase64Single(buffer) {
+  try {
+    return await arrayBufferToBase64SingleInternal(buffer);
+  } catch (ex) {
+    const maybeBuffer = compatGlobal?.Buffer;
+    if (typeof maybeBuffer?.from === "function") {
+      const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+      return maybeBuffer.from(view.buffer, view.byteOffset, view.byteLength).toString("base64");
+    }
+    throw ex;
+  }
+}
+import { uint8ArrayToHexString, hexStringToUint8Array } from "octagonal-wheels/binary/hex";
+import { encodeBinaryEach, decodeToArrayBuffer } from "octagonal-wheels/binary/encodedUTF16";
+import { decodeBinary, encodeBinary } from "octagonal-wheels/binary";
+import { escapeStringToHTML } from "octagonal-wheels/string";
+function versionNumberString2Number(version) {
+  return version.split(".").reverse().map((e, i) => (Number(e) || 0) * 1e3 ** i).reduce((prev, current) => prev + current, 0);
+}
+export {
+  arrayBufferToBase64,
+  arrayBufferToBase64Single,
+  base64ToArrayBuffer,
+  base64ToArrayBufferInternalBrowser,
+  decodeBinary,
+  decodeToArrayBuffer,
+  encodeBinary,
+  encodeBinaryEach,
+  escapeStringToHTML,
+  hexStringToUint8Array,
+  readString,
+  tryConvertBase64ToArrayBuffer,
+  uint8ArrayToHexString,
+  versionNumberString2Number,
+  writeString
+};

package/dist/string_and_binary/hash.d.ts

@@ -0,0 +1,2 @@
+export * from "octagonal-wheels/hash/xxhash.js";
+export type * from "octagonal-wheels/hash/xxhash.js";

package/dist/string_and_binary/hash.js

@@ -0,0 +1 @@
+export * from "octagonal-wheels/hash/xxhash.js";

package/dist/string_and_binary/path.d.ts

@@ -0,0 +1,35 @@
+import { type AnyEntry, type DocumentID, type EntryHasPath, type FilePath, type FilePathWithPrefix } from "../common/types.js";
+export declare function isValidFilenameInWidows(filename: string): boolean;
+export declare function isValidFilenameInDarwin(filename: string): boolean;
+export declare function isValidFilenameInLinux(filename: string): boolean;
+export declare function isValidFilenameInAndroid(filename: string): boolean;
+export declare function isFilePath(path: FilePath | FilePathWithPrefix): path is FilePath;
+export declare function stripAllPrefixes(prefixedPath: FilePathWithPrefix): FilePath;
+export declare function addPrefix(path: FilePath | FilePathWithPrefix, prefix: string): FilePathWithPrefix;
+export declare function expandFilePathPrefix(path: FilePathWithPrefix | FilePath): [string, FilePathWithPrefix];
+export declare function expandDocumentIDPrefix(id: DocumentID): [string, FilePathWithPrefix];
+export declare function path2id_base(filenameSrc: FilePathWithPrefix | FilePath, obfuscatePassphrase: string | false, caseInsensitive: boolean): Promise<DocumentID>;
+export declare function id2path_base(id: DocumentID, entry?: EntryHasPath): FilePathWithPrefix;
+export declare function getPath(entry: AnyEntry): FilePathWithPrefix;
+export declare function getPathWithoutPrefix(entry: AnyEntry): FilePath;
+export declare function stripPrefix(prefixedPath: FilePathWithPrefix): FilePath;
+export declare function shouldBeIgnored(filename: string): boolean;
+export declare function isPlainText(filename: string): boolean;
+export declare function shouldSplitAsPlainText(filename: string): boolean;
+/**
+ * returns whether the given path is accepted (not ignored) by the `.gitignore`.
+ * @param path path of the file which is relative from `.gitignore` file
+ * @param ignore lines of `.gitignore`
+ * @returns true when accepted.
+ * false when not accepted.
+ * undefined when the path is not mentioned in the `.gitignore` file.
+ */
+export declare function isAccepted(path: string, ignore: string[]): boolean | undefined;
+/**
+ * Checks whether the path is accepted by all ignored files.
+ * @param path path of target file
+ * @param ignoreFiles list of ignore files. i.e. [".gitignore", ".dockerignore"]
+ * @param getList function to retrieve the file.
+ * @returns true when accepted. false when should be ignored.
+ */
+export declare function isAcceptedAll(path: string, ignoreFiles: string[], getList: (path: string) => Promise<string[] | false>): Promise<boolean>;