@skbkontur/react-ui 5.6.7 → 5.6.9-5e213.0

package/components/MaskedInput/react-imask/imask/masked/base.d.ts

@@ -0,0 +1,114 @@
+import { ChangeDetails } from '../core/change-details';
+import { type Direction } from '../core/utils';
+import { type TailDetails } from '../core/tail-details';
+export interface MaskedState {
+    _value: string;
+    _rawInputValue: string;
+}
+/** Append flags */
+export interface AppendFlags<State = MaskedState> {
+    input?: boolean;
+    tail?: boolean;
+    raw?: boolean;
+    _beforeTailState?: State;
+}
+/** Extract flags */
+export interface ExtractFlags {
+    raw?: boolean;
+}
+export type MaskedOptions<M extends Masked = Masked, Props extends keyof M = never> = Partial<Pick<M, 'mask' | 'parent' | 'prepare' | 'prepareChar' | 'validate' | 'commit' | 'format' | 'parse' | 'overwrite' | 'eager' | 'skipInvalid' | 'autofix' | Props>>;
+/** Provides common masking stuff */
+export declare abstract class Masked<Value = any> {
+    static DEFAULTS: Pick<MaskedOptions, 'skipInvalid'>;
+    static EMPTY_VALUES: any[];
+    /** */
+    mask: unknown;
+    /** */
+    parent?: Masked;
+    /** Transforms value before mask processing */
+    prepare?: (chars: string, masked: Masked, flags: AppendFlags) => string | [string, ChangeDetails];
+    /** Transforms each char before mask processing */
+    prepareChar?: (chars: string, masked: Masked, flags: AppendFlags) => string | [string, ChangeDetails];
+    /** Validates if value is acceptable */
+    validate?: (value: string, masked: Masked, flags: AppendFlags) => boolean;
+    /** Does additional processing at the end of editing */
+    commit?: (value: string, masked: Masked) => void;
+    /** Format typed value to string */
+    format?: (value: Value, masked: Masked) => string;
+    /** Parse string to get typed value */
+    parse?: (str: string, masked: Masked) => Value;
+    /** Enable characters overwriting */
+    abstract overwrite?: boolean | 'shift' | undefined;
+    /** */
+    abstract eager?: boolean | 'remove' | 'append' | undefined;
+    /** */
+    abstract skipInvalid?: boolean | undefined;
+    /** */
+    abstract autofix?: boolean | 'pad' | undefined;
+    /** */
+    _initialized: boolean;
+    _value: string;
+    _refreshing?: boolean;
+    _isolated?: boolean;
+    constructor(opts: MaskedOptions);
+    /** Sets and applies new options */
+    updateOptions(opts: Partial<MaskedOptions>): void;
+    /** Sets new options */
+    _update(opts: Partial<MaskedOptions>): void;
+    /** Mask state */
+    get state(): MaskedState;
+    set state(state: MaskedState);
+    /** Resets value */
+    reset(): void;
+    get value(): string;
+    set value(value: string);
+    /** Resolve new value */
+    resolve(value: string, flags?: AppendFlags): void;
+    get unmaskedValue(): string;
+    set unmaskedValue(value: string);
+    get typedValue(): Value;
+    set typedValue(value: Value);
+    /** Value that includes raw user input */
+    get rawInputValue(): string;
+    set rawInputValue(value: string);
+    get displayValue(): string;
+    get isComplete(): boolean;
+    get isFilled(): boolean;
+    /** Finds nearest input position in direction */
+    nearestInputPos(cursorPos: number, _direction?: Direction): number;
+    totalInputPositions(fromPos?: number, toPos?: number): number;
+    /** Extracts value in range considering flags */
+    extractInput(fromPos?: number, toPos?: number, _flags?: ExtractFlags): string;
+    /** Extracts tail in range */
+    extractTail(fromPos?: number, toPos?: number): TailDetails;
+    /** Appends tail */
+    appendTail(tail: string | TailDetails): ChangeDetails;
+    /** Appends char */
+    _appendCharRaw(ch: string, _flags?: AppendFlags): ChangeDetails;
+    /** Appends char */
+    _appendChar(ch: string, flags?: AppendFlags, checkTail?: TailDetails): ChangeDetails;
+    /** Appends optional placeholder at the end */
+    _appendPlaceholder(): ChangeDetails;
+    /** Appends optional eager placeholder at the end */
+    _appendEager(): ChangeDetails;
+    /** Appends symbols considering flags */
+    append(str: string, flags?: AppendFlags, tail?: string | TailDetails): ChangeDetails;
+    remove(fromPos?: number, toPos?: number): ChangeDetails;
+    /** Calls function and reapplies current value */
+    withValueRefresh<T>(fn: () => T): T;
+    runIsolated<T>(fn: (masked: this) => T): T;
+    doSkipInvalid(_ch: string, _flags?: AppendFlags, _checkTail?: TailDetails): boolean;
+    /** Prepares string before mask processing */
+    doPrepare(str: string, flags?: AppendFlags): [string, ChangeDetails];
+    /** Prepares each char before mask processing */
+    doPrepareChar(str: string, flags?: AppendFlags): [string, ChangeDetails];
+    /** Validates if value is acceptable */
+    doValidate(flags: AppendFlags): boolean;
+    /** Does additional processing at the end of editing */
+    doCommit(): void;
+    splice(start: number, deleteCount: number, inserted?: string, removeDirection?: Direction, flags?: AppendFlags): ChangeDetails;
+    maskEquals(mask: any): boolean;
+    optionsIsChanged(opts: Partial<MaskedOptions>): boolean;
+    typedValueEquals(value: any): boolean;
+    pad(_flags?: AppendFlags): ChangeDetails;
+}

package/components/MaskedInput/react-imask/imask/masked/factory/factory.js

@@ -0,0 +1,89 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["mask"];
+import { isString, pick, isObject } from "../../core/utils";
+import { Masked } from "../base";
+import { MaskedPattern } from "../pattern";
+import { MaskedRegExp } from "../regexp";
+
+/** Get Masked class by mask type */
+export function maskedClass(mask) {
+  // eslint-disable-next-line eqeqeq
+  if (mask == null) {
+    throw new Error('mask property should be defined');
+  }
+  if (mask instanceof RegExp) {
+    return MaskedRegExp;
+  }
+  if (isString(mask)) {
+    return MaskedPattern;
+  }
+  if (mask.prototype instanceof Masked) {
+    return mask;
+  }
+  if (mask instanceof Masked) {
+    return mask.constructor;
+  }
+  console.warn('Mask not found for mask', mask);
+  return Masked;
+}
+export function normalizeOpts(opts) {
+  if (!opts) {
+    throw new Error('Options in not defined');
+  }
+  if (typeof opts === 'function' && opts.prototype instanceof Masked) {
+    return {
+      mask: opts
+    };
+  }
+
+  /*
+    handle cases like:
+    1) opts = Masked
+    2) opts = { mask: Masked, ...instanceOpts }
+  */
+  var _ref =
+    // eslint-disable-next-line no-nested-ternary
+    opts instanceof Masked ? {
+      mask: opts
+    } : isObject(opts) && opts.mask instanceof Masked ? opts : {},
+    _ref$mask = _ref.mask,
+    mask = _ref$mask === void 0 ? undefined : _ref$mask,
+    instanceOpts = _objectWithoutProperties(_ref, _excluded);
+  if (mask) {
+    var _mask = mask.mask;
+    return _objectSpread(_objectSpread({}, pick(mask, function (_, k) {
+      return !k.startsWith('_');
+    })), {}, {
+      mask: mask.constructor,
+      _mask: _mask
+    }, instanceOpts);
+  }
+  if (!isObject(opts)) {
+    return {
+      mask: opts
+    };
+  }
+  return _objectSpread({}, opts);
+}
+
+/** Creates new {@link Masked} depending on mask type */
+export function createMask(opts) {
+  if (opts instanceof Masked) {
+    return opts;
+  }
+  var nOpts = normalizeOpts(opts);
+  var MaskedClass = maskedClass(nOpts.mask);
+  if (!MaskedClass) {
+    throw new Error("Masked class is not found for provided mask ".concat(nOpts.mask, ", appropriate module needs to be imported manually before creating mask."));
+  }
+  if (nOpts.mask === MaskedClass) {
+    delete nOpts.mask;
+  }
+  var nOptsWithInternal = nOpts;
+  if (nOptsWithInternal._mask !== undefined && nOptsWithInternal._mask !== null) {
+    nOptsWithInternal.mask = nOptsWithInternal._mask;
+    delete nOptsWithInternal._mask;
+  }
+  return new MaskedClass(nOpts);
+}

package/components/MaskedInput/react-imask/imask/masked/factory/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isString","pick","isObject","Masked","MaskedPattern","MaskedRegExp","maskedClass","mask","Error","RegExp","prototype","constructor","console","warn","normalizeOpts","opts","_ref","_ref$mask","undefined","instanceOpts","_objectWithoutProperties","_excluded","_mask","_objectSpread","_","k","startsWith","createMask","nOpts","MaskedClass","concat","nOptsWithInternal"],"sources":["factory.ts"],"sourcesContent":["import { isString, pick, isObject } from '../core/utils';\n\nimport { Masked, type MaskedOptions } from './base';\nimport { MaskedPattern, type MaskedPatternOptions } from './pattern';\nimport { MaskedRegExp, type MaskedRegExpOptions } from './regexp';\n\nexport type FactoryStaticOpts = MaskedPatternOptions | MaskedRegExpOptions;\n\nexport type AllFactoryStaticOpts = MaskedPatternOptions & MaskedRegExpOptions;\n\nexport type FactoryStaticReturnMasked<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions\n  ? MaskedPattern\n  : Opts extends MaskedRegExpOptions\n    ? MaskedRegExp\n    : never;\n\nexport type FactoryStaticMaskReturnMasked<Mask extends FactoryStaticOpts['mask']> =\n  Mask extends MaskedPatternOptions['mask']\n    ? MaskedPattern\n    : Mask extends MaskedRegExpOptions['mask']\n      ? MaskedRegExp\n      : never;\n\nexport type FactoryInstanceOpts =\n  | ({ mask: MaskedRegExp } & Omit<MaskedRegExpOptions, 'mask'>)\n  | ({ mask: MaskedPattern } & Omit<MaskedPatternOptions, 'mask'>)\n  | ({ mask: Masked } & Omit<MaskedOptions, 'mask'>);\n\nexport type FactoryInstanceReturnMasked<Opts extends FactoryInstanceOpts> = Opts extends { mask: infer M } ? M : never;\n\nexport type FactoryConstructorOpts =\n  | ({ mask: typeof MaskedRegExp } & Omit<MaskedRegExpOptions, 'mask'>)\n  | ({ mask: typeof MaskedPattern } & Omit<MaskedPatternOptions, 'mask'>)\n  | ({ mask: typeof Masked } & Omit<MaskedOptions, 'mask'>);\n\nexport type FactoryConstructorReturnMasked<Opts extends FactoryConstructorOpts> = Opts extends {\n  mask: typeof MaskedRegExp;\n}\n  ? MaskedRegExp\n  : Opts extends { mask: typeof MaskedPattern }\n    ? MaskedPattern\n    : Masked;\n\nexport type FactoryOpts = FactoryConstructorOpts | FactoryInstanceOpts | FactoryStaticOpts;\n\nexport type FactoryArg = Masked | FactoryOpts | FactoryStaticOpts['mask'];\n\nexport type ExtendFactoryArgOptions<Opts extends { [key: string]: any }> =\n  | Masked\n  | (FactoryOpts & Opts)\n  | FactoryStaticOpts['mask'];\n\nexport type UpdateStaticOpts<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions\n  ? MaskedPatternOptions\n  : Opts extends MaskedRegExpOptions\n    ? MaskedRegExpOptions\n    : never;\n\ntype AnyOpts = Record<string, any>;\n\nexport type UpdateInstanceOpts<M extends Masked> = M extends MaskedRegExp\n  ? MaskedRegExpOptions\n  : M extends MaskedPattern\n    ? MaskedPatternOptions\n    : AnyOpts;\n\nexport type UpdateConstructorOpts<M extends FactoryConstructorOpts> = M extends { mask: typeof MaskedRegExp }\n  ? MaskedRegExpOptions\n  : M extends { mask: typeof MaskedPattern }\n    ? MaskedPatternOptions\n    : AnyOpts;\n\nexport type UpdateStaticMaskOpts<M extends FactoryStaticOpts['mask']> = M extends MaskedPatternOptions['mask']\n  ? MaskedPatternOptions\n  : M extends MaskedRegExpOptions['mask']\n    ? MaskedRegExpOptions\n    : never;\n\nexport type UpdateOpts<Opts extends FactoryArg> = Partial<\n  Opts extends Masked\n    ? UpdateInstanceOpts<Opts>\n    : Opts extends FactoryStaticOpts['mask']\n      ? UpdateStaticMaskOpts<Opts>\n      : Opts extends FactoryStaticOpts\n        ? UpdateStaticOpts<Opts>\n        : Opts extends FactoryInstanceOpts\n          ? UpdateInstanceOpts<Opts['mask']>\n          : Opts extends FactoryConstructorOpts\n            ? UpdateConstructorOpts<Opts>\n            : AnyOpts\n>;\n\nexport type FactoryReturnMasked<Opts extends FactoryArg> = Opts extends Masked\n  ? Opts\n  : Opts extends FactoryStaticOpts['mask']\n    ? FactoryStaticMaskReturnMasked<Opts>\n    : Opts extends FactoryConstructorOpts\n      ? FactoryConstructorReturnMasked<Opts>\n      : Opts extends FactoryInstanceOpts\n        ? FactoryInstanceReturnMasked<Opts>\n        : Opts extends FactoryStaticOpts\n          ? FactoryStaticReturnMasked<Opts>\n          : never;\n\n/** Get Masked class by mask type */\nexport function maskedClass(\n  mask: Masked | FactoryOpts['mask'],\n): typeof MaskedPattern | typeof MaskedRegExp | typeof Masked {\n  // eslint-disable-next-line eqeqeq\n  if (mask == null) {\n    throw new Error('mask property should be defined');\n  }\n\n  if (mask instanceof RegExp) {\n    return MaskedRegExp;\n  }\n  if (isString(mask)) {\n    return MaskedPattern;\n  }\n  if ((mask as { prototype?: unknown }).prototype instanceof Masked) {\n    return mask as typeof MaskedPattern | typeof MaskedRegExp | typeof Masked;\n  }\n  if (mask instanceof Masked) {\n    return mask.constructor as typeof MaskedPattern | typeof MaskedRegExp | typeof Masked;\n  }\n\n  console.warn('Mask not found for mask', mask);\n  return Masked;\n}\n\ntype MaskedClassOf<M extends Masked> = M extends MaskedRegExp\n  ? typeof MaskedRegExp\n  : M extends MaskedPattern\n    ? typeof MaskedPattern\n    : any;\n\ntype NormalizedMaskedOpts<Opts extends Masked> = Omit<Opts, 'mask'> & {\n  _mask: Opts;\n  mask: MaskedClassOf<Opts>;\n};\n\ntype NormalizedInstanceOpts<Opts extends FactoryInstanceOpts> = Omit<Opts['mask'], `_${string}` | 'mask'> &\n  NormalizedMaskedOpts<Opts['mask']>;\n\nexport type NormalizedOpts<Opts extends FactoryArg> = Opts extends FactoryStaticOpts['mask']\n  ? { mask: Opts }\n  : Opts extends Masked\n    ? NormalizedMaskedOpts<Opts>\n    : Opts extends FactoryInstanceOpts\n      ? NormalizedInstanceOpts<Opts>\n      : Opts extends FactoryStaticOpts | FactoryConstructorOpts\n        ? Opts\n        : { mask: Opts };\n\nexport function normalizeOpts<Opts extends FactoryArg>(opts: Opts): NormalizedOpts<Opts> {\n  if (!opts) {\n    throw new Error('Options in not defined');\n  }\n\n  if (typeof opts === 'function' && (opts as { prototype?: unknown }).prototype instanceof Masked) {\n    return { mask: opts } as unknown as NormalizedOpts<Opts>;\n  }\n\n  /*\n    handle cases like:\n    1) opts = Masked\n    2) opts = { mask: Masked, ...instanceOpts }\n  */\n  const { mask = undefined, ...instanceOpts } =\n    // eslint-disable-next-line no-nested-ternary\n    opts instanceof Masked\n      ? { mask: opts }\n      : isObject(opts) && (opts as FactoryInstanceOpts).mask instanceof Masked\n        ? (opts as FactoryInstanceOpts)\n        : {};\n\n  if (mask) {\n    const _mask = (mask as Masked).mask;\n\n    return {\n      ...pick(mask, (_, k: string) => !k.startsWith('_')),\n      mask: mask.constructor,\n      _mask,\n      ...instanceOpts,\n    } as NormalizedOpts<Opts>;\n  }\n\n  if (!isObject(opts)) {\n    return { mask: opts } as unknown as NormalizedOpts<Opts>;\n  }\n\n  return { ...opts } as unknown as NormalizedOpts<Opts>;\n}\n\n/** Creates new {@link Masked} depending on mask type */\nexport function createMask<Opts extends FactoryArg>(opts: Opts): FactoryReturnMasked<Opts> {\n  if (opts instanceof Masked) {\n    return opts as FactoryReturnMasked<Opts>;\n  }\n  const nOpts = normalizeOpts(opts);\n\n  const MaskedClass = maskedClass(nOpts.mask);\n  if (!MaskedClass) {\n    throw new Error(\n      `Masked class is not found for provided mask ${nOpts.mask}, appropriate module needs to be imported manually before creating mask.`,\n    );\n  }\n\n  if (nOpts.mask === MaskedClass) {\n    delete nOpts.mask;\n  }\n  const nOptsWithInternal = nOpts as NormalizedOpts<Opts> & { _mask?: unknown };\n  if (nOptsWithInternal._mask !== undefined && nOptsWithInternal._mask !== null) {\n    nOptsWithInternal.mask = nOptsWithInternal._mask as NormalizedOpts<Opts>['mask'];\n    delete nOptsWithInternal._mask;\n  }\n  return new (MaskedClass as unknown as new (opts: unknown) => FactoryReturnMasked<Opts>)(nOpts);\n}\n"],"mappings":"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","ignoreList":[]}

package/components/MaskedInput/react-imask/imask/masked/factory/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../../../../cjs/components/MaskedInput/react-imask/imask/masked/factory.js",
+  "module": "factory",
+  "types": "../factory.d.ts",
+  "sideEffects": false
+}

package/components/MaskedInput/react-imask/imask/masked/factory.d.ts

@@ -0,0 +1,62 @@
+import { Masked, type MaskedOptions } from './base';
+import { MaskedPattern, type MaskedPatternOptions } from './pattern';
+import { MaskedRegExp, type MaskedRegExpOptions } from './regexp';
+export type FactoryStaticOpts = MaskedPatternOptions | MaskedRegExpOptions;
+export type AllFactoryStaticOpts = MaskedPatternOptions & MaskedRegExpOptions;
+export type FactoryStaticReturnMasked<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions ? MaskedPattern : Opts extends MaskedRegExpOptions ? MaskedRegExp : never;
+export type FactoryStaticMaskReturnMasked<Mask extends FactoryStaticOpts['mask']> = Mask extends MaskedPatternOptions['mask'] ? MaskedPattern : Mask extends MaskedRegExpOptions['mask'] ? MaskedRegExp : never;
+export type FactoryInstanceOpts = ({
+    mask: MaskedRegExp;
+} & Omit<MaskedRegExpOptions, 'mask'>) | ({
+    mask: MaskedPattern;
+} & Omit<MaskedPatternOptions, 'mask'>) | ({
+    mask: Masked;
+} & Omit<MaskedOptions, 'mask'>);
+export type FactoryInstanceReturnMasked<Opts extends FactoryInstanceOpts> = Opts extends {
+    mask: infer M;
+} ? M : never;
+export type FactoryConstructorOpts = ({
+    mask: typeof MaskedRegExp;
+} & Omit<MaskedRegExpOptions, 'mask'>) | ({
+    mask: typeof MaskedPattern;
+} & Omit<MaskedPatternOptions, 'mask'>) | ({
+    mask: typeof Masked;
+} & Omit<MaskedOptions, 'mask'>);
+export type FactoryConstructorReturnMasked<Opts extends FactoryConstructorOpts> = Opts extends {
+    mask: typeof MaskedRegExp;
+} ? MaskedRegExp : Opts extends {
+    mask: typeof MaskedPattern;
+} ? MaskedPattern : Masked;
+export type FactoryOpts = FactoryConstructorOpts | FactoryInstanceOpts | FactoryStaticOpts;
+export type FactoryArg = Masked | FactoryOpts | FactoryStaticOpts['mask'];
+export type ExtendFactoryArgOptions<Opts extends {
+    [key: string]: any;
+}> = Masked | (FactoryOpts & Opts) | FactoryStaticOpts['mask'];
+export type UpdateStaticOpts<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions ? MaskedPatternOptions : Opts extends MaskedRegExpOptions ? MaskedRegExpOptions : never;
+type AnyOpts = Record<string, any>;
+export type UpdateInstanceOpts<M extends Masked> = M extends MaskedRegExp ? MaskedRegExpOptions : M extends MaskedPattern ? MaskedPatternOptions : AnyOpts;
+export type UpdateConstructorOpts<M extends FactoryConstructorOpts> = M extends {
+    mask: typeof MaskedRegExp;
+} ? MaskedRegExpOptions : M extends {
+    mask: typeof MaskedPattern;
+} ? MaskedPatternOptions : AnyOpts;
+export type UpdateStaticMaskOpts<M extends FactoryStaticOpts['mask']> = M extends MaskedPatternOptions['mask'] ? MaskedPatternOptions : M extends MaskedRegExpOptions['mask'] ? MaskedRegExpOptions : never;
+export type UpdateOpts<Opts extends FactoryArg> = Partial<Opts extends Masked ? UpdateInstanceOpts<Opts> : Opts extends FactoryStaticOpts['mask'] ? UpdateStaticMaskOpts<Opts> : Opts extends FactoryStaticOpts ? UpdateStaticOpts<Opts> : Opts extends FactoryInstanceOpts ? UpdateInstanceOpts<Opts['mask']> : Opts extends FactoryConstructorOpts ? UpdateConstructorOpts<Opts> : AnyOpts>;
+export type FactoryReturnMasked<Opts extends FactoryArg> = Opts extends Masked ? Opts : Opts extends FactoryStaticOpts['mask'] ? FactoryStaticMaskReturnMasked<Opts> : Opts extends FactoryConstructorOpts ? FactoryConstructorReturnMasked<Opts> : Opts extends FactoryInstanceOpts ? FactoryInstanceReturnMasked<Opts> : Opts extends FactoryStaticOpts ? FactoryStaticReturnMasked<Opts> : never;
+/** Get Masked class by mask type */
+export declare function maskedClass(mask: Masked | FactoryOpts['mask']): typeof MaskedPattern | typeof MaskedRegExp | typeof Masked;
+type MaskedClassOf<M extends Masked> = M extends MaskedRegExp ? typeof MaskedRegExp : M extends MaskedPattern ? typeof MaskedPattern : any;
+type NormalizedMaskedOpts<Opts extends Masked> = Omit<Opts, 'mask'> & {
+    _mask: Opts;
+    mask: MaskedClassOf<Opts>;
+};
+type NormalizedInstanceOpts<Opts extends FactoryInstanceOpts> = Omit<Opts['mask'], `_${string}` | 'mask'> & NormalizedMaskedOpts<Opts['mask']>;
+export type NormalizedOpts<Opts extends FactoryArg> = Opts extends FactoryStaticOpts['mask'] ? {
+    mask: Opts;
+} : Opts extends Masked ? NormalizedMaskedOpts<Opts> : Opts extends FactoryInstanceOpts ? NormalizedInstanceOpts<Opts> : Opts extends FactoryStaticOpts | FactoryConstructorOpts ? Opts : {
+    mask: Opts;
+};
+export declare function normalizeOpts<Opts extends FactoryArg>(opts: Opts): NormalizedOpts<Opts>;
+/** Creates new {@link Masked} depending on mask type */
+export declare function createMask<Opts extends FactoryArg>(opts: Opts): FactoryReturnMasked<Opts>;
+export {};

package/components/MaskedInput/react-imask/imask/masked/pattern/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../../../../cjs/components/MaskedInput/react-imask/imask/masked/pattern.js",
+  "module": "pattern",
+  "types": "../pattern.d.ts",
+  "sideEffects": false
+}