@visulima/fs 2.3.5 → 2.3.7

package/dist/packem_shared/ensureSymlink-CFSfreco.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+const isStatsIdentical = require('./is-stats-identical-BfdEfO6i.cjs');
+const resolveSymlinkTarget = require('./resolve-symlink-target-DImIddt6.cjs');
+const ensureDir = require('./ensureDir-iUK2ga5M.cjs');
+const AlreadyExistsError = require('./AlreadyExistsError-DpxtwQot.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlink = /* @__PURE__ */ __name(async (target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget.resolveSymlinkTarget(target, linkName);
+  linkName = path.toNamespacedPath(utils.toPath(linkName));
+  try {
+    const linkStatInfo = await promises.lstat(linkName);
+    if (linkStatInfo.isSymbolicLink() && // eslint-disable-next-line security/detect-non-literal-fs-filename
+    isStatsIdentical.isStatsIdentical(await promises.stat(targetRealPath), await promises.stat(linkName))) {
+      const [sourceStat, destinationStat] = await Promise.all([promises.stat(targetRealPath), promises.stat(linkName)]);
+      if (isStatsIdentical.isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = await promises.lstat(targetRealPath);
+  const sourceFilePathType = getFileInfoType.getFileInfoType(sourceStatInfo);
+  await ensureDir(path.dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    await promises.symlink(path.toNamespacedPath(utils.toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = await promises.lstat(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError("A " + getFileInfoType.getFileInfoType(linkStatInfo) + " already exists at the path: " + linkName);
+    }
+    const linkPath = await promises.readlink(linkName);
+    const linkRealPath = path.toNamespacedPath(path.resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError("A symlink targeting to an undesired path already exists: " + linkName + " -> " + linkRealPath);
+    }
+  }
+}, "ensureSymlink");
+
+module.exports = ensureSymlink;

package/dist/packem_shared/ensureSymlink-CSqngPoI.mjs

@@ -0,0 +1,52 @@
+import { lstat, stat, symlink, readlink } from 'node:fs/promises';
+import { toNamespacedPath, dirname, resolve } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+import { i as isStatsIdentical } from './is-stats-identical-ByTYZ2Aw.mjs';
+import { r as resolveSymlinkTarget } from './resolve-symlink-target-BbpEHdU2.mjs';
+import ensureDir from './ensureDir-XiBlkOLR.mjs';
+import AlreadyExistsError from './AlreadyExistsError-GK7J9fVA.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlink = /* @__PURE__ */ __name(async (target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget(target, linkName);
+  linkName = toNamespacedPath(toPath(linkName));
+  try {
+    const linkStatInfo = await lstat(linkName);
+    if (linkStatInfo.isSymbolicLink() && // eslint-disable-next-line security/detect-non-literal-fs-filename
+    isStatsIdentical(await stat(targetRealPath), await stat(linkName))) {
+      const [sourceStat, destinationStat] = await Promise.all([stat(targetRealPath), stat(linkName)]);
+      if (isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = await lstat(targetRealPath);
+  const sourceFilePathType = getFileInfoType(sourceStatInfo);
+  await ensureDir(dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    await symlink(toNamespacedPath(toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = await lstat(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError("A " + getFileInfoType(linkStatInfo) + " already exists at the path: " + linkName);
+    }
+    const linkPath = await readlink(linkName);
+    const linkRealPath = toNamespacedPath(resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError("A symlink targeting to an undesired path already exists: " + linkName + " -> " + linkRealPath);
+    }
+  }
+}, "ensureSymlink");
+
+export { ensureSymlink as default };

package/dist/packem_shared/ensureSymlinkSync-BCd9bzsx.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+const isStatsIdentical = require('./is-stats-identical-BfdEfO6i.cjs');
+const resolveSymlinkTarget = require('./resolve-symlink-target-DImIddt6.cjs');
+const ensureDirSync = require('./ensureDirSync-CXdMkg0Y.cjs');
+const AlreadyExistsError = require('./AlreadyExistsError-DpxtwQot.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlinkSync = /* @__PURE__ */ __name((target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget.resolveSymlinkTarget(target, linkName);
+  linkName = path.toNamespacedPath(utils.toPath(linkName));
+  try {
+    const linkStatInfo = node_fs.lstatSync(linkName);
+    if (linkStatInfo.isSymbolicLink() && // eslint-disable-next-line security/detect-non-literal-fs-filename
+    isStatsIdentical.isStatsIdentical(node_fs.statSync(targetRealPath), node_fs.statSync(linkName))) {
+      const sourceStat = node_fs.statSync(targetRealPath);
+      const destinationStat = node_fs.statSync(linkName);
+      if (isStatsIdentical.isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = node_fs.lstatSync(targetRealPath);
+  const sourceFilePathType = getFileInfoType.getFileInfoType(sourceStatInfo);
+  ensureDirSync(path.dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    node_fs.symlinkSync(path.toNamespacedPath(utils.toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = node_fs.lstatSync(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError("A " + getFileInfoType.getFileInfoType(linkStatInfo) + " already exists at the path: " + linkName);
+    }
+    const linkPath = node_fs.readlinkSync(linkName);
+    const linkRealPath = path.toNamespacedPath(path.resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError(
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        "A symlink targeting to an undesired path already exists: " + linkName + " -> " + linkRealPath
+      );
+    }
+  }
+}, "ensureSymlinkSync");
+
+module.exports = ensureSymlinkSync;

package/dist/packem_shared/ensureSymlinkSync-QRaNZX2E.mjs

@@ -0,0 +1,56 @@
+import { lstatSync, statSync, symlinkSync, readlinkSync } from 'node:fs';
+import { toNamespacedPath, dirname, resolve } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+import { i as isStatsIdentical } from './is-stats-identical-ByTYZ2Aw.mjs';
+import { r as resolveSymlinkTarget } from './resolve-symlink-target-BbpEHdU2.mjs';
+import ensureDirSync from './ensureDirSync-2IFUHFK2.mjs';
+import AlreadyExistsError from './AlreadyExistsError-GK7J9fVA.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlinkSync = /* @__PURE__ */ __name((target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget(target, linkName);
+  linkName = toNamespacedPath(toPath(linkName));
+  try {
+    const linkStatInfo = lstatSync(linkName);
+    if (linkStatInfo.isSymbolicLink() && // eslint-disable-next-line security/detect-non-literal-fs-filename
+    isStatsIdentical(statSync(targetRealPath), statSync(linkName))) {
+      const sourceStat = statSync(targetRealPath);
+      const destinationStat = statSync(linkName);
+      if (isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = lstatSync(targetRealPath);
+  const sourceFilePathType = getFileInfoType(sourceStatInfo);
+  ensureDirSync(dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    symlinkSync(toNamespacedPath(toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = lstatSync(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError("A " + getFileInfoType(linkStatInfo) + " already exists at the path: " + linkName);
+    }
+    const linkPath = readlinkSync(linkName);
+    const linkRealPath = toNamespacedPath(resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError(
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        "A symlink targeting to an undesired path already exists: " + linkName + " -> " + linkRealPath
+      );
+    }
+  }
+}, "ensureSymlinkSync");
+
+export { ensureSymlinkSync as default };

package/dist/packem_shared/findUp-C8_QpAtD.mjs

@@ -0,0 +1,63 @@
+import { stat, lstat } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { resolve, parse, isAbsolute, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { FIND_UP_STOP } from './F_OK-JER1LjUr.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const findUp = /* @__PURE__ */ __name(async (name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? toPath(options.cwd) : process.cwd();
+  let directory = resolve(cwd);
+  const { root } = parse(directory);
+  const stopPath = toPath(options.stopAt ?? root);
+  const stopAt = resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = /* @__PURE__ */ __name(async function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = await name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  }, "getMatchers");
+  if (options.allowSymlinks === undefined) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? stat : lstat;
+  while (directory && directory !== stopAt && directory !== root) {
+    for await (let fileName of await getMatchers(directory)) {
+      if (fileName === FIND_UP_STOP) {
+        return undefined;
+      }
+      if (fileName === undefined) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = fileURLToPath(fileName);
+      }
+      const filePath = isAbsolute(fileName) ? fileName : resolve(directory, fileName);
+      try {
+        const stats = await statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = dirname(directory);
+  }
+  return undefined;
+}, "findUp");
+
+export { findUp as default };

package/dist/packem_shared/findUp-DA511Swp.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const node_url = require('node:url');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const findUp = /* @__PURE__ */ __name(async (name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? utils.toPath(options.cwd) : process.cwd();
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  const stopPath = utils.toPath(options.stopAt ?? root);
+  const stopAt = path.resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = /* @__PURE__ */ __name(async function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = await name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  }, "getMatchers");
+  if (options.allowSymlinks === undefined) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? promises.stat : promises.lstat;
+  while (directory && directory !== stopAt && directory !== root) {
+    for await (let fileName of await getMatchers(directory)) {
+      if (fileName === F_OK.FIND_UP_STOP) {
+        return undefined;
+      }
+      if (fileName === undefined) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = node_url.fileURLToPath(fileName);
+      }
+      const filePath = path.isAbsolute(fileName) ? fileName : path.resolve(directory, fileName);
+      try {
+        const stats = await statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = path.dirname(directory);
+  }
+  return undefined;
+}, "findUp");
+
+module.exports = findUp;

package/dist/packem_shared/findUpSync-DVOd3V-q.mjs

@@ -0,0 +1,63 @@
+import { statSync, lstatSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolve, parse, isAbsolute, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { FIND_UP_STOP } from './F_OK-JER1LjUr.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const findUpSync = /* @__PURE__ */ __name((name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? toPath(options.cwd) : process.cwd();
+  let directory = resolve(cwd);
+  const { root } = parse(directory);
+  const stopPath = toPath(options.stopAt ?? root);
+  const stopAt = resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = /* @__PURE__ */ __name(function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  }, "getMatchers");
+  if (options.allowSymlinks === undefined) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? statSync : lstatSync;
+  while (directory && directory !== stopAt && directory !== root) {
+    for (let fileName of getMatchers(directory)) {
+      if (fileName === FIND_UP_STOP) {
+        return undefined;
+      }
+      if (fileName === undefined) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = fileURLToPath(fileName);
+      }
+      const filePath = isAbsolute(fileName) ? fileName : resolve(directory, fileName);
+      try {
+        const stats = statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = dirname(directory);
+  }
+  return undefined;
+}, "findUpSync");
+
+export { findUpSync as default };

package/dist/packem_shared/findUpSync-u1rGibzw.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_url = require('node:url');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const findUpSync = /* @__PURE__ */ __name((name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? utils.toPath(options.cwd) : process.cwd();
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  const stopPath = utils.toPath(options.stopAt ?? root);
+  const stopAt = path.resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = /* @__PURE__ */ __name(function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  }, "getMatchers");
+  if (options.allowSymlinks === undefined) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? node_fs.statSync : node_fs.lstatSync;
+  while (directory && directory !== stopAt && directory !== root) {
+    for (let fileName of getMatchers(directory)) {
+      if (fileName === F_OK.FIND_UP_STOP) {
+        return undefined;
+      }
+      if (fileName === undefined) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = node_url.fileURLToPath(fileName);
+      }
+      const filePath = path.isAbsolute(fileName) ? fileName : path.resolve(directory, fileName);
+      try {
+        const stats = statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = path.dirname(directory);
+  }
+  return undefined;
+}, "findUpSync");
+
+module.exports = findUpSync;

package/dist/packem_shared/get-file-info-type-BpRzQHvd.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getFileInfoType = /* @__PURE__ */ __name((fileInfo) => {
+  if (fileInfo.isFile()) {
+    return "file";
+  }
+  if (fileInfo.isDirectory()) {
+    return "dir";
+  }
+  if (fileInfo.isSymbolicLink()) {
+    return "symlink";
+  }
+  return undefined;
+}, "getFileInfoType");
+
+exports.getFileInfoType = getFileInfoType;

package/dist/packem_shared/get-file-info-type-CeiZ6n6g.mjs

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getFileInfoType = /* @__PURE__ */ __name((fileInfo) => {
+  if (fileInfo.isFile()) {
+    return "file";
+  }
+  if (fileInfo.isDirectory()) {
+    return "dir";
+  }
+  if (fileInfo.isSymbolicLink()) {
+    return "symlink";
+  }
+  return undefined;
+}, "getFileInfoType");
+
+export { getFileInfoType as g };

package/dist/packem_shared/index-ajT9ecry.mjs

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const INDENT_REGEX = /^(?:( )+|\t+)/;
+const INDENT_TYPE_SPACE = "space";
+const INDENT_TYPE_TAB = "tab";
+function makeIndentsMap(string, ignoreSingleSpaces) {
+  const indents = /* @__PURE__ */ new Map();
+  let previousSize = 0;
+  let previousIndentType;
+  let key;
+  for (const line of string.split(/\n/g)) {
+    if (!line) {
+      continue;
+    }
+    let indent;
+    let indentType;
+    let use;
+    let weight;
+    let entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
+        continue;
+      }
+      if (indentType !== previousIndentType) {
+        previousSize = 0;
+      }
+      previousIndentType = indentType;
+      use = 1;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === undefined ? [1, 0] : [entry[0] + use, entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+}
+__name(makeIndentsMap, "makeIndentsMap");
+function encodeIndentsKey(indentType, indentAmount) {
+  const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
+  return typeCharacter + String(indentAmount);
+}
+__name(encodeIndentsKey, "encodeIndentsKey");
+function decodeIndentsKey(indentsKey) {
+  const keyHasTypeSpace = indentsKey[0] === "s";
+  const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+  const amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+__name(decodeIndentsKey, "decodeIndentsKey");
+function getMostUsedKey(indents) {
+  let result;
+  let maxUsed = 0;
+  let maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents) {
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  }
+  return result;
+}
+__name(getMostUsedKey, "getMostUsedKey");
+function makeIndentString(type, amount) {
+  const indentCharacter = type === INDENT_TYPE_SPACE ? " " : "	";
+  return indentCharacter.repeat(amount);
+}
+__name(makeIndentString, "makeIndentString");
+function detectIndent(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  let indents = makeIndentsMap(string, true);
+  if (indents.size === 0) {
+    indents = makeIndentsMap(string, false);
+  }
+  const keyOfMostUsedIndent = getMostUsedKey(indents);
+  let type;
+  let amount = 0;
+  let indent = "";
+  if (keyOfMostUsedIndent !== undefined) {
+    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
+    indent = makeIndentString(type, amount);
+  }
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+__name(detectIndent, "detectIndent");
+
+export { detectIndent as d };