@model-ts/dynamodb 4.1.0 → 4.2.1

package/dist/esm/in-memory/expression.js

@@ -0,0 +1,657 @@
+import { NotSupportedError } from "../errors";
+const MISSING = Symbol("missing");
+const KEY_COND_BEGINS_WITH = /^(.+?)\s*=\s*(.+?)\s+and\s+begins_with\((.+?),\s*(.+?)\)$/i;
+const KEY_COND_BETWEEN = /^(.+?)\s*=\s*(.+?)\s+and\s+(.+?)\s+between\s+(.+?)\s+and\s+(.+)$/i;
+const KEY_COND_COMPARE = /^(.+?)\s*=\s*(.+?)\s+and\s+(.+?)\s*(<=|<|>=|>|=)\s*(.+)$/i;
+const KEY_COND_HASH_ONLY = /^(.+?)\s*=\s*(.+)$/i;
+export const parseKeyConditionExpression = (expression, context) => {
+    const source = expression.trim();
+    const beginsMatch = source.match(KEY_COND_BEGINS_WITH);
+    if (beginsMatch) {
+        const [, hashAttrToken, hashValueToken, rangeAttrToken, rangeValueToken] = beginsMatch;
+        const hashAttribute = resolveAttributeToken(hashAttrToken, context);
+        const rangeAttribute = resolveAttributeToken(rangeAttrToken, context);
+        const rangeValue = resolveValueToken(rangeValueToken, undefined, context);
+        if (typeof rangeValue !== "string") {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "KeyConditionExpression.begins_with.value",
+                reason: "begins_with currently supports string operands only.",
+            });
+        }
+        return {
+            hashAttribute,
+            hashValue: resolveValueToken(hashValueToken, undefined, context),
+            range: {
+                attribute: rangeAttribute,
+                condition: { type: "begins_with", value: rangeValue },
+            },
+        };
+    }
+    const betweenMatch = source.match(KEY_COND_BETWEEN);
+    if (betweenMatch) {
+        const [, hashAttrToken, hashValueToken, rangeAttrToken, lowerToken, upperToken] = betweenMatch;
+        return {
+            hashAttribute: resolveAttributeToken(hashAttrToken, context),
+            hashValue: resolveValueToken(hashValueToken, undefined, context),
+            range: {
+                attribute: resolveAttributeToken(rangeAttrToken, context),
+                condition: {
+                    type: "between",
+                    lower: resolveValueToken(lowerToken, undefined, context),
+                    upper: resolveValueToken(upperToken, undefined, context),
+                },
+            },
+        };
+    }
+    const compareMatch = source.match(KEY_COND_COMPARE);
+    if (compareMatch) {
+        const [, hashAttrToken, hashValueToken, rangeAttrToken, operator, rangeValueToken] = compareMatch;
+        return {
+            hashAttribute: resolveAttributeToken(hashAttrToken, context),
+            hashValue: resolveValueToken(hashValueToken, undefined, context),
+            range: {
+                attribute: resolveAttributeToken(rangeAttrToken, context),
+                condition: {
+                    type: operator,
+                    value: resolveValueToken(rangeValueToken, undefined, context),
+                },
+            },
+        };
+    }
+    const hashOnlyMatch = source.match(KEY_COND_HASH_ONLY);
+    if (hashOnlyMatch) {
+        const [, hashAttrToken, hashValueToken] = hashOnlyMatch;
+        return {
+            hashAttribute: resolveAttributeToken(hashAttrToken, context),
+            hashValue: resolveValueToken(hashValueToken, undefined, context),
+        };
+    }
+    throw new NotSupportedError({
+        method: context.method,
+        featurePath: "KeyConditionExpression",
+        reason: "Unsupported key condition expression grammar.",
+    });
+};
+export const evaluateConditionExpression = (expression, item, context) => {
+    const orGroups = splitTopLevelByKeyword(expression, "or");
+    if (orGroups.length === 0) {
+        throw new NotSupportedError({
+            method: context.method,
+            featurePath: "ConditionExpression",
+            reason: "Empty condition expressions are not supported.",
+        });
+    }
+    return orGroups.some((group) => {
+        const andClauses = splitTopLevelByKeyword(group, "and");
+        return andClauses.every((clause) => evaluateSingleClause(clause, item, context));
+    });
+};
+export const parseUpdateExpression = (expression, context) => {
+    var _a, _b;
+    const normalized = expression.trim();
+    if (!normalized) {
+        throw new NotSupportedError({
+            method: context.method,
+            featurePath: "UpdateExpression",
+            reason: "UpdateExpression must not be empty.",
+        });
+    }
+    const setMatch = normalized.match(/\bSET\b/i);
+    const removeMatch = normalized.match(/\bREMOVE\b/i);
+    if (!setMatch && !removeMatch) {
+        throw new NotSupportedError({
+            method: context.method,
+            featurePath: "UpdateExpression",
+            reason: "Only SET and REMOVE update operators are supported.",
+        });
+    }
+    const setStart = (_a = setMatch === null || setMatch === void 0 ? void 0 : setMatch.index) !== null && _a !== void 0 ? _a : -1;
+    const removeStart = (_b = removeMatch === null || removeMatch === void 0 ? void 0 : removeMatch.index) !== null && _b !== void 0 ? _b : -1;
+    let setClause = "";
+    let removeClause = "";
+    if (setStart >= 0) {
+        const setBodyStart = setStart + setMatch[0].length;
+        const setBodyEnd = removeStart >= 0 ? removeStart : normalized.length;
+        setClause = normalized.slice(setBodyStart, setBodyEnd).trim();
+        if (!setClause) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.SET",
+                reason: "Malformed SET assignment.",
+            });
+        }
+    }
+    if (removeStart >= 0) {
+        const removeBodyStart = removeStart + removeMatch[0].length;
+        removeClause = normalized.slice(removeBodyStart).trim();
+        if (!removeClause) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.REMOVE",
+                reason: "Malformed REMOVE assignment.",
+            });
+        }
+    }
+    const set = setClause
+        ? splitTopLevelByDelimiter(setClause, ",")
+            .map((segment) => segment.trim())
+            .filter(Boolean)
+            .map((assignment) => {
+            const split = splitTopLevelAssignment(assignment);
+            if (!split) {
+                throw new NotSupportedError({
+                    method: context.method,
+                    featurePath: "UpdateExpression.SET",
+                    reason: "Malformed SET assignment.",
+                });
+            }
+            const attribute = resolveAttributeToken(split.left, context);
+            const value = resolveUpdateSetValueToken(split.right, context.item, context);
+            return { attribute, value };
+        })
+        : [];
+    const remove = removeClause
+        ? splitTopLevelByDelimiter(removeClause, ",")
+            .map((segment) => segment.trim())
+            .filter(Boolean)
+            .map((token) => resolveAttributeToken(token, context))
+        : [];
+    return { set, remove };
+};
+export const matchesRangeCondition = (value, condition) => {
+    if (value === undefined || value === null)
+        return false;
+    switch (condition.type) {
+        case "begins_with":
+            return String(value).startsWith(condition.value);
+        case "between":
+            return compareValues(value, condition.lower) >= 0 && compareValues(value, condition.upper) <= 0;
+        case "=":
+            return compareValues(value, condition.value) === 0;
+        case "<":
+            return compareValues(value, condition.value) < 0;
+        case "<=":
+            return compareValues(value, condition.value) <= 0;
+        case ">":
+            return compareValues(value, condition.value) > 0;
+        case ">=":
+            return compareValues(value, condition.value) >= 0;
+    }
+};
+export const compareValues = (left, right) => {
+    if (typeof left === "number" && typeof right === "number") {
+        return left - right;
+    }
+    const leftString = String(left);
+    const rightString = String(right);
+    if (leftString < rightString)
+        return -1;
+    if (leftString > rightString)
+        return 1;
+    return 0;
+};
+function evaluateSingleClause(clause, item, context) {
+    const source = clause.trim();
+    const existsMatch = source.match(/^attribute_exists\((.+)\)$/i);
+    if (existsMatch) {
+        const value = resolveAttributeValue(existsMatch[1].trim(), item, context);
+        return value !== MISSING;
+    }
+    const notExistsMatch = source.match(/^attribute_not_exists\((.+)\)$/i);
+    if (notExistsMatch) {
+        const value = resolveAttributeValue(notExistsMatch[1].trim(), item, context);
+        return value === MISSING;
+    }
+    const beginsWithMatch = source.match(/^begins_with\((.+?),\s*(.+)\)$/i);
+    if (beginsWithMatch) {
+        const [, attrToken, valueToken] = beginsWithMatch;
+        const current = resolveAttributeValue(attrToken.trim(), item, context);
+        const expected = resolveValueToken(valueToken.trim(), item, context);
+        if (current === MISSING || expected === MISSING)
+            return false;
+        return String(current).startsWith(String(expected));
+    }
+    const containsMatch = source.match(/^contains\((.+?),\s*(.+)\)$/i);
+    if (containsMatch) {
+        const [, attrToken, valueToken] = containsMatch;
+        const current = resolveAttributeValue(attrToken.trim(), item, context);
+        const expected = resolveValueToken(valueToken.trim(), item, context);
+        if (current === MISSING || expected === MISSING)
+            return false;
+        return containsValue(current, expected);
+    }
+    const attributeTypeMatch = source.match(/^attribute_type\((.+?),\s*(.+)\)$/i);
+    if (attributeTypeMatch) {
+        const [, attrToken, typeToken] = attributeTypeMatch;
+        const current = resolveAttributeValue(attrToken.trim(), item, context);
+        const expectedType = resolveValueToken(typeToken.trim(), item, context);
+        if (current === MISSING)
+            return false;
+        if (typeof expectedType !== "string") {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "ConditionExpression.attribute_type",
+                reason: "attribute_type expects a DynamoDB type string.",
+            });
+        }
+        return attributeMatchesType(current, expectedType);
+    }
+    const betweenMatch = source.match(/^(.+?)\s+between\s+(.+?)\s+and\s+(.+)$/i);
+    if (betweenMatch) {
+        const [, attrToken, lowerToken, upperToken] = betweenMatch;
+        const current = resolveAttributeValue(attrToken.trim(), item, context);
+        const lower = resolveValueToken(lowerToken.trim(), item, context);
+        const upper = resolveValueToken(upperToken.trim(), item, context);
+        if (current === MISSING || lower === MISSING || upper === MISSING)
+            return false;
+        return compareValues(current, lower) >= 0 && compareValues(current, upper) <= 0;
+    }
+    const compareMatch = source.match(/^(.+?)\s*(=|<>|<=|<|>=|>)\s*(.+)$/);
+    if (compareMatch) {
+        const [, leftToken, operator, rightToken] = compareMatch;
+        const left = resolveValueToken(leftToken.trim(), item, context);
+        const right = resolveValueToken(rightToken.trim(), item, context);
+        if (left === MISSING || right === MISSING)
+            return false;
+        const result = compareValues(left, right);
+        switch (operator) {
+            case "=":
+                return result === 0;
+            case "<>":
+                return result !== 0;
+            case "<":
+                return result < 0;
+            case "<=":
+                return result <= 0;
+            case ">":
+                return result > 0;
+            case ">=":
+                return result >= 0;
+            default:
+                return false;
+        }
+    }
+    throw new NotSupportedError({
+        method: context.method,
+        featurePath: "ConditionExpression",
+        reason: `Unsupported clause: ${source}`,
+    });
+}
+const PLACEHOLDER_VALUE = /^:[A-Za-z_][A-Za-z0-9_]*$/;
+const PLACEHOLDER_NAME = /^#[A-Za-z_][A-Za-z0-9_]*$/;
+const NUMBER_LITERAL = /^-?\d+(?:\.\d+)?$/;
+const STRING_LITERAL = /^".*"$|^'.*'$/;
+const ATTRIBUTE_NAME = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+const DOCUMENT_PATH_TOKEN = /^(?:#[A-Za-z_][A-Za-z0-9_]*|[A-Za-z_][A-Za-z0-9_-]*)(?:\[\d+\])*(?:\.(?:#[A-Za-z_][A-Za-z0-9_]*|[A-Za-z_][A-Za-z0-9_-]*)(?:\[\d+\])*)*$/;
+const ATTRIBUTE_SEGMENT = /^[A-Za-z_][A-Za-z0-9_-]*/;
+const PLACEHOLDER_SEGMENT = /^#[A-Za-z_][A-Za-z0-9_]*/;
+function resolveAttributeToken(token, context) {
+    var _a;
+    const trimmed = token.trim();
+    if (PLACEHOLDER_NAME.test(trimmed)) {
+        const resolved = (_a = context.expressionAttributeNames) === null || _a === void 0 ? void 0 : _a[trimmed];
+        if (!resolved) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: `ExpressionAttributeNames.${trimmed}`,
+                reason: "Missing expression attribute name placeholder.",
+            });
+        }
+        return resolved;
+    }
+    if (!ATTRIBUTE_NAME.test(trimmed)) {
+        throw new NotSupportedError({
+            method: context.method,
+            featurePath: "ExpressionAttributeNames",
+            reason: `Unsupported attribute token: ${trimmed}`,
+        });
+    }
+    return trimmed;
+}
+function resolveValueToken(token, item, context) {
+    const trimmed = token.trim();
+    if (PLACEHOLDER_VALUE.test(trimmed)) {
+        if (!context.expressionAttributeValues) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "ExpressionAttributeValues",
+                reason: "ExpressionAttributeValues are required for value placeholders.",
+            });
+        }
+        if (!(trimmed in context.expressionAttributeValues)) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: `ExpressionAttributeValues.${trimmed}`,
+                reason: "Missing expression attribute value placeholder.",
+            });
+        }
+        return context.expressionAttributeValues[trimmed];
+    }
+    if (PLACEHOLDER_NAME.test(trimmed)) {
+        return resolveAttributeValue(trimmed, item, context);
+    }
+    if (STRING_LITERAL.test(trimmed)) {
+        return trimmed.slice(1, -1);
+    }
+    const sizeMatch = trimmed.match(/^size\((.+)\)$/i);
+    if (sizeMatch) {
+        const value = resolveAttributeValue(sizeMatch[1].trim(), item, context);
+        if (value === MISSING)
+            return MISSING;
+        return sizeOfValue(value, context);
+    }
+    if (NUMBER_LITERAL.test(trimmed)) {
+        return Number(trimmed);
+    }
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (trimmed === "null")
+        return null;
+    if (DOCUMENT_PATH_TOKEN.test(trimmed) || ATTRIBUTE_NAME.test(trimmed)) {
+        return resolveAttributeValue(trimmed, item, context);
+    }
+    throw new NotSupportedError({
+        method: context.method,
+        featurePath: "ExpressionValue",
+        reason: `Unsupported value token: ${trimmed}`,
+    });
+}
+function resolveAttributeValue(token, item, context) {
+    const path = parseDocumentPath(token, context);
+    if (!item)
+        return MISSING;
+    let current = item;
+    for (const part of path) {
+        if (part.type === "attribute") {
+            if (!current || typeof current !== "object")
+                return MISSING;
+            if (!(part.value in current))
+                return MISSING;
+            current = current[part.value];
+            continue;
+        }
+        if (!Array.isArray(current))
+            return MISSING;
+        if (!(part.value in current))
+            return MISSING;
+        current = current[part.value];
+    }
+    return current;
+}
+function parseDocumentPath(token, context) {
+    var _a, _b;
+    const source = token.trim();
+    if (!source) {
+        throwUnsupportedAttributeToken(token, context);
+    }
+    const parts = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const remaining = source.slice(cursor);
+        const placeholderMatch = remaining.match(PLACEHOLDER_SEGMENT);
+        const segmentMatch = remaining.match(ATTRIBUTE_SEGMENT);
+        const segmentToken = (_a = placeholderMatch === null || placeholderMatch === void 0 ? void 0 : placeholderMatch[0]) !== null && _a !== void 0 ? _a : segmentMatch === null || segmentMatch === void 0 ? void 0 : segmentMatch[0];
+        if (!segmentToken) {
+            throwUnsupportedAttributeToken(token, context);
+        }
+        if (segmentToken.startsWith("#")) {
+            const resolved = (_b = context.expressionAttributeNames) === null || _b === void 0 ? void 0 : _b[segmentToken];
+            if (!resolved) {
+                throw new NotSupportedError({
+                    method: context.method,
+                    featurePath: `ExpressionAttributeNames.${segmentToken}`,
+                    reason: "Missing expression attribute name placeholder.",
+                });
+            }
+            parts.push({ type: "attribute", value: resolved });
+        }
+        else {
+            parts.push({ type: "attribute", value: segmentToken });
+        }
+        cursor += segmentToken.length;
+        while (source[cursor] === "[") {
+            const start = cursor + 1;
+            let end = start;
+            while (end < source.length && /\d/.test(source[end]))
+                end += 1;
+            if (start === end || source[end] !== "]") {
+                throwUnsupportedAttributeToken(token, context);
+            }
+            parts.push({
+                type: "index",
+                value: Number(source.slice(start, end)),
+            });
+            cursor = end + 1;
+        }
+        if (cursor >= source.length)
+            break;
+        if (source[cursor] !== ".") {
+            throwUnsupportedAttributeToken(token, context);
+        }
+        cursor += 1;
+        if (cursor >= source.length) {
+            throwUnsupportedAttributeToken(token, context);
+        }
+    }
+    return parts;
+}
+function throwUnsupportedAttributeToken(token, context) {
+    throw new NotSupportedError({
+        method: context.method,
+        featurePath: "ExpressionAttributeNames",
+        reason: `Unsupported attribute token: ${token.trim()}`,
+    });
+}
+function splitTopLevelByKeyword(expression, keyword) {
+    const clauses = [];
+    let current = "";
+    let depth = 0;
+    const marker = ` ${keyword} `;
+    for (let i = 0; i < expression.length; i += 1) {
+        const char = expression[i];
+        if (char === "(")
+            depth += 1;
+        if (char === ")")
+            depth = Math.max(0, depth - 1);
+        if (depth === 0 &&
+            expression.slice(i, i + marker.length).toLowerCase() === marker) {
+            clauses.push(current.trim());
+            current = "";
+            i += marker.length - 1;
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        clauses.push(current.trim());
+    return clauses;
+}
+function splitTopLevelByDelimiter(expression, delimiter) {
+    const segments = [];
+    let current = "";
+    let depth = 0;
+    for (let i = 0; i < expression.length; i += 1) {
+        const char = expression[i];
+        if (char === "(")
+            depth += 1;
+        if (char === ")")
+            depth = Math.max(0, depth - 1);
+        if (depth === 0 && char === delimiter) {
+            segments.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0)
+        segments.push(current);
+    return segments;
+}
+function splitTopLevelAssignment(assignment) {
+    let depth = 0;
+    for (let i = 0; i < assignment.length; i += 1) {
+        const char = assignment[i];
+        if (char === "(")
+            depth += 1;
+        if (char === ")")
+            depth = Math.max(0, depth - 1);
+        if (depth === 0 && char === "=") {
+            const left = assignment.slice(0, i).trim();
+            const right = assignment.slice(i + 1).trim();
+            if (!left || !right)
+                return null;
+            return { left, right };
+        }
+    }
+    return null;
+}
+function resolveUpdateSetValueToken(token, item, context) {
+    const trimmed = token.trim();
+    const arithmetic = splitTopLevelArithmetic(trimmed);
+    if (arithmetic) {
+        const left = resolveUpdateSetValueToken(arithmetic.left, item, context);
+        const right = resolveUpdateSetValueToken(arithmetic.right, item, context);
+        if (typeof left !== "number" || typeof right !== "number") {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.SET",
+                reason: "Arithmetic update operands must be numbers.",
+            });
+        }
+        return arithmetic.operator === "+" ? left + right : left - right;
+    }
+    const ifNotExists = parseFunctionCall(trimmed, "if_not_exists");
+    if (ifNotExists) {
+        if (ifNotExists.length !== 2) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.SET",
+                reason: "if_not_exists expects exactly two arguments.",
+            });
+        }
+        const existing = resolveAttributeValue(ifNotExists[0], item, context);
+        if (existing !== MISSING)
+            return existing;
+        return resolveUpdateSetValueToken(ifNotExists[1], item, context);
+    }
+    const listAppend = parseFunctionCall(trimmed, "list_append");
+    if (listAppend) {
+        if (listAppend.length !== 2) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.SET",
+                reason: "list_append expects exactly two arguments.",
+            });
+        }
+        const left = resolveUpdateSetValueToken(listAppend[0], item, context);
+        const right = resolveUpdateSetValueToken(listAppend[1], item, context);
+        if (!Array.isArray(left) || !Array.isArray(right)) {
+            throw new NotSupportedError({
+                method: context.method,
+                featurePath: "UpdateExpression.SET",
+                reason: "list_append expects list operands.",
+            });
+        }
+        return [...left, ...right];
+    }
+    const value = resolveValueToken(trimmed, item, context);
+    if (value === MISSING) {
+        throw new NotSupportedError({
+            method: context.method,
+            featurePath: "UpdateExpression.SET",
+            reason: "The provided expression refers to an attribute that does not exist in the item.",
+        });
+    }
+    return value;
+}
+function splitTopLevelArithmetic(source) {
+    let depth = 0;
+    for (let i = 0; i < source.length; i += 1) {
+        const char = source[i];
+        if (char === "(")
+            depth += 1;
+        if (char === ")")
+            depth = Math.max(0, depth - 1);
+        if (depth !== 0)
+            continue;
+        if (char === "+" || char === "-") {
+            const left = source.slice(0, i).trim();
+            const right = source.slice(i + 1).trim();
+            if (!left || !right)
+                continue;
+            return {
+                left,
+                right,
+                operator: char,
+            };
+        }
+    }
+    return null;
+}
+function parseFunctionCall(source, fnName) {
+    const regex = new RegExp(`^${fnName}\\((.*)\\)$`, "i");
+    const match = source.match(regex);
+    if (!match)
+        return null;
+    return splitTopLevelByDelimiter(match[1], ",")
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function sizeOfValue(value, context) {
+    if (typeof value === "string" || Array.isArray(value))
+        return value.length;
+    if (value instanceof Uint8Array || Buffer.isBuffer(value))
+        return value.length;
+    if (value instanceof Set)
+        return value.size;
+    if (value && typeof value === "object")
+        return Object.keys(value).length;
+    throw new NotSupportedError({
+        method: context.method,
+        featurePath: "ConditionExpression.size",
+        reason: "size supports string, binary, list, set, and map values only.",
+    });
+}
+function containsValue(container, expected) {
+    if (typeof container === "string")
+        return container.includes(String(expected));
+    if (Array.isArray(container))
+        return container.some((entry) => entry === expected);
+    if (container instanceof Set)
+        return container.has(expected);
+    if (container && typeof container === "object") {
+        return Object.prototype.hasOwnProperty.call(container, String(expected));
+    }
+    return false;
+}
+function attributeMatchesType(value, expectedType) {
+    const t = expectedType.toUpperCase();
+    if (t === "S")
+        return typeof value === "string";
+    if (t === "N")
+        return typeof value === "number";
+    if (t === "BOOL")
+        return typeof value === "boolean";
+    if (t === "NULL")
+        return value === null;
+    if (t === "L")
+        return Array.isArray(value);
+    if (t === "M")
+        return !!value && typeof value === "object" && !Array.isArray(value) && !Buffer.isBuffer(value) && !(value instanceof Set);
+    if (t === "B")
+        return Buffer.isBuffer(value) || value instanceof Uint8Array;
+    if (value instanceof Set) {
+        const values = [...value.values()];
+        if (t === "SS")
+            return values.every((entry) => typeof entry === "string");
+        if (t === "NS")
+            return values.every((entry) => typeof entry === "number");
+        if (t === "BS")
+            return values.every((entry) => Buffer.isBuffer(entry) || entry instanceof Uint8Array);
+    }
+    return false;
+}
+//# sourceMappingURL=expression.js.map