@jmespath-community/jmespath 1.1.0

package/dist/lib/utils/strings.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upper = exports.trimRight = exports.trimLeft = exports.trim = exports.split = exports.replace = exports.padRight = exports.padLeft = exports.lower = exports.findLast = exports.findFirst = void 0;
+const _1 = require(".");
+const findFirst = (subject, sub, start, end) => {
+    if (!subject || !sub) {
+        return null;
+    }
+    start = Math.max((0, _1.ensureInteger)((start = start || 0)), 0);
+    end = Math.min((0, _1.ensureInteger)((end = end || subject.length)), subject.length);
+    const offset = subject.slice(start, end).indexOf(sub);
+    return offset === -1 ? null : offset + start;
+};
+exports.findFirst = findFirst;
+const findLast = (subject, sub, start, end) => {
+    if (!subject || !sub) {
+        return null;
+    }
+    start = Math.max((0, _1.ensureInteger)((start = start || 0)), 0);
+    end = Math.min((0, _1.ensureInteger)((end = end || subject.length)), subject.length);
+    const offset = subject.slice(start, end).lastIndexOf(sub);
+    const result = offset === -1 ? null : offset + start;
+    return result;
+};
+exports.findLast = findLast;
+const lower = (subject) => subject.toLowerCase();
+exports.lower = lower;
+const ensurePadFuncParams = (name, width, padding) => {
+    padding = padding || ' ';
+    if (padding.length > 1) {
+        throw new Error(`invalid value, ${name} expects its 'pad' parameter to be a valid string with a single codepoint`);
+    }
+    (0, _1.ensurePositiveInteger)(width);
+    return padding;
+};
+const padLeft = (subject, width, padding) => {
+    padding = ensurePadFuncParams('pad_left', width, padding);
+    return (subject && subject.padStart(width, padding)) || '';
+};
+exports.padLeft = padLeft;
+const padRight = (subject, width, padding) => {
+    padding = ensurePadFuncParams('pad_right', width, padding);
+    return (subject && subject.padEnd(width, padding)) || '';
+};
+exports.padRight = padRight;
+const replace = (subject, string, by, count) => {
+    if (count === 0) {
+        return subject;
+    }
+    if (!count) {
+        // emulating es2021: String.prototype.replaceAll()
+        return subject.split(string).join(by);
+    }
+    (0, _1.ensurePositiveInteger)(count);
+    [...Array(count).keys()].map(() => (subject = subject.replace(string, by)));
+    return subject;
+};
+exports.replace = replace;
+const split = (subject, search, count) => {
+    if (subject.length == 0 && search.length === 0) {
+        return [];
+    }
+    if (count === null || count === undefined) {
+        return subject.split(search);
+    }
+    (0, _1.ensurePositiveInteger)(count);
+    if (count === 0) {
+        return [subject];
+    }
+    const split = subject.split(search);
+    return [
+        ...split.slice(0, count),
+        split.slice(count).join(search)
+    ];
+};
+exports.split = split;
+const trim = (subject, chars) => {
+    return (0, exports.trimLeft)((0, exports.trimRight)(subject, chars), chars);
+};
+exports.trim = trim;
+const trimLeft = (subject, chars) => {
+    return trimImpl(subject, list => new RegExp(`^[${list}]*(.*?)`), chars);
+};
+exports.trimLeft = trimLeft;
+const trimRight = (subject, chars) => {
+    return trimImpl(subject, list => new RegExp(`(.*?)[${list}]*\$`), chars);
+};
+exports.trimRight = trimRight;
+const trimImpl = (subject, regExper, chars) => {
+    const pattern = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&') : '\\s\u0085';
+    return subject.replace(regExper(pattern), '$1');
+};
+const upper = (subject) => subject.toUpperCase();
+exports.upper = upper;
+//# sourceMappingURL=strings.js.map

package/dist/lib/utils/strings.js.map

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

package/dist/lib/utils/text.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = void 0;
+class Text {
+    constructor(text) {
+        this._text = text;
+    }
+    get string() {
+        return this._text;
+    }
+    get length() {
+        return this.codePoints.length;
+    }
+    compareTo(other) {
+        return Text.compare(this, new Text(other));
+    }
+    static get comparer() {
+        const stringComparer = (left, right) => {
+            return new Text(left).compareTo(right);
+        };
+        return stringComparer;
+    }
+    static compare(left, right) {
+        const leftCp = left.codePoints;
+        const rightCp = right.codePoints;
+        for (let index = 0; index < Math.min(leftCp.length, rightCp.length); index++) {
+            if (leftCp[index] === rightCp[index]) {
+                continue;
+            }
+            return (leftCp[index] - rightCp[index]) > 0 ? 1 : -1;
+        }
+        return (leftCp.length - rightCp.length) > 0 ? 1 : -1;
+    }
+    reverse() {
+        return String.fromCodePoint(...this.codePoints.reverse());
+    }
+    get codePoints() {
+        const array = [...this._text].map(s => s.codePointAt(0));
+        return array;
+    }
+}
+exports.Text = Text;
+//# sourceMappingURL=text.js.map

package/dist/lib/utils/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../src/utils/text.ts"],"names":[],"mappings":";;;AAAA,MAAa,IAAI;IAEhB,YAAY,IAAY;QACvB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,IAAW,MAAM;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED,IAAW,MAAM;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;IAC/B,CAAC;IAEM,SAAS,CAAC,KAAa;QAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5C,CAAC;IAEM,MAAM,KAAK,QAAQ;QACzB,MAAM,cAAc,GAAG,CAAC,IAAY,EAAE,KAAa,EAAU,EAAE;YAC9D,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC,CAAA;QACD,OAAO,cAAc,CAAC;IACvB,CAAC;IAEM,MAAM,CAAC,OAAO,CAAC,IAAU,EAAE,KAAW;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;QAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC;QACjC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,EAAC;YAC5E,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,EAAC;gBACpC,SAAS;aACT;YACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SACrD;QACD,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAEM,OAAO;QACb,OAAO,MAAM,CAAC,aAAa,CAC1B,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,IAAY,UAAU;QACrB,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAChC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,CAAC;QACzB,OAAO,KAAK,CAAC;IACd,CAAC;CACD;AA/CD,oBA+CC"}

package/dist/types/AST.type.d.ts

@@ -0,0 +1,85 @@
+import { JSONValue } from './JSON.type';
+import { Token } from './Lexer.type';
+export interface FieldNode {
+    readonly type: 'Field';
+    readonly name: string;
+}
+export interface LiteralNode {
+    readonly type: 'Literal';
+    readonly value: JSONValue;
+}
+export interface IndexNode {
+    readonly type: 'Index';
+    readonly value: number;
+}
+export interface FilterProjectionNode {
+    readonly type: 'FilterProjection';
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+    readonly condition: ExpressionNode;
+}
+export interface SliceNode {
+    readonly type: 'Slice';
+    readonly start: number | null;
+    readonly stop: number | null;
+    readonly step: number | null;
+}
+export type ComparatorType = 'GT' | 'LT' | 'GTE' | 'LTE' | 'NE' | 'EQ';
+export interface ComparatorNode {
+    readonly type: 'Comparator';
+    readonly name: ComparatorType;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export interface KeyValuePairNode {
+    readonly type: 'KeyValuePair';
+    readonly name: string;
+    readonly value: ExpressionNode;
+}
+export interface MultiSelectHashNode {
+    type: 'MultiSelectHash';
+    children: KeyValuePairNode[];
+}
+export interface MultiSelectListNode {
+    type: 'MultiSelectList';
+    children: ExpressionNode[];
+}
+export interface FunctionNode {
+    readonly type: 'Function';
+    readonly name: string;
+    readonly children: ExpressionNode[];
+}
+type BinaryExpressionType = 'AndExpression' | 'IndexExpression' | 'OrExpression' | 'Pipe' | 'Projection' | 'Subexpression' | 'ValueProjection';
+type UnaryExpressionType = 'ExpressionReference' | 'Flatten' | 'NotExpression';
+type SimpleExpressionType = 'Identity' | 'Current' | 'Root';
+export interface SimpleExpressionNode<T extends SimpleExpressionType = SimpleExpressionType> {
+    readonly type: T;
+}
+export interface UnaryExpressionNode<T extends UnaryExpressionType = UnaryExpressionType> {
+    readonly type: T;
+    readonly child: ExpressionNode;
+}
+export type UnaryOperatorType = 'Plus' | 'Minus';
+export interface UnaryArithmeticNode {
+    readonly type: 'Unary';
+    readonly operator: UnaryOperatorType;
+    readonly operand: ExpressionNode;
+}
+export interface BinaryExpressionNode<T extends BinaryExpressionType = BinaryExpressionType> {
+    readonly type: T;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export type BinaryOperatorType = 'Plus' | 'Minus' | 'Multiply' | Token.TOK_STAR | 'Divide' | 'Modulo' | 'Div';
+export interface BinaryArithmeticNode {
+    readonly type: 'Arithmetic';
+    readonly operator: BinaryOperatorType;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export type ExpressionNode = SimpleExpressionNode | UnaryExpressionNode | UnaryArithmeticNode | BinaryExpressionNode | BinaryArithmeticNode | ComparatorNode | SliceNode | FilterProjectionNode | IndexNode | LiteralNode | FieldNode | MultiSelectHashNode | MultiSelectListNode | FunctionNode;
+export type ExpressionReference = {
+    expref: true;
+    context: JSONValue;
+} & ExpressionNode;
+export {};

package/dist/types/JSON.type.d.ts

@@ -0,0 +1,10 @@
+export type ObjectDict<T = unknown> = Record<string, T | undefined>;
+export type JSONPrimitive = string | number | boolean | null;
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+export type JSONObject = {
+    [member: string]: JSONValue;
+};
+export type JSONArrayObject = JSONObject[];
+export type JSONArrayKeyValuePairs = [string, JSONValue][];
+export type JSONArrayArray = JSONArray[];
+export type JSONArray = JSONValue[];

package/dist/types/Lexer.d.ts

@@ -0,0 +1,19 @@
+import { LexerOptions, LexerToken, Token } from './Lexer.type';
+export declare const basicTokens: Record<string, Token>;
+declare class StreamLexer {
+    private _current;
+    private _enable_legacy_literals;
+    tokenize(stream: string, options?: LexerOptions): LexerToken[];
+    private consumeUnquotedIdentifier;
+    private consumeQuotedIdentifier;
+    private consumeRawStringLiteral;
+    private consumeNumber;
+    private consumeLBracket;
+    private consumeOrElse;
+    private consumeOperator;
+    private consumeLiteral;
+    private looksLikeJSON;
+    private parseJSON;
+}
+export declare const Lexer: StreamLexer;
+export default Lexer;

package/dist/types/Lexer.type.d.ts

@@ -0,0 +1,48 @@
+import { JSONValue } from './JSON.type';
+export declare enum Token {
+    TOK_EOF = "EOF",
+    TOK_UNQUOTEDIDENTIFIER = "UnquotedIdentifier",
+    TOK_QUOTEDIDENTIFIER = "QuotedIdentifier",
+    TOK_RBRACKET = "Rbracket",
+    TOK_RPAREN = "Rparen",
+    TOK_COMMA = "Comma",
+    TOK_COLON = "Colon",
+    TOK_RBRACE = "Rbrace",
+    TOK_NUMBER = "Number",
+    TOK_CURRENT = "Current",
+    TOK_ROOT = "Root",
+    TOK_EXPREF = "Expref",
+    TOK_PIPE = "Pipe",
+    TOK_OR = "Or",
+    TOK_AND = "And",
+    TOK_EQ = "EQ",
+    TOK_GT = "GT",
+    TOK_LT = "LT",
+    TOK_GTE = "GTE",
+    TOK_LTE = "LTE",
+    TOK_NE = "NE",
+    TOK_PLUS = "Plus",
+    TOK_MINUS = "Minus",
+    TOK_MULTIPLY = "Multiply",
+    TOK_DIVIDE = "Divide",
+    TOK_MODULO = "Modulo",
+    TOK_DIV = "Div",
+    TOK_FLATTEN = "Flatten",
+    TOK_STAR = "Star",
+    TOK_FILTER = "Filter",
+    TOK_DOT = "Dot",
+    TOK_NOT = "Not",
+    TOK_LBRACE = "Lbrace",
+    TOK_LBRACKET = "Lbracket",
+    TOK_LPAREN = "Lparen",
+    TOK_LITERAL = "Literal"
+}
+export type LexerTokenValue = JSONValue;
+export interface LexerToken {
+    type: Token;
+    value: LexerTokenValue;
+    start: number;
+}
+export interface LexerOptions {
+    enable_legacy_literals?: boolean;
+}

package/dist/types/Parser.d.ts

@@ -0,0 +1,28 @@
+import type { ExpressionNode } from './AST.type';
+import { LexerToken } from './Lexer.type';
+import { Options } from './Parser.type';
+declare class TokenParser {
+    index: number;
+    tokens: LexerToken[];
+    parse(expression: string, options?: Options): ExpressionNode;
+    private loadTokens;
+    expression(rbp: number): ExpressionNode;
+    private lookahead;
+    private lookaheadToken;
+    private advance;
+    nud(token: LexerToken): ExpressionNode;
+    led(tokenName: string, left: ExpressionNode): ExpressionNode;
+    private match;
+    private errorToken;
+    private parseIndexExpression;
+    private projectIfSlice;
+    private parseSliceExpression;
+    private parseComparator;
+    private parseArithmetic;
+    private parseDotRHS;
+    private parseProjectionRHS;
+    private parseMultiselectList;
+    private parseMultiselectHash;
+}
+export declare const Parser: TokenParser;
+export default Parser;

package/dist/types/Parser.type.d.ts

@@ -0,0 +1,2 @@
+import { LexerOptions } from "./Lexer.type";
+export type Options = LexerOptions;

package/dist/types/Runtime.d.ts

@@ -0,0 +1,87 @@
+import type { ExpressionNode } from './AST.type';
+import type { JSONValue } from './JSON.type';
+import type { TreeInterpreter } from './TreeInterpreter';
+export declare enum InputArgument {
+    TYPE_NUMBER = 0,
+    TYPE_ANY = 1,
+    TYPE_STRING = 2,
+    TYPE_ARRAY = 3,
+    TYPE_OBJECT = 4,
+    TYPE_BOOLEAN = 5,
+    TYPE_EXPREF = 6,
+    TYPE_NULL = 7,
+    TYPE_ARRAY_NUMBER = 8,
+    TYPE_ARRAY_STRING = 9,
+    TYPE_ARRAY_OBJECT = 10,
+    TYPE_ARRAY_ARRAY = 11
+}
+export interface InputSignature {
+    types: InputArgument[];
+    variadic?: boolean;
+    optional?: boolean;
+}
+export type RuntimeFunction<T extends any[], U> = (resolvedArgs: T) => U;
+export interface FunctionSignature {
+    _func: RuntimeFunction<any, JSONValue>;
+    _signature: InputSignature[];
+}
+export interface FunctionTable {
+    [functionName: string]: FunctionSignature;
+}
+export declare class Runtime {
+    _interpreter: TreeInterpreter;
+    TYPE_NAME_TABLE: {
+        [InputArgument: number]: string;
+    };
+    constructor(interpreter: TreeInterpreter);
+    registerFunction(name: string, customFunction: RuntimeFunction<(JSONValue | ExpressionNode)[], JSONValue>, signature: InputSignature[]): void;
+    callFunction(name: string, resolvedArgs: (JSONValue | ExpressionNode)[]): JSONValue;
+    private validateInputSignatures;
+    private validateArgs;
+    private typeMatches;
+    private getTypeName;
+    createKeyFunction(exprefNode: ExpressionNode, allowedTypes: InputArgument[]): (x: JSONValue) => JSONValue;
+    private functionAbs;
+    private functionAvg;
+    private functionCeil;
+    private functionContains;
+    private functionEndsWith;
+    private functionFindFirst;
+    private functionFindLast;
+    private functionFloor;
+    private functionFromItems;
+    private functionGroupBy;
+    private functionItems;
+    private functionJoin;
+    private functionKeys;
+    private functionLength;
+    private functionLet;
+    private functionLower;
+    private functionMap;
+    private functionMax;
+    private functionMaxBy;
+    private functionMerge;
+    private functionMin;
+    private functionMinBy;
+    private functionNotNull;
+    private functionPadLeft;
+    private functionPadRight;
+    private functionReplace;
+    private functionSplit;
+    private functionReverse;
+    private functionSort;
+    private functionSortBy;
+    private functionStartsWith;
+    private functionSum;
+    private functionToArray;
+    private functionToNumber;
+    private functionToString;
+    private functionTrim;
+    private functionTrimLeft;
+    private functionTrimRight;
+    private functionType;
+    private functionUpper;
+    private functionValues;
+    private functionZip;
+    private functionTable;
+}

package/dist/types/Scope.d.ts

@@ -0,0 +1,7 @@
+import { JSONObject, JSONValue } from './JSON.type';
+export declare class ScopeChain {
+    private inner?;
+    private data;
+    withScope(data: JSONObject): ScopeChain;
+    getValue(identifier: string): JSONValue;
+}

package/dist/types/TreeInterpreter.d.ts

@@ -0,0 +1,21 @@
+import { Runtime } from './Runtime';
+import type { ExpressionNode, ExpressionReference, SliceNode } from './AST.type';
+import type { JSONArray, JSONObject, JSONValue } from './JSON.type';
+export declare class TreeInterpreter {
+    runtime: Runtime;
+    private _rootValue;
+    private _scope;
+    constructor();
+    withScope(scope: JSONObject): TreeInterpreter;
+    search(node: ExpressionNode, value: JSONValue): JSONValue;
+    visit(node: ExpressionNode, value: JSONValue | ExpressionNode): JSONValue | ExpressionNode | ExpressionReference;
+    computeSliceParams(arrayLength: number, sliceNode: SliceNode): {
+        start: number;
+        stop: number;
+        step: number;
+    };
+    capSliceRange(arrayLength: number, actualValue: number, step: number): number;
+    slice(collection: JSONArray, start: number, end: number, step: number): JSONArray;
+}
+export declare const TreeInterpreterInstance: TreeInterpreter;
+export default TreeInterpreterInstance;

package/dist/types/index.d.ts

@@ -0,0 +1,44 @@
+import { ExpressionNode } from './AST.type';
+import { JSONValue } from './JSON.type';
+import { LexerOptions, LexerToken } from './Lexer.type';
+import { Options } from './Parser.type';
+import { InputArgument, RuntimeFunction, InputSignature } from './Runtime';
+import { ScopeChain } from './Scope';
+export type { Options } from './Parser.type';
+export type { FunctionSignature, RuntimeFunction, InputSignature } from './Runtime';
+export declare const TYPE_ANY = InputArgument.TYPE_ANY;
+export declare const TYPE_ARRAY = InputArgument.TYPE_ARRAY;
+export declare const TYPE_ARRAY_ARRAY = InputArgument.TYPE_ARRAY_ARRAY;
+export declare const TYPE_ARRAY_NUMBER = InputArgument.TYPE_ARRAY_NUMBER;
+export declare const TYPE_ARRAY_OBJECT = InputArgument.TYPE_ARRAY_OBJECT;
+export declare const TYPE_ARRAY_STRING = InputArgument.TYPE_ARRAY_STRING;
+export declare const TYPE_BOOLEAN = InputArgument.TYPE_BOOLEAN;
+export declare const TYPE_EXPREF = InputArgument.TYPE_EXPREF;
+export declare const TYPE_NULL = InputArgument.TYPE_NULL;
+export declare const TYPE_NUMBER = InputArgument.TYPE_NUMBER;
+export declare const TYPE_OBJECT = InputArgument.TYPE_OBJECT;
+export declare const TYPE_STRING = InputArgument.TYPE_STRING;
+export declare function compile(expression: string, options?: Options): ExpressionNode;
+export declare function tokenize(expression: string, options?: LexerOptions): LexerToken[];
+export declare const registerFunction: (functionName: string, customFunction: RuntimeFunction<any[], JSONValue>, signature: InputSignature[]) => void;
+export declare function search(data: JSONValue, expression: string, options?: Options): JSONValue;
+export declare function Scope(): ScopeChain;
+export declare const TreeInterpreter: import("./TreeInterpreter").TreeInterpreter;
+export declare const jmespath: {
+    compile: typeof compile;
+    registerFunction: (functionName: string, customFunction: RuntimeFunction<any[], JSONValue>, signature: InputSignature[]) => void;
+    search: typeof search;
+    tokenize: typeof tokenize;
+    TreeInterpreter: import("./TreeInterpreter").TreeInterpreter;
+    TYPE_ANY: InputArgument;
+    TYPE_ARRAY_NUMBER: InputArgument;
+    TYPE_ARRAY_STRING: InputArgument;
+    TYPE_ARRAY: InputArgument;
+    TYPE_BOOLEAN: InputArgument;
+    TYPE_EXPREF: InputArgument;
+    TYPE_NULL: InputArgument;
+    TYPE_NUMBER: InputArgument;
+    TYPE_OBJECT: InputArgument;
+    TYPE_STRING: InputArgument;
+};
+export default jmespath;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,16 @@
+import { JSONValue } from "../JSON.type";
+export declare const isObject: (obj: unknown) => obj is Record<string, unknown>;
+export declare const strictDeepEqual: (first: unknown, second: unknown) => boolean;
+export declare const isFalse: (obj: unknown) => boolean;
+export declare const isAlpha: (ch: string) => boolean;
+export declare const isNum: (ch: string) => boolean;
+export declare const isAlphaNum: (ch: string) => boolean;
+export declare const ensureInteger: (value: unknown) => number;
+export declare const ensurePositiveInteger: (value: unknown) => number;
+export declare const ensureNumbers: (...operands: (JSONValue | undefined)[]) => void;
+export declare const add: (left?: JSONValue, right?: JSONValue) => number;
+export declare const sub: (left?: JSONValue, right?: JSONValue) => number;
+export declare const mul: (left?: JSONValue, right?: JSONValue) => number;
+export declare const divide: (left?: JSONValue, right?: JSONValue) => number;
+export declare const div: (left?: JSONValue, right?: JSONValue) => number;
+export declare const mod: (left?: JSONValue, right?: JSONValue) => number;

package/dist/types/utils/strings.d.ts

@@ -0,0 +1,11 @@
+export declare const findFirst: (subject: string, sub: string, start?: number, end?: number) => number | null;
+export declare const findLast: (subject: string, sub: string, start?: number, end?: number) => number | null;
+export declare const lower: (subject: string) => string;
+export declare const padLeft: (subject: string, width: number, padding?: string) => string;
+export declare const padRight: (subject: string, width: number, padding?: string) => string;
+export declare const replace: (subject: string, string: string, by: string, count?: number) => string;
+export declare const split: (subject: string, search: string, count?: number) => string[];
+export declare const trim: (subject: string, chars?: string) => string;
+export declare const trimLeft: (subject: string, chars?: string) => string;
+export declare const trimRight: (subject: string, chars?: string) => string;
+export declare const upper: (subject: string) => string;

package/dist/types/utils/text.d.ts

@@ -0,0 +1,11 @@
+export declare class Text {
+    private _text;
+    constructor(text: string);
+    get string(): string;
+    get length(): number;
+    compareTo(other: string): number;
+    static get comparer(): (lhs: string, rhs: string) => number;
+    static compare(left: Text, right: Text): number;
+    reverse(): string;
+    private get codePoints();
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jmespath-community/jmespath",
+  "description": "Typescript implementation of the JMESPath Community specification",
+  "version": "1.1.0",
+  "author": {
+    "name": "JMESPath Community",
+    "email": "springcomp@users.noreply.github.com",
+    "url": "https://jmespath.site"
+  },
+  "main": "dist/jmespath.umd.js",
+  "module": "dist/jmespath.esm.js",
+  "typings": "dist/types/index.d.ts",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "homepage": "https://github.com/nanoporetech/jmespath-ts#readme",
+  "bugs": {
+    "url": "https://github.com/nanoporetech/jmespath-ts/issues",
+    "mail": ""
+  },
+  "keywords": [
+    "jmespath",
+    "jsonpath",
+    "query",
+    "json",
+    "jq",
+    "xpath"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jmespath-community/typescript-jmespath"
+  },
+  "license": "MPL-2.0",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}