@witchcraft/expressit 0.2.0 → 0.2.2

package/src/examples/ParserWithSqlSupport.ts

@@ -0,0 +1,365 @@
+import { unreachable } from "@alanscodelog/utils/unreachable.js"
+
+import { Parser } from "../Parser.js"
+import { AST_TYPE, type NormalizedCondition, type NormalizedExpression, type Position,TOKEN_TYPE } from "../types/ast.js"
+
+export interface BasePropertyDefinition {
+	name: string
+	/** Supported types are: string, boolean, int, float, date. */
+	type: string
+	/** Return how to access the column in the WHERE condition of the SQL query, useful for json properties. It is up to you to properly quote the value if needed. */
+	transformToColumn?: (key: string, name: string) => string
+	/**
+	 * A function that can be used to transform the value before it is inserted into the SQL query. Useful for types like arrays. It is up to you to properly escape values if you use the second parameter which contains the unescaped value.
+	 */
+	transformValue?: (value: any, unescapedValue: any) => any | any[]
+	isArray?: boolean
+	/** If undefined, it's assumed all operators are supported. This should only include the final operator (see {@link BaseOperatorDefinition.operator}), it doesn't need to include it's aliases. */
+	supportedOperators?: string[]
+	/** Further transform the value after the basic parsing has been done. Useful to, for example, parse other strings (e.g. now, today, tomorrow) as dates. */
+	postParse?: (value: any) => any
+}
+export interface BaseOperatorDefinition {
+	/** The final operator to use in the SQL query and while evaluating. */
+	operator: string
+	/** All aliases the user can use to specify the operator. They need not include the real final operator. */
+	operators: string[]
+	/** All negated aliases to the operator. If an operator is listed here, it will be used to "invert" a condition when normalizing. e.g. < can list >= as a negated operator. This greatly simplifies queries. */
+	negatedOperators?: string[]
+	/** How to compare the value when evualuating a condition. This is only used if using `evaluate`. */
+	valueComparer: (condition: any, contextValue: any) => boolean
+}
+export type BaseErrorTokenTypes =
+	| "invalidKey"
+	| "unknownProperty"
+	| "unknownOperator"
+	| "unknownOperatorForType"
+	| "invalidValueType"
+/*
+ * Creates an example parser with a `toSql` method that can be used to convert an AST to a a safe SQL query.
+ *
+ * The parser assumes all column names (i.e. the propertyDefinitions) and operators (i.e. operatorDefinitions) are vetted and safe to use in the SQL queries. They are double quoted (unless transformToColumn is specificed) so you can use special characters if needed. You can use the `transformToColumn` option to specify a custom name (e.g. for json columns) that will be left as is.
+ *
+ * Values are escaped with the given `sqlEscapeValue`. If using drizzle, for simple tables and types, you can just do and it'll be safe. More complex types, such as arrays, or json properties are more comlicated and you'll probably want to specify the definition's transformValue option. See the examples tests for examples.
+ * ```ts
+ * const parser = new ParserWithSqlSupport(
+ * 	propertyDefinitions,
+ * 	{
+ * 		sqlEscapeValue: (value: string) => sql`${value}`
+ * 	}
+ * )
+ * ```
+ *
+ */
+export class ParserWithSqlSupport<TErrorToken extends
+	Position & {
+		type: BaseErrorTokenTypes
+		message?: string
+	} =
+	Position & {
+		type: BaseErrorTokenTypes
+		message?: string
+	},
+	TPropertyDefinition extends BasePropertyDefinition = BasePropertyDefinition,
+	TPropertyDefinitions extends Record<string, TPropertyDefinition> = Record<string, TPropertyDefinition>,
+	TOperatorDefinition extends BaseOperatorDefinition = BaseOperatorDefinition,
+	TOperatorDefinitions extends Record<string, TOperatorDefinition> = Record<string, TOperatorDefinition>,
+	TSqlEscapeValue extends (value: string) => any | ReturnType<TSqlEscapeValue> = (value: string) => any,
+> extends Parser<TErrorToken> {
+	sqlEscapeValue: TSqlEscapeValue
+
+	operatorMap: Record<string, string>
+
+	constructor(
+		public propertyDefinitions: TPropertyDefinitions,
+		public operatorDefinitions: TOperatorDefinitions,
+		{ sqlEscapeValue }: { sqlEscapeValue: TSqlEscapeValue }
+	) {
+		const operators = []
+		const operatorMap: Record<string, string> = {}
+		for (const value of Object.values(operatorDefinitions)) {
+			for (const operator of value.operators) {
+				operatorMap[operator] = value.operator
+				operators.push(operator)
+			}
+			if (value.negatedOperators) {
+				for (const operator of value.negatedOperators) {
+					operatorMap[operator] = value.operator
+					operators.push(operator)
+				}
+			}
+		}
+		super({
+			arrayValues: true,
+			regexValues: false,
+			keywords: {
+				and: [{ isSymbol: true, value: "&&" }],
+				or: [{ isSymbol: true, value: "||" }],
+				not: [{ isSymbol: true, value: "!" }],
+			},
+			customPropertyOperators: operators,
+			prefixableGroups: false,
+			valueComparer: (condition, contextValue, _context) => {
+				if (typeof condition.value !== typeof contextValue) {
+					throw new Error(`Expected type of property ${condition.property[0]} to be the same type as the context value ${contextValue} (${typeof contextValue}). If the ast has been validated this is likely because the type of the context value is incorrect.`)
+				}
+				
+				const prop = condition.property[0]
+				if (!prop) unreachable("Did you validate the ast before evaluating it?")
+
+				const propDefinition = propertyDefinitions[prop]
+				const operatorDefinition = condition.operator && operatorDefinitions[condition.operator]
+				if (!operatorDefinition) unreachable("Did you validate the ast before evaluating it?")
+
+				const isSupported = !propDefinition.supportedOperators?.includes(condition.operator!)
+				if (!isSupported) unreachable("Did you validate the ast before evaluating it?")
+
+				const res = operatorDefinition.valueComparer(condition, contextValue)
+				return res
+			},
+			valueValidator: (_contextValue, query): TErrorToken[] | void => {
+				const prop = query.propertyKeys[0]
+				let tokens: TErrorToken[] = []
+				const propDefinition = propertyDefinitions[prop]
+				if (!propDefinition) {
+					tokens = tokens.concat(query.property.map(token => ({
+						start: token.start,
+						end: token.end,
+						type: "unknownProperty",
+					})) as TErrorToken[])
+					return tokens
+				}
+				const op = query.operator
+				const opKey = op && operatorMap[op.value]
+				if (!op || !opKey) {
+					tokens.push({
+						start: (op ?? query.condition)?.start,
+						end: (op ?? query.condition)?.end,
+						type: "unknownOperator",
+					} as TErrorToken)
+				} else {
+					if (propDefinition.supportedOperators && !propDefinition.supportedOperators?.includes(opKey)) {
+						tokens.push({
+							start: query.condition.start,
+							end: query.condition.end,
+							type: "unknownOperatorForType",
+						} as TErrorToken)
+					}
+				}
+
+				const val = query.value
+				if (Array.isArray(val)) {
+					for (const v of val) {
+						if (v.type !== "VARIABLE") unreachable()
+						const res = convertAndValidateValue(query.isQuoted, v.value.value, prop, propertyDefinitions, { isArray: true })
+						if (res instanceof Error) {
+							if (v.type !== "VARIABLE") unreachable()
+							const token = v
+							tokens.push({
+								start: token.start,
+								end: token.end,
+								type: "invalidValueType",
+								message: res.message,
+							} as TErrorToken)
+						}
+					}
+					if (tokens.length > 0) return tokens
+					return
+				}
+
+				if (val?.type !== "VARIABLE") unreachable()
+				const value = val.value.value
+				const res = convertAndValidateValue(query.isQuoted, value, prop, propertyDefinitions)
+				if (res instanceof Error) {
+					if (!query.value || query.value.type !== "VARIABLE") unreachable()
+					const token = query.value.value
+					tokens.push({
+						start: token.start,
+						end: token.end,
+						type: "invalidValueType",
+						message: res.message,
+					} as TErrorToken)
+				}
+				
+				if (tokens.length > 0) return tokens
+			},
+			conditionNormalizer(query) {
+				const prop = query.property?.[0]
+				if (!prop) unreachable("Did you validate the ast before normalizing it?")
+				const propDefinition = propertyDefinitions[prop]
+
+				let finalValue
+				if (Array.isArray(query.value)) {
+					const values = []
+					if (query.condition.value.type !== AST_TYPE.ARRAY) unreachable()
+					const raw = query.condition.value.values
+					for (let i = 0; i < query.value.length; i += 1) {
+						const token = raw[i]
+						const val = query.value[i]
+						const isQuoted = !!token.quote
+						const res = convertAndValidateValue(isQuoted, val, prop, propertyDefinitions, { isArray: true })
+						if (res instanceof Error) throw res
+						values.push(res)
+					}
+					finalValue = values
+				} else {
+					finalValue = convertAndValidateValue(query.isQuoted, query.value, prop, propertyDefinitions)
+					if (propDefinition.isArray) {
+						finalValue = [finalValue]
+					}
+				}
+
+				let finalOperator: any = query.operator
+				if (finalValue instanceof Error) throw finalValue
+				const opKey = query.operator && operatorMap[query.operator]
+				if (!opKey) unreachable("Did you validate the ast before normalizing it?")
+					
+				const operatorDefinition = opKey && operatorDefinitions[opKey]
+				if (!operatorDefinition) unreachable("Did you validate the ast before normalizing it?")
+			
+
+				const isNegatableOperator = operatorDefinition.negatedOperators?.includes(query.operator!)
+
+				finalOperator = operatorDefinition.operator
+				let isNegated = query.isNegated
+				if (isNegatableOperator) {
+					isNegated = !isNegated
+				}
+				
+				return { value: finalValue, operator: finalOperator, negate: isNegated }
+			},
+		})
+		this.operatorMap = operatorMap
+		this.sqlEscapeValue = sqlEscapeValue
+	}
+	
+	toSql<T>(
+		ast: NormalizedExpression<any, any> | NormalizedCondition<any, any>,
+		/**
+		 * Optionally convert the raw strings to something else. If uding drizzle, you can pass sql.raw here. So later you can just sql.join the return of the function:
+		 *
+		 * ```ts
+		 * sql.join([
+		 * 	sql.raw(db.select().from(someTable).toSQL().sql),
+		 * 	sql.raw(`where`),
+		 * 	...parser.toSql(ast, sql.raw)
+		 * ], sql` `)
+		 * ```
+		 */
+		wrapStrings?: (value: string) => T,
+	): (ReturnType<TSqlEscapeValue> | typeof wrapStrings extends undefined ? string : T)[] {
+		this._checkEvaluationOptions()
+		const chunks = []
+
+		if (ast.type === AST_TYPE.NORMALIZED_CONDITION) {
+			const prop = ast.property?.[0]
+			const definition = this.propertyDefinitions[prop]
+			const value = ast.value
+			const col = definition.transformToColumn?.(prop, definition.name) ?? `"${prop}"`
+			const op = ast.operator
+			if (ast.negate) {
+				chunks.push(wrapStrings?.(`NOT(`) ?? `NOT(`)
+			}
+			chunks.push(wrapStrings?.(`${col} `) ?? `${col} `)
+			chunks.push(wrapStrings?.(`${op} `) ?? `${op} `)
+			const val = this.sqlEscapeValue(value)
+			if (definition.transformValue) {
+				const transformed = definition.transformValue(val, value)
+				if (Array.isArray(transformed)) {
+					chunks.push(...transformed)
+				} else {
+					chunks.push(transformed)
+				}
+			} else {
+				chunks.push(val)
+			}
+			if (ast.negate) {
+				chunks.push(wrapStrings?.(`)`) ?? `)`)
+			}
+			return chunks
+		}
+		if (ast.type === AST_TYPE.NORMALIZED_EXPRESSION) {
+			const left = this.toSql(ast.left, wrapStrings)
+			const right = this.toSql(ast.right, wrapStrings)
+			const op = ast.operator === TOKEN_TYPE.AND ? "AND" : "OR"
+			chunks.push(wrapStrings?.(`(`) ?? `(`)
+			chunks.push(...left)
+			chunks.push(wrapStrings?.(` ${op} `) ?? ` ${op} `)
+			chunks.push(...right)
+			chunks.push(wrapStrings?.(`)`) ?? `)`)
+			return chunks as any
+		}
+
+		return unreachable()
+	}
+}
+export function createTypeError(prop: string, type: string, isArray: boolean): Error {
+	if (isArray) {
+		return new Error(`Property ${prop} must contain items of type ${type}.`)
+	}
+	return new Error(`Property ${prop} must be of type ${type}.`)
+}
+
+export function convertAndValidateValue(
+	isQuoted: boolean,
+	value: any,
+	prop: string,
+	propertyDefinitions: Record<string, BasePropertyDefinition>,
+	{ isArray = false }: { isArray?: boolean } = {},
+): any {
+	let finalValue: any = value
+	let isFloat = false
+	const propDefinition = propertyDefinitions[prop]
+	
+	if (typeof value === "string" && !isQuoted) {
+		if (finalValue === "true") {
+			finalValue = true
+		} else if (finalValue === "false") {
+			finalValue = false
+		} else {
+			const asNum = parseInt(value, 10)
+			if (!isNaN(asNum)) {
+				finalValue = asNum
+			} else {
+				const asFloat = parseFloat(value)
+				if (!isNaN(asFloat)) {
+					finalValue = asFloat
+					isFloat = true
+				}
+			}
+		}
+	}
+	const type = propDefinition.type
+	finalValue = propDefinition.postParse?.(finalValue) ?? finalValue
+
+	switch (type) {
+		case "integer":
+		case "float": {
+			if (typeof finalValue !== "number" || (type === "float" && !isFloat) || (type === "integer" && isFloat)) {
+				return createTypeError(prop, type, isArray)
+			}
+			break
+		}
+		case "string":
+		case "boolean": {
+			if (typeof finalValue !== propDefinition.type) {
+				return createTypeError(prop, type, isArray)
+			}
+			break
+		}
+		case "date": {
+			if (finalValue instanceof Date) {
+				break
+			}
+			const maybeDate = new Date(finalValue)
+			if (isNaN(maybeDate.getTime())) {
+				return createTypeError(prop, "date", isArray)
+			} else {
+				finalValue = maybeDate
+			}
+			break
+		}
+	}
+	
+	return finalValue
+}

package/src/examples/{shortcutContextParser.ts → ShortcutContextParser.ts}

@@ -1,3 +1,7 @@
+import { Parser } from "../Parser.js"
+import type { Position } from "../types/ast.js"
+import type { ValueQuery } from "../types/parser.js"
+
 /* TODO TOUPDATE */
 /**
  * A pre-configured parser for parsing shortcut contexts (similar to VSCode's [when clause contexts](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts)).
@@ -9,15 +13,11 @@
  * The validate function will return a list of positions with a list of errors which includes handling invalid or duplicate regex flags.
  */
 
-import { Parser } from "../Parser.js"
-import type { Position } from "../types/ast.js"
-import type { ValueQuery } from "../types/parser.js"
-
 
-export class ShortcutContextParser<T extends
+export class ShortcutContextParser<TErrorTokens extends
 	Position & { type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag") } =
 	Position & { type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag") },
-> extends Parser<T> {
+> extends Parser<TErrorTokens> {
 	validKeys: string[] = []
 
 	regexablekeys: string[] = []
@@ -49,21 +49,21 @@ export class ShortcutContextParser<T extends
 				}
 				return contextValue === condition.value
 			},
-			valueValidator: (_contextValue, query): T[] | void => {
-				let tokens: T[] = []
+			valueValidator: (_contextValue, query): TErrorTokens[] | void => {
+				let tokens: TErrorTokens[] = []
 				if (!this.validKeys.includes(query.propertyName!)) {
 					tokens = tokens.concat(query.property.map(token => ({
 						start: token.start,
 						end: token.end,
 						type: "invalidKey",
-					})) as T[])
+					})) as TErrorTokens[])
 				}
 				if (query.isRegex && !this.regexablekeys.includes(query.propertyName!)) {
 					tokens = tokens.concat(query.property.map(token => ({
 						start: token.start,
 						end: token.end,
 						type: "unregexableKey",
-					})) as T[])
+					})) as TErrorTokens[])
 				}
 				if (query.regexFlags) {
 					const chars = query.regexFlags.value.split("")
@@ -75,14 +75,14 @@ export class ShortcutContextParser<T extends
 								start: start + i,
 								end: start + i + 1,
 								type: "duplicateRegexFlag",
-							} as T)
+							} as TErrorTokens)
 						}
 						if (!validRegexFlags.includes(char)) {
 							tokens.push({
 								start: start + i,
 								end: start + i + 1,
 								type: "invalidRegexFlag",
-							} as T)
+							} as TErrorTokens)
 						}
 					}
 				}
@@ -93,7 +93,7 @@ export class ShortcutContextParser<T extends
 				let finalOperator: any = operator
 				// another way to allow special unquoted value types is something like this:
 				if (typeof value === "string" && !isQuoted) {
-					const asNum = parseInt(value, 2)
+					const asNum = parseInt(value, 10)
 					if (!isNaN(asNum)) finalValue = asNum
 					if (["true", "false"].includes(value)) {
 						finalValue = value === "true"
@@ -132,7 +132,7 @@ export class ShortcutContextParser<T extends
 		for (const key of Object.keys(context)) {
 			if (typeof context[key] === "boolean") {
 				this.validKeys.push(prev ? `${prev}.${key}` : key)
-				if (context[key] === true) {
+				if (context[key]) {
 					this.regexablekeys.push(prev ? `${prev}.${key}` : key)
 				}
 			} else {

package/src/examples/index.ts

@@ -1,3 +1,4 @@
 /* Autogenerated Index */
 
-export { ShortcutContextParser } from "./shortcutContextParser.js"
+export { ShortcutContextParser } from "./ShortcutContextParser.js"
+export { ParserWithSqlSupport } from "./ParserWithSqlSupport.js"

package/src/internal/ExpressitError.ts

@@ -3,8 +3,8 @@ import { indent } from "@alanscodelog/utils/indent.js"
 import { pretty } from "@alanscodelog/utils/pretty.js"
 import type { Keys } from "@alanscodelog/utils/types"
 
-// @ts-expect-error todo
-import { repository, version } from "../package.js"
+import packageJson from "../../package.json" assert { type: "json" }
+const { version, repository } = packageJson
 import type { ERROR_CODES, ErrorInfo } from "../types/errors.js"
 
 /** @internal */

package/src/internal/checkParserOpts.ts

@@ -9,7 +9,7 @@ import { ERROR_CODES } from "../types/errors.js"
 import type { FullParserOptions, ParserOptions } from "../types/parser.js"
 
 /** @internal */
-export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evaluatorChecks: boolean = false, validatorChecks: boolean = false): void {
+export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks: boolean = false, validatorChecks: boolean = false): void {
 	if (!evaluatorChecks) {
 		const keywordsList = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].map(keyword => keyword.value)
 		const symNots = opts.keywords.not.filter(op => op.isSymbol).map(op => op.value)
@@ -48,8 +48,8 @@ export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evalua
 			`prefixableStrings cannot contain blank entries`,
 			)
 		}
-		for (const key of ["and", "or", "not"]) {
-			const invalid = opts.keywords[key as keyof FullParserOptions["keywords"]]
+		for (const key of ["and", "or", "not"] as const) {
+			const invalid = opts.keywords[key]
 				?.find(_ => isBlank(_.value))
 				?.value
 			if (invalid !== undefined) {

package/src/internal/parseParserOptions.ts

@@ -5,10 +5,10 @@ import { defaultValueComparer } from "../defaults/defaultValueComparer.js"
 import type { FullParserOptions, ParserOptions } from "../types/parser.js"
 
 /** @internal */
-export function parseParserOptions<T extends {} = {}>(
+export function parseParserOptions<T>(
 	options: ParserOptions<T>,
 ): FullParserOptions<T> {
-	const opts: ParserOptions = {
+	const opts: ParserOptions<T> = {
 		prefixApplier: defaultPrefixApplier,
 		keyParser: defaultKeyParser,
 		valueComparer: defaultValueComparer,

package/src/types/parser.ts

@@ -4,7 +4,7 @@ import type { ArrayNode, ConditionNode, NormalizedCondition, Position, TOKEN_TYP
 
 
 // #partially-synced
-export type FullParserOptions<T extends {} = {}> = MakeRequired<
+export type FullParserOptions<T = any> = MakeRequired<
 	ParserOptions<T>,
 	// makes required all except:
 	Exclude<keyof ParserOptions<T>,
@@ -18,7 +18,7 @@ export type FullParserOptions<T extends {} = {}> = MakeRequired<
 	// overrides
 	keywords: DeepRequired<KeywordOptions>
 }
-export type ParserOptions<T extends {} = {}> = {
+export type ParserOptions<T = any> = {
 	/**
 	 * Allows any conditions (i.e. a variable or negated variable) to precede groups and append themselves to all variables inside them. Regular use of groups for changing precedence (e.g. `(a || b) && c` ) or negating expressions `!(a || b)` is still supported even if `prefixableGroups` is false.
 	 *
@@ -116,7 +116,7 @@ export type ParserOptions<T extends {} = {}> = {
 	/**
 	 * Enables regex strings as values. The value is treated as if it was quoted by forward slashes. Any repetition of lowercase characters (even if there are multiple) attached to the end are assumed to be flags and added as a single token to the value's `quotes.mode` property.
 	 *
-	 * Can be passed a custom function to determine when to use the regex value or not (it is converted to a regular value). The function is passed the property, the operator, and whether it's an expanded operator. If their is an error token for the property or operator, an empty string is passed.
+	 * Can be passed a custom function to determine when to use the regex value or not (it is converted to a regular value). The function is passed the property, the operator, and whether it's an expanded operator. If there is an error token for the property or operator, an empty string is passed.
 	 *
 	 * ```ts
 	 * // allow anything (`prop=/val/`, `prop:op:/val`, `prop=(/val/)`, `prop:op(/val/)`) but the value alone (`/regex/`)
@@ -272,7 +272,7 @@ export type ParserOptions<T extends {} = {}> = {
 	 * ```ts
 	 * type Operators = "contains"
 	 * function valueComparer(condition: Omit<Condition, "negate">, contextValue: any, context: any): boolean {
-	 * 	switch (operator as Operators) {
+	 * 	switch (condition.operator as Operators) {
 	 * 		case "contains": return (contextValue as string[]).includes(condition.value as string)
 	 * 		// ...
 	 * 	}
@@ -307,13 +307,13 @@ export type ParserOptions<T extends {} = {}> = {
 	 * 	if (prefix) {
 	 * 		const val = value as string // it's always a string if prefixed
 	 * 		switch (prefix as RawPrefixes) {
-	 * 			case "num": finalValue = parseInt(val, 2); break
+	 * 			case "num": finalValue = parseInt(val, 10); break
 	 * 			// ...
 	 * 		}
 	 * 	}
 	 * 	// another way to allow special unquoted value types is something like this:
 	 * 	if (typeof value === "string" && !isQuoted) {
-	 * 		const asNum = parseInt(value, 2)
+	 * 		const asNum = parseInt(value, 10)
 	 * 		if (!isNaN(asNum)) finalValue = asNum
 	 * 		if (["true","false"].includes(value)) {
 	 * 			finalValue = value === "true" ? true : false

package/src/utils/getCursorInfo.ts

@@ -56,7 +56,7 @@ export function getCursorInfo(
 			}
 		}
 		if (token.start >= index) {
-			info.next ||= token
+			info.next ??= token
 			if (token.valid && !info.valid.next) {
 				info.valid.next = token
 				break

package/dist/examples/shortcutContextParser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shortcutContextParser.d.ts","sourceRoot":"","sources":["../../src/examples/shortcutContextParser.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAI/C,qBAAa,qBAAqB,CAAC,CAAC,SACnC,QAAQ,GAAG;IAAE,IAAI,EAAE,CAAC,YAAY,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC,CAAA;CAAE,GAClG,QAAQ,GAAG;IAAE,IAAI,EAAE,CAAC,YAAY,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC,CAAA;CAAE,CACjG,SAAQ,MAAM,CAAC,CAAC,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAK;IAExB,aAAa,EAAE,MAAM,EAAE,CAAK;gBAG3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,eAAe,GAAE,MAAM,EAAoB;IAmG5C,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAK9C,OAAO,CAAC,uBAAuB;CAa/B"}

package/dist/global.d.js

@@ -1 +0,0 @@
-

package/dist/package.js

@@ -1,7 +0,0 @@
-import pkg from "./package.json.js";
-const version = pkg.version;
-const repository = pkg.repository;
-export {
-  repository,
-  version
-};

package/src/global.d.ts

@@ -1,4 +0,0 @@
-declare module "./package.js" {
-	export const version: string
-	export const repository: string
-}

package/src/package.js

@@ -1,11 +0,0 @@
-import pkg from "../package.json"
-
-/**
- * This library imports it's own package.json for inserting the version number into errors. Doing this is not a problem normally (because babel is used to transpile the typescript instead of tsc), but when tsc is used to output the types, the output is nested (dist-types/src/*) because of the json import being outside the src dir. There is a way around this but it's complicated. The easier way is to just cheat and do the importing in this js file. Typescript consumes it none the wiser and babel transpiles it to cjs/es accordingly.
- *
- * The values could be inlined, but there are no battle tested actively maintained babel plugins for this, and problems would be hard to debug (given when developing, the package.json never contains the real version because the library is semantically released.)
- */
-
-
-export const version = pkg.version
-export const repository = pkg.repository