modern-ts 0.8.0

package/dist/subpath/Str.mjs

@@ -0,0 +1,114 @@
+import { P as u } from "../chunks/Errors-DwUAvFIF.mjs";
+const f = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+}, C = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'"
+}, E = /[&<>"']/g, _ = /&(?:amp|lt|gt|quot|#39);/g, d = /[A-Z]{2,}(?=[A-Z][a-z]+|[0-9]|$)|[A-Z]?[a-z]+[0-9]*|[A-Z]+[0-9]*|[0-9]+[a-z]+|[0-9]+/g, P = /[\p{L}\p{N}]+/gu, L = /^\s+/, h = /\s+$/, A = (e, t) => {
+  if (t === void 0) return e.trim();
+  if (!t) return e;
+  const n = p(t);
+  return e.replace(new RegExp(`^[${n}]+|[${n}]+$`, "g"), "");
+}, R = (e, t) => {
+  if (t === void 0) return e.replace(L, "");
+  if (!t) return e;
+  const n = p(t);
+  return e.replace(new RegExp(`^[${n}]+`), "");
+}, w = (e, t) => {
+  if (t === void 0) return e.replace(h, "");
+  if (!t) return e;
+  const n = p(t);
+  return e.replace(new RegExp(`[${n}]+$`), "");
+}, M = (e, t, n = " ") => {
+  if (!Number.isFinite(t) || t < 0)
+    throw new u("Length must be a finite non-negative number");
+  const r = e.length;
+  if (r >= t || n.length === 0) return e;
+  const a = t - r, c = Math.floor(a / 2), o = a - c, l = n.repeat(Math.ceil(c / n.length)).slice(0, c), g = n.repeat(Math.ceil(o / n.length)).slice(0, o);
+  return l + e + g;
+}, m = (e) => e.normalize("NFD").replace(/[\u0300-\u036f]/g, ""), p = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), S = (e) => e.replace(E, (t) => f[t]), b = (e) => e.replace(_, (t) => C[t]), j = (e) => [...e].reverse().join(""), s = (e) => m(e).match(d) || [], i = (e) => e && e.charAt(0).toUpperCase() + e.slice(1).toLowerCase(), $ = (e) => s(e).map(i).join(" ").replace(
+  /([a-z])(\d)|(\d)([a-z])/gi,
+  (t, n, r, a, c) => `${n || a} ${r || c}`
+).split(" ").map(i).join(" ").trim(), z = (e) => {
+  const t = s(e);
+  return t.length ? t[0].toLowerCase() + t.slice(1).map(i).join("") : "";
+}, v = (e) => e && e.charAt(0).toUpperCase() + e.slice(1).toLowerCase(), T = (e) => s(e).map((t) => t.toUpperCase()).join("_"), N = (e) => s(e).map((t) => t.toLowerCase()).join("-"), U = (e) => s(e).map((t) => t.toLowerCase()).join(" "), G = (e) => e && e.charAt(0).toLowerCase() + e.slice(1), X = (e) => s(e).map(i).join(""), k = (e) => s(e).map((t) => t.toLowerCase()).join("_"), x = (e) => s(e).map((t) => t.toUpperCase()).join(" "), y = (e) => e && e.charAt(0).toUpperCase() + e.slice(1), D = (e) => e.match(P) || [], F = (e, t) => {
+  if (!Number.isInteger(e) || e < 0)
+    throw new u("Length must be a non-negative integer");
+  const n = t ?? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  if (n.length === 0) return "";
+  let r = "";
+  for (let a = 0; a < e; a++)
+    r += n.charAt(Math.floor(Math.random() * n.length));
+  return r;
+}, I = (e, t) => e.replace(/\{\{([^}]+)\}\}/g, (n, r) => {
+  const c = r.trim().split(".");
+  let o = t;
+  for (const l of c) {
+    if (o === null || typeof o != "object") {
+      o = void 0;
+      break;
+    }
+    o = o[l];
+  }
+  return o == null ? "" : String(o);
+}), H = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  camelCase: z,
+  capitalize: v,
+  constantCase: T,
+  deburr: m,
+  escape: S,
+  escapeRegExp: p,
+  kebabCase: N,
+  lowerCase: U,
+  lowerFirst: G,
+  pad: M,
+  pascalCase: X,
+  randomString: F,
+  reverseString: j,
+  snakeCase: k,
+  startCase: $,
+  template: I,
+  trim: A,
+  trimEnd: w,
+  trimStart: R,
+  unescape: b,
+  upperCase: x,
+  upperFirst: y,
+  words: D
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  H as S,
+  z as camelCase,
+  v as capitalize,
+  T as constantCase,
+  m as deburr,
+  S as escape,
+  p as escapeRegExp,
+  N as kebabCase,
+  U as lowerCase,
+  G as lowerFirst,
+  M as pad,
+  X as pascalCase,
+  F as randomString,
+  j as reverseString,
+  k as snakeCase,
+  $ as startCase,
+  I as template,
+  A as trim,
+  w as trimEnd,
+  R as trimStart,
+  b as unescape,
+  x as upperCase,
+  y as upperFirst,
+  D as words
+};
+//# sourceMappingURL=Str.mjs.map

package/dist/subpath/Str.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Str.mjs","sources":["../../src/Utils/String.ts"],"sourcesContent":["// ========================================\r\n// ./src/Utils/String.ts\r\n// ========================================\r\n// cSpell:ignore deburr\r\n\r\nimport {ParameterError} from 'src/Errors';\r\n\r\n// ------ 常量预编译 ------\r\nconst HTML_ESCAPE_MAP: Record<string, string> = {\r\n  '&': '&amp;',\r\n  '<': '&lt;',\r\n  '>': '&gt;',\r\n  '\"': '&quot;',\r\n  \"'\": '&#39;',\r\n} as const;\r\n\r\nconst HTML_UNESCAPE_MAP: Record<string, string> = {\r\n  '&amp;': '&',\r\n  '&lt;': '<',\r\n  '&gt;': '>',\r\n  '&quot;': '\"',\r\n  '&#39;': \"'\",\r\n} as const;\r\n\r\nconst HTML_ESCAPE_REGEXP = /[&<>\"']/g;\r\nconst HTML_UNESCAPE_REGEXP = /&(?:amp|lt|gt|quot|#39);/g;\r\nconst WORD_SPLIT_REGEXP =\r\n  /[A-Z]{2,}(?=[A-Z][a-z]+|[0-9]|$)|[A-Z]?[a-z]+[0-9]*|[A-Z]+[0-9]*|[0-9]+[a-z]+|[0-9]+/g;\r\nconst UNICODE_WORD_REGEXP = /[\\p{L}\\p{N}]+/gu;\r\n\r\nconst TRIM_START_REGEXP = /^\\s+/;\r\nconst TRIM_END_REGEXP = /\\s+$/;\r\n\r\n// ------ 修剪与填充 ------\r\n\r\n/**\r\n * Removes whitespace or specified characters from both ends of a string\r\n * @param str - String to trim\r\n * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from both ends.\r\n * @returns Trimmed string. Returns empty string if input is empty.\r\n * @example\r\n * trim('  hello  ') // 'hello'\r\n * trim('--hello--', '-') // 'hello'\r\n * trim('', '-') // ''\r\n */\r\nexport const trim = (str: string, chars?: string): string => {\r\n  if (chars === undefined) return str.trim();\r\n  if (!chars) return str;\r\n\r\n  const safeChars = escapeRegExp(chars);\r\n  return str.replace(new RegExp(`^[${safeChars}]+|[${safeChars}]+$`, 'g'), '');\r\n};\r\n\r\n/**\r\n * Removes whitespace or specified characters from the start of a string\r\n * @param str - String to trim\r\n * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from the start.\r\n * @returns Trimmed string. Returns empty string if input is empty.\r\n * @example\r\n * trimStart('  hello  ') // 'hello  '\r\n * trimStart('--hello', '-') // 'hello'\r\n */\r\nexport const trimStart = (str: string, chars?: string): string => {\r\n  if (chars === undefined) return str.replace(TRIM_START_REGEXP, '');\r\n  if (!chars) return str;\r\n\r\n  const safeChars = escapeRegExp(chars);\r\n  return str.replace(new RegExp(`^[${safeChars}]+`), '');\r\n};\r\n\r\n/**\r\n * Removes whitespace or specified characters from the end of a string\r\n * @param str - String to trim\r\n * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from the end.\r\n * @returns Trimmed string. Returns empty string if input is empty.\r\n * @example\r\n * trimEnd('  hello  ') // '  hello'\r\n * trimEnd('hello--', '-') // 'hello'\r\n */\r\nexport const trimEnd = (str: string, chars?: string): string => {\r\n  if (chars === undefined) return str.replace(TRIM_END_REGEXP, '');\r\n  if (!chars) return str;\r\n\r\n  const safeChars = escapeRegExp(chars);\r\n  return str.replace(new RegExp(`[${safeChars}]+$`), '');\r\n};\r\n\r\n/**\r\n * Pads a string on both sides with specified characters to reach given length\r\n * @param str - String to pad\r\n * @param length - Target length after padding. If str length >= length, returns original string.\r\n * @param chars - Padding characters (defaults to space). If empty string, returns original string.\r\n * @returns Padded string. Returns original string if padding not needed or chars empty.\r\n * @throws If length is negative\r\n * @example\r\n * pad('hi', 5) // '  hi  '\r\n * pad('hi', 5, '-') // '--hi-'\r\n * pad('hello', 3) // 'hello'\r\n * pad('hi', 6, 'abc') // 'abhiab'\r\n */\r\nexport const pad = (\r\n  str: string,\r\n  length: number,\r\n  chars: string = ' ',\r\n): string => {\r\n  if (!Number.isFinite(length) || length < 0) {\r\n    throw new ParameterError('Length must be a finite non-negative number');\r\n  }\r\n  const strLen = str.length;\r\n  // 提前检查 chars 长度，避免后续计算\r\n  if (strLen >= length || chars.length === 0) return str;\r\n\r\n  const totalPad = length - strLen;\r\n  const leftPad = Math.floor(totalPad / 2);\r\n  const rightPad = totalPad - leftPad;\r\n\r\n  const repeatLeft = chars\r\n    .repeat(Math.ceil(leftPad / chars.length))\r\n    .slice(0, leftPad);\r\n  const repeatRight = chars\r\n    .repeat(Math.ceil(rightPad / chars.length))\r\n    .slice(0, rightPad);\r\n\r\n  return repeatLeft + str + repeatRight;\r\n};\r\n\r\n// ------ 转义处理 ------\r\n\r\n/**\r\n * Removes diacritical marks (accents) from characters using Unicode normalization\r\n * @param str - String to process\r\n * @returns String with diacritical marks removed. Returns empty string if input is empty.\r\n * @example\r\n * deburr('déjà vu') // 'deja vu'\r\n * deburr('') // ''\r\n */\r\nexport const deburr = (str: string): string =>\r\n  str.normalize('NFD').replace(/[\\u0300-\\u036f]/g, '');\r\n\r\n/**\r\n * Escapes special regex characters in a string\r\n * @param str - String containing regex special characters\r\n * @returns Escaped string safe for use in regex construction. Returns empty string if input is empty.\r\n * @example\r\n * escapeRegExp('[test].*') // '\\\\[test\\\\]\\\\.\\\\*'\r\n */\r\nexport const escapeRegExp = (str: string): string =>\r\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n\r\n/**\r\n * Escapes HTML special characters (&, <, >, \", ')\r\n * @param str - String containing HTML\r\n * @returns Escaped string with HTML entities. Returns empty string if input is empty.\r\n * @example\r\n * escape('<div>\"test\"</div>') // '&lt;div&gt;&quot;test&quot;&lt;/div&gt;'\r\n */\r\nexport const escape = (str: string): string =>\r\n  str.replace(HTML_ESCAPE_REGEXP, (match) => HTML_ESCAPE_MAP[match]);\r\n\r\n/**\r\n * Unescapes HTML entities (&amp;, &lt;, &gt;, &quot;, &#39;)\r\n * @param str - String with HTML entities\r\n * @returns Unescaped string. Returns empty string if input is empty.\r\n * @example\r\n * unescape('&lt;div&gt;') // '<div>'\r\n */\r\nexport const unescape = (str: string): string =>\r\n  str.replace(HTML_UNESCAPE_REGEXP, (match) => HTML_UNESCAPE_MAP[match]);\r\n\r\n// ------ Unicode 安全操作 ------\r\n\r\n/**\r\n * Reverses a string while preserving Unicode characters and emojis\r\n * @param str - String to reverse\r\n * @returns Reversed string. Returns empty string if input is empty.\r\n * @example\r\n * reverseString('hello') // 'olleh'\r\n * reverseString('👍👋') // '👋👍'\r\n */\r\nexport const reverseString = (str: string): string =>\r\n  [...str].reverse().join('');\r\n\r\n// ------ 大小写转换核心 ------\r\nconst splitWordsForCase = (str: string): string[] => {\r\n  const normalized = deburr(str);\r\n  return normalized.match(WORD_SPLIT_REGEXP) || [];\r\n};\r\n\r\nconst capitalizeWord = (word: string): string =>\r\n  word ? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() : word;\r\n\r\n/**\r\n * Converts string to Start Case (capitalizes first letter of each word)\r\n * @param str - String to convert\r\n * @returns Start case string. Returns empty string if input contains no words.\r\n * @remarks Handles alphanumeric boundaries (e.g., \"test123\" becomes \"Test 123\")\r\n * @example\r\n * startCase('hello world') // 'Hello World'\r\n * startCase('hello-world') // 'Hello World'\r\n * startCase('test123abc') // 'Test 123 Abc'\r\n */\r\nexport const startCase = (str: string): string => {\r\n  return splitWordsForCase(str)\r\n    .map(capitalizeWord)\r\n    .join(' ')\r\n    .replace(\r\n      /([a-z])(\\d)|(\\d)([a-z])/gi,\r\n      (_, p1, p2, p3, p4) => `${p1 || p3} ${p2 || p4}`,\r\n    )\r\n    .split(' ')\r\n    .map(capitalizeWord)\r\n    .join(' ')\r\n    .trim();\r\n};\r\n\r\n// ------ 大小写转换函数 ------\r\n\r\n/**\r\n * Converts string to camelCase\r\n * @param str - String to convert\r\n * @returns camelCase string. Returns empty string if input contains no words.\r\n * @example\r\n * camelCase('Hello World') // 'helloWorld'\r\n * camelCase('hello-world') // 'helloWorld'\r\n * camelCase('') // ''\r\n */\r\nexport const camelCase = (str: string): string => {\r\n  const words = splitWordsForCase(str);\r\n  if (!words.length) return '';\r\n  return words[0].toLowerCase() + words.slice(1).map(capitalizeWord).join('');\r\n};\r\n\r\n/**\r\n * Capitalizes first character and lowercases the rest\r\n * @param str - String to capitalize\r\n * @returns Capitalized string. Returns empty string if input is empty.\r\n * @example\r\n * capitalize('hello') // 'Hello'\r\n * capitalize('HELLO') // 'Hello'\r\n */\r\nexport const capitalize = (str: string): string =>\r\n  str ? str.charAt(0).toUpperCase() + str.slice(1).toLowerCase() : str;\r\n\r\n/**\r\n * Converts string to CONSTANT_CASE (UPPERCASE_WITH_UNDERSCORES)\r\n * @param str - String to convert\r\n * @returns CONSTANT_CASE string. Returns empty string if input contains no words.\r\n * @example\r\n * constantCase('hello world') // 'HELLO_WORLD'\r\n */\r\nexport const constantCase = (str: string): string =>\r\n  splitWordsForCase(str)\r\n    .map((w) => w.toUpperCase())\r\n    .join('_');\r\n\r\n/**\r\n * Converts string to kebab-case (lowercase-with-hyphens)\r\n * @param str - String to convert\r\n * @returns kebab-case string. Returns empty string if input contains no words.\r\n * @example\r\n * kebabCase('Hello World') // 'hello-world'\r\n */\r\nexport const kebabCase = (str: string): string =>\r\n  splitWordsForCase(str)\r\n    .map((w) => w.toLowerCase())\r\n    .join('-');\r\n\r\n/**\r\n * Converts string to lowercase with spaces\r\n * @param str - String to convert\r\n * @returns Lowercase string with words separated by spaces. Returns empty string if input contains no words.\r\n * @example\r\n * lowerCase('HelloWorld') // 'hello world'\r\n */\r\nexport const lowerCase = (str: string): string =>\r\n  splitWordsForCase(str)\r\n    .map((w) => w.toLowerCase())\r\n    .join(' ');\r\n\r\n/**\r\n * Converts first character to lowercase\r\n * @param str - String to convert\r\n * @returns String with first character lowercased. Returns empty string if input is empty.\r\n * @example\r\n * lowerFirst('Hello') // 'hello'\r\n * lowerFirst('HELLO') // 'hELLO'\r\n */\r\nexport const lowerFirst = (str: string): string =>\r\n  str ? str.charAt(0).toLowerCase() + str.slice(1) : str;\r\n\r\n/**\r\n * Converts string to PascalCase (capitalizes first letter of each word)\r\n * @param str - String to convert\r\n * @returns PascalCase string. Returns empty string if input contains no words.\r\n * @example\r\n * pascalCase('hello world') // 'HelloWorld'\r\n */\r\nexport const pascalCase = (str: string): string =>\r\n  splitWordsForCase(str).map(capitalizeWord).join('');\r\n\r\n/**\r\n * Converts string to snake_case (lowercase_with_underscores)\r\n * @param str - String to convert\r\n * @returns snake_case string. Returns empty string if input contains no words.\r\n * @example\r\n * snakeCase('Hello World') // 'hello_world'\r\n */\r\nexport const snakeCase = (str: string): string =>\r\n  splitWordsForCase(str)\r\n    .map((w) => w.toLowerCase())\r\n    .join('_');\r\n\r\n/**\r\n * Converts string to UPPERCASE WITH SPACES\r\n * @param str - String to convert\r\n * @returns Uppercase string with words separated by spaces. Returns empty string if input contains no words.\r\n * @example\r\n * upperCase('hello-world') // 'HELLO WORLD'\r\n */\r\nexport const upperCase = (str: string): string =>\r\n  splitWordsForCase(str)\r\n    .map((w) => w.toUpperCase())\r\n    .join(' ');\r\n\r\n/**\r\n * Converts first character to uppercase\r\n * @param str - String to convert\r\n * @returns String with first character uppercased. Returns empty string if input is empty.\r\n * @example\r\n * upperFirst('hello') // 'Hello'\r\n * upperFirst('hELLO') // 'HELLO'\r\n */\r\nexport const upperFirst = (str: string): string =>\r\n  str ? str.charAt(0).toUpperCase() + str.slice(1) : str;\r\n\r\n// ------ 单词提取 ------\r\n\r\n/**\r\n * Extracts words from string using Unicode-aware regex (supports all languages)\r\n * @param str - String to extract words from\r\n * @returns Array of words (Unicode letters and numbers). Returns empty array if no words found.\r\n * @example\r\n * words('Hello world!') // ['Hello', 'world']\r\n * words('你好，世界！') // ['你好', '世界']\r\n * words('123 abc') // ['123', 'abc']\r\n */\r\nexport const words = (str: string): string[] =>\r\n  str.match(UNICODE_WORD_REGEXP) || [];\r\n\r\n// ------ 随机字符串生成 ------\r\n\r\n/**\r\n * Generates a random string from the specified character set\r\n * @param length - Length of the string to generate. Must be a non-negative integer.\r\n * @param charset - Character set to use for generation. Defaults to alphanumeric (a-z, A-Z, 0-9).\r\n * @returns Randomly generated string\r\n * @throws ParameterError if length is negative or not an integer\r\n * @example\r\n * randomString(8) // 'aB3xK9pL'\r\n * randomString(6, '0123456789') // '384729'\r\n * randomString(10, 'abc') // 'abccabacba'\r\n */\r\nexport const randomString = (length: number, charset?: string): string => {\r\n  if (!Number.isInteger(length) || length < 0)\r\n    throw new ParameterError('Length must be a non-negative integer');\r\n\r\n  const chars =\r\n    charset ?? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n  if (chars.length === 0) return '';\r\n\r\n  let result = '';\r\n  for (let i = 0; i < length; i++)\r\n    result += chars.charAt(Math.floor(Math.random() * chars.length));\r\n\r\n  return result;\r\n};\r\n\r\n\r\n\r\n// ------ 模板字符串 ------\r\n\r\n/**\r\n * Replaces placeholders in template string with values from data object\r\n * @template T - Type of data object\r\n * @param str - Template string with {{placeholder}} syntax\r\n * @param data - Object containing values to replace placeholders. Supports nested paths like {{user.name}}\r\n * @returns String with placeholders replaced by corresponding values. Undefined values are replaced with empty string.\r\n * @example\r\n * template('Hello {{name}}!', {name: 'Alice'}) // 'Hello Alice!'\r\n * template('Hello {{user.name}}!', {user: {name: 'Bob'}}) // 'Hello Bob!'\r\n * template('Welcome to {{company}}!', {company: 'Tech Corp'}) // 'Welcome to Tech Corp!'\r\n */\r\nexport const template = <T extends Record<string, unknown>>(\r\n  str: string,\r\n  data: T,\r\n): string => {\r\n  return str.replace(/\\{\\{([^}]+)\\}\\}/g, (_, path: string) => {\r\n    const trimmed_path = path.trim();\r\n    const keys = trimmed_path.split('.');\r\n    let current: unknown = data;\r\n\r\n    for (const key of keys) {\r\n      if (current === null || typeof current !== 'object') {\r\n        current = undefined;\r\n        break;\r\n      }\r\n      current = (current as Record<string, unknown>)[key];\r\n    }\r\n\r\n    if (current === undefined || current === null) return '';\r\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\r\n    return String(current);\r\n  });\r\n};\r\n"],"names":["HTML_ESCAPE_MAP","HTML_UNESCAPE_MAP","HTML_ESCAPE_REGEXP","HTML_UNESCAPE_REGEXP","WORD_SPLIT_REGEXP","UNICODE_WORD_REGEXP","TRIM_START_REGEXP","TRIM_END_REGEXP","trim","str","chars","safeChars","escapeRegExp","trimStart","trimEnd","pad","length","ParameterError","strLen","totalPad","leftPad","rightPad","repeatLeft","repeatRight","deburr","escape","match","unescape","reverseString","splitWordsForCase","capitalizeWord","word","startCase","_","p1","p2","p3","p4","camelCase","words","capitalize","constantCase","w","kebabCase","lowerCase","lowerFirst","pascalCase","snakeCase","upperCase","upperFirst","randomString","charset","result","i","template","data","path","keys","current","key"],"mappings":";AAQA,MAAMA,IAA0C;AAAA,EAC9C,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AACP,GAEMC,IAA4C;AAAA,EAChD,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,SAAS;AACX,GAEMC,IAAqB,YACrBC,IAAuB,6BACvBC,IACJ,yFACIC,IAAsB,mBAEtBC,IAAoB,QACpBC,IAAkB,QAcXC,IAAO,CAACC,GAAaC,MAA2B;AAC3D,MAAIA,MAAU,OAAW,QAAOD,EAAI,KAAA;AACpC,MAAI,CAACC,EAAO,QAAOD;AAEnB,QAAME,IAAYC,EAAaF,CAAK;AACpC,SAAOD,EAAI,QAAQ,IAAI,OAAO,KAAKE,CAAS,OAAOA,CAAS,OAAO,GAAG,GAAG,EAAE;AAC7E,GAWaE,IAAY,CAACJ,GAAaC,MAA2B;AAChE,MAAIA,MAAU,OAAW,QAAOD,EAAI,QAAQH,GAAmB,EAAE;AACjE,MAAI,CAACI,EAAO,QAAOD;AAEnB,QAAME,IAAYC,EAAaF,CAAK;AACpC,SAAOD,EAAI,QAAQ,IAAI,OAAO,KAAKE,CAAS,IAAI,GAAG,EAAE;AACvD,GAWaG,IAAU,CAACL,GAAaC,MAA2B;AAC9D,MAAIA,MAAU,OAAW,QAAOD,EAAI,QAAQF,GAAiB,EAAE;AAC/D,MAAI,CAACG,EAAO,QAAOD;AAEnB,QAAME,IAAYC,EAAaF,CAAK;AACpC,SAAOD,EAAI,QAAQ,IAAI,OAAO,IAAIE,CAAS,KAAK,GAAG,EAAE;AACvD,GAeaI,IAAM,CACjBN,GACAO,GACAN,IAAgB,QACL;AACX,MAAI,CAAC,OAAO,SAASM,CAAM,KAAKA,IAAS;AACvC,UAAM,IAAIC,EAAe,6CAA6C;AAExE,QAAMC,IAAST,EAAI;AAEnB,MAAIS,KAAUF,KAAUN,EAAM,WAAW,EAAG,QAAOD;AAEnD,QAAMU,IAAWH,IAASE,GACpBE,IAAU,KAAK,MAAMD,IAAW,CAAC,GACjCE,IAAWF,IAAWC,GAEtBE,IAAaZ,EAChB,OAAO,KAAK,KAAKU,IAAUV,EAAM,MAAM,CAAC,EACxC,MAAM,GAAGU,CAAO,GACbG,IAAcb,EACjB,OAAO,KAAK,KAAKW,IAAWX,EAAM,MAAM,CAAC,EACzC,MAAM,GAAGW,CAAQ;AAEpB,SAAOC,IAAab,IAAMc;AAC5B,GAYaC,IAAS,CAACf,MACrBA,EAAI,UAAU,KAAK,EAAE,QAAQ,oBAAoB,EAAE,GASxCG,IAAe,CAACH,MAC3BA,EAAI,QAAQ,uBAAuB,MAAM,GAS9BgB,IAAS,CAAChB,MACrBA,EAAI,QAAQP,GAAoB,CAACwB,MAAU1B,EAAgB0B,CAAK,CAAC,GAStDC,IAAW,CAAClB,MACvBA,EAAI,QAAQN,GAAsB,CAACuB,MAAUzB,EAAkByB,CAAK,CAAC,GAY1DE,IAAgB,CAACnB,MAC5B,CAAC,GAAGA,CAAG,EAAE,QAAA,EAAU,KAAK,EAAE,GAGtBoB,IAAoB,CAACpB,MACNe,EAAOf,CAAG,EACX,MAAML,CAAiB,KAAK,CAAA,GAG1C0B,IAAiB,CAACC,MACtBA,KAAOA,EAAK,OAAO,CAAC,EAAE,YAAA,IAAgBA,EAAK,MAAM,CAAC,EAAE,eAYzCC,IAAY,CAACvB,MACjBoB,EAAkBpB,CAAG,EACzB,IAAIqB,CAAc,EAClB,KAAK,GAAG,EACR;AAAA,EACC;AAAA,EACA,CAACG,GAAGC,GAAIC,GAAIC,GAAIC,MAAO,GAAGH,KAAME,CAAE,IAAID,KAAME,CAAE;AAAA,EAE/C,MAAM,GAAG,EACT,IAAIP,CAAc,EAClB,KAAK,GAAG,EACR,KAAA,GAcQQ,IAAY,CAAC7B,MAAwB;AAChD,QAAM8B,IAAQV,EAAkBpB,CAAG;AACnC,SAAK8B,EAAM,SACJA,EAAM,CAAC,EAAE,YAAA,IAAgBA,EAAM,MAAM,CAAC,EAAE,IAAIT,CAAc,EAAE,KAAK,EAAE,IADhD;AAE5B,GAUaU,IAAa,CAAC/B,MACzBA,KAAMA,EAAI,OAAO,CAAC,EAAE,YAAA,IAAgBA,EAAI,MAAM,CAAC,EAAE,eAStCgC,IAAe,CAAChC,MAC3BoB,EAAkBpB,CAAG,EAClB,IAAI,CAACiC,MAAMA,EAAE,aAAa,EAC1B,KAAK,GAAG,GASAC,IAAY,CAAClC,MACxBoB,EAAkBpB,CAAG,EAClB,IAAI,CAACiC,MAAMA,EAAE,aAAa,EAC1B,KAAK,GAAG,GASAE,IAAY,CAACnC,MACxBoB,EAAkBpB,CAAG,EAClB,IAAI,CAACiC,MAAMA,EAAE,aAAa,EAC1B,KAAK,GAAG,GAUAG,IAAa,CAACpC,MACzBA,KAAMA,EAAI,OAAO,CAAC,EAAE,YAAA,IAAgBA,EAAI,MAAM,CAAC,GASpCqC,IAAa,CAACrC,MACzBoB,EAAkBpB,CAAG,EAAE,IAAIqB,CAAc,EAAE,KAAK,EAAE,GASvCiB,IAAY,CAACtC,MACxBoB,EAAkBpB,CAAG,EAClB,IAAI,CAACiC,MAAMA,EAAE,aAAa,EAC1B,KAAK,GAAG,GASAM,IAAY,CAACvC,MACxBoB,EAAkBpB,CAAG,EAClB,IAAI,CAACiC,MAAMA,EAAE,aAAa,EAC1B,KAAK,GAAG,GAUAO,IAAa,CAACxC,MACzBA,KAAMA,EAAI,OAAO,CAAC,EAAE,YAAA,IAAgBA,EAAI,MAAM,CAAC,GAapC8B,IAAQ,CAAC9B,MACpBA,EAAI,MAAMJ,CAAmB,KAAK,CAAA,GAevB6C,IAAe,CAAClC,GAAgBmC,MAA6B;AACxE,MAAI,CAAC,OAAO,UAAUnC,CAAM,KAAKA,IAAS;AACxC,UAAM,IAAIC,EAAe,uCAAuC;AAElE,QAAMP,IACJyC,KAAW;AACb,MAAIzC,EAAM,WAAW,EAAG,QAAO;AAE/B,MAAI0C,IAAS;AACb,WAASC,IAAI,GAAGA,IAAIrC,GAAQqC;AAC1B,IAAAD,KAAU1C,EAAM,OAAO,KAAK,MAAM,KAAK,OAAA,IAAWA,EAAM,MAAM,CAAC;AAEjE,SAAO0C;AACT,GAiBaE,IAAW,CACtB7C,GACA8C,MAEO9C,EAAI,QAAQ,oBAAoB,CAACwB,GAAGuB,MAAiB;AAE1D,QAAMC,IADeD,EAAK,KAAA,EACA,MAAM,GAAG;AACnC,MAAIE,IAAmBH;AAEvB,aAAWI,KAAOF,GAAM;AACtB,QAAIC,MAAY,QAAQ,OAAOA,KAAY,UAAU;AACnD,MAAAA,IAAU;AACV;AAAA,IACF;AACA,IAAAA,IAAWA,EAAoCC,CAAG;AAAA,EACpD;AAEA,SAA6BD,KAAY,OAAa,KAE/C,OAAOA,CAAO;AACvB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/subpath/TxScope.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../chunks/types-B7X_LBjM.cjs"),c=require("../chunks/Errors-BWEYu-AB.cjs"),t=Symbol("Data"),a=Symbol("Cleanup");class l{[t];[a];constructor(s,o){this[t]=s,this[a]=o}static open(s,o){return new l(s,o)}[Symbol.dispose](){this[t]!==r.NONE&&(this[a]&&this[a](this[t]),this[t]=r.NONE)}}function p(e,s){if(e[t]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");return s(e[t])}function d(e,s){if(e[t]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");return s(e[t]),e}function f(e){return e[Symbol.dispose](),e}function h(e,s){if(e[t]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");try{s(e[t])}finally{e[Symbol.dispose]()}return e}function w(e,s,o){const i=e;return i[t]=s,i[a]=o,i}const n=Symbol("Data"),y=Symbol("Cleanup");class u{[n];[y];constructor(s,o){this[n]=s,this[y]=o}static open(s,o){return new u(s,o)}async[Symbol.asyncDispose](){this[n]!==r.NONE&&(this[y]&&await this[y](this[n]),this[n]=r.NONE)}}async function N(e,s){if(e[n]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");return await s(e[n])}async function A(e,s){if(e[n]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");return await s(e[n]),e}async function E(e){return await e[Symbol.asyncDispose](),e}async function S(e,s){if(e[n]===r.NONE)throw new c.UseAfterFreeError("Resource already disposed.");try{await s(e[n])}finally{await e[Symbol.asyncDispose]()}return e}function b(e,s,o){const i=e;return i[n]=s,i[y]=o,i}const _=Object.freeze(Object.defineProperty({__proto__:null,Resource:l,ResourceAsync:u,close:f,closeAsync:E,dispose:h,disposeAsync:S,exec:d,execAsync:A,reopen:w,reopenAsync:b,use:p,useAsync:N},Symbol.toStringTag,{value:"Module"}));exports.Resource=l;exports.ResourceAsync=u;exports.__exportTxScope__=_;exports.close=f;exports.closeAsync=E;exports.dispose=h;exports.disposeAsync=S;exports.exec=d;exports.execAsync=A;exports.reopen=w;exports.reopenAsync=b;exports.use=p;exports.useAsync=N;
+//# sourceMappingURL=TxScope.cjs.map

package/dist/subpath/TxScope.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TxScope.cjs","sources":["../../src/Resource/resource.ts","../../src/Resource/resource-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Resource/resource.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateClosed,\r\n  type NoneType,\r\n  type Cleaner,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\n\r\n/**\r\n * Synchronous resource management class.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam S - The state type (opened or closed)\r\n */\r\nexport class Resource<T, S extends StateOpened | StateClosed> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: Cleaner<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(data: T, cleanup_fn?: Cleaner<T>) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened synchronous resource.\r\n   * @typeParam D - The type of the resource data\r\n   * @param data - The resource data\r\n   * @param cleaner - Optional synchronous cleanup function\r\n   * @returns A new opened synchronous resource\r\n   */\r\n  static open<D>(data: D, cleaner?: Cleaner<D>): Resource<D, StateOpened> {\r\n    return new Resource(data, cleaner);\r\n  }\r\n\r\n  /**\r\n   * Synchronously disposes the resource (cleanup).\r\n   */\r\n  [Symbol.dispose](this: Resource<T, StateOpened>): void {\r\n    if (this[_data] === NONE) {\r\n      // 让清理具备幂等性，不会双重释放。这是为了避免被using修饰的资源被手动close之后资源被using再次尝试清理 -> 触发双重释放\r\n      return;\r\n    }\r\n    if (this[_cleanup]) {\r\n      this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for synchronous resource states.\r\n * @typeParam T - The type of the resource data\r\n */\r\nexport type ResType<T> = Resource<T, StateOpened> | Resource<T, StateClosed>;\r\n\r\n/**\r\n * Uses a synchronous resource with a callback function.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the callback\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Function to process the resource data\r\n * @returns The result of the callback\r\n * @throws Error if resource is already disposed\r\n */\r\nexport function use<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): R {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return fn(resource[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on a synchronous resource and returns the resource.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the side effect function\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Side effect function to execute\r\n * @returns The same resource after executing the side effect\r\n * @throws Error if resource is already disposed\r\n */\r\nexport function exec<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): Resource<T, StateOpened> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  fn(resource[_data] as T);\r\n  return resource;\r\n}\r\n\r\n/**\r\n * Closes a synchronous resource (disposes it).\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The opened synchronous resource to close\r\n * @returns The closed synchronous resource\r\n */\r\nexport function close<T>(\r\n  resource: Resource<T, StateOpened>,\r\n): Resource<T, StateClosed> {\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as Resource<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Executes a function on the resource and then closes it,\r\n * guaranteeing cleanup even if the function throws.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the function\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Function to execute before closing\r\n * @returns The closed synchronous resource\r\n */\r\nexport function dispose<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): Resource<T, StateClosed> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  try {\r\n    fn(resource[_data] as T);\r\n  } finally {\r\n    resource[Symbol.dispose]();\r\n  }\r\n  return resource as unknown as Resource<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Reopens a closed synchronous resource with new data.\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The closed synchronous resource\r\n * @param data - New data for the resource\r\n * @param cleaner - Optional new cleanup function\r\n * @returns The reopened synchronous resource\r\n */\r\nexport function reopen<T>(\r\n  resource: Resource<T, StateClosed>,\r\n  data: T,\r\n  cleaner?: Cleaner<T>,\r\n): Resource<T, StateOpened> {\r\n  const r = resource as unknown as Resource<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  return r;\r\n}\r\n","// ========================================\r\n// ./src/Resource/resource-async.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateClosed,\r\n  type AnyCleaner,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\n\r\n/**\r\n * Asynchronous resource management class.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam S - The state type (opened or closed)\r\n */\r\nexport class ResourceAsync<T, S extends StateOpened | StateClosed> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: AnyCleaner<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(data: T, async_cleanup_fn?: AnyCleaner<T>) {\r\n    this[_data] = data;\r\n    this[_cleanup] = async_cleanup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened asynchronous resource.\r\n   * @typeParam D - The type of the resource data\r\n   * @param data - The resource data\r\n   * @param cleaner - Optional asynchronous cleanup function\r\n   * @returns A new opened asynchronous resource\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: AnyCleaner<D>,\r\n  ): ResourceAsync<D, StateOpened> {\r\n    return new ResourceAsync(data, cleaner);\r\n  }\r\n\r\n  /**\r\n   * Asynchronously disposes the resource (cleanup).\r\n   * @returns Promise that resolves when disposal is complete\r\n   */\r\n  async [Symbol.asyncDispose](\r\n    this: ResourceAsync<T, StateOpened>,\r\n  ): Promise<void> {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    if (this[_cleanup]) {\r\n      await this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for asynchronous resource states.\r\n * @typeParam T - The type of the resource data\r\n */\r\nexport type ResAsyncType<T> =\r\n  | ResourceAsync<T, StateOpened>\r\n  | ResourceAsync<T, StateClosed>;\r\n\r\n/**\r\n * Uses an asynchronous resource with a callback function.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the callback\r\n * @param resource - The opened asynchronous resource\r\n * @param callback - Function to process the resource data\r\n * @returns Promise with the result of the callback\r\n * @throws Error if resource is already disposed\r\n */\r\nexport async function useAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  callback: (data: T) => Promise<R> | R,\r\n): Promise<R> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return await callback(resource[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on an asynchronous resource and returns the resource.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the side effect function\r\n * @param resource - The opened asynchronous resource\r\n * @param fn - Side effect function to execute\r\n * @returns The same resource after executing the side effect\r\n * @throws Error if resource is already disposed\r\n */\r\nexport async function execAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<ResourceAsync<T, StateOpened>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  await fn(resource[_data] as T);\r\n  return resource;\r\n}\r\n\r\n/**\r\n * Closes an asynchronous resource (disposes it).\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The opened asynchronous resource to close\r\n * @returns The closed asynchronous resource\r\n */\r\nexport async function closeAsync<T>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n): Promise<ResourceAsync<T, StateClosed>> {\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as ResourceAsync<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Executes an asynchronous or synchronous function on the resource and then closes it,\r\n * guaranteeing asynchronous cleanup even if the function throws.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the function\r\n * @param resource - The opened asynchronous resource\r\n * @param fn - Asynchronous or synchronous function to execute before closing\r\n * @returns A promise that resolves to the closed asynchronous resource\r\n */\r\nexport async function disposeAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<ResourceAsync<T, StateClosed>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  try {\r\n    await fn(resource[_data] as T);\r\n  } finally {\r\n    await resource[Symbol.asyncDispose]();\r\n  }\r\n  return resource as unknown as ResourceAsync<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Reopens a closed asynchronous resource with new data.\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The closed asynchronous resource\r\n * @param data - New data for the resource\r\n * @param cleaner - Optional new cleanup function\r\n * @returns The reopened asynchronous resource\r\n */\r\nexport function reopenAsync<T>(\r\n  resource: ResourceAsync<T, StateClosed>,\r\n  data: T,\r\n  cleaner?: AnyCleaner<T>,\r\n): ResourceAsync<T, StateOpened> {\r\n  const r = resource as unknown as ResourceAsync<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  return r;\r\n}\r\n"],"names":["_data","_cleanup","Resource","data","cleanup_fn","cleaner","NONE","use","resource","fn","UseAfterFreeError","exec","close","dispose","reopen","r","ResourceAsync","async_cleanup_fn","useAsync","callback","execAsync","closeAsync","disposeAsync","reopenAsync"],"mappings":"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"}

package/dist/subpath/TxScope.mjs

@@ -0,0 +1,138 @@
+import { N as e } from "../chunks/types-DE2SnSbz.mjs";
+import { U as r } from "../chunks/Errors-DwUAvFIF.mjs";
+const s = Symbol("Data"), c = Symbol("Cleanup");
+class l {
+  [s];
+  [c];
+  // ------ 构造函数 ------
+  constructor(n, i) {
+    this[s] = n, this[c] = i;
+  }
+  /**
+   * Creates a new opened synchronous resource.
+   * @typeParam D - The type of the resource data
+   * @param data - The resource data
+   * @param cleaner - Optional synchronous cleanup function
+   * @returns A new opened synchronous resource
+   */
+  static open(n, i) {
+    return new l(n, i);
+  }
+  /**
+   * Synchronously disposes the resource (cleanup).
+   */
+  [Symbol.dispose]() {
+    this[s] !== e && (this[c] && this[c](this[s]), this[s] = e);
+  }
+}
+function d(t, n) {
+  if (t[s] === e)
+    throw new r("Resource already disposed.");
+  return n(t[s]);
+}
+function f(t, n) {
+  if (t[s] === e)
+    throw new r("Resource already disposed.");
+  return n(t[s]), t;
+}
+function u(t) {
+  return t[Symbol.dispose](), t;
+}
+function h(t, n) {
+  if (t[s] === e)
+    throw new r("Resource already disposed.");
+  try {
+    n(t[s]);
+  } finally {
+    t[Symbol.dispose]();
+  }
+  return t;
+}
+function w(t, n, i) {
+  const a = t;
+  return a[s] = n, a[c] = i, a;
+}
+const o = Symbol("Data"), y = Symbol("Cleanup");
+class p {
+  [o];
+  [y];
+  // ------ 构造函数 ------
+  constructor(n, i) {
+    this[o] = n, this[y] = i;
+  }
+  /**
+   * Creates a new opened asynchronous resource.
+   * @typeParam D - The type of the resource data
+   * @param data - The resource data
+   * @param cleaner - Optional asynchronous cleanup function
+   * @returns A new opened asynchronous resource
+   */
+  static open(n, i) {
+    return new p(n, i);
+  }
+  /**
+   * Asynchronously disposes the resource (cleanup).
+   * @returns Promise that resolves when disposal is complete
+   */
+  async [Symbol.asyncDispose]() {
+    this[o] !== e && (this[y] && await this[y](this[o]), this[o] = e);
+  }
+}
+async function m(t, n) {
+  if (t[o] === e)
+    throw new r("Resource already disposed.");
+  return await n(t[o]);
+}
+async function b(t, n) {
+  if (t[o] === e)
+    throw new r("Resource already disposed.");
+  return await n(t[o]), t;
+}
+async function S(t) {
+  return await t[Symbol.asyncDispose](), t;
+}
+async function _(t, n) {
+  if (t[o] === e)
+    throw new r("Resource already disposed.");
+  try {
+    await n(t[o]);
+  } finally {
+    await t[Symbol.asyncDispose]();
+  }
+  return t;
+}
+function A(t, n, i) {
+  const a = t;
+  return a[o] = n, a[y] = i, a;
+}
+const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Resource: l,
+  ResourceAsync: p,
+  close: u,
+  closeAsync: S,
+  dispose: h,
+  disposeAsync: _,
+  exec: f,
+  execAsync: b,
+  reopen: w,
+  reopenAsync: A,
+  use: d,
+  useAsync: m
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as Resource,
+  p as ResourceAsync,
+  D as _,
+  u as close,
+  S as closeAsync,
+  h as dispose,
+  _ as disposeAsync,
+  f as exec,
+  b as execAsync,
+  w as reopen,
+  A as reopenAsync,
+  d as use,
+  m as useAsync
+};
+//# sourceMappingURL=TxScope.mjs.map

package/dist/subpath/TxScope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TxScope.mjs","sources":["../../src/Resource/resource.ts","../../src/Resource/resource-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Resource/resource.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateClosed,\r\n  type NoneType,\r\n  type Cleaner,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\n\r\n/**\r\n * Synchronous resource management class.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam S - The state type (opened or closed)\r\n */\r\nexport class Resource<T, S extends StateOpened | StateClosed> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: Cleaner<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(data: T, cleanup_fn?: Cleaner<T>) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened synchronous resource.\r\n   * @typeParam D - The type of the resource data\r\n   * @param data - The resource data\r\n   * @param cleaner - Optional synchronous cleanup function\r\n   * @returns A new opened synchronous resource\r\n   */\r\n  static open<D>(data: D, cleaner?: Cleaner<D>): Resource<D, StateOpened> {\r\n    return new Resource(data, cleaner);\r\n  }\r\n\r\n  /**\r\n   * Synchronously disposes the resource (cleanup).\r\n   */\r\n  [Symbol.dispose](this: Resource<T, StateOpened>): void {\r\n    if (this[_data] === NONE) {\r\n      // 让清理具备幂等性，不会双重释放。这是为了避免被using修饰的资源被手动close之后资源被using再次尝试清理 -> 触发双重释放\r\n      return;\r\n    }\r\n    if (this[_cleanup]) {\r\n      this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for synchronous resource states.\r\n * @typeParam T - The type of the resource data\r\n */\r\nexport type ResType<T> = Resource<T, StateOpened> | Resource<T, StateClosed>;\r\n\r\n/**\r\n * Uses a synchronous resource with a callback function.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the callback\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Function to process the resource data\r\n * @returns The result of the callback\r\n * @throws Error if resource is already disposed\r\n */\r\nexport function use<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): R {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return fn(resource[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on a synchronous resource and returns the resource.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the side effect function\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Side effect function to execute\r\n * @returns The same resource after executing the side effect\r\n * @throws Error if resource is already disposed\r\n */\r\nexport function exec<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): Resource<T, StateOpened> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  fn(resource[_data] as T);\r\n  return resource;\r\n}\r\n\r\n/**\r\n * Closes a synchronous resource (disposes it).\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The opened synchronous resource to close\r\n * @returns The closed synchronous resource\r\n */\r\nexport function close<T>(\r\n  resource: Resource<T, StateOpened>,\r\n): Resource<T, StateClosed> {\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as Resource<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Executes a function on the resource and then closes it,\r\n * guaranteeing cleanup even if the function throws.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the function\r\n * @param resource - The opened synchronous resource\r\n * @param fn - Function to execute before closing\r\n * @returns The closed synchronous resource\r\n */\r\nexport function dispose<T, R>(\r\n  resource: Resource<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): Resource<T, StateClosed> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  try {\r\n    fn(resource[_data] as T);\r\n  } finally {\r\n    resource[Symbol.dispose]();\r\n  }\r\n  return resource as unknown as Resource<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Reopens a closed synchronous resource with new data.\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The closed synchronous resource\r\n * @param data - New data for the resource\r\n * @param cleaner - Optional new cleanup function\r\n * @returns The reopened synchronous resource\r\n */\r\nexport function reopen<T>(\r\n  resource: Resource<T, StateClosed>,\r\n  data: T,\r\n  cleaner?: Cleaner<T>,\r\n): Resource<T, StateOpened> {\r\n  const r = resource as unknown as Resource<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  return r;\r\n}\r\n","// ========================================\r\n// ./src/Resource/resource-async.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateClosed,\r\n  type AnyCleaner,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\n\r\n/**\r\n * Asynchronous resource management class.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam S - The state type (opened or closed)\r\n */\r\nexport class ResourceAsync<T, S extends StateOpened | StateClosed> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: AnyCleaner<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(data: T, async_cleanup_fn?: AnyCleaner<T>) {\r\n    this[_data] = data;\r\n    this[_cleanup] = async_cleanup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened asynchronous resource.\r\n   * @typeParam D - The type of the resource data\r\n   * @param data - The resource data\r\n   * @param cleaner - Optional asynchronous cleanup function\r\n   * @returns A new opened asynchronous resource\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: AnyCleaner<D>,\r\n  ): ResourceAsync<D, StateOpened> {\r\n    return new ResourceAsync(data, cleaner);\r\n  }\r\n\r\n  /**\r\n   * Asynchronously disposes the resource (cleanup).\r\n   * @returns Promise that resolves when disposal is complete\r\n   */\r\n  async [Symbol.asyncDispose](\r\n    this: ResourceAsync<T, StateOpened>,\r\n  ): Promise<void> {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    if (this[_cleanup]) {\r\n      await this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for asynchronous resource states.\r\n * @typeParam T - The type of the resource data\r\n */\r\nexport type ResAsyncType<T> =\r\n  | ResourceAsync<T, StateOpened>\r\n  | ResourceAsync<T, StateClosed>;\r\n\r\n/**\r\n * Uses an asynchronous resource with a callback function.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the callback\r\n * @param resource - The opened asynchronous resource\r\n * @param callback - Function to process the resource data\r\n * @returns Promise with the result of the callback\r\n * @throws Error if resource is already disposed\r\n */\r\nexport async function useAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  callback: (data: T) => Promise<R> | R,\r\n): Promise<R> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return await callback(resource[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on an asynchronous resource and returns the resource.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the side effect function\r\n * @param resource - The opened asynchronous resource\r\n * @param fn - Side effect function to execute\r\n * @returns The same resource after executing the side effect\r\n * @throws Error if resource is already disposed\r\n */\r\nexport async function execAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<ResourceAsync<T, StateOpened>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  await fn(resource[_data] as T);\r\n  return resource;\r\n}\r\n\r\n/**\r\n * Closes an asynchronous resource (disposes it).\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The opened asynchronous resource to close\r\n * @returns The closed asynchronous resource\r\n */\r\nexport async function closeAsync<T>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n): Promise<ResourceAsync<T, StateClosed>> {\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as ResourceAsync<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Executes an asynchronous or synchronous function on the resource and then closes it,\r\n * guaranteeing asynchronous cleanup even if the function throws.\r\n * @typeParam T - The type of the resource data\r\n * @typeParam R - The return type of the function\r\n * @param resource - The opened asynchronous resource\r\n * @param fn - Asynchronous or synchronous function to execute before closing\r\n * @returns A promise that resolves to the closed asynchronous resource\r\n */\r\nexport async function disposeAsync<T, R>(\r\n  resource: ResourceAsync<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<ResourceAsync<T, StateClosed>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  try {\r\n    await fn(resource[_data] as T);\r\n  } finally {\r\n    await resource[Symbol.asyncDispose]();\r\n  }\r\n  return resource as unknown as ResourceAsync<T, StateClosed>;\r\n}\r\n\r\n/**\r\n * Reopens a closed asynchronous resource with new data.\r\n * @typeParam T - The type of the resource data\r\n * @param resource - The closed asynchronous resource\r\n * @param data - New data for the resource\r\n * @param cleaner - Optional new cleanup function\r\n * @returns The reopened asynchronous resource\r\n */\r\nexport function reopenAsync<T>(\r\n  resource: ResourceAsync<T, StateClosed>,\r\n  data: T,\r\n  cleaner?: AnyCleaner<T>,\r\n): ResourceAsync<T, StateOpened> {\r\n  const r = resource as unknown as ResourceAsync<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  return r;\r\n}\r\n"],"names":["_data","_cleanup","Resource","data","cleanup_fn","cleaner","NONE","use","resource","fn","UseAfterFreeError","exec","close","dispose","reopen","r","ResourceAsync","async_cleanup_fn","useAsync","callback","execAsync","closeAsync","disposeAsync","reopenAsync"],"mappings":"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"}

package/dist/subpath/TypeTool.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=e=>e,c=e=>{},s=()=>e=>{};exports.castErr=t;exports.expectAssignable=c;exports.expectIdentical=s;
+//# sourceMappingURL=TypeTool.cjs.map

package/dist/subpath/TypeTool.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeTool.cjs","sources":["../../src/Utils/type-tool.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* v8 ignore file -- @preserve */\n\n/**\n * Represents a value that can be either a plain value or a Promise-like object.\n * @template T - The type of the value or Promise-like object.\n */\nexport type MaybePromise<T> = T | PromiseLike<T>;\n\n/**\n * Creates a deeply partial type where all properties become optional recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type PartialDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {[K in keyof T]?: PartialDeep<T[K]>}\n    : T;\n\n/**\n * Creates a deeply required type where all properties become non-optional recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type RequiredDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {[K in keyof T]-?: RequiredDeep<T[K]>}\n    : T;\n\n/**\n * Creates a deeply readonly type where all properties become immutable recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type ReadonlyDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {readonly [K in keyof T]: ReadonlyDeep<T[K]>}\n    : T;\n\n/**\n * Removes readonly modifiers from all properties at the first level only.\n * @template T - The source type\n */\nexport type Mutable<T> = {-readonly [P in keyof T]: T[P]};\n\n/**\n * Removes readonly modifiers from all properties recursively.\n * @template T - The source type\n * @remarks This affects nested objects as well.\n */\nexport type MutableDeep<T> = {\n  -readonly [K in keyof T]: T[K] extends object ? MutableDeep<T[K]> : T[K];\n};\n\n/**\n * Makes specific properties required while keeping others unchanged.\n * @template T - The source type\n * @template K - Keys of properties to make required\n */\nexport type SetRequired<T, K extends keyof T> = {\n  [P in keyof T as P extends K ? never : P]: T[P];\n} & {\n  [P in K]-?: T[P];\n} extends infer O\n  ? {[P in keyof O]: O[P]}\n  : never;\n\n/**\n * Makes specific properties optional while keeping others unchanged.\n * @template T - The source type\n * @template K - Keys of properties to make optional\n */\nexport type SetOptional<T, K extends keyof T> = {\n  [P in keyof T as P extends K ? never : P]: T[P];\n} & {\n  [P in K]?: T[P];\n} extends infer O\n  ? {[P in keyof O]: O[P]}\n  : never;\n\n/**\n * Creates a union type that includes literal values plus a base type.\n * @template Literal - The literal type(s) to include\n * @template Base - The base string or number type\n * @remarks Useful for allowing string literals while also accepting any string.\n */\nexport type LiteralUnion<Literal, Base extends string | number> =\n  | Literal\n  | (Base & Record<never, never>);\n\n/**\n * Flattens type intersections for better IntelliSense display.\n * @template T - The type to prettify\n * @remarks This doesn't change the type, only its display in IDEs.\n */\nexport type Prettify<T> = {[K in keyof T]: T[K]} & {};\n\n/**\n * Extracts the resolved return type of an async function.\n * @template T - The async function type\n * @remarks Unwraps Promise to get the actual return type.\n */\nexport type AsyncReturnType<T extends (...args: any) => any> = Awaited<\n  ReturnType<T>\n>;\n\n/**\n * Checks if a type is the `any` type.\n * @template T - The type to check\n * @returns `true` if T is `any`, otherwise `false`\n */\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Checks if a type is exactly `undefined`.\n * @template T - The type to check\n * @returns `true` if T is `undefined`, otherwise `false`\n * @remarks Note: This distinguishes `undefined` from optional properties.\n */\nexport type IsUndefined<T> = [T] extends [undefined] ? true : false;\n\n/**\n * Checks if a type is the `never` type.\n * @template T - The type to check\n * @returns `true` if T is `never`, otherwise `false`\n */\nexport type IsNever<T> = [T] extends [never] ? true : false;\n\n/**\n * Checks if a type is the `unknown` type.\n * @template T - The type to check\n * @returns `true` if T is `unknown`, otherwise `false`\n * @remarks Note: Returns `false` for `any` type.\n */\nexport type IsUnknown<T> = unknown extends T\n  ? IsAny<T> extends true\n    ? false\n    : true\n  : false;\n\n/**\n * Transforms a union type into an intersection type.\n * @template U - The union type to transform\n * @example UnionToIntersection<{a:1}|{b:2}> becomes {a:1}&{b:2}\n */\nexport type UnionToIntersection<U> = (\n  U extends any ? (k: U) => void : never\n) extends (k: infer I) => void\n  ? I\n  : never;\n\n/**\n * Represents valid JSON value types.\n * @remarks This is a recursive definition allowing nested structures.\n */\nexport type JSONValue =\n  | string\n  | number\n  | boolean\n  | null\n  | {[key: string]: JSONValue}\n  | JSONValue[];\n\n/**\n * Casts an unknown value to Error type.\n * @param e - The value to cast\n * @returns The casted Error value\n */\nexport const castErr = (e: unknown) => e as Error;\n\n/**\n * Asserts that one type is assignable to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value assignable to T\n */\nexport const expectAssignable = <T>(_: T): void => {};\n\n/**\n * Asserts that one type is identical to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value identical to T\n */\nexport type Equals<X, Y> =\n  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2\n    ? true\n    : false;\n\n/**\n * Asserts that one type is identical to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value identical to T\n *\n * @example\n * ```ts\n * type A = { x: number };\n * type B = { x: number };\n * type C = { x: string };\n *\n * expectIdentical<A>()({} as B); // OK: A and B are identical\n * expectIdentical<A>()({} as C); // Error: C is not assignable to never\n * ```\n */\nexport const expectIdentical =\n  <T>() =>\n  <U extends T>(_value: Equals<T, U> extends true ? U : never): void => {};\n"],"names":["castErr","expectAssignable","_","expectIdentical","_value"],"mappings":"gFA2KO,MAAMA,EAAW,GAAe,EAS1BC,EAAuBC,GAAe,CAAC,EA+BvCC,EACX,IACcC,GAAwD,CAAC"}

package/dist/subpath/TypeTool.mjs

@@ -0,0 +1,9 @@
+const t = (e) => e, c = (e) => {
+}, s = () => (e) => {
+};
+export {
+  t as castErr,
+  c as expectAssignable,
+  s as expectIdentical
+};
+//# sourceMappingURL=TypeTool.mjs.map

package/dist/subpath/TypeTool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeTool.mjs","sources":["../../src/Utils/type-tool.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* v8 ignore file -- @preserve */\n\n/**\n * Represents a value that can be either a plain value or a Promise-like object.\n * @template T - The type of the value or Promise-like object.\n */\nexport type MaybePromise<T> = T | PromiseLike<T>;\n\n/**\n * Creates a deeply partial type where all properties become optional recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type PartialDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {[K in keyof T]?: PartialDeep<T[K]>}\n    : T;\n\n/**\n * Creates a deeply required type where all properties become non-optional recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type RequiredDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {[K in keyof T]-?: RequiredDeep<T[K]>}\n    : T;\n\n/**\n * Creates a deeply readonly type where all properties become immutable recursively.\n * @template T - The source type\n * @remarks Functions are left untouched (preserved as-is).\n */\nexport type ReadonlyDeep<T> = T extends (...args: any[]) => any\n  ? T\n  : T extends object\n    ? {readonly [K in keyof T]: ReadonlyDeep<T[K]>}\n    : T;\n\n/**\n * Removes readonly modifiers from all properties at the first level only.\n * @template T - The source type\n */\nexport type Mutable<T> = {-readonly [P in keyof T]: T[P]};\n\n/**\n * Removes readonly modifiers from all properties recursively.\n * @template T - The source type\n * @remarks This affects nested objects as well.\n */\nexport type MutableDeep<T> = {\n  -readonly [K in keyof T]: T[K] extends object ? MutableDeep<T[K]> : T[K];\n};\n\n/**\n * Makes specific properties required while keeping others unchanged.\n * @template T - The source type\n * @template K - Keys of properties to make required\n */\nexport type SetRequired<T, K extends keyof T> = {\n  [P in keyof T as P extends K ? never : P]: T[P];\n} & {\n  [P in K]-?: T[P];\n} extends infer O\n  ? {[P in keyof O]: O[P]}\n  : never;\n\n/**\n * Makes specific properties optional while keeping others unchanged.\n * @template T - The source type\n * @template K - Keys of properties to make optional\n */\nexport type SetOptional<T, K extends keyof T> = {\n  [P in keyof T as P extends K ? never : P]: T[P];\n} & {\n  [P in K]?: T[P];\n} extends infer O\n  ? {[P in keyof O]: O[P]}\n  : never;\n\n/**\n * Creates a union type that includes literal values plus a base type.\n * @template Literal - The literal type(s) to include\n * @template Base - The base string or number type\n * @remarks Useful for allowing string literals while also accepting any string.\n */\nexport type LiteralUnion<Literal, Base extends string | number> =\n  | Literal\n  | (Base & Record<never, never>);\n\n/**\n * Flattens type intersections for better IntelliSense display.\n * @template T - The type to prettify\n * @remarks This doesn't change the type, only its display in IDEs.\n */\nexport type Prettify<T> = {[K in keyof T]: T[K]} & {};\n\n/**\n * Extracts the resolved return type of an async function.\n * @template T - The async function type\n * @remarks Unwraps Promise to get the actual return type.\n */\nexport type AsyncReturnType<T extends (...args: any) => any> = Awaited<\n  ReturnType<T>\n>;\n\n/**\n * Checks if a type is the `any` type.\n * @template T - The type to check\n * @returns `true` if T is `any`, otherwise `false`\n */\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Checks if a type is exactly `undefined`.\n * @template T - The type to check\n * @returns `true` if T is `undefined`, otherwise `false`\n * @remarks Note: This distinguishes `undefined` from optional properties.\n */\nexport type IsUndefined<T> = [T] extends [undefined] ? true : false;\n\n/**\n * Checks if a type is the `never` type.\n * @template T - The type to check\n * @returns `true` if T is `never`, otherwise `false`\n */\nexport type IsNever<T> = [T] extends [never] ? true : false;\n\n/**\n * Checks if a type is the `unknown` type.\n * @template T - The type to check\n * @returns `true` if T is `unknown`, otherwise `false`\n * @remarks Note: Returns `false` for `any` type.\n */\nexport type IsUnknown<T> = unknown extends T\n  ? IsAny<T> extends true\n    ? false\n    : true\n  : false;\n\n/**\n * Transforms a union type into an intersection type.\n * @template U - The union type to transform\n * @example UnionToIntersection<{a:1}|{b:2}> becomes {a:1}&{b:2}\n */\nexport type UnionToIntersection<U> = (\n  U extends any ? (k: U) => void : never\n) extends (k: infer I) => void\n  ? I\n  : never;\n\n/**\n * Represents valid JSON value types.\n * @remarks This is a recursive definition allowing nested structures.\n */\nexport type JSONValue =\n  | string\n  | number\n  | boolean\n  | null\n  | {[key: string]: JSONValue}\n  | JSONValue[];\n\n/**\n * Casts an unknown value to Error type.\n * @param e - The value to cast\n * @returns The casted Error value\n */\nexport const castErr = (e: unknown) => e as Error;\n\n/**\n * Asserts that one type is assignable to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value assignable to T\n */\nexport const expectAssignable = <T>(_: T): void => {};\n\n/**\n * Asserts that one type is identical to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value identical to T\n */\nexport type Equals<X, Y> =\n  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2\n    ? true\n    : false;\n\n/**\n * Asserts that one type is identical to another.\n * @template T - The source type\n * @template U - The target type\n * @param _value - The value to use for type inference\n * @returns A function that expects a value identical to T\n *\n * @example\n * ```ts\n * type A = { x: number };\n * type B = { x: number };\n * type C = { x: string };\n *\n * expectIdentical<A>()({} as B); // OK: A and B are identical\n * expectIdentical<A>()({} as C); // Error: C is not assignable to never\n * ```\n */\nexport const expectIdentical =\n  <T>() =>\n  <U extends T>(_value: Equals<T, U> extends true ? U : never): void => {};\n"],"names":["castErr","expectAssignable","_","expectIdentical","_value"],"mappings":"AA2KO,MAAMA,IAAU,CAAC,MAAe,GAS1BC,IAAmB,CAAIC,MAAe;AAAC,GA+BvCC,IACX,MACA,CAAcC,MAAwD;AAAC;"}

package/dist/subpath/Utils.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const tt=require("./Arr.cjs"),L=require("./Str.cjs"),et=require("./Sets.cjs"),rt=require("./Maps.cjs"),p=require("../chunks/Math-CWZVxSF-.cjs"),A=require("../chunks/helper-tsqZMRHW.cjs"),m=require("../chunks/base-r6kn0B0D.cjs"),S=require("../chunks/Errors-BWEYu-AB.cjs");function x(t,e){let r=t;for(const n of e)r=n(r);return r}function F(t,e){let r=t;for(let n=0;n<e.length;n++)if(r=e[n](r),A.isPromiseLike(r))return(async()=>{let o=await r;for(let i=n+1;i<e.length;i++)o=e[i](o),A.isPromiseLike(o)&&(o=await o);return o})();return r}function nt(t,...e){return x(t,e)}function st(...t){return t.length===0?m.identity:(...e)=>{const r=t[0](...e),n=t.slice(1);return x(r,n)}}function it(t,...e){return F(t,e)}function ot(...t){return t.length===0?m.identity:(...e)=>{const r=t[0](...e),n=t.slice(1);return A.isPromiseLike(r)?(async()=>{const o=await r;return F(o,n)})():F(r,n)}}const O=Symbol("Curry placeholder");function ct(t,e){if(e<=0||!Number.isInteger(e))throw new S.ParameterError(`Invalid length: Expected a positive integer, but received ${e}.`);const r=(n,o)=>(...i)=>{const a=[...n];let[l,c]=[0,o];for(let s=0;s<a.length&&l<i.length;s++)a[s]===O&&i[l]!==O?(a[s]=i[l++],c--):a[s]===O&&i[l]===O&&l++;for(;l<i.length;){const s=i[l++];a.push(s),s===O&&c++}return a.length-c>=e?t(...a.map(s=>s===O?void 0:s).slice(0,e)):r(a,c)};return r([],0)}const k=Symbol("skipped"),b=Symbol("requestAnimationFrame");class j{constructor(e,r,n=!1,o=!0,i){if(this.wait=r,this.leading=n,this.trailing=o,this.max_wait=i,r===b&&typeof requestAnimationFrame!="function")throw new S.ParameterError("Error: wait = useRAF, But the environment does not support requestAnimationFrame.");if(r===b&&i!=null)throw new S.ParameterError("Error: maxWait cannot be used when wait is set to useRAF.");if(r!==b&&(r<0||!Number.isFinite(r)))throw new S.ParameterError(`Error: wait = ${r} < 0 or is not a finite number.`);if(i!=null&&(!Number.isFinite(i)||i<=0||r!==b&&i<r))throw new S.ParameterError(`Error: maxWait (${i}) must be positive and at least the value of wait (${String(r)}).`);if(!n&&!o)throw new S.ParameterError("Error: Both leading and trailing are false, which is meaningless.");this.fn=e}fn;last_args=null;last_this=null;result_=k;timer_id=null;last_call_time=0;last_invoke_time=0;static getTime=typeof performance<"u"?performance.now.bind(performance):Date.now;get result(){return this.result_}get pending(){return this.timer_id!==null}invokeFunc(e){const r=this.last_args;if(r===null){this.result_=k;return}const n=this.last_this;this.clearTimers(),this.last_args=this.last_this=null,this.last_invoke_time=e,this.result_=this.fn.call(n,...r)}shouldInvoke(e){if(this.last_call_time===0)return!0;if(this.wait===b)return this.timer_id===null;const r=e-this.last_call_time;return!!(r>=this.wait||this.max_wait&&e-this.last_invoke_time>=this.max_wait||r<0)}remainingWait(e){if(this.wait===b)return 0;const r=e-this.last_call_time,n=this.wait-r;if(!this.max_wait)return n;const o=e-this.last_invoke_time,i=this.max_wait-o;return Math.min(n,i)}static Task(e){const r=j.getTime();e.wait===b||e.shouldInvoke(r)?e.invokeFunc(r):e.refreshTimer(e.remainingWait(r))}refreshTimer(e){this.clearTimers(),this.wait===b?this.timer_id=requestAnimationFrame(()=>j.Task(this)):this.timer_id=setTimeout(j.Task,e,this)}clearTimers(){this.timer_id!==null&&(this.wait===b?cancelAnimationFrame(this.timer_id):clearTimeout(this.timer_id),this.timer_id=null)}call(e,...r){const n=j.getTime(),o=this.shouldInvoke(n);return this.last_args=r,this.last_this=e,this.last_call_time=n,this.last_invoke_time===0&&(this.last_invoke_time=n),this.result_=k,o&&this.leading&&this.invokeFunc(n),this.trailing&&this.refreshTimer(this.remainingWait(n)),this.result_}cancel(){this.clearTimers(),this.last_invoke_time=this.last_call_time=0,this.last_args=this.last_this=null,this.result_=k}flush(){if(this.timer_id===null)return this.result_;if(this.trailing&&this.last_args!==null)this.invokeFunc(j.getTime());else return this.clearTimers(),k;return this.result_}[Symbol.dispose](){this.cancel(),this.fn=null,this.last_args=null,this.last_this=null}}function at(t,e,r={leading:!1,trailing:!0}){const{leading:n=!1,trailing:o=!0,maxWait:i,useRAF:a}=r,l=a?b:e,c=new j(t,l,n,o,i),s=function(...u){return c.call(this,...u)};s.cancel=()=>c.cancel(),s.flush=()=>c.flush(),s.pending=()=>c.pending,s.result=()=>c.result;const f=()=>{c[Symbol.dispose]()};return s[Symbol.dispose]=f,s}function lt(t,e,r={leading:!0,trailing:!0}){const{leading:n=!0,trailing:o=!0,useRAF:i}=r,a=i?b:e,l=new j(t,a,n,o,i?void 0:e),c=function(...f){return l.call(this,...f)};c.cancel=()=>l.cancel(),c.flush=()=>l.flush(),c.pending=()=>l.pending,c.result=()=>l.result;const s=()=>{l[Symbol.dispose]()};return c[Symbol.dispose]=s,c}const M=Symbol("No Error"),ut=async t=>{const e=[],r=a=>void e.push(a);let n,o=M;const i=[];try{n=await A.dynamicAwait(t(r))}catch(a){o=a}finally{for(let a=e.length-1;a>=0;a--)try{await e[a](o)}catch(l){i.push(l)}}if(o!==M){if(i.length>0){const a=[o,...i];throw new AggregateError(a,"defer: task and callbacks failed")}throw o}if(i.length>0)throw new AggregateError(i,"defer: callbacks failed");return n},h=t=>t==null?t===void 0?"[object Undefined]":"[object Null]":Object.prototype.toString.call(t),E=t=>typeof t=="string"||h(t)==="[object String]",N=t=>typeof t=="number"||h(t)==="[object Number]",ft=t=>N(t)&&globalThis.isFinite(t),pt=t=>typeof t=="boolean"||h(t)==="[object Boolean]",K=t=>typeof t=="symbol"||h(t)==="[object Symbol]",yt=t=>t===null,ht=t=>t===void 0,P=t=>t==null,mt=t=>!P(t),bt=t=>!P(t),C=t=>{if(t===null)return!0;const e=typeof t;return e!=="object"&&e!=="function"},B=t=>typeof t=="function"||typeof t=="object"&&t!==null,gt=t=>typeof t=="function",D=t=>Array.isArray(t),d=t=>{if(h(t)!=="[object Object]")return!1;const e=Object.getPrototypeOf(t);return e===null?!0:e===Object.prototype||e.constructor===Object},dt=t=>N(t)&&Number.isInteger(t),_t=t=>N(t)&&Number.isSafeInteger(t),jt=t=>typeof t=="number"&&t>-1&&t%1===0&&t<=Number.MAX_SAFE_INTEGER,Ot=t=>h(t)==="[object Date]",wt=t=>h(t)==="[object RegExp]",Et=t=>{const e=h(t);return e==="[object Error]"||e==="[object DOMException]"},V=t=>h(t)==="[object Map]",$=t=>h(t)==="[object Set]",St=t=>h(t)==="[object WeakMap]",kt=t=>h(t)==="[object WeakSet]",At=t=>h(t)==="[object ArrayBuffer]",Nt=/^\[object (?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)Array\]$/,Pt=t=>B(t)&&Nt.test(h(t)),Rt=()=>typeof window<"u"&&typeof document<"u"&&window.document===document,It=()=>typeof window<"u"||typeof self<"u",Tt=()=>typeof process<"u"&&process.versions!=null&&process.versions.node!=null,Bt=t=>{try{if(t!=null&&t.constructor&&typeof t.constructor.isBuffer=="function")return t.constructor.isBuffer(t)}catch{return!1}return!1},Dt=t=>h(t)==="[object Blob]",Ft=t=>h(t)==="[object File]",Mt=t=>!P(t)&&typeof t[Symbol.iterator]=="function",Wt=t=>B(t)&&Symbol.asyncIterator in t,Lt=t=>t instanceof Promise||h(t)==="[object Promise]"||A.isPromiseLike(t),Ct=(t,e)=>B(t)&&t instanceof e,Ut=t=>E(t)||N(t)||K(t),qt=t=>P(t)?!0:D(t)||E(t)?t.length===0:V(t)||$(t)?t.size===0:d(t)?Object.keys(t).length===0:!1,xt=t=>d(t)&&Object.keys(t).length===0,W=t=>t===void 0||typeof t=="symbol"||typeof t=="function"?!1:C(t)?!0:D(t)?t.every(W):d(t)?Object.values(t).every(W):!1,U=t=>t===void 0||typeof t=="symbol"?!1:C(t)||J(t)||G(t),J=t=>d(t)?Object.entries(t).every(([r,n])=>U(n)):!1,G=t=>D(t)?t.every(U):!1,Kt=t=>{if(!E(t))return!1;const e=t.trim();if(e.length===0)return!1;if(e==="null"||e==="true"||e==="false")return!0;if(e.startsWith("{")&&e.endsWith("}")||e.startsWith("[")&&e.endsWith("]"))try{return JSON.parse(e),!0}catch{return!1}try{return JSON.parse(e),!0}catch{return!1}},Vt=t=>E(t)&&/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(t),$t=t=>{if(!E(t))return!1;try{return new URL(t),!0}catch{return!1}},Jt=t=>E(t)?/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(t):!1,Y=(t,e,r)=>{const n=new WeakMap,o=(i,a)=>{if(r){const s=r(i,a);if(s!==void 0)return s}if(i===a||typeof i=="number"&&typeof a=="number"&&isNaN(i)&&isNaN(a))return!0;if(i==null||a==null)return!1;const l=h(i),c=h(a);if(l!==c)return!1;if(typeof i=="object"||typeof i=="function"){const s=n.get(i);if(s?.has(a))return!0;s?s.add(a):n.set(i,new Set([a]))}switch(l){case"[object Date]":case"[object Number]":return+i==+a;case"[object RegExp]":case"[object String]":return String(i)===String(a);case"[object Array]":{const s=i,f=a;return s.length!==f.length?!1:s.every((u,y)=>o(u,f[y]))}case"[object Object]":{if(!d(i)||!d(a))return!1;const s=Object.keys(i),f=Object.keys(a);return s.length!==f.length?!1:s.every(u=>Object.prototype.hasOwnProperty.call(a,u)?o(i[u],a[u]):!1)}case"[object Map]":{const s=i,f=a;if(s.size!==f.size)return!1;for(const[u,y]of s)if(!f.has(u)||!o(y,f.get(u)))return!1;return!0}case"[object Set]":{const s=i,f=a;if(s.size!==f.size)return!1;const u=Array.from(f);for(const y of s){const _=u.findIndex(R=>o(y,R));if(_===-1)return!1;u.splice(_,1)}return!0}case"[object ArrayBuffer]":{const s=new Uint8Array(i),f=new Uint8Array(a);if(s.length!==f.length)return!1;for(let u=0;u<s.length;u++)if(s[u]!==f[u])return!1;return!0}default:return!1}};return o(t,e)},Gt=(t,e)=>Y(t,e),Yt=(t,e)=>Object.fromEntries(Object.entries(t).map(([r,n])=>[e(n,r),n])),Ht=(t,e)=>Object.fromEntries(Object.entries(t).map(([r,n])=>[r,e(n,r)])),Xt=t=>Object.fromEntries(Object.entries(t).map(([e,r])=>[r,e])),Qt=(t,e)=>{const r={};for(const n of e)n in t&&(r[n]=t[n]);return r},Zt=(t,e)=>Object.fromEntries(Object.entries(t).filter(([r,n])=>e(n,r))),zt=(t,e)=>{const r={},n=new Set(e);for(const o of Object.keys(t))n.has(o)||(r[o]=t[o]);return r},vt=(t,e)=>Object.fromEntries(Object.entries(t).filter(([r,n])=>!e(n,r))),te=(t,e)=>{for(const r in t)if(Object.prototype.hasOwnProperty.call(t,r)&&e(t[r],r))return r},H=Symbol("Merge skip"),X=Symbol("Merge default"),q=(t,e,...r)=>{if(!r.length)return t;for(const n of r){const o=[[t,n]];for(;o.length>0;){const[i,a]=o.pop();for(const l in a)if(Object.prototype.hasOwnProperty.call(a,l)){const c=a[l],s=i[l],f=c;if(e){const u=e(s,c,l,i,a);if(u!==X){u!==H&&(i[l]=u);continue}}d(f)?(d(s)||(i[l]={}),o.push([i[l],f])):i[l]=f}}}return t},ee=(t,...e)=>q(structuredClone(t),void 0,...e),re=(t,e,...r)=>q(structuredClone(t),e,...r),ne=(t,e=".")=>{const r={},n=[[t,""]];for(;n.length>0;){const[o,i]=n.pop();for(const a in o)if(Object.prototype.hasOwnProperty.call(o,a)){const l=o[a],c=i?`${i}${e}${a}`:a;d(l)&&Object.keys(l).length>0?n.push([l,c]):r[c]=l}}return r},T=(t,e)=>{if(t===null||typeof t!="object")return t;if(Array.isArray(t))return t.map(n=>T(n,e));const r=Object.getPrototypeOf(t);return r!==Object.prototype&&r!==null?t:Object.fromEntries(Object.entries(t).map(([n,o])=>[e(n),T(o,e)]))},se=t=>T(t,L.camelCase),ie=t=>T(t,L.snakeCase),w=Symbol("Clone filter"),Q=Symbol("Clone default"),Z=Symbol("Clone hole"),oe=t=>t===null||typeof t!="object"?t:Array.isArray(t)?[...t]:t instanceof Date?new Date(t.getTime()):t instanceof RegExp?new RegExp(t.source,t.flags):{...t},z=(t,e=0)=>typeof t!="symbol"?(e=Number(t),e>>>0===e&&e!==4294967295&&String(e)===t):!1,ce=/^\[object (?:Int8|Uint8|Uint8Clamped|Int16|Uint16|Int32|Uint32|Float32|Float64|BigInt64|BigUint64)Array\]$/;function g(t,e,r,n,o=void 0,i=void 0,a=[]){if(n<=0)return t;if(e){const s=e(t,o,i,r);if(s!==Q)return s}if(t===null||typeof t!="object")return t;if(r.has(t))return r.get(t);const l=h(t);if(l==="[object Promise]"||l==="[object Function]"||typeof t=="function")return t;let c;switch(l){case"[object ArrayBuffer]":return c=t.slice(0),r.set(t,c),c;case"[object WeakMap]":return c=new WeakMap,r.set(t,c),c;case"[object WeakSet]":return c=new WeakSet,r.set(t,c),c;case"[object Date]":{c=new Date(t.getTime());break}case"[object RegExp]":{const s=t;c=new RegExp(s.source,s.flags),c.lastIndex=s.lastIndex;break}case"[object Error]":{const s=t;c=Object.create(Object.getPrototypeOf(s));const f=Object.getOwnPropertyDescriptors(s);Object.defineProperties(c,f);break}case"[object Array]":{c=[];break}case"[object Map]":{c=new Map;break}case"[object Set]":{c=new Set;break}case"[object DataView]":{const s=t,f=g(s.buffer,e,r,n-1,"buffer",s,a);c=new DataView(f,s.byteOffset,s.byteLength);break}default:{if(ce.test(l)){const s=t,f=g(s.buffer,e,r,n-1,"buffer",s,a);c=new s.constructor(f,s.byteOffset,s.length)}else c=Object.create(Object.getPrototypeOf(t));break}}return r.set(t,c),a.push({source:t,target:c,tag:l,depth:n-1}),c}function I(t,e,r,n,o,i){const a=Array.isArray(t),l=Object.keys(t),c=l.length;for(let u=0;u<c;u++){const y=l[u];if(a&&z(y))continue;const _=g(t[y],n,o,r,y,t,i);_!==w&&(e[y]=_)}const s=Object.getOwnPropertySymbols(t),f=s.length;for(let u=0;u<f;u++){const y=s[u];if(Object.getOwnPropertyDescriptor(t,y)?.enumerable){const R=g(t[y],n,o,r,y,t,i);R!==w&&(e[y]=R)}}}function v(t,e,r){for(;t.length>0;){const n=t.pop(),{source:o,target:i,tag:a,depth:l}=n;switch(a){case"[object Array]":{const c=o,s=i,f=c.length;s.length=0;for(let u=0;u<f;u++){if(!(u in c)){s.length++;continue}const y=g(c[u],e,r,l,u,c,t);y!==w&&(y===Z?s.length++:s.push(y))}I(o,i,l,e,r,t);break}case"[object Map]":{const c=o,s=i;c.forEach((f,u)=>{const y=g(u,e,r,l,u,c,t);if(y!==w){const _=g(f,e,r,l,u,c,t);_!==w&&s.set(y,_)}}),I(o,i,l,e,r,t);break}case"[object Set]":{const c=o,s=i;c.forEach(f=>{const u=g(f,e,r,l,f,c,t);u!==w&&s.add(u)}),I(o,i,l,e,r,t);break}default:{I(o,i,l,e,r,t);break}}}}const ae=(t,e=1/0)=>{const r=[],n=new WeakMap,o=g(t,void 0,n,e,void 0,void 0,r);return v(r,void 0,n),o},le=(t,e,r=1/0)=>{const n=[],o=new WeakMap,i=g(t,e,o,r,void 0,void 0,n);return v(n,e,o),i};exports.Arr=tt.__export__;exports.Str=L.String;exports.Sets=et.Set;exports.Maps=rt.Map;exports.angleDist=p.angleDist;exports.approxEqual=p.approxEqual;exports.bezier2=p.bezier2;exports.clamp=p.clamp;exports.gcd=p.gcd;exports.getDistance=p.getDistance;exports.getDistanceSq=p.getDistanceSq;exports.inRange=p.inRange;exports.isEven=p.isEven;exports.isOdd=p.isOdd;exports.lcm=p.lcm;exports.lerp=p.lerp;exports.mapRange=p.mapRange;exports.mean=p.mean;exports.meanBy=p.meanBy;exports.median=p.median;exports.medianBy=p.medianBy;exports.normalize=p.normalize;exports.random=p.random;exports.randomInt=p.randomInt;exports.range=p.range;exports.rangeRight=p.rangeRight;exports.round=p.round;exports.stdDev=p.stdDev;exports.sum=p.sum;exports.sumBy=p.sumBy;exports.toDegrees=p.toDegrees;exports.toRadians=p.toRadians;exports.wrapAngle=p.wrapAngle;exports.isPromiseLike=A.isPromiseLike;exports.after=m.after;exports.ary=m.ary;exports.asyncNoop=m.asyncNoop;exports.attempt=m.attempt;exports.before=m.before;exports.identity=m.identity;exports.memoize=m.memoize;exports.negate=m.negate;exports.noop=m.noop;exports.once=m.once;exports.partial=m.partial;exports.partialRight=m.partialRight;exports.rest=m.rest;exports.spread=m.spread;exports.unary=m.unary;exports.CLONE_DEFAULT=Q;exports.CLONE_FILTER=w;exports.CLONE_HOLE=Z;exports.Debounced=j;exports.MERGE_DEFAULT=X;exports.MERGE_SKIP=H;exports.NO_ERROR=M;exports.SKIPPED=k;exports.__=O;exports.clone=oe;exports.cloneDeep=ae;exports.cloneDeepWith=le;exports.createDebounce=at;exports.createThrottle=lt;exports.curry=ct;exports.defer=ut;exports.findKey=te;exports.flattenObject=ne;exports.getTag=h;exports.internalMerge=q;exports.invert=Xt;exports.isArray=D;exports.isArrayBuffer=At;exports.isArrayIndex=z;exports.isAsyncIterable=Wt;exports.isBlob=Dt;exports.isBoolean=pt;exports.isBrowser=Rt;exports.isBuffer=Bt;exports.isClient=It;exports.isDate=Ot;exports.isEmail=Vt;exports.isEmpty=qt;exports.isEmptyObject=xt;exports.isEqual=Gt;exports.isEqualWith=Y;exports.isError=Et;exports.isFile=Ft;exports.isFinite=ft;exports.isFunction=gt;exports.isInstanceOf=Ct;exports.isInteger=dt;exports.isIterable=Mt;exports.isJSON=Kt;exports.isJSONArray=G;exports.isJSONObject=J;exports.isJSONValue=U;exports.isLength=jt;exports.isMap=V;exports.isNil=P;exports.isNode=Tt;exports.isNotNil=mt;exports.isNotNullish=bt;exports.isNull=yt;exports.isNumber=N;exports.isObject=B;exports.isPlainObject=d;exports.isPrimitive=C;exports.isPromise=Lt;exports.isPropertyKey=Ut;exports.isRegExp=wt;exports.isSafeInteger=_t;exports.isSerializable=W;exports.isSet=$;exports.isString=E;exports.isSymbol=K;exports.isTypedArray=Pt;exports.isUUID=Jt;exports.isUndefined=ht;exports.isUrl=$t;exports.isWeakMap=St;exports.isWeakSet=kt;exports.mapKeys=Yt;exports.mapValues=Ht;exports.merge=ee;exports.mergeWith=re;exports.omit=zt;exports.omitBy=vt;exports.pick=Qt;exports.pickBy=Zt;exports.pipe=st;exports.pipeAsync=ot;exports.run=nt;exports.runAsync=it;exports.toCamelCaseKeys=se;exports.toSnakeCaseKeys=ie;exports.useRAF=b;
+//# sourceMappingURL=Utils.cjs.map