@design-edito/tools 0.3.0 → 1.0.1

package/agnostic/random/uuid/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * Generates a random hexadecimal string of given length.
- *
- * @param {number} [length=4] - Number of hex characters.
- * @returns {string} Random hexadecimal string.
- */
-export declare function randomHash(length?: number): string;
-/**
- * Generates a random hexadecimal string following a pattern.
- *
- * @param {number[]} pattern - Array of segment lengths.
- * @param {string} [joiner='-'] - String used to join the segments.
- * @returns {string} Random hexadecimal string with segments joined by `joiner`.
- */
-export declare function randomHashPattern(pattern: number[], joiner?: string): string;
-/**
- * Generates a random UUID-like string (version 4 style, not RFC-compliant).
- *
- * @returns {string} Random UUID-like string.
- */
-export declare function randomUUID(): string;

package/agnostic/random/uuid/index.js

@@ -1,12 +0,0 @@
-import {
-  randomHash,
-  randomHashPattern,
-  randomUUID
-} from "../../../chunks/chunk-75BICI4L.js";
-import "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  randomHash,
-  randomHashPattern,
-  randomUUID
-};

package/agnostic/regexps/index.d.ts

@@ -1,95 +0,0 @@
-/**
- * Merges multiple flag strings into a single string containing each flag only once.
- *
- * @param {...string[]} flagStrs - Flag strings to merge.
- * @returns {string} Merged flags string.
- */
-export declare function mergeFlags(...flagStrs: string[]): string;
-/**
- * Returns a new RegExp with combined flags.
- *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} flags - Flags to add.
- * @returns {RegExp} New regular expression with combined flags.
- */
-export declare function setFlags(regexp: RegExp, flags: string): RegExp;
-/**
- * Anchors a RegExp to the start of a string.
- *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
- */
-export declare function fromStart(regexp: RegExp, flags?: string): RegExp;
-/**
- * Anchors a RegExp to the end of a string.
- *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
- */
-export declare function toEnd(regexp: RegExp, flags?: string): RegExp;
-/**
- * Anchors a RegExp to match the entire string.
- *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
- */
-export declare function fromStartToEnd(regexp: RegExp, flags?: string): RegExp;
-/**
- * Checks if a string starts with a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=true] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringStartsWith(string: string, regexp: RegExp): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
-/**
- * Checks if a string ends with a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=true] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringEndsWith(string: string, regexp: RegExp): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
-/**
- * Checks if a string fully matches a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=false] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringIs(string: string, regexp: RegExp): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
-/**
- * Creates a RegExp that matches any of the provided strings.
- *
- * @param {string[]} strings - Strings to match.
- * @returns {RegExp} Regular expression matching all strings.
- */
-export declare function fromStrings(strings: string[]): RegExp;
-/**
- * Escapes special RegExp characters in a string.
- *
- * @param {string} string - String to escape.
- * @returns {string} Escaped string.
- */
-export declare function escape(string: string): string;

package/agnostic/regexps/index.js

@@ -1,88 +0,0 @@
-import "../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/regexps/index.ts
-function mergeFlags(...flagStrs) {
-  const flagsSet = /* @__PURE__ */ new Set();
-  flagStrs.forEach(
-    (flagStr) => flagStr.split("").forEach((char) => flagsSet.add(char))
-  );
-  return Array.from(flagsSet.values()).join("");
-}
-function setFlags(regexp, flags) {
-  const mergedFlags = mergeFlags(regexp.flags, flags);
-  return new RegExp(`${regexp.source}`, mergedFlags);
-}
-function fromStart(regexp, flags = "g") {
-  const mergedFlags = mergeFlags(regexp.flags, flags);
-  return new RegExp(`^(${regexp.source})`, mergedFlags);
-}
-function toEnd(regexp, flags = "g") {
-  const mergedFlags = mergeFlags(regexp.flags, flags);
-  return new RegExp(`(${regexp.source})$`, mergedFlags);
-}
-function fromStartToEnd(regexp, flags = "g") {
-  const mergedFlags = mergeFlags(regexp.flags, flags);
-  return fromStart(toEnd(regexp, mergedFlags), mergedFlags);
-}
-function stringStartsWith(string, regexp, returnMatches = true, flags = "g") {
-  const actualRegexp = fromStart(regexp, flags);
-  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
-}
-function stringEndsWith(string, regexp, returnMatches = true, flags = "g") {
-  const actualRegexp = toEnd(regexp, flags);
-  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
-}
-function stringIs(string, regexp, returnMatches = false, flags = "g") {
-  const actualRegexp = fromStartToEnd(regexp, flags);
-  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
-}
-function fromStrings(strings) {
-  const rootsMap = stringsToRootsMap(strings);
-  const source = sourceFromRootsMap(rootsMap, false);
-  const regexp = new RegExp(source);
-  return regexp;
-}
-function escape(string) {
-  return string.replace(/\s/igm, "\\s").replace(/\n/igm, "\\n").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function stringsToRootsMap(strings, rootsMap = /* @__PURE__ */ new Map()) {
-  const lengthSorted = strings.sort((strA, strB) => strA.length - strB.length);
-  lengthSorted.forEach((string) => {
-    const [firstChar, ...lastChars] = string.split("");
-    const isWordEnd = lastChars.length === 0;
-    if (firstChar === void 0) return;
-    const roots = Array.from(rootsMap.keys());
-    const foundRoot = roots.find((root) => new RegExp(`^(${escape(root)})`).test(string));
-    const subRootsMap = foundRoot !== void 0 ? rootsMap.get(foundRoot)?.subRootsMap : void 0;
-    if (foundRoot === void 0 || subRootsMap === void 0) {
-      const subRootsMap2 = /* @__PURE__ */ new Map();
-      stringsToRootsMap([lastChars.join("")], subRootsMap2);
-      return rootsMap.set(firstChar, { subRootsMap: subRootsMap2, isWordEnd });
-    }
-    stringsToRootsMap([lastChars.join("")], subRootsMap);
-  });
-  return rootsMap;
-}
-function sourceFromRootsMap(rootsMap, isOptional) {
-  const rootsMapEntries = Array.from(rootsMap.entries());
-  if (rootsMapEntries.length === 0) return "";
-  const regexpBody = rootsMapEntries.map(([root, rootData]) => {
-    return `${escape(root)}${sourceFromRootsMap(
-      rootData.subRootsMap,
-      rootData.isWordEnd
-    )}`;
-  }).join("|");
-  return isOptional ? `(${regexpBody})?` : `(${regexpBody})`;
-}
-export {
-  escape,
-  fromStart,
-  fromStartToEnd,
-  fromStrings,
-  mergeFlags,
-  setFlags,
-  stringEndsWith,
-  stringIs,
-  stringStartsWith,
-  toEnd
-};

package/agnostic/sanitization/file-name/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Sanitizes a single file name by removing invalid characters and normalizing Unicode.
- *
- * - Removes characters forbidden in Windows and Unix file systems.
- * - Replaces multiple spaces with a single space.
- * - Replaces multiple dots with a single dot and removes leading/trailing dots.
- * - Normalizes Unicode to NFKC form to prevent homoglyph attacks.
- *
- * @param {string} input - The file name to sanitize.
- * @param {number} [maxLength=255] - Maximum allowed length of the sanitized file name.
- * @returns {string | null} Sanitized file name, or null if empty or exceeds maxLength.
- */
-export declare function sanitizeFileName(input: string, maxLength?: number): string | null;

package/agnostic/sanitization/file-name/index.js

@@ -1,7 +0,0 @@
-import {
-  sanitizeFileName
-} from "../../../chunks/chunk-HYPEWMYZ.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  sanitizeFileName
-};

package/agnostic/sanitization/html/index.d.ts

@@ -1,61 +0,0 @@
-import type { SanitizeHtmlOptions } from '../types.js';
-/**
- * Default sanitization options.
- *
- * Only sets a default recursion depth of 20.
- */
-export declare const defaultOptions: SanitizeHtmlOptions;
-/**
- * Sanitizes an HTML string according to the provided options.
- *
- * @deprecated
- * @security
- * ⚠️ SECURITY WARNING
- * This function is **not a hardened or complete HTML sanitizer**.
- * It does not guarantee protection against XSS or other injection attacks.
- *
- * Correctness and safety depend entirely on strict caller configuration.
- * In particular, unsafe usage may occur if:
- * - Wildcards (`'*'`) are used for allowed tags or attributes
- * - URL-based attributes (`href`, `src`, `xlink:href`, etc.) are insufficiently constrained
- * - Event handler attributes (`on*`) are not explicitly forbidden
- * - SVG or MathML content is allowed
- *
- * This API must not be used as a security boundary for untrusted HTML.
- * For security-critical sanitization, use a dedicated, security-audited library.
- *
- * @param {string} inputStr - The HTML string to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {string} The sanitized HTML string.
- *
- * @throws Will throw an error if no document object is available for creating elements.
- */
-export declare function sanitizeHtml(inputStr: string, options?: SanitizeHtmlOptions): string;
-/**
- * Recursively sanitizes a DOM element and its descendants according to the provided options.
- *
- * @deprecated
- * @security
- * ⚠️ SECURITY WARNING
- * This function is **not a hardened or complete HTML sanitizer**.
- * It does not guarantee protection against XSS or other injection attacks.
- *
- * Correctness and safety depend entirely on strict caller configuration.
- * In particular, unsafe usage may occur if:
- * - Wildcards (`'*'`) are used for allowed tags or attributes
- * - URL-based attributes (`href`, `src`, `xlink:href`, etc.) are insufficiently constrained
- * - Event handler attributes (`on*`) are not explicitly forbidden
- * - SVG or MathML content is allowed
- *
- * This API must not be used as a security boundary for untrusted HTML.
- * For security-critical sanitization, use a dedicated, security-audited library.
- *
- * @param {Element} element - The DOM element to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {Element | null}
- * - A sanitized clone of the original element with allowed attributes and children.
- * - `null` if the element is forbidden or maximum recursion depth is reached.
- *
- * @throws Will throw an error if no document object is available for creating elements.
- */
-export declare function sanitizeElement(element: Element, options?: SanitizeHtmlOptions): Element | null;

package/agnostic/sanitization/html/index.js

@@ -1,121 +0,0 @@
-import {
-  get
-} from "../../../chunks/chunk-ROWPCMQY.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/sanitization/html/index.ts
-var defaultOptions = { depth: 20 };
-function sanitizeHtml(inputStr, options = defaultOptions) {
-  const { document } = get();
-  const wrapperDiv = document.createElement("div");
-  const { inputFreeTransform } = options;
-  wrapperDiv.innerHTML = inputFreeTransform !== void 0 ? inputFreeTransform(inputStr) : inputStr;
-  const sanitizedWrapper = sanitizeElement(wrapperDiv, options);
-  const returned = sanitizedWrapper?.innerHTML;
-  return returned ?? "";
-}
-function sanitizeElement(element, options = defaultOptions) {
-  const { tagName, attributes, childNodes } = element;
-  const {
-    allowedTags = [],
-    allowedAttributes = {},
-    forbiddenTags = [],
-    forbiddenAttributes = {},
-    depth = 20,
-    verbose = false
-  } = options;
-  if (depth <= 0) {
-    console.warn("Max depth reached");
-    return null;
-  }
-  const normalizedTagName = tagName.toLowerCase().trim();
-  const tagIsInForbidden = forbiddenTags.includes("*") || forbiddenTags.includes(normalizedTagName);
-  if (tagIsInForbidden) {
-    if (verbose === true) console.warn(tagName, "tag is forbidden");
-    return null;
-  }
-  const tagIsInAllowed = allowedTags.includes("*") || allowedTags.includes(normalizedTagName);
-  if (!tagIsInAllowed) {
-    if (verbose === true) console.warn(tagName, "tag is not allowed");
-    return null;
-  }
-  const returnedElement = get().document.createElement(tagName);
-  const returnedAttributes = Array.from(attributes).filter(({ name: attributeName, value: attributeValue }) => {
-    const allTagsForbiddenAttributes = forbiddenAttributes["*"] ?? [];
-    const thisTagForbiddenAttributes = forbiddenAttributes[normalizedTagName] ?? [];
-    const mergedForbiddenAttributes = [...allTagsForbiddenAttributes, ...thisTagForbiddenAttributes];
-    const isInForbidden = mergedForbiddenAttributes.some(({
-      attributeName: nameTester,
-      attributeValues: valTesters
-    }) => {
-      if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) return false;
-      if (typeof nameTester !== "string" && !nameTester.test(attributeName)) return false;
-      if (valTesters === void 0) {
-        if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
-        return true;
-      }
-      if (valTesters.includes("*")) {
-        if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
-        return true;
-      }
-      return valTesters.some((valTester) => {
-        if (typeof valTester === "string" && attributeValue === valTester) {
-          if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
-          return true;
-        }
-        if (typeof valTester !== "string" && valTester.test(attributeValue)) {
-          if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
-          return true;
-        }
-        return false;
-      });
-    });
-    if (isInForbidden) return false;
-    const allTagsAllowedAttributes = allowedAttributes["*"] ?? [];
-    const thisTagAllowedAttributes = allowedAttributes[normalizedTagName] ?? [];
-    const mergedAllowedAttributes = [...allTagsAllowedAttributes, ...thisTagAllowedAttributes];
-    let latestNotAllowedReason = [tagName, "has no allowed attributes"];
-    const isInAllowed = mergedAllowedAttributes.some(({
-      attributeName: nameTester,
-      attributeValues: valTesters
-    }) => {
-      if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) {
-        latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
-        return false;
-      }
-      if (typeof nameTester !== "string" && !nameTester.test(attributeName)) {
-        latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
-        return false;
-      }
-      if (valTesters === void 0) return true;
-      if (valTesters.includes("*")) return true;
-      return valTesters.some((valTester) => {
-        if (typeof valTester === "string" && attributeValue === valTester) return true;
-        if (typeof valTester !== "string" && valTester.test(attributeValue)) return true;
-        latestNotAllowedReason = [attributeValue, "value for", attributeName, "attribute on", tagName, "tag is not allowed"];
-        return false;
-      });
-    });
-    if (!isInAllowed) {
-      if (verbose === true) console.warn(...latestNotAllowedReason);
-      return false;
-    }
-    return true;
-  });
-  returnedAttributes.forEach(({ name, value }) => {
-    returnedElement.setAttribute(name, value);
-  });
-  const sanitizedChildNodes = Array.from(childNodes).map((node) => {
-    if (node.nodeType === Node.ELEMENT_NODE) return sanitizeElement(node, { ...options, depth: depth - 1 });
-    else if (node.nodeType === Node.TEXT_NODE) return node;
-    else if (options.keepComments === true && node.nodeType === Node.COMMENT_NODE) return node;
-    return null;
-  }).filter((elt) => elt !== null);
-  returnedElement.replaceChildren(...sanitizedChildNodes);
-  return returnedElement;
-}
-export {
-  defaultOptions,
-  sanitizeElement,
-  sanitizeHtml
-};

package/agnostic/sanitization/path/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Sanitizes a path string by sanitizing each path segment.
- *
- * - Removes empty segments and `..` segments to prevent path traversal.
- * - Sanitizes each segment using `sanitizeFileName`.
- * - Ensures the returned path starts with a `/`.
- *
- * @param {string} targetPath - The path to sanitize.
- * @returns {string | null} Sanitized absolute path, or null if invalid/empty.
- */
-export declare function sanitizePath(targetPath: string): string | null;

package/agnostic/sanitization/path/index.js

@@ -1,14 +0,0 @@
-import {
-  sanitizeFileName
-} from "../../../chunks/chunk-HYPEWMYZ.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/sanitization/path/index.ts
-function sanitizePath(targetPath) {
-  const sanitized = targetPath.split("/").filter((chunk) => chunk !== "").map((chunk) => sanitizeFileName(chunk) ?? "").filter((chunk) => chunk !== "" && chunk !== "..").join("/");
-  if (sanitized === "") return null;
-  return sanitized.startsWith("/") ? sanitized : `/${sanitized}`;
-}
-export {
-  sanitizePath
-};

package/agnostic/sanitization/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * Represents an attribute filtering rule for sanitization.
- *
- * - `attributeName`: The attribute name to match, either as a string or a RegExp.
- * - `attributeValues` (optional): Array of allowed or forbidden values for the attribute,
- *   each being a string or a RegExp. If omitted, all values are affected.
- */
-export type AttributeNameValPair = {
-    attributeName: string | RegExp;
-    attributeValues?: Array<string | RegExp>;
-};
-/**
- * Configuration options for HTML sanitization.
- *
- * - `inputFreeTransform` (optional): Function applied to input HTML string before sanitization.
- * - `keepComments` (optional): Whether to preserve comment nodes. Default is `false`.
- * - `allowedTags` (optional): Array of allowed tag names. `'*'` allows all tags.
- * - `forbiddenTags` (optional): Array of forbidden tag names. `'*'` forbids all tags.
- * - `allowedAttributes` (optional): Object mapping tag names to allowed attributes (`AttributeNameValPair` arrays).
- * - `forbiddenAttributes` (optional): Object mapping tag names to forbidden attributes (`AttributeNameValPair` arrays).
- * - `depth` (optional): Maximum recursion depth for nested elements. Default is 20.
- * - `verbose` (optional): Enables console warnings for forbidden elements/attributes. Default is `false`.
- */
-export type SanitizeHtmlOptions = {
-    inputFreeTransform?: (input: string) => string;
-    keepComments?: boolean;
-    allowedTags?: string[];
-    forbiddenTags?: string[];
-    allowedAttributes?: {
-        [tagName: string]: AttributeNameValPair[];
-    };
-    forbiddenAttributes?: {
-        [tagName: string]: AttributeNameValPair[];
-    };
-    depth?: number;
-    verbose?: boolean;
-};

package/agnostic/sanitization/user-input/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Recursively sanitizes user input to prevent XSS.
- *
- * - Strings are sanitized using `xss`.
- * - Arrays and objects are sanitized recursively.
- * - Circular references are safely handled via a `WeakSet`.
- *
- * @template T
- * @param input - Input value to sanitize (string, object, or array).
- * @param [seen] - Internal set to track circular references.
- * @returns Sanitized input with the same structure as the original.
- */
-export declare const sanitizeUserInput: <T>(input: T, seen?: WeakSet<WeakKey>) => T;

package/agnostic/sanitization/user-input/index.js

@@ -1,23 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/sanitization/user-input/index.ts
-import xss from "xss";
-var sanitizeUserInput = (input, seen = /* @__PURE__ */ new WeakSet()) => {
-  if (typeof input === "string") return xss(input);
-  if (Array.isArray(input)) {
-    if (seen.has(input)) return input;
-    seen.add(input);
-    return input.map((item) => sanitizeUserInput(item, seen));
-  }
-  if (input !== null && typeof input === "object") {
-    if (seen.has(input)) return input;
-    seen.add(input);
-    const entries = Object.entries(input);
-    const sanitizedEntries = entries.map(([key, value]) => [xss(key), sanitizeUserInput(value, seen)]);
-    return Object.fromEntries(sanitizedEntries);
-  }
-  return input;
-};
-export {
-  sanitizeUserInput
-};

package/agnostic/strings/char-codes/index.d.ts

@@ -1,82 +0,0 @@
-/** A standard Unicode character code (number). */
-export type CharCode = number;
-/** A base-36 encoded character code (string). */
-export type B36CharCode = string;
-/**
- * Converts a Unicode character code to a base-36 string.
- * @param charCode - The character code to convert.
- * @returns Base-36 encoded character code.
- */
-export declare function charCodeToB36(charCode: CharCode): B36CharCode;
-/**
- * Converts a base-36 character code string back to a Unicode character code.
- * @param b36CharCode - Base-36 encoded character code.
- * @returns Unicode character code.
- */
-export declare function b36CharCodeToCharCode(b36CharCode: B36CharCode): CharCode;
-/**
- * Converts a single character to its Unicode character code.
- * @param char - The character to convert.
- * @returns Unicode character code.
- */
-export declare function charToCharCode(char: string): CharCode;
-/**
- * Converts a single character to its base-36 encoded character code.
- * @param char - The character to convert.
- * @returns Base-36 character code.
- */
-export declare function charToB36CharCode(char: string): B36CharCode;
-/**
- * Returns the character corresponding to a Unicode character code.
- * @param charCode - Unicode character code.
- * @returns Single-character string.
- */
-export declare function charFromCharCode(charCode: CharCode): string;
-/**
- * Returns the character corresponding to a base-36 encoded character code.
- * @param b36CharCode - Base-36 character code.
- * @returns Single-character string.
- */
-export declare function charFromB36CharCode(b36CharCode: B36CharCode): string;
-/**
- * Converts a string into an array of Unicode character codes.
- * @param string - Input string.
- * @returns Array of character codes.
- */
-export declare function toCharCodes(string: string): Array<CharCode>;
-/**
- * Converts a string into an array of base-36 encoded character codes.
- * @param string - Input string.
- * @returns Array of base-36 character codes.
- */
-export declare function toB36CharCodes(string: string): Array<B36CharCode>;
-/**
- * Converts an array of Unicode character codes back to a string.
- * @param charCodes - Array of character codes.
- * @returns Reconstructed string.
- */
-export declare function fromCharCodes(charCodes: Array<CharCode>): string;
-/**
- * Converts an array of base-36 encoded character codes back to a string.
- * @param b36CharCodes - Array of base-36 character codes.
- * @returns Reconstructed string.
- */
-export declare function fromB36CharCodes(b36CharCodes: Array<B36CharCode>): string;
-/**
- * Serializes an array of character codes (Unicode or base-36) into a string.
- * @param charCodes - Array of character codes to serialize.
- * @returns Serialized string representation.
- */
-export declare function serialize(charCodes: Array<CharCode | B36CharCode>): string;
-/**
- * Deserializes a string of base-36 character codes into an array of Unicode character codes.
- * @param serializedCharCodes - Serialized string.
- * @returns Array of Unicode character codes.
- */
-export declare function deserialize(serializedCharCodes: string): Array<CharCode>;
-/**
- * Deserializes a string of base-36 character codes and reconstructs the original string.
- * @param serializedCharCodes - Serialized string.
- * @returns Original string.
- */
-export declare function fromSerialized(serializedCharCodes: string): string;