better-supabase 0.0.0 → 0.1.0

package/dist/simplify-oHiDKRVQ.js

@@ -0,0 +1,665 @@
+import { n as dbError, t as DbException } from "./errors-Bl3rkOzo.js";
+import { i as or, r as not, t as and } from "./types-6cYK9pbJ.js";
+//#region src/schema/define.ts
+/**
+* Binds generated model types to runtime metadata. Called from the generated
+* module; apps import the returned `schema`, never call this themselves.
+*/
+function defineSchema(meta) {
+	return { meta: validateMeta(meta) };
+}
+function validateMeta(meta) {
+	if (meta.version !== 1) throw new TypeError(`better-supabase: unsupported schema metadata version ${String(meta.version)}. Run \`better-supabase gen\` again.`);
+	return meta;
+}
+function tableMeta(meta, table) {
+	const found = meta.tables[table];
+	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+	return found;
+}
+function relationMeta(meta, table, relation) {
+	const found = table.relations[relation];
+	if (!found) throw new TypeError(`better-supabase: unknown relation "${relation}" on "${table.key}"`);
+	return {
+		relation: found,
+		target: tableMeta(meta, found.table)
+	};
+}
+//#endregion
+//#region src/ir/codec.ts
+/** Wire form of an app value: `Date` to ISO text, `bigint` to decimal text. */
+function encodeValue(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) return value.map(encodeValue);
+	return value;
+}
+function decodeScalar(codec, value) {
+	if (value === null || value === void 0) return value;
+	switch (codec) {
+		case "date": return new Date(value);
+		case "bigint": return BigInt(value);
+		case "string": return String(value);
+		default: return codec;
+	}
+}
+function decode(codec, value) {
+	return Array.isArray(value) ? value.map((item) => decodeScalar(codec, item)) : decodeScalar(codec, value);
+}
+/** Whether decoding `selection` changes anything, so plain reads skip the walk. */
+function needsDecoding(selection) {
+	return selection.aggregate !== void 0 || selection.columns.some((column) => column.codec !== void 0) || selection.includes.some((include) => include.count !== void 0 || include.aggregate !== void 0 || needsDecoding(include.selection));
+}
+/** PostgREST returns `[{ count }]` for a `(count)` embed; SQL returns the number. */
+function countOf(value) {
+	if (Array.isArray(value)) {
+		const first = value[0];
+		return Number(first?.count ?? 0);
+	}
+	return Number(value ?? 0);
+}
+function measureOf(measure, value) {
+	if (value === void 0 || value === null) return null;
+	return measure.codec ? decodeScalar(measure.codec, value) : value;
+}
+/** Adds `value` under `row[key][name]`, next to what is already there. */
+function fold(row, key, name, value) {
+	row[key] = {
+		...row[key] ?? {},
+		[name]: value
+	};
+}
+function decodeRow(selection, row) {
+	const out = { ...row };
+	for (const column of selection.columns) if (column.codec && column.alias in out) out[column.alias] = decode(column.codec, out[column.alias]);
+	if (selection.aggregate) {
+		if (selection.aggregate.count) out["_count"] = countOf(out["_count"]);
+		for (const measure of selection.aggregate.measures) {
+			const value = out[measure.key];
+			delete out[measure.key];
+			fold(out, `_${measure.fn}`, measure.alias, measureOf(measure, value));
+		}
+	}
+	for (const include of selection.includes) {
+		const value = out[include.alias];
+		if (include.count !== void 0) {
+			if (!(include.alias in out)) continue;
+			delete out[include.alias];
+			fold(out, "_count", include.count, countOf(value));
+			continue;
+		}
+		if (include.aggregate !== void 0) {
+			if (!(include.alias in out)) continue;
+			delete out[include.alias];
+			const inner = Array.isArray(value) ? value[0] : value;
+			const measures = {};
+			for (const measure of include.selection.aggregate?.measures ?? []) measures[measure.alias] = measureOf(measure, inner?.[measure.key]);
+			fold(out, `_${include.aggregate.fn}`, include.aggregate.name, measures);
+			continue;
+		}
+		if (Array.isArray(value)) out[include.alias] = value.map((item) => decodeRow(include.selection, item));
+		else if (value && typeof value === "object") out[include.alias] = decodeRow(include.selection, value);
+	}
+	return out;
+}
+/** Applies column codecs to returned rows, including embedded relations. */
+function decodeRows(selection, rows) {
+	if (!selection || !needsDecoding(selection)) return rows;
+	return rows.map((row) => decodeRow(selection, row));
+}
+//#endregion
+//#region src/ir/build.ts
+const AGGREGATE_KEYS = {
+	_sum: "sum",
+	_avg: "avg",
+	_min: "min",
+	_max: "max"
+};
+const NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"smallint",
+	"integer",
+	"bigint",
+	"real",
+	"double precision"
+]);
+/** Thrown while building IR; surfaces as an `invalid_request` Result. */
+function invalidRequest(message, table) {
+	throw new DbException(dbError("invalid_request", message, table ? { table } : {}));
+}
+const FIELD_OPS = /* @__PURE__ */ new Set([
+	"eq",
+	"neq",
+	"in",
+	"notIn",
+	"isNull",
+	"not",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"contains",
+	"startsWith",
+	"endsWith",
+	"search",
+	"hasEvery",
+	"hasSome",
+	"has",
+	"containedBy"
+]);
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isOpsObject(value) {
+	if (!isPlainObject(value)) return false;
+	const keys = Object.keys(value);
+	return keys.length > 0 && keys.every((key) => FIELD_OPS.has(key));
+}
+function writable(meta, mode) {
+	if (meta.generated || meta.identity === "always") return false;
+	return mode === "insert" ? meta.insertable !== false : meta.updatable !== false;
+}
+/** Escapes LIKE wildcards so user input matches literally. */
+function escapeLike(value) {
+	return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+var IrBuilder = class {
+	meta;
+	constructor(meta) {
+		this.meta = meta;
+	}
+	table(key) {
+		const table = this.meta.tables[key];
+		if (!table) invalidRequest(`Unknown table "${key}"`);
+		return table;
+	}
+	column(table, name) {
+		const column = table.columns[name];
+		if (!column) invalidRequest(`Unknown column "${name}" on "${table.key}"`, table.key);
+		return column.db;
+	}
+	where(table, input) {
+		if (input === void 0) return void 0;
+		if (!isPlainObject(input)) invalidRequest(`"where" on "${table.key}" must be an object`, table.key);
+		const items = [];
+		for (const [key, value] of Object.entries(input)) {
+			if (value === void 0) continue;
+			if (key === "AND") {
+				const list = Array.isArray(value) ? value : [value];
+				items.push(and(...list.map((item) => this.where(table, item))));
+			} else if (key === "OR") {
+				if (!Array.isArray(value)) invalidRequest(`"OR" on "${table.key}" must be an array`, table.key);
+				const branches = value.map((item) => this.where(table, item)).filter((item) => item !== void 0);
+				items.push(branches.length === 0 ? not({
+					kind: "and",
+					items: []
+				}) : or(...branches));
+			} else if (key === "NOT") {
+				const inner = this.where(table, value);
+				if (inner) items.push(not(inner));
+			} else if (key in table.relations) items.push(this.relationFilter(table, key, value));
+			else items.push(this.fieldFilter(table, key, value));
+		}
+		return and(...items);
+	}
+	relationFilter(table, name, value) {
+		const { relation, target } = relationMeta(this.meta, table, name);
+		const make = (quantifier, where) => ({
+			kind: "relation",
+			name,
+			relation,
+			target,
+			quantifier,
+			where: where === null ? void 0 : this.where(target, where)
+		});
+		if (relation.kind === "many") {
+			if (!isPlainObject(value)) invalidRequest(`Filter on to-many relation "${name}" needs some, none or every`, table.key);
+			const items = [];
+			for (const [quantifier, where] of Object.entries(value)) {
+				if (where === void 0) continue;
+				if (quantifier !== "some" && quantifier !== "none" && quantifier !== "every") invalidRequest(`Unknown quantifier "${quantifier}" on relation "${name}"`, table.key);
+				items.push(make(quantifier, where));
+			}
+			return and(...items) ?? make("some", {});
+		}
+		if (value === null) return make("none", null);
+		if (isPlainObject(value)) {
+			const keys = Object.keys(value);
+			if (keys.length > 0 && keys.every((key) => key === "is" || key === "isNot")) {
+				const items = [];
+				if (value.is !== void 0) items.push(value.is === null ? make("none", null) : make("some", value.is));
+				if (value.isNot !== void 0) items.push(value.isNot === null ? make("some", null) : not(make("some", value.isNot)));
+				return and(...items) ?? make("some", null);
+			}
+		}
+		return make("some", value);
+	}
+	fieldFilter(table, name, value) {
+		const column = this.column(table, name);
+		if (value === null) return {
+			kind: "column",
+			column,
+			op: "is",
+			value: null
+		};
+		if (!isOpsObject(value)) return {
+			kind: "column",
+			column,
+			op: "eq",
+			value: encodeValue(value)
+		};
+		const items = [];
+		for (const [op, operand] of Object.entries(value)) {
+			if (operand === void 0) continue;
+			items.push(this.fieldOp(table, name, column, op, operand));
+		}
+		return and(...items) ?? {
+			kind: "and",
+			items: []
+		};
+	}
+	fieldOp(table, name, column, op, operand) {
+		const col = (kind, value) => ({
+			kind: "column",
+			column,
+			op: kind,
+			value: encodeValue(value)
+		});
+		const meta = table.columns[name];
+		switch (op) {
+			case "eq": return operand === null ? col("is", null) : col("eq", operand);
+			case "neq": return operand === null ? not(col("is", null)) : col("neq", operand);
+			case "in":
+			case "notIn": {
+				if (!Array.isArray(operand)) invalidRequest(`"${op}" on "${name}" needs an array`, table.key);
+				const condition = col("in", operand);
+				return op === "in" ? condition : not(condition);
+			}
+			case "isNull": return operand ? col("is", null) : not(col("is", null));
+			case "not": {
+				const inner = this.fieldFilter(table, name, operand);
+				return not(inner);
+			}
+			case "gt":
+			case "gte":
+			case "lt":
+			case "lte":
+			case "like":
+			case "ilike": return col(op, operand);
+			case "contains":
+				if (meta?.json || meta?.array) return col("contains", operand);
+				return col("ilike", `%${escapeLike(String(operand))}%`);
+			case "startsWith": return col("like", `${escapeLike(String(operand))}%`);
+			case "endsWith": return col("like", `%${escapeLike(String(operand))}`);
+			case "search": {
+				if (typeof operand === "string") return col("fts", operand);
+				const { query, config } = operand;
+				return config ? {
+					kind: "column",
+					column,
+					op: "fts",
+					value: query,
+					config
+				} : col("fts", query);
+			}
+			case "hasEvery": return col("contains", operand);
+			case "has": return col("contains", [operand]);
+			case "hasSome": return col("overlaps", operand);
+			case "containedBy": return col("containedBy", operand);
+			default: return invalidRequest(`Unknown operator "${op}" on "${name}"`, table.key);
+		}
+	}
+	selection(table, select, include) {
+		const columns = (select ?? Object.keys(table.columns)).map((alias) => this.selectColumn(table, alias));
+		const includes = [];
+		if (include !== void 0) {
+			if (!isPlainObject(include)) invalidRequest(`"include" on "${table.key}" must be an object`, table.key);
+			for (const [name, value] of Object.entries(include)) {
+				if (value === void 0 || value === false) continue;
+				const fn = AGGREGATE_KEYS[name];
+				if (name === "_count") includes.push(...this.counts(table, value));
+				else if (fn) includes.push(...this.relationAggregates(table, fn, value));
+				else includes.push(this.include(table, name, value));
+			}
+		}
+		return {
+			columns,
+			includes
+		};
+	}
+	/**
+	* `db.x.aggregate(args)`: the grouping columns, `_count` and the measures
+	* of each group.
+	*/
+	aggregation(table, args) {
+		const groupBy = args.groupBy ?? [];
+		if (!Array.isArray(groupBy)) invalidRequest(`"groupBy" on "${table.key}" must be an array`, table.key);
+		const columns = groupBy.map((name) => this.selectColumn(table, String(name)));
+		const measures = [];
+		for (const [key, fn] of Object.entries(AGGREGATE_KEYS)) {
+			const value = args[key];
+			if (value === void 0) continue;
+			for (const alias of this.measured(table, key, value)) measures.push(this.measure(table, fn, alias, `${key}_${alias}`));
+		}
+		const count = args._count === true;
+		if (!count && measures.length === 0) invalidRequest(`aggregate on "${table.key}" needs _count, _sum, _avg, _min or _max`, table.key);
+		return {
+			columns,
+			includes: [],
+			aggregate: {
+				count,
+				measures
+			}
+		};
+	}
+	relationAggregates(table, fn, value) {
+		const key = `_${fn}`;
+		if (!isPlainObject(value)) invalidRequest(`"${key}" on "${table.key}" must map relations to columns`, table.key);
+		const includes = [];
+		for (const [name, entry] of Object.entries(value)) {
+			if (entry === void 0 || entry === false) continue;
+			const { relation, target } = relationMeta(this.meta, table, name);
+			if (relation.kind !== "many") invalidRequest(`"${key}.${name}" on "${table.key}" needs a to-many relation`, table.key);
+			const measures = this.measured(target, `${key}.${name}`, entry).map((alias) => this.measure(target, fn, alias, alias));
+			if (measures.length === 0) continue;
+			includes.push({
+				alias: `${key}_${name}`,
+				relation,
+				target,
+				selection: {
+					columns: [],
+					includes: [],
+					aggregate: {
+						count: false,
+						measures
+					}
+				},
+				where: void 0,
+				orderBy: [],
+				limit: void 0,
+				required: false,
+				aggregate: {
+					fn,
+					name
+				}
+			});
+		}
+		return includes;
+	}
+	/** The columns switched on in `{ amount: true, tax: true }`. */
+	measured(table, path, value) {
+		if (!isPlainObject(value)) invalidRequest(`"${path}" on "${table.key}" must map columns to true`, table.key);
+		return Object.entries(value).filter(([, on]) => on === true).map(([alias]) => alias);
+	}
+	measure(table, fn, alias, key) {
+		const column = this.column(table, alias);
+		const meta = table.columns[alias];
+		if ((fn === "sum" || fn === "avg") && !NUMERIC_TYPES.has(meta?.type ?? "")) invalidRequest(`_${fn} needs a numeric column; "${alias}" on "${table.key}" is ${meta?.type}`, table.key);
+		const codec = fn === "avg" ? void 0 : meta?.codec;
+		if (!codec) return {
+			fn,
+			key,
+			alias,
+			column
+		};
+		return codec === "date" ? {
+			fn,
+			key,
+			alias,
+			column,
+			codec
+		} : {
+			fn,
+			key,
+			alias,
+			column,
+			cast: "text",
+			codec
+		};
+	}
+	/** A selected column, with the cast and codec its metadata asks for. */
+	selectColumn(table, alias) {
+		const column = this.column(table, alias);
+		const codec = table.columns[alias]?.codec;
+		if (!codec) return {
+			alias,
+			column
+		};
+		return codec === "date" ? {
+			alias,
+			column,
+			codec
+		} : {
+			alias,
+			column,
+			cast: "text",
+			codec
+		};
+	}
+	counts(table, value) {
+		if (!isPlainObject(value)) invalidRequest(`"_count" on "${table.key}" must map relations to true or { where }`, table.key);
+		const counts = [];
+		for (const [name, entry] of Object.entries(value)) {
+			if (entry === void 0 || entry === false) continue;
+			const { relation, target } = relationMeta(this.meta, table, name);
+			if (relation.kind !== "many") invalidRequest(`"_count.${name}" on "${table.key}" needs a to-many relation`, table.key);
+			const args = isPlainObject(entry) ? entry : {};
+			counts.push({
+				alias: `_count_${name}`,
+				relation,
+				target,
+				selection: {
+					columns: [],
+					includes: []
+				},
+				where: this.where(target, args.where),
+				orderBy: [],
+				limit: void 0,
+				required: false,
+				count: name
+			});
+		}
+		return counts;
+	}
+	include(table, name, value) {
+		const { relation, target } = relationMeta(this.meta, table, name);
+		const args = value === true ? {} : isPlainObject(value) ? value : {};
+		return {
+			alias: name,
+			relation,
+			target,
+			selection: this.selection(target, args.select, args.include),
+			where: this.where(target, args.where),
+			orderBy: this.orderBy(target, args.orderBy),
+			limit: typeof args.limit === "number" ? args.limit : void 0,
+			required: args.required === true
+		};
+	}
+	orderBy(table, input) {
+		if (input === void 0) return [];
+		const list = Array.isArray(input) ? input : [input];
+		const terms = [];
+		for (const item of list) {
+			if (!isPlainObject(item)) invalidRequest(`"orderBy" on "${table.key}" must be an object`, table.key);
+			for (const [name, spec] of Object.entries(item)) {
+				if (spec === void 0) continue;
+				const column = this.column(table, name);
+				if (spec === "asc" || spec === "desc") terms.push({
+					column,
+					direction: spec
+				});
+				else if (isPlainObject(spec)) {
+					const direction = spec.direction === "desc" ? "desc" : "asc";
+					const nulls = spec.nulls;
+					terms.push(nulls === "first" || nulls === "last" ? {
+						column,
+						direction,
+						nulls
+					} : {
+						column,
+						direction
+					});
+				} else invalidRequest(`Invalid sort for "${name}" on "${table.key}"`, table.key);
+			}
+		}
+		return terms;
+	}
+	/**
+	* Maps an app-cased row to database column names. Rejects columns the
+	* database won't accept for `mode`: generated columns, `identity always`
+	* columns and read-only view columns.
+	*/
+	row(table, input, mode = "insert") {
+		if (!isPlainObject(input)) invalidRequest(`Row for "${table.key}" must be an object`, table.key);
+		const out = {};
+		for (const [name, value] of Object.entries(input)) {
+			if (value === void 0) continue;
+			const column = this.column(table, name);
+			const meta = table.columns[name];
+			if (meta && !writable(meta, mode)) invalidRequest(`"${name}" on "${table.key}" is read-only${meta.generated ? " (generated)" : meta.identity === "always" ? " (identity always)" : ""} and can't be set in an ${mode}`, table.key);
+			out[column] = encodeValue(value);
+		}
+		return out;
+	}
+	/**
+	* Condition matching exactly one row by the primary key or by the columns
+	* of a named unique key. The given columns must be one complete key.
+	*/
+	uniqueKey(table, input) {
+		if (!isPlainObject(input)) invalidRequest(`"where" on "${table.key}" must be an object`, table.key);
+		const given = Object.keys(input).filter((key) => input[key] !== void 0);
+		const keys = [table.primaryKey, ...Object.values(table.uniqueKeys)];
+		const match = keys.find((key) => key.length > 0 && key.length === given.length && key.every((column) => given.includes(column)));
+		if (!match) {
+			const names = keys.filter((key) => key.length > 0).map((key) => `{ ${key.join(", ")} }`).join(", ");
+			invalidRequest(`findUnique on "${table.key}" needs one complete unique key: ${names}`, table.key);
+		}
+		return {
+			kind: "and",
+			items: match.map((name) => ({
+				kind: "column",
+				column: this.column(table, name),
+				op: input[name] === null ? "is" : "eq",
+				value: encodeValue(input[name])
+			}))
+		};
+	}
+	/** Condition matching one primary key value. */
+	primaryKey(table, id) {
+		const pk = table.primaryKey;
+		if (pk.length === 0) invalidRequest(`Table "${table.key}" has no primary key`, table.key);
+		if (pk.length === 1) {
+			const [name] = pk;
+			const value = isPlainObject(id) && name in id ? id[name] : id;
+			return {
+				kind: "column",
+				column: this.column(table, name),
+				op: "eq",
+				value: encodeValue(value)
+			};
+		}
+		if (!isPlainObject(id)) invalidRequest(`Table "${table.key}" has a composite key; pass { ${pk.join(", ")} }`, table.key);
+		return {
+			kind: "and",
+			items: pk.map((name) => ({
+				kind: "column",
+				column: this.column(table, name),
+				op: "eq",
+				value: encodeValue(id[name])
+			}))
+		};
+	}
+};
+//#endregion
+//#region src/ir/simplify.ts
+/**
+* Folds constant conditions. `true` means "no filter", `false` means "matches
+* nothing", so executors can skip the request entirely.
+*/
+function simplify(condition) {
+	if (condition === void 0) return true;
+	switch (condition.kind) {
+		case "and": {
+			const items = [];
+			for (const item of condition.items) {
+				const simple = simplify(item);
+				if (simple === false) return false;
+				if (simple !== true) items.push(simple);
+			}
+			if (items.length === 0) return true;
+			return items.length === 1 && items[0] ? items[0] : {
+				kind: "and",
+				items
+			};
+		}
+		case "or": {
+			const items = [];
+			for (const item of condition.items) {
+				const simple = simplify(item);
+				if (simple === true) return true;
+				if (simple !== false) items.push(simple);
+			}
+			if (items.length === 0) return false;
+			return items.length === 1 && items[0] ? items[0] : {
+				kind: "or",
+				items
+			};
+		}
+		case "not": {
+			const inner = simplify(condition.item);
+			if (typeof inner === "boolean") return !inner;
+			if (inner.kind === "not") return inner.item;
+			return {
+				kind: "not",
+				item: inner
+			};
+		}
+		case "relation": {
+			const where = simplify(condition.where);
+			if (where === true) {
+				if (condition.quantifier === "every") return true;
+				return {
+					...condition,
+					where: void 0
+				};
+			}
+			if (where === false) {
+				if (condition.quantifier === "some") return false;
+				if (condition.quantifier === "none") return true;
+				return {
+					...condition,
+					quantifier: "none",
+					where: void 0
+				};
+			}
+			return {
+				...condition,
+				where
+			};
+		}
+		case "column":
+			if (condition.op === "in" && Array.isArray(condition.value) && condition.value.length === 0) return false;
+			return condition;
+		default: return condition;
+	}
+}
+/** Returns the condition, or `undefined` when it folds to `true`. */
+function simplifyOrFalse(condition) {
+	const simple = simplify(condition);
+	if (simple === false) return { never: true };
+	return {
+		never: false,
+		condition: simple === true ? void 0 : simple
+	};
+}
+//#endregion
+export { invalidRequest as a, needsDecoding as c, escapeLike as i, defineSchema as l, simplifyOrFalse as n, decodeRows as o, IrBuilder as r, encodeValue as s, simplify as t, tableMeta as u };

package/dist/spec-pins-CJPVghHy.d.ts

@@ -0,0 +1,20 @@
+//#region src/core/spec-pins.d.ts
+/**
+ * Versions of evolving specs and conventions the code follows. Moving a pin
+ * is a minor release with a changeset (see the standards docs page).
+ */
+declare const SPEC_PINS: {
+  readonly otelSemconv: "1.37.0";
+  readonly mcp: "2025-06-18";
+  readonly openapi: "3.1.1";
+  readonly cloudevents: "1.0.2";
+  readonly standardWebhooks: "1.0.0";
+  readonly sarif: "2.1.0";
+  readonly jsonSchema: "2020-12";
+  readonly postgrestAggregates: "12";
+  readonly serverTiming: "WD-20260407";
+  readonly stripeSyncEngine: "0.48.5";
+  readonly pgvector: "0.8";
+};
+//#endregion
+export { SPEC_PINS as t };

package/dist/spec-pins-t6sPaHvl.js

@@ -0,0 +1,20 @@
+//#region src/core/spec-pins.ts
+/**
+* Versions of evolving specs and conventions the code follows. Moving a pin
+* is a minor release with a changeset (see the standards docs page).
+*/
+const SPEC_PINS = {
+	otelSemconv: "1.37.0",
+	mcp: "2025-06-18",
+	openapi: "3.1.1",
+	cloudevents: "1.0.2",
+	standardWebhooks: "1.0.0",
+	sarif: "2.1.0",
+	jsonSchema: "2020-12",
+	postgrestAggregates: "12",
+	serverTiming: "WD-20260407",
+	stripeSyncEngine: "0.48.5",
+	pgvector: "0.8"
+};
+//#endregion
+export { SPEC_PINS as t };