@labdigital/commercetools-mock 2.66.0 → 3.0.0-beta.0

package/dist/abstract-BKFcva6S.mjs

@@ -0,0 +1,1044 @@
+import { v4 } from "uuid";
+
+//#region src/exceptions.ts
+var CommercetoolsError = class extends Error {
+	info;
+	statusCode;
+	errors;
+	constructor(info, statusCode = 400) {
+		super(info.message);
+		this.info = info;
+		this.statusCode = statusCode || 500;
+		this.errors = info.errors ?? [];
+	}
+};
+
+//#endregion
+//#region src/helpers.ts
+const getBaseResourceProperties = (clientId) => {
+	const clientInfo = {
+		clientId: clientId ?? "",
+		isPlatformClient: false
+	};
+	return {
+		id: v4(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		lastModifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		version: 0,
+		createdBy: clientInfo,
+		lastModifiedBy: clientInfo
+	};
+};
+/**
+* Do a nested lookup by using a path. For example `foo.bar.value` will
+* return obj['foo']['bar']['value']
+*/
+const nestedLookup = (obj, path) => {
+	if (!path || path === "") return obj;
+	const parts = path.split(".");
+	let val = obj;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (val === void 0) return;
+		val = val[part];
+	}
+	return val;
+};
+const queryParamsArray = (input) => {
+	if (input === void 0) return;
+	const values = Array.isArray(input) ? input : [input];
+	if (values.length < 1) return;
+	return values;
+};
+const queryParamsValue = (value) => {
+	const values = queryParamsArray(value);
+	if (values && values.length > 0) return values[0];
+};
+const cloneObject = (o) => JSON.parse(JSON.stringify(o));
+const mapHeaderType = (outgoingHttpHeaders) => {
+	const headersInit = {};
+	for (const key in outgoingHttpHeaders) {
+		const value = outgoingHttpHeaders[key];
+		if (Array.isArray(value)) headersInit[key] = value.join(", ");
+		else if (value !== void 0) headersInit[key] = value.toString();
+	}
+	return headersInit;
+};
+const generateRandomString = (length) => {
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	for (let i = 0; i < length; i++) {
+		const randomIndex = Math.floor(Math.random() * 62);
+		result += characters[randomIndex];
+	}
+	return result;
+};
+
+//#endregion
+//#region src/lib/expandParser.ts
+const parseExpandClause = (clause) => {
+	const result = {
+		element: clause,
+		index: void 0,
+		rest: void 0
+	};
+	const pos = clause.indexOf(".");
+	if (pos > 0) {
+		result.element = clause.substring(0, pos);
+		result.rest = clause.substring(pos + 1);
+	}
+	const match = result.element.match(/\[([^\]+])]/);
+	if (match) {
+		result.index = match[1] === "*" ? "*" : Number.parseInt(match[1], 10);
+		result.element = result.element.substring(0, match.index);
+	}
+	return result;
+};
+
+//#endregion
+//#region vendor/perplex/lexer-state.ts
+/**
+* @private
+*/
+var LexerState = class LexerState {
+	source;
+	position;
+	tokenTypes;
+	constructor(source, position = 0) {
+		this.source = source;
+		this.position = position;
+	}
+	copy() {
+		return new LexerState(this.source, this.position);
+	}
+};
+
+//#endregion
+//#region vendor/perplex/token.ts
+/**
+* @typedef {{
+*   start: Position,
+*   end: Position,
+* }} TokenPosition
+*/
+/**
+* Represents a token instance
+*/
+var Token = class {
+	type;
+	match;
+	groups;
+	start;
+	end;
+	lexer;
+	/**
+	* Constructs a token
+	* @param {T} type The token type
+	* @param {string} match The string that the lexer consumed to create this token
+	* @param {string[]} groups Any RegExp groups that accrued during the match
+	* @param {number} start The string position where this match started
+	* @param {number} end The string position where this match ends
+	* @param {Lexer<T>} lexer The parent {@link Lexer}
+	*/
+	constructor(type, match, groups, start, end, lexer) {
+		/**
+		* The token type
+		* @type {T}
+		*/
+		this.type = type;
+		/**
+		* The string that the lexer consumed to create this token
+		* @type {string}
+		*/
+		this.match = match;
+		/**
+		* Any RegExp groups that accrued during the match
+		* @type {string[]}
+		*/
+		this.groups = groups;
+		/**
+		* The string position where this match started
+		* @type {number}
+		*/
+		this.start = start;
+		/**
+		* The string position where this match ends
+		* @type {number}
+		*/
+		this.end = end;
+		/**
+		* The parent {@link Lexer}
+		* @type {Lexer<T>}
+		*/
+		this.lexer = lexer;
+	}
+	/**
+	* Returns the bounds of this token, each in `{line, column}` format
+	* @return {TokenPosition}
+	*/
+	strpos() {
+		return {
+			start: this.lexer.strpos(this.start),
+			end: this.lexer.strpos(this.end)
+		};
+	}
+	isEof() {
+		return false;
+	}
+};
+var EOFToken = class extends Token {
+	constructor(lexer) {
+		const end = lexer.source.length;
+		super(null, "(eof)", [], end, end, lexer);
+	}
+	isEof() {
+		return true;
+	}
+};
+/**
+* @private
+*/
+const EOF = (lexer) => new EOFToken(lexer);
+
+//#endregion
+//#region vendor/perplex/token-types.ts
+function toRegExp(str) {
+	return new RegExp(str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
+}
+function normalize(regex) {
+	if (typeof regex === "string") regex = toRegExp(regex);
+	if (!regex.source.startsWith("^")) return new RegExp(`^${regex.source}`, regex.flags);
+	else return regex;
+}
+function first(arr, predicate) {
+	let i = 0;
+	for (const item of arr) {
+		const result = predicate(item, i++);
+		if (result) return {
+			item,
+			result
+		};
+	}
+}
+/**
+* @private
+*/
+var TokenTypes = class {
+	tokenTypes;
+	constructor() {
+		this.tokenTypes = [];
+	}
+	disable(type) {
+		return this.enable(type, false);
+	}
+	enable(type, enabled = true) {
+		this.tokenTypes.filter((t) => t.type == type).forEach((t) => t.enabled = enabled);
+		return this;
+	}
+	isEnabled(type) {
+		const ttypes = this.tokenTypes.filter((tt) => tt.type == type);
+		if (ttypes.length == 0) throw new Error(`Token of type ${type} does not exists`);
+		return ttypes[0].enabled;
+	}
+	peek(source, position) {
+		const s = source.substr(position);
+		return first(this.tokenTypes.filter((tt) => tt.enabled), (tt) => {
+			tt.regex.lastIndex = 0;
+			return tt.regex.exec(s);
+		});
+	}
+	token(type, pattern, skip = false) {
+		this.tokenTypes.push({
+			type,
+			regex: normalize(pattern),
+			enabled: true,
+			skip
+		});
+		return this;
+	}
+};
+
+//#endregion
+//#region vendor/perplex/lexer.ts
+/**
+* @typedef {{
+*   line: number,
+*   column: number,
+* }} Position
+*/
+/**
+* Lexes a source-string into tokens.
+*
+* @example
+* const lex = perplex('...')
+*   .token('ID', /my-id-regex/)
+*   .token('(', /\(/)
+*   .token(')', /\)/)
+*   .token('WS', /\s+/, true) // true means 'skip'
+*
+* while ((let t = lex.next()).type != 'EOF') {
+*   console.log(t)
+* }
+* // alternatively:
+* console.log(lex.toArray())
+* // or:
+* console.log(...lex)
+*/
+var Lexer = class {
+	_state;
+	_tokenTypes;
+	/**
+	* Creates a new Lexer instance
+	* @param {string} [source = ''] The source string to operate on.
+	*/
+	constructor(source = "") {
+		this._state = new LexerState(source);
+		this._tokenTypes = new TokenTypes();
+	}
+	/**
+	* Gets the current lexer position
+	* @return {number} Returns the position
+	*/
+	get position() {
+		return this._state.position;
+	}
+	/**
+	* Sets the current lexer position
+	* @param {number} i The position to move to
+	*/
+	set position(i) {
+		this._state.position = i;
+	}
+	/**
+	* Gets the source the lexer is operating on
+	* @return {string} Returns the source
+	*/
+	get source() {
+		return this._state.source;
+	}
+	/**
+	* Sets the source the lexer is operating on
+	* @param {string} s The source to set
+	*/
+	set source(s) {
+		this._state = new LexerState(s);
+	}
+	/**
+	* Attaches this lexer to another lexer's state
+	* @param {Lexer<T>} other The other lexer to attach to
+	*/
+	attachTo(other) {
+		this._state = other._state;
+	}
+	/**
+	* Disables a token type
+	* @param {T} type The token type to disable
+	* @return {Lexer<T>}
+	*/
+	disable(type) {
+		this._tokenTypes.disable(type);
+		return this;
+	}
+	/**
+	* Enables a token type
+	* @param {T} type The token type to enalbe
+	* @param {?boolean} [enabled=true] Whether to enable/disable the specified token type
+	* @return {Lexer<T>}
+	*/
+	enable(type, enabled) {
+		this._tokenTypes.enable(type, enabled);
+		return this;
+	}
+	/**
+	* Like {@link next}, but throws an exception if the next token is
+	* not of the required type.
+	* @param {T} type The token type expected from {@link next}
+	* @return {Token<T>} Returns the {@link Token} on success
+	*/
+	expect(type) {
+		const t = this.next();
+		if (t.type != type) {
+			const pos = t.strpos();
+			throw new Error("Expected " + type + (t ? ", got " + t.type : "") + " at " + pos.start.line + ":" + pos.start.column);
+		}
+		return t;
+	}
+	/**
+	* Looks up whether a token is enabled.
+	* @param tokenType The token type to look up
+	* @return {boolean} Returns whether the token is enabled
+	*/
+	isEnabled(tokenType) {
+		return this._tokenTypes.isEnabled(tokenType);
+	}
+	/**
+	* Consumes and returns the next {@link Token} in the source string.
+	* If there are no more tokens, it returns a {@link Token} of type `$EOF`
+	* @return {Token<T>}
+	*/
+	next() {
+		try {
+			const t = this.peek();
+			this._state.position = t.end;
+			return t;
+		} catch (e) {
+			this._state.position = e.end;
+			throw e;
+		}
+	}
+	/**
+	* Returns the next {@link Token} in the source string, but does
+	* not consume it.
+	* If there are no more tokens, it returns a {@link Token} of type `$EOF`
+	* @param {number} [position=`this.position`] The position at which to start reading
+	* @return {Token<T>}
+	*/
+	peek(position = this._state.position) {
+		const read = (i = position) => {
+			if (i >= this._state.source.length) return EOF(this);
+			const n = this._tokenTypes.peek(this._state.source, i);
+			if (!n || !n.result) throw new Error(`Unexpected input: ${this._state.source.substring(i, i + 1)} at (${this.strpos(i).line}:${this.strpos(i).column})`);
+			return n ? n.item.skip ? read(i + n.result[0].length) : new Token(n.item.type, n.result[0], n.result.map((x) => x), i, i + n.result[0].length, this) : null;
+		};
+		const t = read();
+		if (t) return t;
+		let unexpected = this._state.source.substring(position, position + 1);
+		try {
+			this.peek(position + 1);
+		} catch (e) {
+			unexpected += e.unexpected;
+		}
+		const { line, column } = this.strpos(position);
+		const e = /* @__PURE__ */ new Error(`Unexpected input: ${unexpected} at (${line}:${column})`);
+		e.unexpected = unexpected;
+		e.end = position + unexpected.length;
+		throw e;
+	}
+	/**
+	* Converts a string-index (relative to the source string) to a line and a column.
+	* @param {number} i The index to compute
+	* @return {Position}
+	*/
+	strpos(i) {
+		let lines = this._state.source.substring(0, i).split(/\r?\n/);
+		if (!Array.isArray(lines)) lines = [lines];
+		return {
+			line: lines.length,
+			column: lines[lines.length - 1].length + 1
+		};
+	}
+	/**
+	* Converts the token stream to an array of Tokens
+	* @return {Token<T>[]} The array of tokens (not including (EOF))
+	*/
+	toArray() {
+		return [...this];
+	}
+	/**
+	* Implements the Iterable protocol
+	* Iterates lazily over the entire token stream (not including (EOF))
+	* @return {Iterator<Token<T>>} Returns an iterator over all remaining tokens
+	*/
+	*[Symbol.iterator]() {
+		const oldState = this._state.copy();
+		this._state.position = 0;
+		let t;
+		while (!(t = this.next()).isEof()) yield t;
+		this._state = oldState;
+	}
+	/**
+	* Creates a new token type
+	* @param {T} type The token type
+	* @param {string|RegExp} pattern The pattern to match
+	* @param {?boolean} skip Whether this type of token should be skipped
+	* @return {Lexer<T>}
+	*/
+	token(type, pattern, skip) {
+		this._tokenTypes.token(type, pattern, skip);
+		return this;
+	}
+	/**
+	* Creates a keyword
+	* @param kwd The keyword to add as a token
+	*/
+	keyword(kwd) {
+		return this.token(kwd, new RegExp(`${kwd}(?=\\W|$)`));
+	}
+	/**
+	* Creates an operator
+	* @param op The operator to add as a token
+	*/
+	operator(op) {
+		const sOp = new String(op).valueOf();
+		return this.token(op, sOp);
+	}
+};
+
+//#endregion
+//#region vendor/pratt/index.ts
+const createStop = () => {
+	let stopCalled = false;
+	return Object.assign((x) => {
+		stopCalled = true;
+		return x;
+	}, { isStopped() {
+		return stopCalled;
+	} });
+};
+/**
+* A Pratt parser.
+* @example
+* const lex = new perplex.Lexer('1 + -2 * 3^4')
+*   .token('NUM', /\d+/)
+*   .token('+', /\+/)
+*   .token('-', /-/)
+*   .token('*', new RegExp('*'))
+*   .token('/', /\//)
+*   .token('^', /\^/)
+*   .token('(', /\(/)
+*   .token(')', /\)/)
+*   .token('$SKIP_WS', /\s+/)
+*
+* const parser = new Parser(lex)
+*   .builder()
+*   .nud('NUM', 100, t => parseInt(t.match))
+*   .nud('-', 10, (t, bp) => -parser.parse(bp))
+*   .nud('(', 10, (t, bp) => {
+*     const expr = parser.parse(bp)
+*     lex.expect(')')
+*     return expr
+*   })
+*   .bp(')', 0)
+*
+*   .led('^', 20, (left, t, bp) => Math.pow(left, parser.parse(20 - 1)))
+*   .led('+', 30, (left, t, bp) => left + parser.parse(bp))
+*   .led('-', 30, (left, t, bp) => left - parser.parse(bp))
+*   .led('*', 40, (left, t, bp) => left * parser.parse(bp))
+*   .led('/', 40, (left, t, bp) => left / parser.parse(bp))
+*   .build()
+* parser.parse()
+* // => 161
+*/
+var Parser = class {
+	lexer;
+	_nuds;
+	_leds;
+	_bps;
+	/**
+	* Constructs a Parser instance
+	* @param {ILexer<T>} lexer The lexer to obtain tokens from
+	*/
+	constructor(lexer) {
+		/**
+		* The lexer that this parser is operating on.
+		* @type {ILexer<T>}
+		*/
+		this.lexer = lexer;
+		this._nuds = /* @__PURE__ */ new Map();
+		this._leds = /* @__PURE__ */ new Map();
+		this._bps = /* @__PURE__ */ new Map();
+	}
+	_type(tokenOrType) {
+		return tokenOrType && typeof tokenOrType.isEof == "function" ? tokenOrType.type : tokenOrType;
+	}
+	/**
+	* Create a {@link ParserBuilder}
+	* @return {ParserBuilder<T>} Returns the ParserBuilder
+	*/
+	builder() {
+		return new ParserBuilder(this);
+	}
+	/**
+	* Define binding power for a token-type
+	* @param {IToken<T>|T} tokenOrType The token type to define the binding power for
+	* @returns {number} The binding power of the specified token type
+	*/
+	bp(tokenOrType) {
+		if (tokenOrType == null) return Number.NEGATIVE_INFINITY;
+		if (tokenOrType && typeof tokenOrType.isEof == "function" && tokenOrType.isEof()) return Number.NEGATIVE_INFINITY;
+		const type = this._type(tokenOrType);
+		const bp = this._bps.has(type) ? this._bps.get(type) : Number.POSITIVE_INFINITY;
+		return typeof bp == "function" ? bp() : bp;
+	}
+	/**
+	* Computes the token's `nud` value and returns it
+	* @param {NudInfo<T>} info The info to compute the `nud` from
+	* @returns {any} The result of invoking the pertinent `nud` operator
+	*/
+	nud(info) {
+		const fn = this._nuds.get(info.token.type);
+		if (!fn) {
+			const { start } = info.token.strpos();
+			throw new Error(`Unexpected token: ${info.token.match} (at ${start.line}:${start.column})`);
+		}
+		return fn(info);
+	}
+	/**
+	* Computes a token's `led` value and returns it
+	* @param {LedInfo<T>} info The info to compute the `led` value for
+	* @returns {any} The result of invoking the pertinent `led` operator
+	*/
+	led(info) {
+		let fn = this._leds.get(info.token.type);
+		if (!fn) {
+			const { start } = info.token.strpos();
+			throw new Error(`Unexpected token: ${info.token.match} (at ${start.line}:${start.column})`);
+		}
+		return fn(info);
+	}
+	/**
+	* Kicks off the Pratt parser, and returns the result
+	* @param {ParseOpts<T>} opts The parse options
+	* @returns {any}
+	*/
+	parse(opts = { terminals: [0] }) {
+		const stop = opts.stop = opts.stop || createStop();
+		const check = () => {
+			if (stop.isStopped()) return false;
+			const t = this.lexer.peek();
+			const bp = this.bp(t);
+			return opts.terminals.reduce((canContinue, rbpOrType) => {
+				if (!canContinue) return false;
+				if (typeof rbpOrType == "number") return rbpOrType < bp;
+				if (typeof rbpOrType == "string") return t.type != rbpOrType;
+			}, true);
+		};
+		const mkinfo = (token) => {
+			return {
+				token,
+				bp: this.bp(token),
+				stop,
+				ctx: opts.ctx,
+				options: opts
+			};
+		};
+		if (!opts.terminals) opts.terminals = [0];
+		if (opts.terminals.length == 0) opts.terminals.push(0);
+		let left = this.nud(mkinfo(this.lexer.next()));
+		while (check()) {
+			const operator = this.lexer.next();
+			left = this.led(Object.assign(mkinfo(operator), { left }));
+		}
+		return left;
+	}
+};
+/**
+* Builds `led`/`nud` rules for a {@link Parser}
+*/
+var ParserBuilder = class {
+	_parser;
+	/**
+	* Constructs a ParserBuilder
+	* See also: {@link Parser.builder}
+	* @param {Parser<T>} parser The parser
+	*/
+	constructor(parser) {
+		this._parser = parser;
+	}
+	/**
+	* Define `nud` for a token type
+	* @param {T} tokenType The token type
+	* @param {number} bp The binding power
+	* @param {NudFunction<T>} fn The function that will parse the token
+	* @return {ParserBuilder<T>} Returns this ParserBuilder
+	*/
+	nud(tokenType, bp, fn) {
+		this._parser._nuds.set(tokenType, fn);
+		this.bp(tokenType, bp);
+		return this;
+	}
+	/**
+	* Define `led` for a token type
+	* @param {T} tokenType The token type
+	* @param {number} bp The binding power
+	* @param {LedFunction<T>} fn The function that will parse the token
+	* @return {ParserBuilder<T>} Returns this ParserBuilder
+	*/
+	led(tokenType, bp, fn) {
+		this._parser._leds.set(tokenType, fn);
+		this.bp(tokenType, bp);
+		return this;
+	}
+	/**
+	* Define both `led` and `nud` for a token type at once.
+	* The supplied `LedFunction` may be called with a null `left`
+	* parameter when invoked from a `nud` context.
+	* @param {strTng} tokenType The token type
+	* @param {number} bp The binding power
+	* @param {LedFunction<T>} fn The function that will parse the token
+	* @return {ParserBuilder<T>} Returns this ParserBuilder
+	*/
+	either(tokenType, bp, fn) {
+		return this.nud(tokenType, bp, (inf) => fn(Object.assign(inf, { left: null }))).led(tokenType, bp, fn);
+	}
+	/**
+	* Define the binding power for a token type
+	* @param {T} tokenType The token type
+	* @param {BP} bp The binding power
+	* @return {ParserBuilder<T>} Returns this ParserBuilder
+	*/
+	bp(tokenType, bp) {
+		this._parser._bps.set(tokenType, bp);
+		return this;
+	}
+	/**
+	* Returns the parent {@link Parser} instance
+	* @returns {Parser<T>}
+	*/
+	build() {
+		return this._parser;
+	}
+};
+
+//#endregion
+//#region src/lib/haversine.ts
+/**
+* Returns the distance between src and dst as meters
+*/
+const haversineDistance = (src, dst) => {
+	const RADIUS_OF_EARTH_IN_KM = 6371;
+	const toRadian = (deg) => deg * (Math.PI / 180);
+	const dLat = toRadian(dst.latitude - src.latitude);
+	const dLon = toRadian(dst.longitude - src.longitude);
+	const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRadian(src.latitude)) * Math.cos(toRadian(dst.latitude)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+	return RADIUS_OF_EARTH_IN_KM * (2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))) * 1e3;
+};
+
+//#endregion
+//#region src/lib/predicateParser.ts
+/**
+* This module implements the commercetools query predicate filter expression.
+* Support should be 100% complete.
+*
+* See https://docs.commercetools.com/api/predicates/query
+*/
+var PredicateError = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+const parseQueryExpression = (predicate) => {
+	if (Array.isArray(predicate)) {
+		const callbacks = predicate.map((item) => generateMatchFunc(item));
+		return (target, variables) => callbacks.every((callback) => callback(target, variables));
+	}
+	return generateMatchFunc(predicate);
+};
+const validateSymbol = (val) => {
+	if (!val.type) throw new PredicateError("Internal error");
+	if (val.type === "identifier") {
+		const char = val.value.charAt(0);
+		const line = val.pos?.start.line;
+		const column = val.pos?.start.column;
+		throw new PredicateError(`Invalid input '${char}', expected input parameter or primitive value (line ${line}, column ${column})`);
+	}
+};
+const resolveSymbol = (val, vars) => {
+	if (val.type === "var") {
+		if (!(val.value in (vars ?? {}))) throw new PredicateError(`Missing parameter value for ${val.value}`);
+		return vars[val.value];
+	}
+	return val.value;
+};
+const resolveValue = (obj, val) => {
+	if (val.type !== "identifier") throw new PredicateError("Internal error");
+	if (val.value === "variants" && obj.masterVariant && obj.variants !== void 0) return [obj.masterVariant, ...obj.variants ?? []];
+	if (!(val.value in obj)) {
+		if (Array.isArray(obj)) return Object.values(obj).filter((v) => val.value in v).map((v) => v[val.value]);
+		return;
+	}
+	return obj[val.value];
+};
+const getLexer = (value) => new Lexer(value).token("AND", /and(?![-_a-z0-9]+)/i).token("OR", /or(?![-_a-z0-9]+)/i).token("NOT", /not(?![-_a-z0-9]+)/i).token("WITHIN", /within(?![-_a-z0-9]+)/i).token("IN", /in(?![-_a-z0-9]+)/i).token("MATCHES_IGNORE_CASE", /matches\s+ignore\s+case(?![-_a-z0-9]+)/i).token("CONTAINS", /contains(?![-_a-z0-9]+)/i).token("ALL", /all(?![-_a-z0-9]+)/i).token("ANY", /any(?![-_a-z0-9]+)/i).token("EMPTY", /empty(?![-_a-z0-9]+)/i).token("IS", /is(?![-_a-z0-9]+)/i).token("DEFINED", /defined(?![-_a-z0-9]+)/i).token("IDENTIFIER", /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/).token("FLOAT", /\d+\.\d+/).token("INT", /\d+/).token("VARIABLE", /:([-_A-Za-z0-9]+)/).token("BOOLEAN", /(true|false)/).token("IDENTIFIER", /[-_A-Za-z0-9]+/).token("STRING", /"((?:\\.|[^"\\])*)"/).token("STRING", /'((?:\\.|[^'\\])*)'/).token("COMMA", ",").token("(", "(").token(")", ")").token(">=", ">=").token("<=", "<=").token(">", ">").token("<", "<").token("!=", "!=").token("=", "=").token("\"", "\"").token("WS", /\s+/, true);
+/**
+* This function converts a query expression in to a callable which returns a
+* boolean to indicate if the given object matches or not.
+*
+* This currently parses the predicate each time it is called, but it should be
+* straight-forward to add a query cache (lru-cache)
+*/
+const generateMatchFunc = (predicate) => {
+	const lexer = getLexer(predicate);
+	const parser = new Parser(lexer).builder().nud("IDENTIFIER", 100, (t) => ({
+		type: "identifier",
+		value: t.token.match,
+		pos: t.token.strpos()
+	})).nud("BOOLEAN", 1, (t) => ({
+		type: "boolean",
+		value: t.token.match === "true",
+		pos: t.token.strpos()
+	})).nud("VARIABLE", 100, (t) => ({
+		type: "var",
+		value: t.token.groups[1],
+		pos: t.token.strpos()
+	})).nud("STRING", 100, (t) => ({
+		type: "string",
+		value: t.token.groups[1],
+		pos: t.token.strpos()
+	})).nud("INT", 1, (t) => ({
+		type: "int",
+		value: Number.parseInt(t.token.match, 10),
+		pos: t.token.strpos()
+	})).nud("FLOAT", 1, (t) => ({
+		type: "float",
+		value: Number.parseFloat(t.token.match),
+		pos: t.token.strpos()
+	})).nud("NOT", 100, ({ bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		return (obj) => !expr(obj);
+	}).nud("EMPTY", 10, ({ bp }) => "empty").nud("DEFINED", 10, ({ bp }) => "defined").led("AND", 5, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		return (obj, vars) => left(obj, vars) && expr(obj, vars);
+	}).led("OR", 5, ({ left, token, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		return (obj, vars) => left(obj, vars) || expr(obj, vars);
+	}).led("COMMA", 1, ({ left, token, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		if (Array.isArray(expr)) return [left, ...expr];
+		return [left, expr];
+	}).nud("(", 100, (t) => {
+		return parser.parse({ terminals: [")"] });
+	}).led("(", 100, ({ left, bp }) => {
+		const expr = parser.parse();
+		lexer.expect(")");
+		return (obj, vars) => {
+			if (Array.isArray(obj)) return obj.some((item) => {
+				const value = resolveValue(item, left);
+				if (value) return expr(value, vars);
+				return false;
+			});
+			const value = resolveValue(obj, left);
+			if (value) {
+				if (Array.isArray(value)) return value.some((item) => expr(item, vars));
+				return expr(value, vars);
+			}
+			return false;
+		};
+	}).bp(")", 0).led("=", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => {
+			if (Array.isArray(obj)) return obj.some((item) => {
+				const value = resolveValue(item, left);
+				const other = resolveSymbol(expr, vars);
+				if (Array.isArray(value)) return !!value.some((elem) => elem === other);
+				return value === other;
+			});
+			const resolvedValue = resolveValue(obj, left);
+			const resolvedSymbol = resolveSymbol(expr, vars);
+			if (Array.isArray(resolvedValue)) return !!resolvedValue.some((elem) => elem === resolvedSymbol);
+			return resolvedValue === resolvedSymbol;
+		};
+	}).led("!=", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => resolveValue(obj, left) !== resolveSymbol(expr, vars);
+	}).led(">", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => resolveValue(obj, left) > resolveSymbol(expr, vars);
+	}).led(">=", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => resolveValue(obj, left) >= resolveSymbol(expr, vars);
+	}).led("<", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => resolveValue(obj, left) < resolveSymbol(expr, vars);
+	}).led("<=", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => resolveValue(obj, left) <= resolveSymbol(expr, vars);
+	}).led("IS", 20, ({ left, bp }) => {
+		let invert = false;
+		if (lexer.peek().type === "NOT") {
+			invert = true;
+			lexer.next();
+		}
+		switch (parser.parse({ terminals: [bp - 1] })) {
+			case "empty":
+				if (!invert) return (obj, vars) => {
+					return resolveValue(obj, left).length === 0;
+				};
+				return (obj, vars) => {
+					return resolveValue(obj, left).length !== 0;
+				};
+			case "defined":
+				if (!invert) return (obj, vars) => {
+					return resolveValue(obj, left) !== void 0;
+				};
+				return (obj, vars) => {
+					return resolveValue(obj, left) === void 0;
+				};
+			default: throw new Error("Unexpected");
+		}
+	}).led("IN", 20, ({ left, bp }) => {
+		const firstToken = lexer.peek();
+		const expr = parser.parse({ terminals: [bp - 1] });
+		if (firstToken.match === "(") lexer.expect(")");
+		return (obj, vars) => {
+			let symbols = expr;
+			if (!Array.isArray(symbols)) symbols = [expr];
+			const inValues = symbols.flatMap((item) => resolveSymbol(item, vars));
+			const value = resolveValue(obj, left);
+			if (Array.isArray(value)) return inValues.some((inValue) => value.includes(inValue));
+			return inValues.includes(value);
+		};
+	}).led("MATCHES_IGNORE_CASE", 20, ({ left, bp }) => {
+		const expr = parser.parse({ terminals: [bp - 1] });
+		validateSymbol(expr);
+		return (obj, vars) => {
+			const value = resolveValue(obj, left);
+			const other = resolveSymbol(expr, vars);
+			if (typeof value !== "string") throw new PredicateError(`The field '${left.value}' does not support this expression.`);
+			return value.toLowerCase() === other.toLowerCase();
+		};
+	}).led("WITHIN", 20, ({ left, bp }) => {
+		const type = lexer.next();
+		if (type.match !== "circle") throw new PredicateError(`Invalid input '${type.match}', expected circle`);
+		lexer.expect("(");
+		const expr = parser.parse({ terminals: [")"] });
+		lexer.expect(")");
+		return (obj, vars) => {
+			const value = resolveValue(obj, left);
+			if (!value) return false;
+			const maxDistance = resolveSymbol(expr[2], vars);
+			return haversineDistance({
+				longitude: value[0],
+				latitude: value[1]
+			}, {
+				longitude: resolveSymbol(expr[0], vars),
+				latitude: resolveSymbol(expr[1], vars)
+			}) <= maxDistance;
+		};
+	}).led("CONTAINS", 20, ({ left, bp }) => {
+		const keyword = lexer.next();
+		let expr = parser.parse();
+		if (!Array.isArray(expr)) expr = [expr];
+		return (obj, vars) => {
+			const value = resolveValue(obj, left);
+			if (!Array.isArray(value)) throw new PredicateError(`The field '${left.value}' does not support this expression.`);
+			const array = expr.map((item) => resolveSymbol(item, vars));
+			if (keyword.type === "ALL") return array.every((item) => value.includes(item));
+			return array.some((item) => value.includes(item));
+		};
+	}).build();
+	const result = parser.parse();
+	if (typeof result !== "function") {
+		const lines = predicate.split("\n");
+		const column = lines[lines.length - 1].length;
+		throw new PredicateError(`Unexpected end of input, expected SphereIdentifierChar, comparison operator, not, in, contains, is, within or matches (line ${lines.length}, column ${column})`);
+	}
+	return result;
+};
+
+//#endregion
+//#region src/storage/abstract.ts
+var AbstractStorage = class {
+	/**
+	* Close the storage backend and release any resources.
+	* Override this in subclasses that hold external resources (e.g. database connections).
+	*/
+	close() {}
+	async expand(projectKey, obj, clause) {
+		if (!clause) return obj;
+		if (Array.isArray(clause)) for (const c of clause) await this._resolveResource(projectKey, obj, c);
+		else await this._resolveResource(projectKey, obj, clause);
+		return obj;
+	}
+	async getByResourceIdentifier(projectKey, identifier) {
+		if (identifier.id) {
+			const resource = await this.get(projectKey, identifier.typeId, identifier.id);
+			if (resource) return resource;
+			throw new CommercetoolsError({
+				code: "ReferencedResourceNotFound",
+				message: `The referenced object of type '${identifier.typeId}' with id '${identifier.id}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+				typeId: identifier.typeId,
+				id: identifier.id
+			});
+		}
+		if (identifier.key) {
+			const resource = await this.getByKey(projectKey, identifier.typeId, identifier.key);
+			if (resource) return resource;
+			throw new CommercetoolsError({
+				code: "ReferencedResourceNotFound",
+				message: `The referenced object of type '${identifier.typeId}' with key '${identifier.key}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+				typeId: identifier.typeId,
+				key: identifier.key
+			});
+		}
+		throw new CommercetoolsError({
+			code: "InvalidJsonInput",
+			message: "Request body does not contain valid JSON.",
+			detailedErrorMessage: "ResourceIdentifier requires an 'id' xor a 'key'"
+		});
+	}
+	async search(projectKey, typeId, params) {
+		let resources = await this.all(projectKey, typeId);
+		if (params.where) try {
+			const filterFunc = parseQueryExpression(params.where);
+			resources = resources.filter((resource) => filterFunc(resource, {}));
+		} catch (err) {
+			throw new CommercetoolsError({
+				code: "InvalidInput",
+				message: err.message
+			}, 400);
+		}
+		const totalResources = resources.length;
+		const offset = params.offset || 0;
+		const limit = params.limit || 20;
+		resources = resources.slice(offset, offset + limit);
+		if (params.expand !== void 0) resources = await Promise.all(resources.map((resource) => this.expand(projectKey, resource, params.expand)));
+		return {
+			count: resources.length,
+			total: totalResources,
+			offset,
+			limit,
+			results: resources
+		};
+	}
+	async _resolveResource(projectKey, obj, expand) {
+		const params = parseExpandClause(expand);
+		if (params.index === "*") {
+			const reference = obj[params.element];
+			if (params.element === "lineItems" && params.rest?.startsWith("variant") && reference.every((item) => item.variant === void 0 && item.variantId !== void 0)) for (const item of reference) await this._resolveShoppingListLineItemVariant(projectKey, item);
+		}
+		if (!params.index) {
+			const reference = obj[params.element];
+			if (reference === void 0) return;
+			await this._resolveReference(projectKey, reference, params.rest);
+		} else if (params.index === "*") {
+			const reference = obj[params.element];
+			if (reference === void 0 || !Array.isArray(reference)) return;
+			for (const itemRef of reference) await this._resolveReference(projectKey, itemRef, params.rest);
+		} else {
+			const reference = obj[params.element][params.index];
+			if (reference === void 0) return;
+			await this._resolveReference(projectKey, reference, params.rest);
+		}
+	}
+	async _resolveReference(projectKey, reference, expand) {
+		if (reference === void 0) return;
+		if (reference.typeId !== void 0 && (reference.id !== void 0 || reference.key !== void 0)) {
+			if (!reference.obj) reference.obj = await this.getByResourceIdentifier(projectKey, {
+				typeId: reference.typeId,
+				id: reference.id,
+				key: reference.key
+			});
+			if (expand) await this._resolveResource(projectKey, reference.obj, expand);
+		} else if (expand) await this._resolveResource(projectKey, reference, expand);
+	}
+	async _resolveShoppingListLineItemVariant(projectKey, lineItem) {
+		const product = await this.getByResourceIdentifier(projectKey, {
+			typeId: "product",
+			id: lineItem.productId
+		});
+		if (!product) return;
+		lineItem.variant = [product.masterData.current.masterVariant, ...product.masterData.current.variants].find((e) => e.id === lineItem.variantId);
+	}
+};
+
+//#endregion
+export { parseExpandClause as a, getBaseResourceProperties as c, queryParamsArray as d, queryParamsValue as f, Lexer as i, mapHeaderType as l, parseQueryExpression as n, cloneObject as o, CommercetoolsError as p, Parser as r, generateRandomString as s, AbstractStorage as t, nestedLookup as u };
+//# sourceMappingURL=abstract-BKFcva6S.mjs.map