form-char-count 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# form-char-count
+
+A lightweight JavaScript/TypeScript library that accurately calculates how form input values (`<textarea>`, `<input>`) will be counted after HTTP submission and in backend/database storage.
+
+## Why?
+
+### Problem 1: Surrogate Pairs
+
+```javascript
+'🎉'.length // → 2 (JavaScript)
+// MySQL CHAR_LENGTH("🎉") → 1
+```
+
+### Problem 2: Newline Normalization
+
+```javascript
+textarea.value // "a\nb" → 3 chars (JavaScript)
+// After HTTP submission → "a\r\nb" → 4 chars (Backend)
+```
+
+### Problem 3: Lone Surrogates
+
+Corrupted data from copy-paste. MySQL treats these as invalid UTF-8.
+
+## Installation
+
+```bash
+npm install form-char-count
+```
+
+## Usage
+
+### Basic
+
+```typescript
+import { countChars, isValidLength } from 'form-char-count'
+
+const text = 'Hello\nWorld🎉'
+
+const result = countChars(text)
+// {
+//   length: 13,        // "Hello\r\nWorld🎉" = 13 code points
+//   byteLength: 16,    // UTF-8 bytes
+//   hasLoneSurrogate: false,
+//   newlineCount: 1
+// }
+
+// VARCHAR(255) validation
+if (isValidLength(text, 255)) {
+  // OK
+}
+```
+
+### React Example
+
+```tsx
+import { countChars } from 'form-char-count'
+
+function TextArea({ maxLength }: { maxLength: number }) {
+  const [value, setValue] = useState('')
+  const { length } = countChars(value)
+  const isOver = length > maxLength
+
+  return (
+    <div>
+      <textarea value={value} onChange={(e) => setValue(e.target.value)} />
+      <span style={{ color: isOver ? 'red' : 'inherit' }}>
+        {length} / {maxLength}
+      </span>
+    </div>
+  )
+}
+```
+
+### Vue.js Example
+
+```vue
+<script setup lang="ts">
+import { ref, computed } from 'vue'
+import { countChars } from 'form-char-count'
+
+const text = ref('')
+const maxLength = 255
+
+const charCount = computed(() => countChars(text.value))
+const isOver = computed(() => charCount.value.length > maxLength)
+</script>
+
+<template>
+  <div>
+    <textarea v-model="text" />
+    <span :class="{ error: isOver }">
+      {{ charCount.length }} / {{ maxLength }}
+    </span>
+  </div>
+</template>
+```
+
+### Options
+
+```typescript
+// LF normalization (if backend converts \r\n → \n)
+const result = countChars(text, { newline: 'lf' })
+
+// No normalization
+const result = countChars(text, { newline: 'none' })
+```
+
+## API
+
+### `countChars(str, options?)`
+
+Returns character count information.
+
+```typescript
+interface CountResult {
+  length: number // Code point count (MySQL CHAR_LENGTH compatible)
+  byteLength: number // UTF-8 byte length (MySQL LENGTH compatible)
+  hasLoneSurrogate: boolean // Contains invalid surrogate?
+  newlineCount: number // Number of newlines
+}
+```
+
+### `isValidLength(str, maxLength, options?)`
+
+Returns `true` if within the character limit. Useful for VARCHAR(N) validation.
+
+### `isValidByteLength(str, maxBytes, options?)`
+
+Returns `true` if within the byte limit. Useful for index size restrictions.
+
+### Options
+
+```typescript
+interface CountOptions {
+  newline?: 'crlf' | 'lf' | 'none' // Default: 'crlf'
+}
+```
+
+| Value    | Description                                                   |
+| -------- | ------------------------------------------------------------- |
+| `'crlf'` | Convert `\n` → `\r\n` (default, matches HTTP form submission) |
+| `'lf'`   | Convert `\r\n` → `\n`                                         |
+| `'none'` | No normalization                                              |
+
+## Features
+
+- Zero dependencies
+- ESM and CommonJS support
+- TypeScript types included
+- Tiny size (~1KB minified, ~500B gzipped)
+
+## Browser Support
+
+- Modern browsers (ES2018+)
+- Node.js >= 16
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=new RegExp("[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]","g");function g(n){return u.test(n)}function l(n){return n.replace(u,"")}function h(n,e){switch(e){case"crlf":return n.replace(/\r\n/g,`
+`).replace(/\r/g,`
+`).replace(/\n/g,`\r
+`);case"lf":return n.replace(/\r\n/g,`
+`).replace(/\r/g,`
+`);case"none":return n}}function f(n){const e=n.replace(/\r\n/g,`
+`).replace(/\r/g,`
+`);let t=0;for(const r of e)r===`
+`&&t++;return t}function d(n){return[...l(n)].length}function L(n){const e=l(n);return new TextEncoder().encode(e).length}function c(n,e){const t=e?.newline??"crlf",r=g(n),a=f(n),o=h(n,t),i=d(o),s=L(o);return{length:i,byteLength:s,hasLoneSurrogate:r,newlineCount:a}}function F(n,e,t){return c(n,t).length<=e}function p(n,e,t){return c(n,t).byteLength<=e}exports.countChars=c;exports.isValidByteLength=p;exports.isValidLength=F;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["/**\n * Options for character counting\n */\nexport interface CountOptions {\n  /**\n   * How to normalize newlines\n   * - 'crlf': Convert \\n to \\r\\n (default, matches HTTP form submission)\n   * - 'lf': Convert \\r\\n to \\n\n   * - 'none': No normalization\n   */\n  newline?: 'crlf' | 'lf' | 'none'\n}\n\n/**\n * Result of character counting\n */\nexport interface CountResult {\n  /** Code point count (after CRLF normalization, excluding lone surrogates) */\n  length: number\n  /** UTF-8 byte length (after CRLF normalization, excluding lone surrogates) */\n  byteLength: number\n  /** Whether the string contains lone surrogates */\n  hasLoneSurrogate: boolean\n  /** Number of newlines */\n  newlineCount: number\n}\n\n// Regex to match lone surrogates (unpaired high or low surrogates)\nconst LONE_SURROGATE_REGEX =\n  /[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/g\n\n/**\n * Check if a string contains lone surrogates\n */\nfunction hasLoneSurrogates(str: string): boolean {\n  return LONE_SURROGATE_REGEX.test(str)\n}\n\n/**\n * Remove lone surrogates from a string\n */\nfunction removeLoneSurrogates(str: string): string {\n  return str.replace(LONE_SURROGATE_REGEX, '')\n}\n\n/**\n * Normalize newlines according to the specified mode\n */\nfunction normalizeNewlines(str: string, mode: 'crlf' | 'lf' | 'none'): string {\n  switch (mode) {\n    case 'crlf':\n      // First normalize all line endings to LF, then convert to CRLF\n      return str\n        .replace(/\\r\\n/g, '\\n')\n        .replace(/\\r/g, '\\n')\n        .replace(/\\n/g, '\\r\\n')\n    case 'lf':\n      // Convert CRLF to LF and standalone CR to LF\n      return str.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n')\n    case 'none':\n      return str\n  }\n}\n\n/**\n * Count newlines in a string (counts \\r\\n as 1, \\n as 1, \\r as 1)\n */\nfunction countNewlines(str: string): number {\n  // Normalize to LF first, then count\n  const normalized = str.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n')\n  let count = 0\n  for (const char of normalized) {\n    if (char === '\\n') count++\n  }\n  return count\n}\n\n/**\n * Count code points excluding lone surrogates\n */\nfunction countCodePoints(str: string): number {\n  // Remove lone surrogates first\n  const clean = removeLoneSurrogates(str)\n  // Count code points using spread operator\n  return [...clean].length\n}\n\n/**\n * Calculate UTF-8 byte length\n */\nfunction calcByteLength(str: string): number {\n  // Remove lone surrogates first\n  const clean = removeLoneSurrogates(str)\n  // Use TextEncoder for accurate UTF-8 byte count\n  return new TextEncoder().encode(clean).length\n}\n\n/**\n * Count characters in a string, accurately reflecting how the string\n * will be counted after HTTP form submission and in backend/database.\n *\n * @param str - The string to count\n * @param options - Counting options\n * @returns Counting result\n */\nexport function countChars(str: string, options?: CountOptions): CountResult {\n  const newlineMode = options?.newline ?? 'crlf'\n  const hasLoneSurrogate = hasLoneSurrogates(str)\n\n  // Check newline count before normalization (logical newlines)\n  const newlineCount = countNewlines(str)\n\n  // Normalize newlines for counting\n  const normalized = normalizeNewlines(str, newlineMode)\n\n  // Count code points and bytes after normalization\n  const length = countCodePoints(normalized)\n  const byteLength = calcByteLength(normalized)\n\n  return {\n    length,\n    byteLength,\n    hasLoneSurrogate,\n    newlineCount,\n  }\n}\n\n/**\n * Check if a string is within the specified character length limit.\n * Useful for VARCHAR(N) validation.\n *\n * @param str - The string to check\n * @param maxLength - Maximum allowed code point count\n * @param options - Counting options\n * @returns true if within limit\n */\nexport function isValidLength(\n  str: string,\n  maxLength: number,\n  options?: CountOptions\n): boolean {\n  return countChars(str, options).length <= maxLength\n}\n\n/**\n * Check if a string is within the specified byte length limit.\n * Useful for byte-based column limits or index restrictions.\n *\n * @param str - The string to check\n * @param maxBytes - Maximum allowed byte count\n * @param options - Counting options\n * @returns true if within limit\n */\nexport function isValidByteLength(\n  str: string,\n  maxBytes: number,\n  options?: CountOptions\n): boolean {\n  return countChars(str, options).byteLength <= maxBytes\n}\n"],"names":["LONE_SURROGATE_REGEX","hasLoneSurrogates","str","removeLoneSurrogates","normalizeNewlines","mode","countNewlines","normalized","count","char","countCodePoints","calcByteLength","clean","countChars","options","newlineMode","hasLoneSurrogate","newlineCount","length","byteLength","isValidLength","maxLength","isValidByteLength","maxBytes"],"mappings":"gFA4BA,MAAMA,EACJ,WAAA,iFAAA,GAAA,EAKF,SAASC,EAAkBC,EAAsB,CAC/C,OAAOF,EAAqB,KAAKE,CAAG,CACtC,CAKA,SAASC,EAAqBD,EAAqB,CACjD,OAAOA,EAAI,QAAQF,EAAsB,EAAE,CAC7C,CAKA,SAASI,EAAkBF,EAAaG,EAAsC,CAC5E,OAAQA,EAAA,CACN,IAAK,OAEH,OAAOH,EACJ,QAAQ,QAAS;AAAA,CAAI,EACrB,QAAQ,MAAO;AAAA,CAAI,EACnB,QAAQ,MAAO;AAAA,CAAM,EAC1B,IAAK,KAEH,OAAOA,EAAI,QAAQ,QAAS;AAAA,CAAI,EAAE,QAAQ,MAAO;AAAA,CAAI,EACvD,IAAK,OACH,OAAOA,CAAA,CAEb,CAKA,SAASI,EAAcJ,EAAqB,CAE1C,MAAMK,EAAaL,EAAI,QAAQ,QAAS;AAAA,CAAI,EAAE,QAAQ,MAAO;AAAA,CAAI,EACjE,IAAIM,EAAQ,EACZ,UAAWC,KAAQF,EACbE,IAAS;AAAA,GAAMD,IAErB,OAAOA,CACT,CAKA,SAASE,EAAgBR,EAAqB,CAI5C,MAAO,CAAC,GAFMC,EAAqBD,CAAG,CAEtB,EAAE,MACpB,CAKA,SAASS,EAAeT,EAAqB,CAE3C,MAAMU,EAAQT,EAAqBD,CAAG,EAEtC,OAAO,IAAI,YAAA,EAAc,OAAOU,CAAK,EAAE,MACzC,CAUO,SAASC,EAAWX,EAAaY,EAAqC,CAC3E,MAAMC,EAAcD,GAAS,SAAW,OAClCE,EAAmBf,EAAkBC,CAAG,EAGxCe,EAAeX,EAAcJ,CAAG,EAGhCK,EAAaH,EAAkBF,EAAKa,CAAW,EAG/CG,EAASR,EAAgBH,CAAU,EACnCY,EAAaR,EAAeJ,CAAU,EAE5C,MAAO,CACL,OAAAW,EACA,WAAAC,EACA,iBAAAH,EACA,aAAAC,CAAA,CAEJ,CAWO,SAASG,EACdlB,EACAmB,EACAP,EACS,CACT,OAAOD,EAAWX,EAAKY,CAAO,EAAE,QAAUO,CAC5C,CAWO,SAASC,EACdpB,EACAqB,EACAT,EACS,CACT,OAAOD,EAAWX,EAAKY,CAAO,EAAE,YAAcS,CAChD"}

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+/**
+ * Options for character counting
+ */
+export interface CountOptions {
+    /**
+     * How to normalize newlines
+     * - 'crlf': Convert \n to \r\n (default, matches HTTP form submission)
+     * - 'lf': Convert \r\n to \n
+     * - 'none': No normalization
+     */
+    newline?: 'crlf' | 'lf' | 'none';
+}
+/**
+ * Result of character counting
+ */
+export interface CountResult {
+    /** Code point count (after CRLF normalization, excluding lone surrogates) */
+    length: number;
+    /** UTF-8 byte length (after CRLF normalization, excluding lone surrogates) */
+    byteLength: number;
+    /** Whether the string contains lone surrogates */
+    hasLoneSurrogate: boolean;
+    /** Number of newlines */
+    newlineCount: number;
+}
+/**
+ * Count characters in a string, accurately reflecting how the string
+ * will be counted after HTTP form submission and in backend/database.
+ *
+ * @param str - The string to count
+ * @param options - Counting options
+ * @returns Counting result
+ */
+export declare function countChars(str: string, options?: CountOptions): CountResult;
+/**
+ * Check if a string is within the specified character length limit.
+ * Useful for VARCHAR(N) validation.
+ *
+ * @param str - The string to check
+ * @param maxLength - Maximum allowed code point count
+ * @param options - Counting options
+ * @returns true if within limit
+ */
+export declare function isValidLength(str: string, maxLength: number, options?: CountOptions): boolean;
+/**
+ * Check if a string is within the specified byte length limit.
+ * Useful for byte-based column limits or index restrictions.
+ *
+ * @param str - The string to check
+ * @param maxBytes - Maximum allowed byte count
+ * @param options - Counting options
+ * @returns true if within limit
+ */
+export declare function isValidByteLength(str: string, maxBytes: number, options?: CountOptions): boolean;

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Options for character counting
+ */
+export interface CountOptions {
+    /**
+     * How to normalize newlines
+     * - 'crlf': Convert \n to \r\n (default, matches HTTP form submission)
+     * - 'lf': Convert \r\n to \n
+     * - 'none': No normalization
+     */
+    newline?: 'crlf' | 'lf' | 'none';
+}
+/**
+ * Result of character counting
+ */
+export interface CountResult {
+    /** Code point count (after CRLF normalization, excluding lone surrogates) */
+    length: number;
+    /** UTF-8 byte length (after CRLF normalization, excluding lone surrogates) */
+    byteLength: number;
+    /** Whether the string contains lone surrogates */
+    hasLoneSurrogate: boolean;
+    /** Number of newlines */
+    newlineCount: number;
+}
+/**
+ * Count characters in a string, accurately reflecting how the string
+ * will be counted after HTTP form submission and in backend/database.
+ *
+ * @param str - The string to count
+ * @param options - Counting options
+ * @returns Counting result
+ */
+export declare function countChars(str: string, options?: CountOptions): CountResult;
+/**
+ * Check if a string is within the specified character length limit.
+ * Useful for VARCHAR(N) validation.
+ *
+ * @param str - The string to check
+ * @param maxLength - Maximum allowed code point count
+ * @param options - Counting options
+ * @returns true if within limit
+ */
+export declare function isValidLength(str: string, maxLength: number, options?: CountOptions): boolean;
+/**
+ * Check if a string is within the specified byte length limit.
+ * Useful for byte-based column limits or index restrictions.
+ *
+ * @param str - The string to check
+ * @param maxBytes - Maximum allowed byte count
+ * @param options - Counting options
+ * @returns true if within limit
+ */
+export declare function isValidByteLength(str: string, maxBytes: number, options?: CountOptions): boolean;

package/dist/index.js

@@ -0,0 +1,60 @@
+const o = new RegExp("[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]", "g");
+function g(n) {
+  return o.test(n);
+}
+function u(n) {
+  return n.replace(o, "");
+}
+function f(n, e) {
+  switch (e) {
+    case "crlf":
+      return n.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).replace(/\n/g, `\r
+`);
+    case "lf":
+      return n.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+    case "none":
+      return n;
+  }
+}
+function h(n) {
+  const e = n.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  let t = 0;
+  for (const r of e)
+    r === `
+` && t++;
+  return t;
+}
+function F(n) {
+  return [...u(n)].length;
+}
+function p(n) {
+  const e = u(n);
+  return new TextEncoder().encode(e).length;
+}
+function l(n, e) {
+  const t = e?.newline ?? "crlf", r = g(n), a = h(n), c = f(n, t), i = F(c), s = p(c);
+  return {
+    length: i,
+    byteLength: s,
+    hasLoneSurrogate: r,
+    newlineCount: a
+  };
+}
+function L(n, e, t) {
+  return l(n, t).length <= e;
+}
+function d(n, e, t) {
+  return l(n, t).byteLength <= e;
+}
+export {
+  l as countChars,
+  d as isValidByteLength,
+  L as isValidLength
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * Options for character counting\n */\nexport interface CountOptions {\n  /**\n   * How to normalize newlines\n   * - 'crlf': Convert \\n to \\r\\n (default, matches HTTP form submission)\n   * - 'lf': Convert \\r\\n to \\n\n   * - 'none': No normalization\n   */\n  newline?: 'crlf' | 'lf' | 'none'\n}\n\n/**\n * Result of character counting\n */\nexport interface CountResult {\n  /** Code point count (after CRLF normalization, excluding lone surrogates) */\n  length: number\n  /** UTF-8 byte length (after CRLF normalization, excluding lone surrogates) */\n  byteLength: number\n  /** Whether the string contains lone surrogates */\n  hasLoneSurrogate: boolean\n  /** Number of newlines */\n  newlineCount: number\n}\n\n// Regex to match lone surrogates (unpaired high or low surrogates)\nconst LONE_SURROGATE_REGEX =\n  /[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/g\n\n/**\n * Check if a string contains lone surrogates\n */\nfunction hasLoneSurrogates(str: string): boolean {\n  return LONE_SURROGATE_REGEX.test(str)\n}\n\n/**\n * Remove lone surrogates from a string\n */\nfunction removeLoneSurrogates(str: string): string {\n  return str.replace(LONE_SURROGATE_REGEX, '')\n}\n\n/**\n * Normalize newlines according to the specified mode\n */\nfunction normalizeNewlines(str: string, mode: 'crlf' | 'lf' | 'none'): string {\n  switch (mode) {\n    case 'crlf':\n      // First normalize all line endings to LF, then convert to CRLF\n      return str\n        .replace(/\\r\\n/g, '\\n')\n        .replace(/\\r/g, '\\n')\n        .replace(/\\n/g, '\\r\\n')\n    case 'lf':\n      // Convert CRLF to LF and standalone CR to LF\n      return str.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n')\n    case 'none':\n      return str\n  }\n}\n\n/**\n * Count newlines in a string (counts \\r\\n as 1, \\n as 1, \\r as 1)\n */\nfunction countNewlines(str: string): number {\n  // Normalize to LF first, then count\n  const normalized = str.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n')\n  let count = 0\n  for (const char of normalized) {\n    if (char === '\\n') count++\n  }\n  return count\n}\n\n/**\n * Count code points excluding lone surrogates\n */\nfunction countCodePoints(str: string): number {\n  // Remove lone surrogates first\n  const clean = removeLoneSurrogates(str)\n  // Count code points using spread operator\n  return [...clean].length\n}\n\n/**\n * Calculate UTF-8 byte length\n */\nfunction calcByteLength(str: string): number {\n  // Remove lone surrogates first\n  const clean = removeLoneSurrogates(str)\n  // Use TextEncoder for accurate UTF-8 byte count\n  return new TextEncoder().encode(clean).length\n}\n\n/**\n * Count characters in a string, accurately reflecting how the string\n * will be counted after HTTP form submission and in backend/database.\n *\n * @param str - The string to count\n * @param options - Counting options\n * @returns Counting result\n */\nexport function countChars(str: string, options?: CountOptions): CountResult {\n  const newlineMode = options?.newline ?? 'crlf'\n  const hasLoneSurrogate = hasLoneSurrogates(str)\n\n  // Check newline count before normalization (logical newlines)\n  const newlineCount = countNewlines(str)\n\n  // Normalize newlines for counting\n  const normalized = normalizeNewlines(str, newlineMode)\n\n  // Count code points and bytes after normalization\n  const length = countCodePoints(normalized)\n  const byteLength = calcByteLength(normalized)\n\n  return {\n    length,\n    byteLength,\n    hasLoneSurrogate,\n    newlineCount,\n  }\n}\n\n/**\n * Check if a string is within the specified character length limit.\n * Useful for VARCHAR(N) validation.\n *\n * @param str - The string to check\n * @param maxLength - Maximum allowed code point count\n * @param options - Counting options\n * @returns true if within limit\n */\nexport function isValidLength(\n  str: string,\n  maxLength: number,\n  options?: CountOptions\n): boolean {\n  return countChars(str, options).length <= maxLength\n}\n\n/**\n * Check if a string is within the specified byte length limit.\n * Useful for byte-based column limits or index restrictions.\n *\n * @param str - The string to check\n * @param maxBytes - Maximum allowed byte count\n * @param options - Counting options\n * @returns true if within limit\n */\nexport function isValidByteLength(\n  str: string,\n  maxBytes: number,\n  options?: CountOptions\n): boolean {\n  return countChars(str, options).byteLength <= maxBytes\n}\n"],"names":["LONE_SURROGATE_REGEX","hasLoneSurrogates","str","removeLoneSurrogates","normalizeNewlines","mode","countNewlines","normalized","count","char","countCodePoints","calcByteLength","clean","countChars","options","newlineMode","hasLoneSurrogate","newlineCount","length","byteLength","isValidLength","maxLength","isValidByteLength","maxBytes"],"mappings":"AA4BA,MAAMA,IACJ,WAAA,kFAAA,GAAA;AAKF,SAASC,EAAkBC,GAAsB;AAC/C,SAAOF,EAAqB,KAAKE,CAAG;AACtC;AAKA,SAASC,EAAqBD,GAAqB;AACjD,SAAOA,EAAI,QAAQF,GAAsB,EAAE;AAC7C;AAKA,SAASI,EAAkBF,GAAaG,GAAsC;AAC5E,UAAQA,GAAA;AAAA,IACN,KAAK;AAEH,aAAOH,EACJ,QAAQ,SAAS;AAAA,CAAI,EACrB,QAAQ,OAAO;AAAA,CAAI,EACnB,QAAQ,OAAO;AAAA,CAAM;AAAA,IAC1B,KAAK;AAEH,aAAOA,EAAI,QAAQ,SAAS;AAAA,CAAI,EAAE,QAAQ,OAAO;AAAA,CAAI;AAAA,IACvD,KAAK;AACH,aAAOA;AAAA,EAAA;AAEb;AAKA,SAASI,EAAcJ,GAAqB;AAE1C,QAAMK,IAAaL,EAAI,QAAQ,SAAS;AAAA,CAAI,EAAE,QAAQ,OAAO;AAAA,CAAI;AACjE,MAAIM,IAAQ;AACZ,aAAWC,KAAQF;AACjB,IAAIE,MAAS;AAAA,KAAMD;AAErB,SAAOA;AACT;AAKA,SAASE,EAAgBR,GAAqB;AAI5C,SAAO,CAAC,GAFMC,EAAqBD,CAAG,CAEtB,EAAE;AACpB;AAKA,SAASS,EAAeT,GAAqB;AAE3C,QAAMU,IAAQT,EAAqBD,CAAG;AAEtC,SAAO,IAAI,YAAA,EAAc,OAAOU,CAAK,EAAE;AACzC;AAUO,SAASC,EAAWX,GAAaY,GAAqC;AAC3E,QAAMC,IAAcD,GAAS,WAAW,QAClCE,IAAmBf,EAAkBC,CAAG,GAGxCe,IAAeX,EAAcJ,CAAG,GAGhCK,IAAaH,EAAkBF,GAAKa,CAAW,GAG/CG,IAASR,EAAgBH,CAAU,GACnCY,IAAaR,EAAeJ,CAAU;AAE5C,SAAO;AAAA,IACL,QAAAW;AAAA,IACA,YAAAC;AAAA,IACA,kBAAAH;AAAA,IACA,cAAAC;AAAA,EAAA;AAEJ;AAWO,SAASG,EACdlB,GACAmB,GACAP,GACS;AACT,SAAOD,EAAWX,GAAKY,CAAO,EAAE,UAAUO;AAC5C;AAWO,SAASC,EACdpB,GACAqB,GACAT,GACS;AACT,SAAOD,EAAWX,GAAKY,CAAO,EAAE,cAAcS;AAChD;"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "form-char-count",
+  "version": "0.0.1",
+  "description": "Calculate form input character count accurately for HTTP submission and backend/DB storage",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build && tsc --emitDeclarationOnly && node -e \"require('fs').copyFileSync('dist/index.d.ts', 'dist/index.d.cts')\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src tests",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "spell": "cspell \"**/*.{ts,js,json,md}\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/usapopopooon/form-char-count.git"
+  },
+  "keywords": [
+    "form",
+    "character-count",
+    "textarea",
+    "input",
+    "validation",
+    "surrogate-pair",
+    "crlf",
+    "mysql",
+    "varchar"
+  ],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/usapopopooon/form-char-count/issues"
+  },
+  "homepage": "https://github.com/usapopopooon/form-char-count#readme",
+  "volta": {
+    "node": "22.22.0",
+    "npm": "11.8.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.10",
+    "cspell": "^9.6.0",
+    "eslint": "^9.39.2",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.17"
+  }
+}