@higher.archi/boe 1.0.0

package/dist/core/operators/logical/not.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/logical/not.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,QAUjB,CAAC;;AAEF,wBAAqB"}

package/dist/core/operators/logical/not.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Not Operator
+ *
+ * Logical NOT - negates a boolean value.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not = void 0;
+const operator_1 = require("../operator");
+/**
+ * Not operator - negates a boolean value
+ */
+exports.not = (0, operator_1.unaryOp)('not', (a) => !a, {
+    paramType: 'boolean',
+    returns: 'boolean',
+    category: 'logical',
+    description: 'Negates a boolean value',
+    aliases: ['!', 'negate'],
+});
+exports.default = [exports.not];
+//# sourceMappingURL=not.js.map

package/dist/core/operators/logical/not.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not.js","sourceRoot":"","sources":["../../../../src/core/operators/logical/not.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAsC;AAGtC;;GAEG;AACU,QAAA,GAAG,GAAa,IAAA,kBAAO,EAClC,KAAK,EACL,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EACT;IACE,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,SAAS;IACnB,WAAW,EAAE,yBAAyB;IACtC,OAAO,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC;CACzB,CACF,CAAC;AAEF,kBAAe,CAAC,WAAG,CAAC,CAAC"}

package/dist/core/operators/logical/or.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Or Operator
+ *
+ * Logical OR - returns true if any operand is true.
+ */
+import { Operator } from '../types';
+/**
+ * Or operator - returns true if any operand is true
+ */
+export declare const or: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=or.d.ts.map

package/dist/core/operators/logical/or.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"or.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/logical/or.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,EAAE,EAAE,QAUhB,CAAC;;AAEF,wBAAoB"}

package/dist/core/operators/logical/or.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Or Operator
+ *
+ * Logical OR - returns true if any operand is true.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.or = void 0;
+const operator_1 = require("../operator");
+/**
+ * Or operator - returns true if any operand is true
+ */
+exports.or = (0, operator_1.variadicOp)('or', (...args) => args.some(Boolean), {
+    paramType: 'boolean',
+    returns: 'boolean',
+    category: 'logical',
+    description: 'Returns true if any operand is true',
+    aliases: ['||', 'any'],
+});
+exports.default = [exports.or];
+//# sourceMappingURL=or.js.map

package/dist/core/operators/logical/or.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"or.js","sourceRoot":"","sources":["../../../../src/core/operators/logical/or.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAyC;AAGzC;;GAEG;AACU,QAAA,EAAE,GAAa,IAAA,qBAAU,EACpC,IAAI,EACJ,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAC/B;IACE,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,SAAS;IACnB,WAAW,EAAE,qCAAqC;IAClD,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;CACvB,CACF,CAAC;AAEF,kBAAe,CAAC,UAAE,CAAC,CAAC"}

package/dist/core/operators/logical/xor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Xor Operator
+ *
+ * Logical XOR - returns true if exactly one operand is true.
+ */
+import { Operator } from '../types';
+/**
+ * Xor operator (binary) - returns true if exactly one operand is true
+ */
+export declare const xor: Operator;
+/**
+ * Xor variadic - returns true if an odd number of operands are true
+ */
+export declare const xorAll: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=xor.d.ts.map

package/dist/core/operators/logical/xor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/logical/xor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,QAWjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,QASpB,CAAC;;AAEF,wBAA6B"}

package/dist/core/operators/logical/xor.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Xor Operator
+ *
+ * Logical XOR - returns true if exactly one operand is true.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xorAll = exports.xor = void 0;
+const operator_1 = require("../operator");
+/**
+ * Xor operator (binary) - returns true if exactly one operand is true
+ */
+exports.xor = (0, operator_1.binaryOp)('xor', (a, b) => a !== b, {
+    leftType: 'boolean',
+    rightType: 'boolean',
+    returns: 'boolean',
+    category: 'logical',
+    description: 'Returns true if exactly one of two operands is true',
+    aliases: ['^'],
+});
+/**
+ * Xor variadic - returns true if an odd number of operands are true
+ */
+exports.xorAll = (0, operator_1.variadicOp)('xorAll', (...args) => args.filter(Boolean).length % 2 === 1, {
+    paramType: 'boolean',
+    returns: 'boolean',
+    category: 'logical',
+    description: 'Returns true if an odd number of operands are true',
+});
+exports.default = [exports.xor, exports.xorAll];
+//# sourceMappingURL=xor.js.map

package/dist/core/operators/logical/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.js","sourceRoot":"","sources":["../../../../src/core/operators/logical/xor.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAmD;AAGnD;;GAEG;AACU,QAAA,GAAG,GAAa,IAAA,mBAAQ,EACnC,KAAK,EACL,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EACjB;IACE,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,SAAS;IACnB,WAAW,EAAE,qDAAqD;IAClE,OAAO,EAAE,CAAC,GAAG,CAAC;CACf,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,MAAM,GAAa,IAAA,qBAAU,EACxC,QAAQ,EACR,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAClD;IACE,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,SAAS;IACnB,WAAW,EAAE,oDAAoD;CAClE,CACF,CAAC;AAEF,kBAAe,CAAC,WAAG,EAAE,cAAM,CAAC,CAAC"}

package/dist/core/operators/operator.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Operator Factory Functions
+ *
+ * Helper functions to create operators with proper type safety
+ * and consistent structure.
+ */
+import { Operator, OperatorArity, OperatorCategory, OperatorParameter, OperatorReturnType, ParameterType, PolymorphicOperator } from './types';
+/**
+ * Base options for all operator types
+ */
+export interface OperatorOptionsBase {
+    /** Return type of the operator */
+    returns: OperatorReturnType;
+    /** Human-readable description */
+    description?: string;
+    /** Operator category for grouping */
+    category?: OperatorCategory;
+    /** Alternative names for this operator */
+    aliases?: string[];
+    /** Supported input types (for documentation) */
+    supportedTypes?: ParameterType[];
+}
+/**
+ * Options for unary operators
+ */
+export interface UnaryOpOptions extends OperatorOptionsBase {
+    /** Type of the input parameter */
+    paramType: ParameterType;
+}
+/**
+ * Options for binary operators
+ */
+export interface BinaryOpOptions extends OperatorOptionsBase {
+    /** Type of the left operand */
+    leftType: ParameterType;
+    /** Type of the right operand */
+    rightType: ParameterType;
+}
+/**
+ * Options for ternary operators
+ */
+export interface TernaryOpOptions extends OperatorOptionsBase {
+    /** Types of the three parameters */
+    params: [ParameterType, ParameterType, ParameterType];
+}
+/**
+ * Options for variadic operators
+ */
+export interface VariadicOpOptions extends OperatorOptionsBase {
+    /** Type of each parameter */
+    paramType: ParameterType;
+}
+/**
+ * Options for "one + rest" variadic operators (first arg + variadic rest)
+ */
+export interface OneRestOpOptions extends OperatorOptionsBase {
+    /** Type of the first (left) parameter */
+    leftType: ParameterType;
+    /** Type of the rest parameters */
+    restType: ParameterType;
+}
+/**
+ * Options for polymorphic operators
+ */
+export interface PolymorphicOpOptions extends Omit<OperatorOptionsBase, 'supportedTypes'> {
+    /** Arity of the operator */
+    arity: OperatorArity;
+}
+/**
+ * Create a unary operator (single argument)
+ *
+ * @example
+ * ```ts
+ * const isEven = unaryOp<number>('isEven', (a) => a % 2 === 0, {
+ *   paramType: 'number',
+ *   returns: 'boolean',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+export declare function unaryOp<T>(name: string, implementation: (a: T) => any, options: UnaryOpOptions): Operator;
+/**
+ * Create a binary operator (two arguments)
+ *
+ * @example
+ * ```ts
+ * const divide = binaryOp<number>('divide', (a, b) => a / b, {
+ *   leftType: 'number',
+ *   rightType: 'number',
+ *   returns: 'number',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+export declare function binaryOp<T, U = T>(name: string, implementation: (a: T, b: U) => any, options: BinaryOpOptions): Operator;
+/**
+ * Create a ternary operator (three arguments)
+ *
+ * @example
+ * ```ts
+ * const substring = ternaryOp<string, number, number>(
+ *   'substring',
+ *   (str, start, end) => str.substring(start, end),
+ *   {
+ *     params: ['string', 'number', 'number'],
+ *     returns: 'string',
+ *     category: 'transform',
+ *   }
+ * );
+ * ```
+ */
+export declare function ternaryOp<T, U = T, V = T>(name: string, implementation: (a: T, b: U, c: V) => any, options: TernaryOpOptions): Operator;
+/**
+ * Create a variadic operator (variable number of arguments)
+ *
+ * @example
+ * ```ts
+ * const sum = variadicOp<number>('sum', (...args) => args.reduce((a, b) => a + b, 0), {
+ *   paramType: 'number',
+ *   returns: 'number',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+export declare function variadicOp<T>(name: string, implementation: (...args: T[]) => any, options: VariadicOpOptions): Operator;
+/**
+ * Create a "one + rest" variadic operator (first arg + variadic rest)
+ * Returns true if the first arg matches ANY of the rest args
+ *
+ * @example
+ * ```ts
+ * const soundsLike = oneRestOp<string>(
+ *   'soundsLike',
+ *   (left, ...rest) => rest.some(r => soundexMatch(left, r)),
+ *   {
+ *     leftType: 'string',
+ *     restType: 'string',
+ *     returns: 'boolean',
+ *     category: 'phonetic',
+ *   }
+ * );
+ * // soundsLike('smith', 'smyth', 'smythe') -> true if any match
+ * ```
+ */
+export declare function oneRestOp<T, U = T>(name: string, implementation: (left: T, ...rest: U[]) => any, options: OneRestOpOptions): Operator;
+/**
+ * Create a polymorphic operator with multiple type-specific implementations
+ *
+ * @example
+ * ```ts
+ * const equals = polymorphicOp('equals', {
+ *   string: (a, b) => a === b,
+ *   number: (a, b) => a === b,
+ *   date: (a, b) => a.getTime() === b.getTime(),
+ * }, {
+ *   arity: 'binary',
+ *   returns: 'boolean',
+ *   category: 'comparison',
+ * });
+ * ```
+ */
+export declare function polymorphicOp(name: string, implementations: Partial<Record<ParameterType, (...args: any[]) => any>>, options: PolymorphicOpOptions): PolymorphicOperator;
+/**
+ * Helper to create parameter definitions with convenience
+ */
+export declare function param(name: string, type: ParameterType, description?: string, optional?: boolean): OperatorParameter;
+/**
+ * Check if an operator is polymorphic
+ */
+export declare function isPolymorphic(op: Operator | PolymorphicOperator): op is PolymorphicOperator;
+//# sourceMappingURL=operator.d.ts.map

package/dist/core/operators/operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../../src/core/operators/operator.ts"],"names":[],"mappings":"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"}

package/dist/core/operators/operator.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Operator Factory Functions
+ *
+ * Helper functions to create operators with proper type safety
+ * and consistent structure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unaryOp = unaryOp;
+exports.binaryOp = binaryOp;
+exports.ternaryOp = ternaryOp;
+exports.variadicOp = variadicOp;
+exports.oneRestOp = oneRestOp;
+exports.polymorphicOp = polymorphicOp;
+exports.param = param;
+exports.isPolymorphic = isPolymorphic;
+/**
+ * Create a unary operator (single argument)
+ *
+ * @example
+ * ```ts
+ * const isEven = unaryOp<number>('isEven', (a) => a % 2 === 0, {
+ *   paramType: 'number',
+ *   returns: 'boolean',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+function unaryOp(name, implementation, options) {
+    return {
+        name,
+        category: options.category ?? 'comparison',
+        arity: 'unary',
+        parameters: [{ name: 'value', type: options.paramType }],
+        returns: options.returns,
+        implementation,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes: options.supportedTypes,
+    };
+}
+/**
+ * Create a binary operator (two arguments)
+ *
+ * @example
+ * ```ts
+ * const divide = binaryOp<number>('divide', (a, b) => a / b, {
+ *   leftType: 'number',
+ *   rightType: 'number',
+ *   returns: 'number',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+function binaryOp(name, implementation, options) {
+    return {
+        name,
+        category: options.category ?? 'comparison',
+        arity: 'binary',
+        parameters: [
+            { name: 'left', type: options.leftType },
+            { name: 'right', type: options.rightType },
+        ],
+        returns: options.returns,
+        implementation,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes: options.supportedTypes,
+    };
+}
+/**
+ * Create a ternary operator (three arguments)
+ *
+ * @example
+ * ```ts
+ * const substring = ternaryOp<string, number, number>(
+ *   'substring',
+ *   (str, start, end) => str.substring(start, end),
+ *   {
+ *     params: ['string', 'number', 'number'],
+ *     returns: 'string',
+ *     category: 'transform',
+ *   }
+ * );
+ * ```
+ */
+function ternaryOp(name, implementation, options) {
+    return {
+        name,
+        category: options.category ?? 'transform',
+        arity: 'ternary',
+        parameters: [
+            { name: 'first', type: options.params[0] },
+            { name: 'second', type: options.params[1] },
+            { name: 'third', type: options.params[2] },
+        ],
+        returns: options.returns,
+        implementation,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes: options.supportedTypes,
+    };
+}
+/**
+ * Create a variadic operator (variable number of arguments)
+ *
+ * @example
+ * ```ts
+ * const sum = variadicOp<number>('sum', (...args) => args.reduce((a, b) => a + b, 0), {
+ *   paramType: 'number',
+ *   returns: 'number',
+ *   category: 'arithmetic',
+ * });
+ * ```
+ */
+function variadicOp(name, implementation, options) {
+    return {
+        name,
+        category: options.category ?? 'logical',
+        arity: 'variadic',
+        parameters: [{ name: 'values', type: options.paramType }],
+        returns: options.returns,
+        implementation,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes: options.supportedTypes,
+    };
+}
+/**
+ * Create a "one + rest" variadic operator (first arg + variadic rest)
+ * Returns true if the first arg matches ANY of the rest args
+ *
+ * @example
+ * ```ts
+ * const soundsLike = oneRestOp<string>(
+ *   'soundsLike',
+ *   (left, ...rest) => rest.some(r => soundexMatch(left, r)),
+ *   {
+ *     leftType: 'string',
+ *     restType: 'string',
+ *     returns: 'boolean',
+ *     category: 'phonetic',
+ *   }
+ * );
+ * // soundsLike('smith', 'smyth', 'smythe') -> true if any match
+ * ```
+ */
+function oneRestOp(name, implementation, options) {
+    return {
+        name,
+        category: options.category ?? 'comparison',
+        arity: 'variadic',
+        parameters: [
+            { name: 'left', type: options.leftType },
+            { name: 'rest', type: options.restType },
+        ],
+        returns: options.returns,
+        implementation,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes: options.supportedTypes,
+    };
+}
+/**
+ * Create a polymorphic operator with multiple type-specific implementations
+ *
+ * @example
+ * ```ts
+ * const equals = polymorphicOp('equals', {
+ *   string: (a, b) => a === b,
+ *   number: (a, b) => a === b,
+ *   date: (a, b) => a.getTime() === b.getTime(),
+ * }, {
+ *   arity: 'binary',
+ *   returns: 'boolean',
+ *   category: 'comparison',
+ * });
+ * ```
+ */
+function polymorphicOp(name, implementations, options) {
+    const supportedTypes = Object.keys(implementations);
+    // Generate parameters based on arity
+    const paramCount = arityToCount(options.arity);
+    const parameters = options.arity === 'variadic'
+        ? [{ name: 'values', type: 'any' }]
+        : Array.from({ length: paramCount }, (_, i) => ({
+            name: ['left', 'right', 'third'][i] ?? `arg${i}`,
+            type: 'any',
+        }));
+    return {
+        name,
+        category: options.category ?? 'comparison',
+        arity: options.arity,
+        parameters,
+        returns: options.returns,
+        implementations: implementations,
+        defaultImplementation: implementations.any,
+        description: options.description,
+        aliases: options.aliases,
+        supportedTypes,
+    };
+}
+/**
+ * Convert arity to expected argument count
+ */
+function arityToCount(arity) {
+    switch (arity) {
+        case 'unary':
+            return 1;
+        case 'binary':
+            return 2;
+        case 'ternary':
+            return 3;
+        case 'variadic':
+            return -1;
+    }
+}
+/**
+ * Helper to create parameter definitions with convenience
+ */
+function param(name, type, description, optional) {
+    return { name, type, description, optional };
+}
+/**
+ * Check if an operator is polymorphic
+ */
+function isPolymorphic(op) {
+    return 'implementations' in op;
+}
+//# sourceMappingURL=operator.js.map

package/dist/core/operators/operator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator.js","sourceRoot":"","sources":["../../../src/core/operators/operator.ts"],"names":[],"mappings":"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"}

package/dist/core/operators/phonetic/caverphone.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Caverphone Operators
+ *
+ * Caverphone2 phonetic encoding (optimized for New Zealand names).
+ */
+import { Operator } from '../types';
+/**
+ * Caverphone2 encode - returns the Caverphone2 code for a string
+ */
+export declare const caverphone2: Operator;
+/**
+ * Caverphone2 match - checks if first string sounds like ANY of the rest
+ */
+export declare const caverphone2Equals: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=caverphone.d.ts.map

package/dist/core/operators/phonetic/caverphone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caverphone.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/phonetic/caverphone.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,QASzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAU/B,CAAC;;AAEF,wBAAgD"}

package/dist/core/operators/phonetic/caverphone.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Caverphone Operators
+ *
+ * Caverphone2 phonetic encoding (optimized for New Zealand names).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.caverphone2Equals = exports.caverphone2 = void 0;
+const operator_1 = require("../operator");
+const phonetic_1 = require("../../../functions/phonetic");
+/**
+ * Caverphone2 encode - returns the Caverphone2 code for a string
+ */
+exports.caverphone2 = (0, operator_1.unaryOp)('caverphone2', (a) => (0, phonetic_1.caverphone2)(a), {
+    paramType: 'string',
+    returns: 'string',
+    category: 'phonetic',
+    description: 'Returns the Caverphone2 phonetic code for a string',
+});
+/**
+ * Caverphone2 match - checks if first string sounds like ANY of the rest
+ */
+exports.caverphone2Equals = (0, operator_1.oneRestOp)('caverphone2Match', (left, ...rest) => rest.some((r) => (0, phonetic_1.caverphone2Match)(left, r)), {
+    leftType: 'string',
+    restType: 'string',
+    returns: 'boolean',
+    category: 'phonetic',
+    description: 'Checks if the first string sounds like any of the following strings (Caverphone2)',
+});
+exports.default = [exports.caverphone2, exports.caverphone2Equals];
+//# sourceMappingURL=caverphone.js.map

package/dist/core/operators/phonetic/caverphone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caverphone.js","sourceRoot":"","sources":["../../../../src/core/operators/phonetic/caverphone.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAiD;AAEjD,0DAAiG;AAEjG;;GAEG;AACU,QAAA,WAAW,GAAa,IAAA,kBAAO,EAC1C,aAAa,EACb,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,sBAAiB,EAAC,CAAC,CAAC,EAC3B;IACE,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,UAAU;IACpB,WAAW,EAAE,oDAAoD;CAClE,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,iBAAiB,GAAa,IAAA,oBAAS,EAClD,kBAAkB,EAClB,CAAC,IAAI,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,2BAAgB,EAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAC9D;IACE,QAAQ,EAAE,QAAQ;IAClB,QAAQ,EAAE,QAAQ;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,WAAW,EAAE,mFAAmF;CACjG,CACF,CAAC;AAEF,kBAAe,CAAC,mBAAW,EAAE,yBAAiB,CAAC,CAAC"}

package/dist/core/operators/phonetic/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Phonetic Operators
+ *
+ * Exports all phonetic operators for registry registration.
+ */
+export * from './soundex';
+export * from './nysiis';
+export * from './caverphone';
+/**
+ * All phonetic operators as an array for bulk registration
+ */
+export declare const phoneticOperators: import("..").Operator<import("..").OperatorParameter[], import("..").OperatorReturnType>[];
+export default phoneticOperators;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/operators/phonetic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/phonetic/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAE7B;;GAEG;AACH,eAAO,MAAM,iBAAiB,4FAI7B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/core/operators/phonetic/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Phonetic Operators
+ *
+ * Exports all phonetic operators for registry registration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phoneticOperators = void 0;
+const soundex_1 = __importDefault(require("./soundex"));
+const nysiis_1 = __importDefault(require("./nysiis"));
+const caverphone_1 = __importDefault(require("./caverphone"));
+__exportStar(require("./soundex"), exports);
+__exportStar(require("./nysiis"), exports);
+__exportStar(require("./caverphone"), exports);
+/**
+ * All phonetic operators as an array for bulk registration
+ */
+exports.phoneticOperators = [
+    ...soundex_1.default,
+    ...nysiis_1.default,
+    ...caverphone_1.default,
+];
+exports.default = exports.phoneticOperators;
+//# sourceMappingURL=index.js.map

package/dist/core/operators/phonetic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/operators/phonetic/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;;;;;;;;;;;;;;;AAEH,wDAAmC;AACnC,sDAAiC;AACjC,8DAAyC;AAEzC,4CAA0B;AAC1B,2CAAyB;AACzB,+CAA6B;AAE7B;;GAEG;AACU,QAAA,iBAAiB,GAAG;IAC/B,GAAG,iBAAU;IACb,GAAG,gBAAS;IACZ,GAAG,oBAAa;CACjB,CAAC;AAEF,kBAAe,yBAAiB,CAAC"}