@skbkontur/react-ui 6.1.4 → 6.1.6-084cd.0

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

@@ -0,0 +1,62 @@
+import { Masked, type MaskedOptions } from './base.js';
+import type { MaskedPattern, MaskedPatternOptions } from './pattern.js';
+import { MaskedRegExp, type MaskedRegExpOptions } from './regexp.js';
+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/MaskedInputV2/react-imask/imask/masked/factory.js

@@ -0,0 +1,107 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { isString, pick, isObject } from '../core/utils.js';
+import { Masked } from './base.js';
+import { MaskedRegExp } from './regexp.js';
+/** Set by pattern.ts to break the factory ↔ pattern import cycle. */
+var MaskedPatternClass;
+/** @internal */
+export function registerMaskedPatternClass(Class) {
+    MaskedPatternClass = Class;
+}
+function getMaskedPatternClass() {
+    if (!MaskedPatternClass) {
+        throw new Error('MaskedPattern is not registered. Import pattern module before creating a pattern mask.');
+    }
+    return MaskedPatternClass;
+}
+/** 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 getMaskedPatternClass();
+    }
+    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 _a = 
+    // eslint-disable-next-line no-nested-ternary
+    opts instanceof Masked
+        ? { mask: opts }
+        : isObject(opts) && opts.mask instanceof Masked
+            ? opts
+            : {}, _b = _a.mask, mask = _b === void 0 ? undefined : _b, instanceOpts = __rest(_a, ["mask"]);
+    if (mask) {
+        var _mask = mask.mask;
+        return __assign(__assign(__assign({}, pick(mask, function (_, k) { return !k.startsWith('_'); })), { mask: mask.constructor, _mask: _mask }), instanceOpts);
+    }
+    if (!isObject(opts)) {
+        return { mask: opts };
+    }
+    return __assign({}, 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);
+}
+//# sourceMappingURL=factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { isString, pick, isObject } from '../core/utils.js';\nimport { Masked, type MaskedOptions } from './base.js';\nimport type { MaskedPattern, MaskedPatternOptions } from './pattern.js';\nimport { MaskedRegExp, type MaskedRegExpOptions } from './regexp.js';\n\ntype MaskedPatternConstructor = typeof MaskedPattern;\n\n/** Set by pattern.ts to break the factory ↔ pattern import cycle. */\nlet MaskedPatternClass: MaskedPatternConstructor | undefined;\n\n/** @internal */\nexport function registerMaskedPatternClass(Class: MaskedPatternConstructor): void {\n  MaskedPatternClass = Class;\n}\n\nfunction getMaskedPatternClass(): MaskedPatternConstructor {\n  if (!MaskedPatternClass) {\n    throw new Error('MaskedPattern is not registered. Import pattern module before creating a pattern mask.');\n  }\n  return MaskedPatternClass;\n}\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 getMaskedPatternClass();\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"]}

package/components/MaskedInputV2/react-imask/imask/masked/pattern.d.ts

@@ -0,0 +1,101 @@
+import { ChangeDetails } from '../core/change-details.js';
+import { type TailDetails } from '../core/tail-details.js';
+import { type Direction } from '../core/utils.js';
+import { Masked, type AppendFlags, type ExtractFlags, type MaskedOptions, type MaskedState } from './base.js';
+import { type FactoryArg, type ExtendFactoryArgOptions } from './factory.js';
+import type { PatternBlock } from './patterns/block.js';
+import { PatternFixedDefinition } from './patterns/fixed-definition.js';
+import { PatternInputDefinition } from './patterns/input-definition.js';
+import './regexp.js';
+export type MaskedPatternOptions<Value = string, M extends MaskedPattern<Value> = MaskedPattern<Value>, Props extends keyof M = never> = MaskedOptions<M, 'definitions' | 'blocks' | 'placeholderChar' | 'displayChar' | 'lazy' | Props>;
+export interface Definitions {
+    [k: string]: FactoryArg;
+}
+export type MaskedPatternState = MaskedState & {
+    _blocks: MaskedState[];
+};
+export interface BlockPosData {
+    index: number;
+    offset: number;
+}
+export interface BlockExtraOptions {
+    expose?: boolean;
+}
+/** Pattern mask */
+export declare class MaskedPattern<Value = string> extends Masked<Value> {
+    static DEFAULTS: {
+        lazy: boolean;
+        placeholderChar: string;
+        skipInvalid?: boolean | undefined | undefined;
+    };
+    static STOP_CHAR: string;
+    static ESCAPE_CHAR: string;
+    static InputDefinition: typeof PatternInputDefinition;
+    static FixedDefinition: typeof PatternFixedDefinition;
+    mask: string;
+    /** */
+    blocks: {
+        [key: string]: ExtendFactoryArgOptions<BlockExtraOptions>;
+    };
+    /** */
+    definitions: Definitions;
+    /** Single char for empty input */
+    placeholderChar: string;
+    /** Single char for filled input */
+    displayChar: string;
+    /** Show placeholder only when needed */
+    lazy: boolean;
+    /** Enable characters overwriting */
+    overwrite?: boolean | 'shift' | undefined;
+    /** */
+    eager?: boolean | 'remove' | 'append' | undefined;
+    /** */
+    skipInvalid?: boolean | undefined;
+    /** */
+    autofix?: boolean | 'pad' | undefined;
+    _blocks: PatternBlock[];
+    _maskedBlocks: {
+        [key: string]: number[];
+    };
+    _stops: number[];
+    exposeBlock?: Masked;
+    constructor(opts: MaskedPatternOptions<Value>);
+    updateOptions(opts: Partial<MaskedPatternOptions<Value>>): void;
+    _update(opts: Partial<MaskedPatternOptions<Value>>): void;
+    _rebuildMask(): void;
+    get state(): MaskedPatternState;
+    set state(state: MaskedPatternState);
+    reset(): void;
+    get isComplete(): boolean;
+    get isFilled(): boolean;
+    get isFixed(): boolean;
+    get isOptional(): boolean;
+    doCommit(): void;
+    get unmaskedValue(): string;
+    set unmaskedValue(unmaskedValue: string);
+    get value(): string;
+    set value(value: string);
+    get typedValue(): Value;
+    set typedValue(value: Value);
+    get displayValue(): string;
+    appendTail(tail: string | TailDetails): ChangeDetails;
+    _appendEager(): ChangeDetails;
+    _appendCharRaw(ch: string, flags?: AppendFlags<MaskedPatternState>): ChangeDetails;
+    extractTail(fromPos?: number, toPos?: number): TailDetails;
+    extractInput(fromPos?: number, toPos?: number, flags?: ExtractFlags): string;
+    _findStopBefore(blockIndex: number): number | undefined;
+    /** Appends placeholder depending on laziness */
+    _appendPlaceholder(toBlockIndex?: number): ChangeDetails;
+    /** Finds block in pos */
+    _mapPosToBlock(pos: number): BlockPosData | undefined;
+    _blockStartPos(blockIndex: number): number;
+    _forEachBlocksInRange(fromPos: number, toPos: number | undefined, fn: (block: PatternBlock, blockIndex: number, fromPos: number, toPos: number) => void): void;
+    remove(fromPos?: number, toPos?: number): ChangeDetails;
+    nearestInputPos(cursorPos: number, direction?: Direction): number;
+    totalInputPositions(fromPos?: number, toPos?: number): number;
+    /** Get block by name */
+    maskedBlock(name: string): PatternBlock | undefined;
+    /** Get all blocks by name */
+    maskedBlocks(name: string): PatternBlock[];
+    pad(flags?: AppendFlags): ChangeDetails;
+}