@unikue/ts-lang-utils 1.0.0

package/dist/cjs/util/RandomUtils/randomString.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomString.ts
+var randomString_exports = {};
+__export(randomString_exports, {
+  randomString: () => randomString
+});
+module.exports = __toCommonJS(randomString_exports);
+var import_randomInteger = require("./randomInteger");
+var import_randomElement = require("./randomElement");
+function randomString(minLength, maxLength, characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") {
+  if (!minLength || minLength <= 0 || maxLength && maxLength < minLength || !characters) {
+    return void 0;
+  }
+  if (maxLength === void 0 && characters.length === 1) {
+    return characters.repeat(minLength);
+  }
+  const result = [];
+  const length = maxLength === void 0 ? minLength : (0, import_randomInteger.randomInteger)(minLength, maxLength);
+  const source = characters.split("");
+  for (let i = 0; i < length; i++) {
+    result.push((0, import_randomElement.randomElement)(source));
+  }
+  return result.join("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomString
+});

package/dist/cjs/util/RandomUtils/randomStrings.d.ts

@@ -0,0 +1 @@
+export declare function randomStrings(size?: number, minLength?: number, maxLength?: number, characters?: string): string[] | undefined;

package/dist/cjs/util/RandomUtils/randomStrings.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RandomUtils/randomStrings.ts
+var randomStrings_exports = {};
+__export(randomStrings_exports, {
+  randomStrings: () => randomStrings
+});
+module.exports = __toCommonJS(randomStrings_exports);
+var import_randomString = require("./randomString");
+function randomStrings(size, minLength, maxLength, characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") {
+  if (!size || size <= 0 || size > Number.MAX_SAFE_INTEGER || !minLength || minLength <= 0) {
+    return void 0;
+  }
+  const result = [];
+  for (let i = 0; i < size; i++) {
+    const value = (0, import_randomString.randomString)(minLength, maxLength, characters);
+    if (!value) {
+      break;
+    }
+    result.push(value);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomStrings
+});

package/dist/cjs/util/RegexUtils/compilePattern.d.ts

@@ -0,0 +1 @@
+export declare function compilePattern(pattern?: string | null, flags?: string): RegExp | undefined;

package/dist/cjs/util/RegexUtils/compilePattern.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/compilePattern.ts
+var compilePattern_exports = {};
+__export(compilePattern_exports, {
+  compilePattern: () => compilePattern
+});
+module.exports = __toCommonJS(compilePattern_exports);
+function compilePattern(pattern, flags) {
+  if (!pattern) {
+    return void 0;
+  }
+  try {
+    return new RegExp(pattern, flags);
+  } catch {
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compilePattern
+});

package/dist/cjs/util/RegexUtils/escapePattern.d.ts

@@ -0,0 +1 @@
+export declare function escapePattern(pattern?: string | null): string | null | undefined;

package/dist/cjs/util/RegexUtils/escapePattern.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/escapePattern.ts
+var escapePattern_exports = {};
+__export(escapePattern_exports, {
+  escapePattern: () => escapePattern
+});
+module.exports = __toCommonJS(escapePattern_exports);
+function escapePattern(pattern) {
+  const regex = /[\\^$.*+?\-()[\]{}|]/g;
+  return !pattern || !regex.test(pattern) ? pattern : pattern.replace(regex, "\\$&");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapePattern
+});

package/dist/cjs/util/RegexUtils/extractWords.d.ts

@@ -0,0 +1 @@
+export declare function extractWords(text?: string | null, search?: string | RegExp): string[] | undefined;

package/dist/cjs/util/RegexUtils/extractWords.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/extractWords.ts
+var extractWords_exports = {};
+__export(extractWords_exports, {
+  extractWords: () => extractWords
+});
+module.exports = __toCommonJS(extractWords_exports);
+function extractWords(text, search = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g) {
+  return !text ? void 0 : text.match(search) || void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractWords
+});

package/dist/cjs/util/RegexUtils/index.d.ts

@@ -0,0 +1,14 @@
+export { compilePattern } from './compilePattern';
+export { escapePattern } from './escapePattern';
+export { extractWords } from './extractWords';
+export { isAlphabetic } from './isAlphabetic';
+export { isAlphabeticLower } from './isAlphabeticLower';
+export { isAlphabeticUpper } from './isAlphabeticUpper';
+export { isAlphanumeric } from './isAlphanumeric';
+export { isAlphanumericLower } from './isAlphanumericLower';
+export { isAlphanumericUpper } from './isAlphanumericUpper';
+export { isCompilable } from './isCompilable';
+export { isNumeric } from './isNumeric';
+export { normalizePattern } from './normalizePattern';
+export { testResetting } from './testResetting';
+export { unescapePattern } from './unescapePattern';

package/dist/cjs/util/RegexUtils/index.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/index.ts
+var RegexUtils_exports = {};
+__export(RegexUtils_exports, {
+  compilePattern: () => import_compilePattern.compilePattern,
+  escapePattern: () => import_escapePattern.escapePattern,
+  extractWords: () => import_extractWords.extractWords,
+  isAlphabetic: () => import_isAlphabetic.isAlphabetic,
+  isAlphabeticLower: () => import_isAlphabeticLower.isAlphabeticLower,
+  isAlphabeticUpper: () => import_isAlphabeticUpper.isAlphabeticUpper,
+  isAlphanumeric: () => import_isAlphanumeric.isAlphanumeric,
+  isAlphanumericLower: () => import_isAlphanumericLower.isAlphanumericLower,
+  isAlphanumericUpper: () => import_isAlphanumericUpper.isAlphanumericUpper,
+  isCompilable: () => import_isCompilable.isCompilable,
+  isNumeric: () => import_isNumeric.isNumeric,
+  normalizePattern: () => import_normalizePattern.normalizePattern,
+  testResetting: () => import_testResetting.testResetting,
+  unescapePattern: () => import_unescapePattern.unescapePattern
+});
+module.exports = __toCommonJS(RegexUtils_exports);
+var import_compilePattern = require("./compilePattern");
+var import_escapePattern = require("./escapePattern");
+var import_extractWords = require("./extractWords");
+var import_isAlphabetic = require("./isAlphabetic");
+var import_isAlphabeticLower = require("./isAlphabeticLower");
+var import_isAlphabeticUpper = require("./isAlphabeticUpper");
+var import_isAlphanumeric = require("./isAlphanumeric");
+var import_isAlphanumericLower = require("./isAlphanumericLower");
+var import_isAlphanumericUpper = require("./isAlphanumericUpper");
+var import_isCompilable = require("./isCompilable");
+var import_isNumeric = require("./isNumeric");
+var import_normalizePattern = require("./normalizePattern");
+var import_testResetting = require("./testResetting");
+var import_unescapePattern = require("./unescapePattern");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compilePattern,
+  escapePattern,
+  extractWords,
+  isAlphabetic,
+  isAlphabeticLower,
+  isAlphabeticUpper,
+  isAlphanumeric,
+  isAlphanumericLower,
+  isAlphanumericUpper,
+  isCompilable,
+  isNumeric,
+  normalizePattern,
+  testResetting,
+  unescapePattern
+});

package/dist/cjs/util/RegexUtils/isAlphabetic.d.ts

@@ -0,0 +1 @@
+export declare function isAlphabetic(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphabetic.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphabetic.ts
+var isAlphabetic_exports = {};
+__export(isAlphabetic_exports, {
+  isAlphabetic: () => isAlphabetic
+});
+module.exports = __toCommonJS(isAlphabetic_exports);
+function isAlphabetic(text) {
+  return !!text && /^[A-Za-z]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphabetic
+});

package/dist/cjs/util/RegexUtils/isAlphabeticLower.d.ts

@@ -0,0 +1 @@
+export declare function isAlphabeticLower(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphabeticLower.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphabeticLower.ts
+var isAlphabeticLower_exports = {};
+__export(isAlphabeticLower_exports, {
+  isAlphabeticLower: () => isAlphabeticLower
+});
+module.exports = __toCommonJS(isAlphabeticLower_exports);
+function isAlphabeticLower(text) {
+  return !!text && /^[a-z]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphabeticLower
+});

package/dist/cjs/util/RegexUtils/isAlphabeticUpper.d.ts

@@ -0,0 +1 @@
+export declare function isAlphabeticUpper(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphabeticUpper.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphabeticUpper.ts
+var isAlphabeticUpper_exports = {};
+__export(isAlphabeticUpper_exports, {
+  isAlphabeticUpper: () => isAlphabeticUpper
+});
+module.exports = __toCommonJS(isAlphabeticUpper_exports);
+function isAlphabeticUpper(text) {
+  return !!text && /^[A-Z]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphabeticUpper
+});

package/dist/cjs/util/RegexUtils/isAlphanumeric.d.ts

@@ -0,0 +1 @@
+export declare function isAlphanumeric(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphanumeric.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphanumeric.ts
+var isAlphanumeric_exports = {};
+__export(isAlphanumeric_exports, {
+  isAlphanumeric: () => isAlphanumeric
+});
+module.exports = __toCommonJS(isAlphanumeric_exports);
+function isAlphanumeric(text) {
+  return !!text && /^[A-Za-z\d]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphanumeric
+});

package/dist/cjs/util/RegexUtils/isAlphanumericLower.d.ts

@@ -0,0 +1 @@
+export declare function isAlphanumericLower(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphanumericLower.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphanumericLower.ts
+var isAlphanumericLower_exports = {};
+__export(isAlphanumericLower_exports, {
+  isAlphanumericLower: () => isAlphanumericLower
+});
+module.exports = __toCommonJS(isAlphanumericLower_exports);
+function isAlphanumericLower(text) {
+  return !!text && /^[a-z\d]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphanumericLower
+});

package/dist/cjs/util/RegexUtils/isAlphanumericUpper.d.ts

@@ -0,0 +1 @@
+export declare function isAlphanumericUpper(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isAlphanumericUpper.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isAlphanumericUpper.ts
+var isAlphanumericUpper_exports = {};
+__export(isAlphanumericUpper_exports, {
+  isAlphanumericUpper: () => isAlphanumericUpper
+});
+module.exports = __toCommonJS(isAlphanumericUpper_exports);
+function isAlphanumericUpper(text) {
+  return !!text && /^[A-Z\d]+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlphanumericUpper
+});

package/dist/cjs/util/RegexUtils/isCompilable.d.ts

@@ -0,0 +1 @@
+export declare function isCompilable(pattern?: string | null, flags?: string): boolean;

package/dist/cjs/util/RegexUtils/isCompilable.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isCompilable.ts
+var isCompilable_exports = {};
+__export(isCompilable_exports, {
+  isCompilable: () => isCompilable
+});
+module.exports = __toCommonJS(isCompilable_exports);
+function isCompilable(pattern, flags) {
+  if (!pattern) {
+    return false;
+  }
+  try {
+    new RegExp(pattern, flags);
+    return true;
+  } catch {
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCompilable
+});

package/dist/cjs/util/RegexUtils/isNumeric.d.ts

@@ -0,0 +1 @@
+export declare function isNumeric(text?: string | null): boolean;

package/dist/cjs/util/RegexUtils/isNumeric.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/isNumeric.ts
+var isNumeric_exports = {};
+__export(isNumeric_exports, {
+  isNumeric: () => isNumeric
+});
+module.exports = __toCommonJS(isNumeric_exports);
+function isNumeric(text) {
+  return !!text && /^\d+$/.test(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNumeric
+});

package/dist/cjs/util/RegexUtils/normalizePattern.d.ts

@@ -0,0 +1 @@
+export declare function normalizePattern(pattern?: string | null): string | null | undefined;

package/dist/cjs/util/RegexUtils/normalizePattern.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/RegexUtils/normalizePattern.ts
+var normalizePattern_exports = {};
+__export(normalizePattern_exports, {
+  normalizePattern: () => normalizePattern
+});
+module.exports = __toCommonJS(normalizePattern_exports);
+function normalizePattern(pattern) {
+  if (!pattern) {
+    return pattern;
+  }
+  return pattern.replace(/\\\\/g, "\\").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\'/g, "'");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizePattern
+});

package/dist/cjs/util/RegexUtils/testResetting.d.ts

@@ -0,0 +1 @@
+export declare function testResetting(regex?: RegExp, text?: string | null): boolean;