@kigi/components 1.63.2-beta.1 → 1.63.3-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kigi/components",
-  "version": "1.63.2-beta.1",
+  "version": "1.63.3-beta.1",
   "description": "@kigi/components",
   "main": "src/components/index.ts",
   "scripts": {
@@ -32,7 +32,6 @@
     "@firebase/remote-config": "^0.1.25",
     "@firebase/storage": "^0.3.39",
     "@firebase/util": "^0.2.50",
-    "@kigi/components": "^1.63.1-beta.1",
     "@syncfusion/ej2-base": "^17.4.43",
     "@syncfusion/ej2-buttons": "^17.4.43",
     "@syncfusion/ej2-documenteditor": "^17.4.43",
@@ -101,4 +100,4 @@
     "webpack": "^2.5.1",
     "webpack-dev-server": "^2.6.1"
   }
-}
+}

package/src/components/mbg-input-cnpj/mbg-input-cnpj.html

@@ -2,20 +2,6 @@
      ng-if="$ctrl.props"
      mbg-autocomplete-off>
     <input type="text"
-           ng-if="$ctrl.allowAlphanumeric"
-           ng-model="$ctrl.ngModel"
-           ng-change="$ctrl.onChange()"
-           placeholder="{{ $ctrl.props.placeholder }}"
-           ng-required="$ctrl.ngRequired"
-           ng-disabled="$ctrl.ngDisabled"
-           ng-blur="$ctrl.ngBlur({ $event })"
-           ng-focus="$ctrl.ngFocus({ $event })"
-           ng-keyup="$ctrl.ngKeyup({ $event })"
-           ng-keypress="$ctrl.ngKeypress({ $event })"
-           ng-keydown="$ctrl.ngKeydown({ $event })"
-           mbg-alphanumeric-cnpj-mask />
-    <input type="text"
-           ng-if="!$ctrl.allowAlphanumeric"
            ng-model="$ctrl.ngModel"
            ng-change="$ctrl.onChange()"
            placeholder="{{ $ctrl.props.placeholder }}"

package/src/components/mbg-input-cnpj/mbg-input-cnpj.ts

@@ -1,76 +1,82 @@
 import './mbg-input-cnpj.scss'
 import template from './mbg-input-cnpj.html'
-import {
-  normalizeAlphanumericCnpj,
-  formatAlphanumericCnpj,
-  isValidAlphanumericCnpj,
-  mbgDocumentMaskDirective,
-} from '../../helpers/mbg-document-mask-directive'
-import { isValidCnpj } from '../../helpers/cnpj-validador'
 
 class MbgInputCnpjController {
-  private ngChange
-  private ngModel
-  private ngRequired
-  private ngDisabled
-  private props
-  private allowAlphanumeric: boolean
-  public valid = true
+    private ngChange
+    private ngModel
+    private ngRequired
+    private ngDisabled
+    private props
+    public valid = true
 
-  constructor(
-    public $scope,
-    public $element,
-    public $attrs,
-  ) {
-    if ($attrs.ngRequired === '') {
-      this.ngRequired = true
+    constructor(public $scope, public $element, public $attrs) {
+        if ($attrs.ngRequired === '') {
+            this.ngRequired = true
+        }
+        if ($attrs.ngDisabled === '') {
+            this.ngDisabled = true
+        }
+        this.props = {
+            placeholder: $attrs.placeholder || '',
+        }
     }
-    if ($attrs.ngDisabled === '') {
-      this.ngDisabled = true
-    }
-    this.props = {
-      placeholder: $attrs.placeholder || '',
-    }
-  }
 
-  $onInit() {
-    this.allowAlphanumeric = this.allowAlphanumeric === true
-  }
+    ngBlur(evt) {
+        this.valid = this.validaCnpj(evt.$event.target.value)
+    }
 
-  ngBlur(evt) {
-    const raw = evt.$event.target.value
-    const clean = normalizeAlphanumericCnpj(raw)
+    validaCnpj(value) {
+        let original = value
+        let firstNumbers = value.substr(0, 12)
+        let firstCalc = this.CalcDigits(firstNumbers, 5)
+        let secondCalc = this.CalcDigits(firstCalc, 6)
+        if (secondCalc === original) {
+            return true
+        }
+        return false
+    }
 
-    if (clean.length === 14) {
-      this.valid = isValidAlphanumericCnpj(clean)
-    } else {
-      this.valid = isValidCnpj(clean)
+    CalcDigits(digits, positions = 10, sumDigits = 0) {
+        digits = digits.toString()
+        for (let i = 0; i < digits.length; i++) {
+            sumDigits = sumDigits + (digits[i] * positions)
+            positions--
+            if (positions < 2) {
+                positions = 9
+            }
+        }
+        sumDigits = sumDigits % 11
+        if (sumDigits < 2) {
+            sumDigits = 0
+        } else {
+            sumDigits = 11 - sumDigits
+        }
+        let cnpj = digits + sumDigits
+        return cnpj
     }
-  }
 
-  onChange() {
-    if (this.ngChange) {
-      this.ngChange({})
+    onChange() {
+        if (this.ngChange) {
+            this.ngChange({})
+        }
     }
-  }
 }
 MbgInputCnpjController.$inject = ['$scope', '$element', '$attrs']
 
 const mbgInputCnpj = {
-  bindings: {
-    ngModel: '=',
-    ngChange: '&?',
-    ngRequired: '=?',
-    ngDisabled: '=?',
-    ngBlur: '&?',
-    ngFocus: '&?',
-    ngKeyup: '&?',
-    ngKeypress: '&?',
-    ngKeydown: '&?',
-    allowAlphanumeric: '<?',
-  },
-  template,
-  controller: MbgInputCnpjController,
+    bindings: {
+        ngModel: '=',
+        ngChange: '&?',
+        ngRequired: '=?',
+        ngDisabled: '=?',
+        ngBlur: '&?',
+        ngFocus: '&?',
+        ngKeyup: '&?',
+        ngKeypress: '&?',
+        ngKeydown: '&?',
+    },
+    template,
+    controller: MbgInputCnpjController,
 }
 
-export { mbgInputCnpj, mbgDocumentMaskDirective }
+export { mbgInputCnpj }

package/src/components/mbg-input-cpfcnpj/index.ts

@@ -1,10 +1,9 @@
 import * as angular from 'angular'
-import { mbgInputCpfCnpj, mbgDocumentMaskDirective } from './mbg-input-cpfcnpj'
+import { mbgInputCpfCnpj } from './mbg-input-cpfcnpj'
 
 const mbgInputCpfCnpjModule = angular
     .module('mbg.components.mbgInputCpfCnpj', [])
     .component('mbgInputCpfCnpj', mbgInputCpfCnpj)
-    .directive('mbgAlphanumericCnpjMask', mbgDocumentMaskDirective)
     .name
 
 export { mbgInputCpfCnpjModule }

package/src/components/mbg-input-cpfcnpj/mbg-input-cpfcnpj.html

@@ -1,32 +1,16 @@
 <div class="mbg-input-wrapper mb-input-cpfcnpj-wrapper"
      ng-if="$ctrl.props"
      mbg-autocomplete-off>
-     <input type="text"
-            ng-if="$ctrl.allowAlphanumeric"
-            ng-model="$ctrl.ngModel"
-            name="{{$ctrl.name}}"
-            ng-change="$ctrl.onChange()"
-            placeholder="{{ $ctrl.props.placeholder }}"
-            ng-required="$ctrl.ngRequired"
-            ng-disabled="$ctrl.ngDisabled"
-            ng-blur="$ctrl.ngBlur({ $event })"
-            ng-focus="$ctrl.ngFocus({ $event })"
-            ng-keyup="$ctrl.ngKeyup({ $event })"
-            ng-keypress="$ctrl.ngKeypress({ $event })"
-            ng-keydown="$ctrl.ngKeydown({ $event })"
-            mbg-alphanumeric-cnpj-mask />
-     <input type="text"
-            ng-if="!$ctrl.allowAlphanumeric"
-            ng-model="$ctrl.ngModel"
-            name="{{$ctrl.name}}"
-            ng-change="$ctrl.onChange()"
-            placeholder="{{ $ctrl.props.placeholder }}"
-            ng-required="$ctrl.ngRequired"
-            ng-disabled="$ctrl.ngDisabled"
-            ng-blur="$ctrl.ngBlur({ $event })"
-            ng-focus="$ctrl.ngFocus({ $event })"
-            ng-keyup="$ctrl.ngKeyup({ $event })"
-            ng-keypress="$ctrl.ngKeypress({ $event })"
-            ng-keydown="$ctrl.ngKeydown({ $event })"
-            ui-br-cpfcnpj-mask />
-</div>
+    <input type="text"
+           ng-model="$ctrl.ngModel"
+           ng-change="$ctrl.onChange()"
+           placeholder="{{ $ctrl.props.placeholder }}"
+           ng-required="$ctrl.ngRequired"
+           ng-disabled="$ctrl.ngDisabled"
+           ng-blur="$ctrl.ngBlur({ $event })"
+           ng-focus="$ctrl.ngFocus({ $event })"
+           ng-keyup="$ctrl.ngKeyup({ $event })"
+           ng-keypress="$ctrl.ngKeypress({ $event })"
+           ng-keydown="$ctrl.ngKeydown({ $event })"
+           ui-br-cpfcnpj-mask />
+</div>

package/src/components/mbg-input-cpfcnpj/mbg-input-cpfcnpj.ts

@@ -1,100 +1,99 @@
 import './mbg-input-cpfcnpj.scss'
 import template from './mbg-input-cpfcnpj.html'
-import { mbgDocumentMaskDirective } from '../../helpers/mbg-document-mask-directive'
-import { isValidCnpj } from '../../helpers/cnpj-validador'
-
-// ---------------------------------------------------------------------------
-// Directive: mbg-document-mask-directive
-// (lógica movida para o helper, re-exportada via import acima)
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Component: mbg-input-cpfcnpj
-// ---------------------------------------------------------------------------
 
 class MbgInputCpfCnpjController {
-  private ngChange
-  private ngModel
-  private ngRequired
-  private ngDisabled
-  private allowAlphanumeric: boolean
-  private name
-  private props
-  public valid
+    private ngChange
+    private ngModel
+    private ngRequired
+    private ngDisabled
+    private props
+    public valid
 
-  constructor(
-    public $scope,
-    public $element,
-    public $attrs,
-  ) {
-    if ($attrs.ngRequired === '') {
-      this.ngRequired = true
-    }
-    if ($attrs.ngDisabled === '') {
-      this.ngDisabled = true
-    }
-    this.props = {
-      placeholder: $attrs.placeholder || '',
+    constructor(public $scope, public $element, public $attrs) {
+        if ($attrs.ngRequired === '') { this.ngRequired = true }
+        if ($attrs.ngDisabled === '') { this.ngDisabled = true }
+        this.props = {
+            placeholder: $attrs.placeholder || '',
+        }
     }
-  }
 
-  $onInit() {
-    this.allowAlphanumeric = this.allowAlphanumeric === true
-  }
+    ngBlur(evt) {
+        this.valid = evt.$event.target.value
+        this.valid = this.valid.toString()
+        this.valid = this.valid.replace(/[^0-9]/g, '')
+        if (this.valid.length === 11) {
+            this.validCpf(this.valid)
+        }
+        if (this.valid.length === 14) {
+            this.validCnpj(this.valid)
+        } else {
+            return false
+        }
+    }
 
-  ngBlur(evt) {
-    const raw = `${evt.$event.target.value || ''}`.replace(/[^A-Za-z0-9]/g, '').toUpperCase()
-    if (raw.length === 11) {
-      this.valid = this.validCpf(raw)
-    } else if (raw.length === 14) {
-      this.valid = isValidCnpj(raw)
-    } else {
-      this.valid = false
+    CalcDigits(digits, positions = 10, sumDigits = 0) {
+        digits = digits.toString()
+        for (let i = 0; i < digits.length; i++) {
+            sumDigits = sumDigits + (digits[i] * positions)
+            positions--
+            if (positions < 2) {
+                positions = 9
+            }
+        }
+        sumDigits = sumDigits % 11
+        if (sumDigits < 2) {
+            sumDigits = 0
+        } else {
+            sumDigits = 11 - sumDigits
+        }
+        let cnpj = digits + sumDigits
+        return cnpj
     }
-  }
 
-  CalcDigits(digits, positions = 10, sumDigits = 0) {
-    digits = digits.toString()
-    for (let i = 0; i < digits.length; i++) {
-      sumDigits += digits[i] * positions
-      positions--
-      if (positions < 2) positions = 9
+    validCpf(value) {
+        let digits = value.substr(0, 9)
+        let firstCalc = this.CalcDigits(digits)
+        let newCpf = this.CalcDigits(firstCalc, 11)
+        if (newCpf === value) {
+            return true
+        } else {
+            return false
+        }
     }
-    sumDigits = sumDigits % 11
-    if (sumDigits < 2) sumDigits = 0
-    else sumDigits = 11 - sumDigits
-    return digits + sumDigits
-  }
 
-  validCpf(value) {
-    const digits = value.substr(0, 9)
-    const firstCalc = this.CalcDigits(digits)
-    const newCpf = this.CalcDigits(firstCalc, 11)
-    return newCpf === value
-  }
+    validCnpj(value) {
+        let original = value
+        let firstNumbers = value.substr(0, 12)
+        let firstCalc = this.CalcDigits(firstNumbers, 5)
+        let secondCalc = this.CalcDigits(firstCalc, 6)
+        if (secondCalc === original) {
+            return true
+        }
+        return false
+    }
 
-  onChange() {
-    if (this.ngChange) this.ngChange({})
-  }
+    onChange() {
+        if (this.ngChange) {
+            this.ngChange({})
+        }
+    }
 }
 MbgInputCpfCnpjController.$inject = ['$scope', '$element', '$attrs']
 
 const mbgInputCpfCnpj = {
-  bindings: {
-    ngModel: '=',
-    ngChange: '&?',
-    ngRequired: '=?',
-    ngDisabled: '=?',
-    ngBlur: '&?',
-    ngFocus: '&?',
-    ngKeyup: '&?',
-    ngKeypress: '&?',
-    ngKeydown: '&?',
-    allowAlphanumeric: '<?',
-    name: '@?',
-  },
-  template,
-  controller: MbgInputCpfCnpjController,
+    bindings: {
+        ngModel: '=',
+        ngChange: '&?',
+        ngRequired: '=?',
+        ngDisabled: '=?',
+        ngBlur: '&?',
+        ngFocus: '&?',
+        ngKeyup: '&?',
+        ngKeypress: '&?',
+        ngKeydown: '&?',
+    },
+    template,
+    controller: MbgInputCpfCnpjController,
 }
 
-export { mbgInputCpfCnpj, mbgDocumentMaskDirective }
+export { mbgInputCpfCnpj }

package/src/components/mbg-input-ie/mbg-input-ie.html

@@ -1,12 +1,12 @@
 <div class="mbg-input-wrapper mbg-input-name-wrapper"
      ng-if="$ctrl.props">
        <input type="text"
-              ng-if="$ctrl.state == 'TO' || $ctrl.state == 'MT' || $ctrl.state == 'AL' || $ctrl.state == 'GO'"
+              ng-if="$ctrl.state == 'TO' || $ctrl.state == 'MT' || $ctrl.state == 'AL' || $ctrl.state == 'GO' || $ctrl.state == 'MS' || $ctrl.state == 'RS'"
               mbg-mask-ie
               ng-model="$ctrl.ngModel"
               name="{{$ctrl.name}}"
               ng-init="$ctrl.onInit()"
-              ng-change="$ctrl.onChangeTO()"
+              ng-change="$ctrl.onChange()"
               ng-required="$ctrl.ngRequired"
               ng-disabled="$ctrl.ngDisabled"
               ng-blur="$ctrl.ngBlur({ $event })"
@@ -17,7 +17,7 @@
               placeholder="{{ $ctrl.props.placeholder }}" />
 
        <input type="text"
-              ng-if="!$ctrl.state || ($ctrl.state != 'TO' && $ctrl.state != 'MT' && $ctrl.state != 'AL' && $ctrl.state != 'GO')"
+              ng-if="!$ctrl.state || ($ctrl.state != 'TO' && $ctrl.state != 'MT' && $ctrl.state != 'AL' && $ctrl.state != 'GO' && $ctrl.state != 'MS' && $ctrl.state != 'RS')"
               ng-model="$ctrl.ngModel"
               name="{{$ctrl.name}}"
               ng-init="$ctrl.onInit()"

package/src/helpers/ie-directive/ie-directive.ts

@@ -21,22 +21,25 @@ export class NgMaskIe {
   }
 
   link(scope, elm, attrs, ngModelController) {
+    const getState = () => (scope.$ctrl ? scope.$ctrl.state : null)
+
     scope.$watch(attrs.ngModel, (data) => {
-      const state =
-        scope.$parent && scope.$parent.$parent && scope.$parent.$parent.$ctrl
-          ? scope.$parent.$parent.$ctrl.state
-          : null
+      const state = getState()
       const valid = this.validate(data, state)
+      console.log('[mbg-mask-ie] watch — data:', data, '| state:', state, '| valid:', valid)
+
+      ngModelController.$setValidity('ie', !!valid)
+
       const form = elm.closest('form')
       const formName = form.attr('name')
       const formScope = form.scope()
       if (formName && formScope) {
         this.setIeValidate(elm, valid)
-        if (!valid) {
-          elm.addClass('mbg-error')
-        } else {
-          elm.removeClass('mbg-error')
-        }
+      }
+      if (!valid) {
+        elm.addClass('mbg-error')
+      } else {
+        elm.removeClass('mbg-error')
       }
     })
 
@@ -48,8 +51,15 @@ export class NgMaskIe {
       return value.replace(/\D/g, '').replace(/^(\d{10})(\d{1}).*/, '$1-$2')
     }
 
+    const maskIeRS = (value) => {
+      return value.replace(/\D/g, '').replace(/^(\d{3})(\d{1,7})$/, '$1/$2')
+    }
+
     const maskViewParser = (value) => {
-      if (value.length <= 9) {
+      const state = getState()
+      if (state === 'RS') {
+        ngModelController.$viewValue = maskIeRS(value)
+      } else if (value.length <= 9) {
         ngModelController.$viewValue = maskIe9(value)
       } else {
         ngModelController.$viewValue = maskIe11(value)
@@ -59,6 +69,7 @@ export class NgMaskIe {
     }
 
     const formatterView = (value) => {
+      if (getState() === 'RS') return maskIeRS(value || '')
       return (value || '').length <= 9 ? maskIe9(value) : maskIe11(value)
     }
 
@@ -71,6 +82,7 @@ export class NgMaskIe {
   }
 
   validate(ngModel, state) {
+    console.log('[mbg-mask-ie] validate — ngModel:', ngModel, '| state:', state)
     switch (state) {
       case 'TO':
         return this.validateTO(ngModel)
@@ -80,6 +92,12 @@ export class NgMaskIe {
         return this.validateAL(ngModel)
       case 'GO':
         return this.validateGO(ngModel)
+      case 'MS':
+        return this.validateMS(ngModel)
+      case 'RS':
+        return this.validateRS(ngModel)
+      default:
+        return true
     }
   }
 
@@ -181,6 +199,44 @@ export class NgMaskIe {
     }
   }
 
+  validateMS(ie) {
+    const digits = (ie || '').replace(/\D/g, '')
+    if (digits.length !== 9) return false
+    if (!/^(28|50)/.test(digits)) return false
+    const weights = [9, 8, 7, 6, 5, 4, 3, 2]
+    let sum = 0
+    for (let i = 0; i < weights.length; i++) {
+      sum += parseInt(digits[i]) * weights[i]
+    }
+    const remainder = sum % 11
+    const dv = remainder === 0 || remainder === 1 ? 0 : 11 - remainder
+    return dv === parseInt(digits[8])
+  }
+
+  validateRS(ie) {
+    console.log('[validateRS] ie recebido:', ie)
+    const digits = (ie || '').replace(/\D/g, '')
+    console.log('[validateRS] digits (só números):', digits, '| length:', digits.length)
+    const padded = digits.length === 9 ? '0' + digits : digits
+    console.log('[validateRS] padded:', padded, '| length:', padded.length)
+    if (padded.length !== 10) {
+      console.log('[validateRS] INVÁLIDO — length esperado 10, recebido:', padded.length)
+      return false
+    }
+    const weights = [2, 9, 8, 7, 6, 5, 4, 3, 2]
+    let sum = 0
+    for (let i = 0; i < weights.length; i++) {
+      const partial = parseInt(padded[i]) * weights[i]
+      console.log(`[validateRS] i=${i} dígito=${padded[i]} peso=${weights[i]} parcial=${partial}`)
+      sum += partial
+    }
+    const remainder = sum % 11
+    const dv = remainder < 2 ? 0 : 11 - remainder
+    const dvIe = parseInt(padded[9])
+    console.log('[validateRS] soma:', sum, '| resto:', remainder, '| dv calculado:', dv, '| dv do IE:', dvIe, '| VÁLIDO:', dv === dvIe)
+    return dv === dvIe
+  }
+
   setIeValidate(elm, valid) {
     const form = elm.closest('form')
     const formName = form.attr('name')

package/src/helpers/cnpj-validador.ts

@@ -1,38 +0,0 @@
-// Single source of truth for CNPJ normalization and validation.
-
-// Strips punctuation/spaces, uppercases letters, truncates to 14 chars.
-// Preserves letters — safe for both numeric and alphanumeric CNPJs.
-export function normalizeCnpj(value: string): string {
-  const clean = `${value || ''}`.replace(/[^A-Za-z0-9]/g, '').toUpperCase()
-  return clean.substring(0, 14)
-}
-
-const WEIGHTS_D1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
-const WEIGHTS_D2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
-
-function charToValue(char: string): number {
-  return char.charCodeAt(0) - 48
-}
-
-function calcDigit(base: string, weights: number[]): number {
-  let sum = 0
-  for (let i = 0; i < base.length; i++) {
-    sum += charToValue(base[i]) * weights[i]
-  }
-  const r = sum % 11
-  return r < 2 ? 0 : 11 - r
-}
-
-// Accepts raw or pre-normalized input (with or without punctuation/mask).
-// Validates numeric and alphanumeric CNPJs (Receita Federal 2026).
-export function isValidCnpj(value: string): boolean {
-  const cnpj = normalizeCnpj(value)
-
-  if (!/^[A-Z0-9]{12}[0-9]{2}$/.test(cnpj)) return false
-  if (/^\d{14}$/.test(cnpj) && /^(\d)\1+$/.test(cnpj)) return false
-
-  const base = cnpj.slice(0, 12)
-  const d1 = calcDigit(base, WEIGHTS_D1)
-  const d2 = calcDigit(`${base}${d1}`, WEIGHTS_D2)
-  return cnpj.slice(12) === `${d1}${d2}`
-}

package/src/helpers/mbg-document-mask-directive.ts

@@ -1,160 +0,0 @@
-// ---------------------------------------------------------------------------
-// Shared utilities: Alphanumeric CNPJ mask, formatting and validation
-// Used by: mbg-input-cpfcnpj, mbg-input-cnpj
-// ---------------------------------------------------------------------------
-
-import { isValidCnpj, normalizeCnpj } from './cnpj-validador'
-export { isValidCnpj as isValidAlphanumericCnpj }
-export { normalizeCnpj as normalizeAlphanumericCnpj }
-
-const CNPJ_MASK = '##.###.###/####-##'
-const CPF_MASK = '###.###.###-##'
-
-export function hasLetters(value: string): boolean {
-  return /[A-Za-z]/.test(value)
-}
-
-export function formatCpf(clean: string): string {
-  const digits = clean.replace(/[^0-9]/g, '').substring(0, 11)
-  const result: string[] = []
-  let digitIdx = 0
-  for (let i = 0; i < CPF_MASK.length && digitIdx < digits.length; i++) {
-    if (CPF_MASK[i] === '#') result.push(digits[digitIdx++])
-    else result.push(CPF_MASK[i])
-  }
-  return result.join('')
-}
-
-function smartFormat(clean: string): string {
-  if (!clean) return ''
-  if (hasLetters(clean)) return formatAlphanumericCnpj(clean)
-  if (clean.length <= 11) return formatCpf(clean)
-  return formatAlphanumericCnpj(clean)
-}
-
-export function formatAlphanumericCnpj(clean: string): string {
-  const safe = clean.substring(0, 14)
-  const result: string[] = []
-  let cleanIndex = 0
-
-  for (let i = 0; i < CNPJ_MASK.length && cleanIndex < safe.length; i++) {
-    const maskChar = CNPJ_MASK[i]
-
-    if (maskChar === '#') {
-      const char = safe[cleanIndex]
-      const isCheckDigitPosition = cleanIndex >= 12
-
-      if (isCheckDigitPosition) {
-        if (/[0-9]/.test(char)) result.push(char)
-        cleanIndex++
-      } else {
-        if (/[A-Z0-9]/.test(char)) result.push(char)
-        cleanIndex++
-      }
-    } else {
-      result.push(maskChar)
-    }
-  }
-
-  return result.join('')
-}
-
-export function isCnpjCandidate(value: string): boolean {
-  return value.length > 11 || hasLetters(value)
-}
-
-export function isCpfCandidate(value: string): boolean {
-  return /^\d*$/.test(value) && value.length <= 11
-}
-
-function isRepeatedNumeric(value: string): boolean {
-  return /^(\d)\1+$/.test(value)
-}
-
-function calculateCpfDigit(base: string, startWeight: number): number {
-  let sum = 0
-  for (let i = 0; i < base.length; i++) {
-    sum += Number(base[i]) * (startWeight - i)
-  }
-  const remainder = sum % 11
-  return remainder < 2 ? 0 : 11 - remainder
-}
-
-export function isValidCpf(value: string): boolean {
-  if (!/^\d{11}$/.test(value) || isRepeatedNumeric(value)) return false
-  const firstDigit = calculateCpfDigit(value.slice(0, 9), 10)
-  const secondDigit = calculateCpfDigit(`${value.slice(0, 9)}${firstDigit}`, 11)
-  return value === `${value.slice(0, 9)}${firstDigit}${secondDigit}`
-}
-
-function isDocumentValid(value: string): boolean {
-  if (!value) return true
-  if (isCpfCandidate(value)) {
-    if (value.length < 11) return true
-    return isValidCpf(value)
-  }
-  if (isCnpjCandidate(value)) {
-    if (value.length < 14) {
-      if (hasLetters(value)) return false
-      return true
-    }
-    if (value.length > 14) return false
-    return isValidCnpj(value)
-  }
-  return false
-}
-
-// ---------------------------------------------------------------------------
-// AngularJS directive factory — reusable in any module
-// ---------------------------------------------------------------------------
-
-class MbgDocumentMaskDirective {
-  static $inject = []
-
-  require = 'ngModel'
-  restrict = 'A'
-
-  link = (_scope, _element, _attrs, ngModel) => {
-    ngModel.$parsers.push((viewValue: string) => {
-      const clean = normalizeCnpj(viewValue || '')
-      const formatted = smartFormat(clean)
-
-      if ((viewValue || '') !== formatted) {
-        ngModel.$setViewValue(formatted)
-        ngModel.$render()
-      }
-
-      return clean
-    })
-
-    ngModel.$formatters.push((modelValue: string) => {
-      return smartFormat(normalizeCnpj(modelValue || ''))
-    })
-
-    ngModel.$validators.cpf = (modelValue: string) => {
-      const clean = normalizeCnpj(modelValue || '')
-      if (!clean || !isCpfCandidate(clean)) return true
-      if (clean.length < 11) return true
-      return isValidCpf(clean)
-    }
-
-    ngModel.$validators.cnpj = (modelValue: string) => {
-      const clean = normalizeCnpj(modelValue || '')
-      if (!clean || !isCnpjCandidate(clean)) return true
-      if (clean.length < 14) {
-        if (hasLetters(clean)) return false
-        if (clean.length >= 12 && /[A-Z]/.test(clean.slice(12))) return false
-        return true
-      }
-      if (clean.length > 14) return false
-      return isValidCnpj(clean)
-    }
-
-    ngModel.$validators.cpfcnpj = (modelValue: string) => {
-      const clean = normalizeCnpj(modelValue || '')
-      return isDocumentValid(clean)
-    }
-  }
-}
-
-export const mbgDocumentMaskDirective = () => new MbgDocumentMaskDirective()