maskarajs 1.0.2 → 1.0.3

package/README.md

@@ -94,6 +94,89 @@ const cpf = useMaskara('cpf', { engine: appMaskara })
 
 The hook stores field state. The engine stores mask configuration.
 
+## Vue 3 adapter
+
+The Vue adapter is optional and lives in `maskarajs/vue`. Its default export is a Vue 3 directive ready for `v-maskara`. Use it locally in a component or register it once as a plugin.
+
+### Local directive
+
+```vue
+<script setup lang="ts">
+import { maskaraDirective as vMaskara } from 'maskarajs/vue'
+
+const pattern = '###[.]###[.]###[-]##'
+</script>
+
+<template>
+  <input v-maskara="pattern" inputmode="numeric" />
+</template>
+```
+
+### With `v-model` and raw value callback
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import { maskaraDirective as vMaskara } from 'maskarajs/vue'
+
+const document = ref('')
+const rawDocument = ref('')
+</script>
+
+<template>
+  <input
+    v-model="document"
+    v-maskara="{
+      pattern: '###[.]###[.]###[-]##',
+      onValue: value => rawDocument = value
+    }"
+    inputmode="numeric"
+  />
+</template>
+```
+
+The directive listens during the capture phase, so Vue's `v-model` receives the masked value during the same input event.
+
+### Register globally
+
+```ts
+import { createApp } from 'vue'
+import { createMaskaraPlugin } from 'maskarajs/vue'
+import App from './App.vue'
+
+createApp(App)
+  .use(createMaskaraPlugin())
+  .mount('#app')
+```
+
+Then use it anywhere:
+
+```vue
+<input v-maskara="'#####[-]###'" />
+```
+
+### Use an isolated engine
+
+```ts
+import maskara from 'maskarajs'
+import { createMaskaraPlugin } from 'maskarajs/vue'
+
+const br = maskara.create({
+  cpf: { pattern: '###[.]###[.]###[-]##' },
+  phone: { pattern: ['[(]##[)] ####[-]####', '[(]##[)] #####[-]####'] },
+})
+
+app.use(createMaskaraPlugin({ engine: br }))
+```
+
+You can also create a directive instance manually:
+
+```ts
+import { createMaskaraDirective } from 'maskarajs/vue'
+
+const vMaskara = createMaskaraDirective({ engine: br })
+```
+
 ## Examples
 
 ```js

package/package.json

@@ -1,48 +1,49 @@
 {
   "name": "maskarajs",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Engine de máscaras declarativo — framework-agnostic, zero dependências, ~4kb",
-  "main": "./mask.cjs.js",
-  "module": "./mask.mjs",
-  "types": "./mask.d.ts",
+  "main": "./src/core/mask.cjs.js",
+  "module": "./src/core/mask.mjs",
+  "types": "./src/core/mask.d.ts",
   "scripts": {
     "test": "node test/mask.test.mjs"
   },
   "exports": {
     ".": {
-      "import": "./mask.mjs",
-      "require": "./mask.cjs.js",
-      "types": "./mask.d.ts"
+      "import": "./src/core/mask.mjs",
+      "require": "./src/core/mask.cjs.js",
+      "types": "./src/core/mask.d.ts"
     },
     "./react": {
-      "import": "./react.mjs",
-      "require": "./react.cjs.js",
-      "types": "./react.d.ts"
+      "import": "./src/adapters/react/index.mjs",
+      "require": "./src/adapters/react/index.cjs.js",
+      "types": "./src/adapters/react/index.d.ts"
+    },
+    "./vue": {
+      "import": "./src/adapters/vue/index.mjs",
+      "require": "./src/adapters/vue/index.cjs.js",
+      "types": "./src/adapters/vue/index.d.ts"
     },
     "./presets/br": {
-      "import": "./presets/br.mjs",
-      "require": "./presets/br.cjs.js",
-      "types": "./presets/br.d.ts"
+      "import": "./src/presets/br.mjs",
+      "require": "./src/presets/br.cjs.js",
+      "types": "./src/presets/br.d.ts"
     }
   },
   "files": [
     "src",
-    "mask.js",
-    "mask.mjs",
-    "mask.cjs.js",
-    "mask.d.ts",
-    "react.mjs",
-    "react.cjs.js",
-    "react.d.ts",
-    "presets",
     "README.md"
   ],
   "peerDependencies": {
-    "react": ">=18"
+    "react": ">=18",
+    "vue": ">=3"
   },
   "peerDependenciesMeta": {
     "react": {
       "optional": true
+    },
+    "vue": {
+      "optional": true
     }
   },
   "sideEffects": false,

package/{react.cjs.js → src/adapters/react/index.cjs.js}

@@ -1,7 +1,7 @@
 'use strict'
 
 const React = require('react')
-const maskara = require('./mask.cjs.js')
+const maskara = require('../../core/mask.cjs.js')
 
 const MaskaraEngineContext = React.createContext(maskara)
 

package/{react.d.ts → src/adapters/react/index.d.ts}

@@ -1,5 +1,5 @@
 import type { ChangeEvent, InputHTMLAttributes, ReactNode } from 'react'
-import type { MaskaraInstance, MaskaraPattern } from './mask'
+import type { MaskaraInstance, MaskaraPattern } from '../../core/mask'
 
 export type MaskaraInputChange = ChangeEvent<HTMLInputElement> | string | number | null | undefined
 export type MaskInputChange = MaskaraInputChange
@@ -7,7 +7,7 @@ export type MaskInputChange = MaskaraInputChange
 export interface UseMaskaraOptions<T = string> {
   value?: string | null | undefined
   defaultValue?: string | null | undefined
-  engine?: MaskaraInstance | typeof import('./mask').default
+  engine?: MaskaraInstance | typeof import('../../core/mask').default
   onValue?: (value: T) => void
   onMaskara?: (masked: string) => void
   onMasked?: (masked: string) => void
@@ -33,7 +33,7 @@ export interface UseMaskaraResult<T = string> {
 export type UseMaskResult<T = string> = UseMaskaraResult<T>
 
 export interface MaskaraProviderProps {
-  engine?: MaskaraInstance | typeof import('./mask').default
+  engine?: MaskaraInstance | typeof import('../../core/mask').default
   children?: ReactNode
 }
 export type MaskProviderProps = MaskaraProviderProps
@@ -41,8 +41,8 @@ export type MaskProviderProps = MaskaraProviderProps
 export declare function MaskaraProvider(props: MaskaraProviderProps): ReactNode
 export declare function MaskProvider(props: MaskProviderProps): ReactNode
 
-export declare function useMaskaraEngine(): MaskaraInstance | typeof import('./mask').default
-export declare function useMaskEngine(): MaskaraInstance | typeof import('./mask').default
+export declare function useMaskaraEngine(): MaskaraInstance | typeof import('../../core/mask').default
+export declare function useMaskEngine(): MaskaraInstance | typeof import('../../core/mask').default
 
 export declare function useMaskara<T = string>(
   pattern: MaskaraPattern,

package/src/{react/useMask.mjs → adapters/react/index.mjs}

@@ -1,5 +1,5 @@
 import { createContext, createElement, useCallback, useContext, useMemo, useState } from 'react'
-import maskara from '../../mask.mjs'
+import maskara from '../../core/mask.mjs'
 
 const MaskaraEngineContext = createContext(maskara)
 

package/src/adapters/vue/index.cjs.js

@@ -0,0 +1,151 @@
+const maskara = require('../../core/mask.cjs.js')
+
+const STATE = Symbol('maskaraDirectiveState')
+
+function frame(callback) {
+  if (typeof requestAnimationFrame === 'function') {
+    requestAnimationFrame(callback)
+    return
+  }
+
+  callback()
+}
+
+function normalizeBinding(value, defaults = {}) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return {
+      engine: value.engine ?? defaults.engine ?? maskara,
+      pattern: value.pattern ?? value.maskara ?? value.mask,
+      onValue: value.onValue,
+      onMaskara: value.onMaskara,
+      onMasked: value.onMasked,
+    }
+  }
+
+  return {
+    engine: defaults.engine ?? maskara,
+    pattern: value,
+  }
+}
+
+function applyMask(el, config, notify = false) {
+  if (!config.pattern) return
+
+  const current = el.value ?? ''
+  const masked = config.engine(config.pattern, current)
+  el.value = masked
+
+  if (!notify) return
+
+  config.onMaskara?.(masked)
+  config.onMasked?.(masked)
+  config.onValue?.(config.engine.raw(config.pattern, masked))
+}
+
+function bind(el, binding, defaults = {}) {
+  el[STATE]?.cleanup?.()
+
+  const config = normalizeBinding(binding.value, defaults)
+  if (!config.pattern) {
+    el[STATE] = { cleanup: null, bindingValue: binding.value }
+    return
+  }
+
+  function onKeydown(event) {
+    if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return
+    const rawLength = config.engine.rawLength(config.pattern, el.value)
+    const maxLength = config.engine.patternLength(config.pattern)
+    if (rawLength >= maxLength) event.preventDefault()
+  }
+
+  function onInput(event) {
+    const target = event.target
+    const raw = target.value ?? ''
+    const cursor = target.selectionStart ?? raw.length
+    const masked = config.engine(config.pattern, raw)
+    const diff = masked.length - raw.length
+
+    target.value = masked
+
+    frame(() => {
+      const position = Math.max(0, cursor + diff)
+      target.setSelectionRange?.(position, position)
+    })
+
+    config.onMaskara?.(masked)
+    config.onMasked?.(masked)
+    config.onValue?.(config.engine.raw(config.pattern, masked))
+  }
+
+  el.addEventListener('keydown', onKeydown)
+  el.addEventListener('input', onInput, true)
+  applyMask(el, config)
+
+  el[STATE] = {
+    bindingValue: binding.value,
+    cleanup() {
+      el.removeEventListener('keydown', onKeydown)
+      el.removeEventListener('input', onInput, true)
+    },
+  }
+}
+
+function sameBindingValue(previous, next) {
+  if (previous === next) return true
+  if (!previous || !next) return false
+  if (typeof previous !== 'object' || typeof next !== 'object') return false
+
+  return (
+    previous.pattern === next.pattern &&
+    previous.maskara === next.maskara &&
+    previous.mask === next.mask &&
+    previous.engine === next.engine &&
+    previous.onValue === next.onValue &&
+    previous.onMaskara === next.onMaskara &&
+    previous.onMasked === next.onMasked
+  )
+}
+
+function createMaskaraDirective(defaults = {}) {
+  return {
+    mounted(el, binding) {
+      bind(el, binding, defaults)
+    },
+    updated(el, binding) {
+      if (!sameBindingValue(el[STATE]?.bindingValue, binding.value)) {
+        bind(el, binding, defaults)
+        return
+      }
+
+      const config = normalizeBinding(binding.value, defaults)
+      applyMask(el, config)
+    },
+    beforeUnmount(el) {
+      el[STATE]?.cleanup?.()
+      delete el[STATE]
+    },
+  }
+}
+
+function createMaskaraPlugin(options = {}) {
+  const name = options.name ?? 'maskara'
+  const directive = createMaskaraDirective(options)
+
+  return {
+    install(app) {
+      app.directive(name, directive)
+    },
+  }
+}
+
+const maskaraDirective = createMaskaraDirective()
+const vMaskara = maskaraDirective
+const useMaskaraDirective = createMaskaraDirective
+
+module.exports = maskaraDirective
+module.exports.default = maskaraDirective
+module.exports.maskaraDirective = maskaraDirective
+module.exports.vMaskara = vMaskara
+module.exports.createMaskaraDirective = createMaskaraDirective
+module.exports.createMaskaraPlugin = createMaskaraPlugin
+module.exports.useMaskaraDirective = useMaskaraDirective

package/src/adapters/vue/index.d.ts

@@ -0,0 +1,46 @@
+import type { Directive, ObjectDirective, Plugin } from 'vue'
+import type { MaskaraInstance, MaskaraOnOptions, MaskaraPattern } from '../../core/mask'
+
+export type MaskaraDirectivePattern = MaskaraPattern | keyof Record<string, unknown>
+
+export interface MaskaraDirectiveOptions<T = string> extends MaskaraOnOptions<T> {
+  pattern?: MaskaraPattern | string
+  maskara?: MaskaraPattern | string
+  mask?: MaskaraPattern | string
+  engine?: MaskaraInstance | typeof import('../../core/mask').default
+}
+
+export type MaskaraDirectiveValue<T = string> =
+  | MaskaraPattern
+  | string
+  | MaskaraDirectiveOptions<T>
+
+export type MaskaraDirective<T = string> = ObjectDirective<
+  HTMLInputElement,
+  MaskaraDirectiveValue<T>
+>
+
+export interface CreateMaskaraDirectiveOptions {
+  engine?: MaskaraInstance | typeof import('../../core/mask').default
+}
+
+export interface CreateMaskaraPluginOptions extends CreateMaskaraDirectiveOptions {
+  name?: string
+}
+
+export declare function createMaskaraDirective<T = string>(
+  options?: CreateMaskaraDirectiveOptions
+): MaskaraDirective<T>
+
+export declare function useMaskaraDirective<T = string>(
+  options?: CreateMaskaraDirectiveOptions
+): MaskaraDirective<T>
+
+export declare function createMaskaraPlugin(
+  options?: CreateMaskaraPluginOptions
+): Plugin
+
+export declare const maskaraDirective: MaskaraDirective
+export declare const vMaskara: Directive<HTMLInputElement, MaskaraDirectiveValue>
+
+export default maskaraDirective

package/src/adapters/vue/index.mjs

@@ -0,0 +1,147 @@
+import maskara from '../../core/mask.mjs'
+
+const STATE = Symbol('maskaraDirectiveState')
+
+function frame(callback) {
+  if (typeof requestAnimationFrame === 'function') {
+    requestAnimationFrame(callback)
+    return
+  }
+
+  callback()
+}
+
+function normalizeBinding(value, defaults = {}) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return {
+      engine: value.engine ?? defaults.engine ?? maskara,
+      pattern: value.pattern ?? value.maskara ?? value.mask,
+      onValue: value.onValue,
+      onMaskara: value.onMaskara,
+      onMasked: value.onMasked,
+    }
+  }
+
+  return {
+    engine: defaults.engine ?? maskara,
+    pattern: value,
+  }
+}
+
+function applyMask(el, config, notify = false) {
+  if (!config.pattern) return
+
+  const current = el.value ?? ''
+  const masked = config.engine(config.pattern, current)
+  el.value = masked
+
+  if (!notify) return
+
+  config.onMaskara?.(masked)
+  config.onMasked?.(masked)
+  config.onValue?.(config.engine.raw(config.pattern, masked))
+}
+
+function bind(el, binding, defaults = {}) {
+  el[STATE]?.cleanup?.()
+
+  const config = normalizeBinding(binding.value, defaults)
+  if (!config.pattern) {
+    el[STATE] = { cleanup: null, bindingValue: binding.value }
+    return
+  }
+
+  function onKeydown(event) {
+    if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return
+    const rawLength = config.engine.rawLength(config.pattern, el.value)
+    const maxLength = config.engine.patternLength(config.pattern)
+    if (rawLength >= maxLength) event.preventDefault()
+  }
+
+  function onInput(event) {
+    const target = event.target
+    const raw = target.value ?? ''
+    const cursor = target.selectionStart ?? raw.length
+    const masked = config.engine(config.pattern, raw)
+    const diff = masked.length - raw.length
+
+    target.value = masked
+
+    frame(() => {
+      const position = Math.max(0, cursor + diff)
+      target.setSelectionRange?.(position, position)
+    })
+
+    config.onMaskara?.(masked)
+    config.onMasked?.(masked)
+    config.onValue?.(config.engine.raw(config.pattern, masked))
+  }
+
+  el.addEventListener('keydown', onKeydown)
+  el.addEventListener('input', onInput, true)
+  applyMask(el, config)
+
+  el[STATE] = {
+    bindingValue: binding.value,
+    cleanup() {
+      el.removeEventListener('keydown', onKeydown)
+      el.removeEventListener('input', onInput, true)
+    },
+  }
+}
+
+function sameBindingValue(previous, next) {
+  if (previous === next) return true
+  if (!previous || !next) return false
+  if (typeof previous !== 'object' || typeof next !== 'object') return false
+
+  return (
+    previous.pattern === next.pattern &&
+    previous.maskara === next.maskara &&
+    previous.mask === next.mask &&
+    previous.engine === next.engine &&
+    previous.onValue === next.onValue &&
+    previous.onMaskara === next.onMaskara &&
+    previous.onMasked === next.onMasked
+  )
+}
+
+export function createMaskaraDirective(defaults = {}) {
+  return {
+    mounted(el, binding) {
+      bind(el, binding, defaults)
+    },
+    updated(el, binding) {
+      if (!sameBindingValue(el[STATE]?.bindingValue, binding.value)) {
+        bind(el, binding, defaults)
+        return
+      }
+
+      const config = normalizeBinding(binding.value, defaults)
+      applyMask(el, config)
+    },
+    beforeUnmount(el) {
+      el[STATE]?.cleanup?.()
+      delete el[STATE]
+    },
+  }
+}
+
+export function createMaskaraPlugin(options = {}) {
+  const name = options.name ?? 'maskara'
+  const directive = createMaskaraDirective(options)
+
+  return {
+    install(app) {
+      app.directive(name, directive)
+    },
+  }
+}
+
+export const maskaraDirective = createMaskaraDirective()
+export const vMaskara = maskaraDirective
+
+const useMaskaraDirective = createMaskaraDirective
+
+export { useMaskaraDirective }
+export default maskaraDirective

package/{mask.cjs.js → src/core/mask.cjs.js}

@@ -994,7 +994,9 @@ mask.create = function (presets = {}) {
 
 // ─── Export ────────────────────────────────────────────────────────────────
 
-// export { mask }
+const maskara = mask
+
+// export { mask, maskara }
 // export default mask
 
 module.exports = mask

package/src/core/mask.d.ts

@@ -322,7 +322,7 @@ export declare namespace mask {
    *   onValue: date => ...  // date: Date | null ✓ (inferido)
    * })
    */
-  function create<R extends Record<string, unknown> = Record<string, string>>(
+  function create<R extends Record<string, unknown> = {}>(
     presets?: { [K in keyof R]: MaskDefinition<R[K]> }
   ): MaskInstance<R>
 }

package/{presets → src/presets}/br.d.ts

@@ -1,4 +1,4 @@
-import type { MaskaraDefinition } from '../mask'
+import type { MaskaraDefinition } from '../core/mask'
 
 export interface BrazilPresetRegistry {
   cpf: string

package/mask.d.ts

@@ -1,333 +0,0 @@
-/**
- * mask.d.ts
- *
- * Tipagens com parâmetro de registry para autocomplete de nomes registrados.
- *
- * Uso básico (sem generics — funciona, sem autocomplete de nomes):
- *   import maskara from './mask.js'
- *   maskara('cpf', value)
- *
- * Uso tipado (com autocomplete de nomes):
- *   const m = maskara.create<{ cpf: string; date: Date | null; money: number }>({
- *     cpf:   { pattern: '###[.]###[.]###[-]##' },
- *     date:  { pattern: '##[/]##[/]####', transform: ... },
- *     money: { pattern: '########[,]##', transform: ... },
- *   })
- *   m('cpf', value)          // ← autocomplete sugere 'cpf' | 'date' | 'money'
- *   m.raw('date', value)     // ← retorno inferido: Date | null
- *   m.raw('money', value)    // ← retorno inferido: number
- *   m.raw('cpf', value)      // ← retorno inferido: string
- */
-
-// ─── Primitivos ───────────────────────────────────────────────────────────
-
-/** Regra condicional para escolher um pattern a partir do raw digitado */
-export interface MaskPatternRule {
-  pattern: string | string[]
-  when?: (raw: string, value: string) => boolean
-}
-export type MaskaraPatternRule = MaskPatternRule
-
-/** Mapa de patterns usado por máscaras nomeadas condicionais */
-export type MaskPatternMap = Record<string, string | string[]>
-export type MaskaraPatternMap = MaskPatternMap
-
-/** Função que escolhe uma chave de patterns a partir do valor digitado */
-export type MaskSelect<K extends string = string> = (raw: string, value: string) => K
-export type MaskaraSelect<K extends string = string> = MaskSelect<K>
-
-/** String de padrão declarativo, array dinâmico ou array de regras condicionais */
-export type MaskPattern = string | string[] | MaskPatternRule[]
-export type MaskaraPattern = MaskPattern
-
-/** Função de transformação — recebe (raw, masked, complete) e retorna T */
-export type MaskTransform<T> = (raw: string, masked: string, complete: boolean) => T
-export type MaskaraTransform<T> = MaskTransform<T>
-
-/** Validação incremental — retorna false para recusar o próximo caractere */
-export type MaskValidate = (raw: string, masked: string, complete: boolean) => boolean
-export type MaskaraValidate = MaskValidate
-
-/** Predicado usado por um slot customizado */
-export type MaskSlotTest = (ch: string) => boolean
-export type MaskaraSlotTest = MaskSlotTest
-
-/** Definição completa de um slot customizado */
-export interface MaskSlotDefinition {
-  test: MaskSlotTest
-  hint?: string
-}
-export type MaskaraSlotDefinition = MaskSlotDefinition
-
-/** Formas aceitas para registrar um slot customizado */
-export type MaskSlotInput = MaskSlotTest | RegExp | MaskSlotDefinition
-export type MaskaraSlotInput = MaskSlotInput
-
-/** Definição de uma máscara nomeada com pattern único ou array dinâmico */
-export interface MaskPatternDefinition<T = string> {
-  pattern: MaskPattern
-  transform?: MaskTransform<T>
-  validate?: MaskValidate
-}
-export type MaskaraPatternDefinition<T = string> = MaskPatternDefinition<T>
-
-/** Definição de uma máscara nomeada que seleciona um pattern por raw/value */
-export interface MaskConditionalDefinition<T = string, K extends string = string> {
-  patterns: Record<K, MaskPattern>
-  select: MaskSelect<K>
-  transform?: MaskTransform<T>
-  validate?: MaskValidate
-}
-export type MaskaraConditionalDefinition<T = string, K extends string = string> = MaskConditionalDefinition<T, K>
-
-/** Definição de uma máscara nomeada */
-export type MaskDefinition<T = string> = MaskPatternDefinition<T> | MaskConditionalDefinition<T>
-export type MaskaraDefinition<T = string> = MaskDefinition<T>
-
-/** Opções de mask.on */
-export interface MaskOnOptions<T> {
-  /** Chamado a cada keystroke com o valor limpo / resultado do transform */
-  onValue?: (value: T) => void
-  /** Chamado a cada keystroke com o valor mascarado (display). Nome preferido. */
-  onMaskara?: (masked: string) => void
-  /** Chamado a cada keystroke com o valor mascarado (display) */
-  onMasked?: (masked: string) => void
-}
-export type MaskaraOnOptions<T> = MaskOnOptions<T>
-
-// ─── Registry map ─────────────────────────────────────────────────────────
-//
-// R = Record dos nomes registrados com seus tipos de retorno do transform.
-//
-// Exemplo:
-//   type MyRegistry = {
-//     cpf:   string        // sem transform → string
-//     date:  Date | null   // transform retorna Date | null
-//     money: number        // transform retorna number
-//   }
-//
-// Usado para inferir o tipo de retorno de raw() a partir do nome.
-
-/** Extrai o tipo de retorno de raw() para um nome de máscara */
-type RawReturn<R extends Record<string, unknown>, K extends keyof R | MaskPattern> =
-  K extends keyof R ? R[K] : string
-
-/** Union de nomes registrados + MaskPattern (para aceitar padrão literal também) */
-type PatternOrName<R extends Record<string, unknown>> = keyof R | MaskPattern
-
-// ─── MaskInstance ─────────────────────────────────────────────────────────
-
-/**
- * Instância tipada retornada por mask.create<R>(presets).
- *
- * R = mapa de nomes para tipos de retorno do transform.
- * Autocomplete sugere os nomes registrados em todos os métodos.
- */
-export interface MaskInstance<R extends Record<string, unknown> = Record<string, string>> {
-
-  /**
-   * Aplica máscara — retorna string formatada para exibição.
-   * @param pattern nome registrado (autocomplete) ou padrão literal
-   */
-  <K extends PatternOrName<R>>(pattern: K, value: string | null | undefined): string
-
-  /**
-   * Retorna o raw value passado pelo transform.
-   * O tipo de retorno é inferido automaticamente pelo nome registrado.
-   *
-   * @example
-   * m.raw('date', v)   // → Date | null  (inferido do registry)
-   * m.raw('money', v)  // → number       (inferido do registry)
-   * m.raw('cpf', v)    // → string       (inferido do registry)
-   */
-  raw<K extends PatternOrName<R>>(
-    pattern: K,
-    value: string | null | undefined
-  ): RawReturn<R, K>
-
-  /**
-   * Verifica se o valor preenche completamente o padrão.
-   */
-  is<K extends PatternOrName<R>>(pattern: K, value: string | null | undefined): boolean
-
-  /**
-   * Retorna o placeholder legível do padrão.
-   * @example m.hint('cpf') // → '000.000.000-00'
-   */
-  hint<K extends PatternOrName<R>>(pattern: K): string
-
-  /**
-   * Formata um valor vindo da API para exibição. Alias semântico de apply.
-   * @example m.format('cpf', user.cpf) // → '123.456.789-09'
-   */
-  format<K extends PatternOrName<R>>(pattern: K, value: string | null | undefined): string
-
-  /**
-   * Comprimento do raw atual — chars de input preenchidos (sem literais).
-   * Nunca passa pelo transform. Útil para progress bars.
-   * @example
-   * const pct = m.rawLength('cpf', v) / m.patternLength('cpf') * 100
-   */
-  rawLength<K extends PatternOrName<R>>(pattern: K, value: string | null | undefined): number
-
-  /**
-   * Comprimento total do valor mascarado completo.
-   * Conta slots como 1 caractere e literais pelo tamanho real.
-   * Para arrays, retorna o maior valor mascarado possível.
-   */
-  patternLength<K extends PatternOrName<R>>(pattern: K): number
-
-  /**
-   * Registra uma nova máscara nesta instância.
-   * Não afeta outras instâncias nem o registry global.
-   */
-  define<N extends string, T = string>(name: N, definition: MaskDefinition<T>): void
-
-  /**
-   * Remove uma máscara desta instância.
-   */
-  undefine<K extends keyof R>(name: K): void
-
-  /**
-   * Lista os nomes registrados nesta instância.
-   */
-  names(): Array<keyof R & string>
-
-  /**
-   * Cria ou sobrescreve um símbolo de slot apenas nesta instância.
-   * Use [N] quando precisar tratar um símbolo registrado como literal.
-   */
-  defineSlot(symbol: string, definition: MaskSlotInput): void
-
-  /**
-   * Remove um slot desta instância.
-   * Slots padrão (#, @, *) voltam ao comportamento original.
-   */
-  undefineSlot(symbol: string): void
-
-  /** Lista os símbolos de slot disponíveis nesta instância */
-  slots(): string[]
-
-  /**
-   * Vincula máscara a um input DOM. Retorna cleanup().
-   * Framework-agnostic — funciona em React, Vue, Svelte, Vanilla.
-   *
-   * @example
-   * // React
-   * useEffect(() => m.on(ref.current, 'date', { onValue: setDate }), [])
-   *
-   * // Vue
-   * onMounted(() => m.on(inputRef.value, 'phone', { onValue: v => emit('update:modelValue', v) }))
-   *
-   * // Svelte action
-   * const maskAction = (node, name) => ({ destroy: m.on(node, name) })
-   */
-  on<K extends PatternOrName<R>>(
-    input: HTMLInputElement,
-    pattern: K,
-    options?: MaskOnOptions<RawReturn<R, K>>
-  ): () => void
-
-  /** Cria uma sub-instância com registry próprio */
-  create<S extends Record<string, unknown>>(
-    presets?: { [K in keyof S]: MaskDefinition<S[K]> }
-  ): MaskInstance<S>
-}
-export type MaskaraInstance<R extends Record<string, unknown> = Record<string, string>> = MaskInstance<R>
-
-// ─── Função principal (registry global, sem generics de nome) ─────────────
-
-/**
- * Aplica máscara a um valor.
- *
- * @example
- * mask('###[.]###[.]###[-]##', '12345678909') // → '123.456.789-09'
- * mask(['[(]##[)] ####[-]####', '[(]##[)] #####[-]####'], '11987654321')
- */
-export declare function mask(pattern: MaskPattern, value: string | null | undefined): string
-
-export declare namespace mask {
-
-  /** Retorna o raw value / resultado do transform */
-  function raw<T = string>(pattern: MaskPattern, value: string | null | undefined): T
-
-  /** Verifica se o valor preenche completamente o padrão */
-  function is(pattern: MaskPattern, value: string | null | undefined): boolean
-
-  /** Retorna o placeholder legível do padrão */
-  function hint(pattern: MaskPattern): string
-
-  /** Alias semântico de mask() para formatar valores da API */
-  function format(pattern: MaskPattern, value: string | null | undefined): string
-
-  /** Chars de input preenchidos — sem literais, sem transform */
-  function rawLength(pattern: MaskPattern, value: string | null | undefined): number
-
-  /** Comprimento total do valor mascarado completo */
-  function patternLength(pattern: MaskPattern): number
-
-  /** Registra máscara nomeada no registry global */
-  function define<T = string>(name: string, definition: MaskDefinition<T>): void
-
-  /** Remove máscara do registry global */
-  function undefine(name: string): void
-
-  /** Lista nomes do registry global */
-  function names(): string[]
-
-  /**
-   * Cria ou sobrescreve um símbolo de slot no engine global.
-   * Use [N] quando precisar tratar um símbolo registrado como literal.
-   */
-  function defineSlot(symbol: string, definition: MaskSlotInput): void
-
-  /**
-   * Remove um slot global.
-   * Slots padrão (#, @, *) voltam ao comportamento original.
-   */
-  function undefineSlot(symbol: string): void
-
-  /** Lista os símbolos de slot disponíveis no engine global */
-  function slots(): string[]
-
-  /** Vincula máscara a input DOM — retorna cleanup() */
-  function on<T = string>(
-    input: HTMLInputElement,
-    pattern: MaskPattern,
-    options?: MaskOnOptions<T>
-  ): () => void
-
-  /**
-   * Cria uma instância isolada com registry próprio e tipos inferidos.
-   *
-   * O generic R mapeia cada nome ao tipo de retorno do seu transform —
-   * isso habilita autocomplete de nomes e inferência de tipo em raw().
-   *
-   * @example
-   * const m = mask.create<{
-   *   cpf:   string
-   *   date:  Date | null
-   *   money: number
-   * }>({
-   *   cpf:   { pattern: '###[.]###[.]###[-]##' },
-   *   date:  { pattern: '##[/]##[/]####', transform: (r,_,c) => c ? new Date(...) : null },
-   *   money: { pattern: '########[,]##', transform: r => parseInt(r||'0',10)/100 },
-   * })
-   *
-   * m('cpf', v)           // autocomplete: 'cpf' | 'date' | 'money'
-   * m.raw('date', v)      // → Date | null  ✓
-   * m.raw('money', v)     // → number       ✓
-   * m.rawLength('cpf', v) // → number       ✓
-   * m.on(el, 'date', {
-   *   onValue: date => ...  // date: Date | null ✓ (inferido)
-   * })
-   */
-  function create<R extends Record<string, unknown> = Record<string, string>>(
-    presets?: { [K in keyof R]: MaskDefinition<R[K]> }
-  ): MaskInstance<R>
-}
-
-/** Preferred alias for the main engine. `mask` remains available for compatibility. */
-export declare const maskara: typeof mask
-
-export default mask

package/mask.js

@@ -1,2 +0,0 @@
-export { mask, maskara } from './src/core/mask.mjs'
-export { default } from './src/core/mask.mjs'

package/mask.mjs

@@ -1,2 +0,0 @@
-export { mask, maskara } from './src/core/mask.mjs'
-export { default } from './src/core/mask.mjs'

package/react.mjs

@@ -1,2 +0,0 @@
-export { MaskaraProvider, MaskProvider, useMaskara, useMask, useMaskaraEngine, useMaskEngine } from './src/react/useMask.mjs'
-export { default } from './src/react/useMask.mjs'