@bessemer/cornerstone 0.5.0 → 0.5.3

package/dist/expression/numeric-expression.d.ts

@@ -0,0 +1,79 @@
+import { Expression } from '@bessemer/cornerstone/expression';
+import { Maths } from '@bessemer/cornerstone';
+export declare const SumExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [initialOperands: Expression<number>[]], Expression<number> & {
+    operands: Expression<number>[];
+}>;
+export declare const sum: (initialOperands: Expression<number>[]) => Expression<number> & {
+    operands: Expression<number>[];
+};
+export declare const MultiplyExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [initialOperands: Expression<number>[]], Expression<number> & {
+    operands: Expression<number>[];
+}>;
+export declare const multiply: (initialOperands: Expression<number>[]) => Expression<number> & {
+    operands: Expression<number>[];
+};
+export declare const LessThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<number>, right: Expression<number>], Expression<boolean> & {
+    left: Expression<number>;
+    right: Expression<number>;
+}>;
+export declare const lessThan: (left: Expression<number>, right: Expression<number>) => Expression<boolean> & {
+    left: Expression<number>;
+    right: Expression<number>;
+};
+export declare const GreaterThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<number>, right: Expression<number>], Expression<boolean> & {
+    left: Expression<number>;
+    right: Expression<number>;
+}>;
+export declare const greaterThan: (left: Expression<number>, right: Expression<number>) => Expression<boolean> & {
+    left: Expression<number>;
+    right: Expression<number>;
+};
+export declare const BoundsExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null], Expression<number> & {
+    value: Expression<number>;
+    minimumThreshold: Expression<number> | null;
+    maximumThreshold: Expression<number> | null;
+}>;
+export declare const bounds: (value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null) => Expression<number> & {
+    value: Expression<number>;
+    minimumThreshold: Expression<number> | null;
+    maximumThreshold: Expression<number> | null;
+};
+export declare const FloorExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, minimumThreshold: Expression<number> | null], Expression<number> & {
+    value: Expression<number>;
+    minimumThreshold: Expression<number> | null;
+}>;
+export declare const floor: (value: Expression<number>, minimumThreshold: Expression<number> | null) => Expression<number> & {
+    value: Expression<number>;
+    minimumThreshold: Expression<number> | null;
+};
+export declare const CeilingExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, maximumThreshold: Expression<number> | null], Expression<number> & {
+    value: Expression<number>;
+    maximumThreshold: Expression<number> | null;
+}>;
+export declare const ceiling: (value: Expression<number>, maximumThreshold: Expression<number> | null) => Expression<number> & {
+    value: Expression<number>;
+    maximumThreshold: Expression<number> | null;
+};
+export declare const RoundExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, scale: number, roundingMode: Maths.RoundingMode], Expression<number> & {
+    value: Expression<number>;
+    scale: number;
+    roundingMode: Maths.RoundingMode;
+}>;
+export declare const round: (value: Expression<number>, scale: number, roundingMode: Maths.RoundingMode) => Expression<number> & {
+    value: Expression<number>;
+    scale: number;
+    roundingMode: Maths.RoundingMode;
+};
+export declare const MinExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [initialOperands: Expression<number>[]], Expression<number> & {
+    operands: Expression<number>[];
+}>;
+export declare const min: (initialOperands: Expression<number>[]) => Expression<number> & {
+    operands: Expression<number>[];
+};
+export declare const MaxExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [initialOperands: Expression<number>[]], Expression<number> & {
+    operands: Expression<number>[];
+}>;
+export declare const max: (initialOperands: Expression<number>[]) => Expression<number> & {
+    operands: Expression<number>[];
+};
+//# sourceMappingURL=numeric-expression.d.ts.map

package/dist/expression/numeric-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-expression.d.ts","sourceRoot":"","sources":["../../src/expression/numeric-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAC7D,OAAO,EAAE,KAAK,EAAW,MAAM,uBAAuB,CAAA;AAGtD,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,kBAAkB;;EAiB7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;CAA6B,CAAA;AAElD,eAAO,MAAM,kBAAkB;;;EAQ7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;CAA6B,CAAA;AAElD,eAAO,MAAM,qBAAqB;;;EAQhC,CAAA;AAEF,eAAO,MAAM,WAAW;;;CAAgC,CAAA;AAExD,eAAO,MAAM,gBAAgB;;;;EAkB3B,CAAA;AAEF,eAAO,MAAM,MAAM;;;;CAA2B,CAAA;AAE9C,eAAO,MAAM,eAAe;;;EAc1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,iBAAiB;;;EAc5B,CAAA;AAEF,eAAO,MAAM,OAAO;;;CAA4B,CAAA;AAEhD,eAAO,MAAM,eAAe;;;;EAQ1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA"}

package/dist/expression/numeric-expression.js

@@ -0,0 +1,177 @@
+// src/expression/numeric-expression.ts
+import { defineExpression, isType } from "@bessemer/cornerstone/expression/internal";
+import { Maths, Objects } from "@bessemer/cornerstone";
+var SumExpression = defineExpression({
+  expressionKey: "Numeric.Sum",
+  builder: (initialOperands) => {
+    const operands = initialOperands.flatMap((it) => {
+      if (isType(it, SumExpression)) {
+        return it.operands;
+      } else {
+        return [it];
+      }
+    });
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it));
+    return values.reduce((x, y) => x + y, 0);
+  }
+});
+var sum = SumExpression.builder;
+var MultiplyExpression = defineExpression({
+  expressionKey: "Numeric.Multiply",
+  builder: (initialOperands) => {
+    const operands = initialOperands.flatMap((it) => {
+      if (isType(it, MultiplyExpression)) {
+        return it.operands;
+      } else {
+        return [it];
+      }
+    });
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it));
+    return values.reduce((x, y) => x * y, 1);
+  }
+});
+var multiply = MultiplyExpression.builder;
+var LessThanExpression = defineExpression({
+  expressionKey: "Numeric.LessThan",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) < evaluate(right);
+  }
+});
+var lessThan = LessThanExpression.builder;
+var GreaterThanExpression = defineExpression({
+  expressionKey: "Numeric.GreaterThan",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) > evaluate(right);
+  }
+});
+var greaterThan = GreaterThanExpression.builder;
+var BoundsExpression = defineExpression({
+  expressionKey: "Numeric.Bounds",
+  builder: (value, minimumThreshold, maximumThreshold) => {
+    return { value, minimumThreshold, maximumThreshold };
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value);
+    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null;
+    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null;
+    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {
+      value = minimumThreshold;
+    }
+    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {
+      value = maximumThreshold;
+    }
+    return value;
+  }
+});
+var bounds = BoundsExpression.builder;
+var FloorExpression = defineExpression({
+  expressionKey: "Numeric.Floor",
+  builder: (value, minimumThreshold) => {
+    return { value, minimumThreshold };
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value);
+    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null;
+    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {
+      value = minimumThreshold;
+    }
+    return value;
+  }
+});
+var floor = FloorExpression.builder;
+var CeilingExpression = defineExpression({
+  expressionKey: "Numeric.Ceiling",
+  builder: (value, maximumThreshold) => {
+    return { value, maximumThreshold };
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value);
+    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null;
+    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {
+      value = maximumThreshold;
+    }
+    return value;
+  }
+});
+var ceiling = CeilingExpression.builder;
+var RoundExpression = defineExpression({
+  expressionKey: "Numeric.Round",
+  builder: (value, scale, roundingMode) => {
+    return { value, scale, roundingMode };
+  },
+  resolver: ({ value, scale, roundingMode }, evaluate) => {
+    return Maths.round(evaluate(value), scale, roundingMode);
+  }
+});
+var round = RoundExpression.builder;
+var MinExpression = defineExpression({
+  expressionKey: "Numeric.Min",
+  builder: (initialOperands) => {
+    const operands = initialOperands.flatMap((it) => {
+      if (isType(it, MinExpression)) {
+        return it.operands;
+      } else {
+        return [it];
+      }
+    });
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it));
+    return Math.min(...values);
+  }
+});
+var min = MinExpression.builder;
+var MaxExpression = defineExpression({
+  expressionKey: "Numeric.Max",
+  builder: (initialOperands) => {
+    const operands = initialOperands.flatMap((it) => {
+      if (isType(it, MaxExpression)) {
+        return it.operands;
+      } else {
+        return [it];
+      }
+    });
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it));
+    return Math.max(...values);
+  }
+});
+var max = MaxExpression.builder;
+export {
+  BoundsExpression,
+  CeilingExpression,
+  FloorExpression,
+  GreaterThanExpression,
+  LessThanExpression,
+  MaxExpression,
+  MinExpression,
+  MultiplyExpression,
+  RoundExpression,
+  SumExpression,
+  bounds,
+  ceiling,
+  floor,
+  greaterThan,
+  lessThan,
+  max,
+  min,
+  multiply,
+  round,
+  sum
+};
+//# sourceMappingURL=numeric-expression.js.map

package/dist/expression/numeric-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/numeric-expression.ts"],"sourcesContent":["import { defineExpression, isType } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { Maths, Objects } from '@bessemer/cornerstone'\nimport { RoundingMode } from '@bessemer/cornerstone/math'\n\nexport const SumExpression = defineExpression({\n  expressionKey: 'Numeric.Sum',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, SumExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x + y, 0)\n  },\n})\n\nexport const sum = SumExpression.builder\n\nexport const MultiplyExpression = defineExpression({\n  expressionKey: 'Numeric.Multiply',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MultiplyExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x * y, 1)\n  },\n})\n\nexport const multiply = MultiplyExpression.builder\n\nexport const LessThanExpression = defineExpression({\n  expressionKey: 'Numeric.LessThan',\n  builder: (left: Expression<number>, right: Expression<number>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) < evaluate(right)\n  },\n})\n\nexport const lessThan = LessThanExpression.builder\n\nexport const GreaterThanExpression = defineExpression({\n  expressionKey: 'Numeric.GreaterThan',\n  builder: (left: Expression<number>, right: Expression<number>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) > evaluate(right)\n  },\n})\n\nexport const greaterThan = GreaterThanExpression.builder\n\nexport const BoundsExpression = defineExpression({\n  expressionKey: 'Numeric.Bounds',\n  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null) => {\n    return { value, minimumThreshold, maximumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null\n    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const bounds = BoundsExpression.builder\n\nexport const FloorExpression = defineExpression({\n  expressionKey: 'Numeric.Floor',\n  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null) => {\n    return { value, minimumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const floor = FloorExpression.builder\n\nexport const CeilingExpression = defineExpression({\n  expressionKey: 'Numeric.Ceiling',\n  builder: (value: Expression<number>, maximumThreshold: Expression<number> | null) => {\n    return { value, maximumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const ceiling = CeilingExpression.builder\n\nexport const RoundExpression = defineExpression({\n  expressionKey: 'Numeric.Round',\n  builder: (value: Expression<number>, scale: number, roundingMode: RoundingMode) => {\n    return { value, scale, roundingMode }\n  },\n  resolver: ({ value, scale, roundingMode }, evaluate) => {\n    return Maths.round(evaluate(value), scale, roundingMode)\n  },\n})\n\nexport const round = RoundExpression.builder\n\nexport const MinExpression = defineExpression({\n  expressionKey: 'Numeric.Min',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MinExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.min(...values)\n  },\n})\n\nexport const min = MinExpression.builder\n\nexport const MaxExpression = defineExpression({\n  expressionKey: 'Numeric.Max',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MaxExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.max(...values)\n  },\n})\n\nexport const max = MaxExpression.builder\n"],"mappings":"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","names":[]}

package/dist/expression/string-expression.d.ts

@@ -0,0 +1,24 @@
+import { Expression } from '@bessemer/cornerstone/expression';
+export declare const ConcatenateExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<string, [first: Expression<string>, second: Expression<string>], Expression<string> & {
+    first: Expression<string>;
+    second: Expression<string>;
+}>;
+export declare const concatenate: (first: Expression<string>, second: Expression<string>) => Expression<string> & {
+    first: Expression<string>;
+    second: Expression<string>;
+};
+export declare const UppercaseExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<string, [value: Expression<string>], Expression<string> & {
+    value: Expression<string>;
+}>;
+export declare const uppercase: (value: Expression<string>) => Expression<string> & {
+    value: Expression<string>;
+};
+export declare const SubstringExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [string: Expression<string>, substring: Expression<string>], Expression<boolean> & {
+    string: Expression<string>;
+    substring: Expression<string>;
+}>;
+export declare const substring: (string: Expression<string>, substring: Expression<string>) => Expression<boolean> & {
+    string: Expression<string>;
+    substring: Expression<string>;
+};
+//# sourceMappingURL=string-expression.d.ts.map

package/dist/expression/string-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-expression.d.ts","sourceRoot":"","sources":["../../src/expression/string-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAE7D,eAAO,MAAM,qBAAqB;;;EAQhC,CAAA;AAEF,eAAO,MAAM,WAAW;;;CAAgC,CAAA;AAExD,eAAO,MAAM,mBAAmB;;EAQ9B,CAAA;AAEF,eAAO,MAAM,SAAS;;CAA8B,CAAA;AAEpD,eAAO,MAAM,mBAAmB;;;EAQ9B,CAAA;AAEF,eAAO,MAAM,SAAS;;;CAA8B,CAAA"}

package/dist/expression/string-expression.js

@@ -0,0 +1,41 @@
+// src/expression/string-expression.ts
+import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+var ConcatenateExpression = defineExpression({
+  expressionKey: "Concatenate",
+  builder: (first, second) => {
+    return { first, second };
+  },
+  resolver: () => {
+    throw new Error("Not yet implemented");
+  }
+});
+var concatenate = ConcatenateExpression.builder;
+var UppercaseExpression = defineExpression({
+  expressionKey: "Uppercase",
+  builder: (value) => {
+    return { value };
+  },
+  resolver: () => {
+    throw new Error("Not yet implemented");
+  }
+});
+var uppercase = UppercaseExpression.builder;
+var SubstringExpression = defineExpression({
+  expressionKey: "Substring",
+  builder: (string, substring2) => {
+    return { string, substring: substring2 };
+  },
+  resolver: () => {
+    throw new Error("Not yet implemented");
+  }
+});
+var substring = SubstringExpression.builder;
+export {
+  ConcatenateExpression,
+  SubstringExpression,
+  UppercaseExpression,
+  concatenate,
+  substring,
+  uppercase
+};
+//# sourceMappingURL=string-expression.js.map

package/dist/expression/string-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/string-expression.ts"],"sourcesContent":["import { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\n\nexport const ConcatenateExpression = defineExpression({\n  expressionKey: 'Concatenate',\n  builder: (first: Expression<string>, second: Expression<string>) => {\n    return { first, second }\n  },\n  resolver: (): string => {\n    throw new Error('Not yet implemented')\n  },\n})\n\nexport const concatenate = ConcatenateExpression.builder\n\nexport const UppercaseExpression = defineExpression({\n  expressionKey: 'Uppercase',\n  builder: (value: Expression<string>) => {\n    return { value }\n  },\n  resolver: (): string => {\n    throw new Error('Not yet implemented')\n  },\n})\n\nexport const uppercase = UppercaseExpression.builder\n\nexport const SubstringExpression = defineExpression({\n  expressionKey: 'Substring',\n  builder: (string: Expression<string>, substring: Expression<string>) => {\n    return { string, substring }\n  },\n  resolver: (): boolean => {\n    throw new Error('Not yet implemented')\n  },\n})\n\nexport const substring = SubstringExpression.builder\n"],"mappings":";AAAA,SAAS,wBAAwB;AAG1B,IAAM,wBAAwB,iBAAiB;AAAA,EACpD,eAAe;AAAA,EACf,SAAS,CAAC,OAA2B,WAA+B;AAClE,WAAO,EAAE,OAAO,OAAO;AAAA,EACzB;AAAA,EACA,UAAU,MAAc;AACtB,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AACF,CAAC;AAEM,IAAM,cAAc,sBAAsB;AAE1C,IAAM,sBAAsB,iBAAiB;AAAA,EAClD,eAAe;AAAA,EACf,SAAS,CAAC,UAA8B;AACtC,WAAO,EAAE,MAAM;AAAA,EACjB;AAAA,EACA,UAAU,MAAc;AACtB,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AACF,CAAC;AAEM,IAAM,YAAY,oBAAoB;AAEtC,IAAM,sBAAsB,iBAAiB;AAAA,EAClD,eAAe;AAAA,EACf,SAAS,CAAC,QAA4BA,eAAkC;AACtE,WAAO,EAAE,QAAQ,WAAAA,WAAU;AAAA,EAC7B;AAAA,EACA,UAAU,MAAe;AACvB,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AACF,CAAC;AAEM,IAAM,YAAY,oBAAoB;","names":["substring"]}

package/dist/expression.d.ts

@@ -0,0 +1,35 @@
+import * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression';
+import * as StringExpressions from '@bessemer/cornerstone/expression/string-expression';
+import * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression';
+import * as Expressions from '@bessemer/cornerstone/expression/expression';
+import { NominalType } from '@bessemer/cornerstone/types';
+import { Signable } from '@bessemer/cornerstone/signature';
+import { UnknownRecord } from 'type-fest';
+export { Expressions, NumericExpressions, StringExpressions, ArrayExpressions };
+export type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>;
+export type Expression<ReturnType> = ReturnType | IExpression<ReturnType>;
+export interface IExpression<ReturnType> {
+    expressionKey: ExpressionKey<ReturnType, Array<unknown>>;
+}
+export interface ExpressionReference<ReturnType, ArgumentType extends Array<unknown>> {
+    expressionKey: ExpressionKey<ReturnType, ArgumentType>;
+}
+export interface ReducingExpression<ReturnType, ArgumentType> extends ExpressionReference<ReturnType, [Array<Expression<ArgumentType>>]> {
+}
+export type EvaluateExpression = <T>(expression: Expression<T>) => T;
+export type ExpressionDefinition<ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>> = ExpressionReference<ReturnType, ArgumentType> & {
+    expressionKey: ExpressionKey<ReturnType, ArgumentType>;
+    builder: (...parameters: ArgumentType) => ExpressionType;
+    resolver: (expression: ExpressionType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType;
+};
+export interface ExpressionVariable<T> extends IExpression<T> {
+    expressionKey: 'Variable';
+    name: string;
+}
+export interface ParameterizedVariable<ValueType, ParameterType extends Array<Signable>> {
+    apply(...parameters: ParameterType): ExpressionVariable<ValueType>;
+}
+export type ExpressionContext = {
+    variables: UnknownRecord;
+};
+//# sourceMappingURL=expression.d.ts.map

package/dist/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../src/expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,kBAAkB,MAAM,qDAAqD,CAAA;AACzF,OAAO,KAAK,iBAAiB,MAAM,oDAAoD,CAAA;AACvF,OAAO,KAAK,gBAAgB,MAAM,mDAAmD,CAAA;AACrF,OAAO,KAAK,WAAW,MAAM,6CAA6C,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAA;AAE/E,MAAM,MAAM,aAAa,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC,eAAe,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAA;AAE7I,MAAM,MAAM,UAAU,CAAC,UAAU,IAAI,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;AAEzE,MAAM,WAAW,WAAW,CAAC,UAAU;IACrC,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC;IAClF,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;CACvD;AAED,MAAM,WAAW,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAE,SAAQ,mBAAmB,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAAG;AAE3I,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;AAEpE,MAAM,MAAM,oBAAoB,CAC9B,UAAU,EACV,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACnC,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,IAC3C,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG;IAClD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,cAAc,CAAA;IACxD,QAAQ,EAAE,CAAC,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC/G,CAAA;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC3D,aAAa,EAAE,UAAU,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,qBAAqB,CAAC,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC;IACrF,KAAK,CAAC,GAAG,UAAU,EAAE,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;CACnE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,aAAa,CAAA;CACzB,CAAA"}

package/dist/expression.js

@@ -0,0 +1,12 @@
+// src/expression.ts
+import * as NumericExpressions from "@bessemer/cornerstone/expression/numeric-expression";
+import * as StringExpressions from "@bessemer/cornerstone/expression/string-expression";
+import * as ArrayExpressions from "@bessemer/cornerstone/expression/array-expression";
+import * as Expressions from "@bessemer/cornerstone/expression/expression";
+export {
+  ArrayExpressions,
+  Expressions,
+  NumericExpressions,
+  StringExpressions
+};
+//# sourceMappingURL=expression.js.map

package/dist/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/expression.ts"],"sourcesContent":["import * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression'\nimport * as StringExpressions from '@bessemer/cornerstone/expression/string-expression'\nimport * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression'\nimport * as Expressions from '@bessemer/cornerstone/expression/expression'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { UnknownRecord } from 'type-fest'\n\nexport { Expressions, NumericExpressions, StringExpressions, ArrayExpressions }\n\nexport type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>\n\nexport type Expression<ReturnType> = ReturnType | IExpression<ReturnType>\n\nexport interface IExpression<ReturnType> {\n  expressionKey: ExpressionKey<ReturnType, Array<unknown>>\n}\n\nexport interface ExpressionReference<ReturnType, ArgumentType extends Array<unknown>> {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n}\n\nexport interface ReducingExpression<ReturnType, ArgumentType> extends ExpressionReference<ReturnType, [Array<Expression<ArgumentType>>]> {}\n\nexport type EvaluateExpression = <T>(expression: Expression<T>) => T\n\nexport type ExpressionDefinition<\n  ReturnType,\n  ArgumentType extends Array<unknown>,\n  ExpressionType extends Expression<ReturnType>\n> = ExpressionReference<ReturnType, ArgumentType> & {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => ExpressionType\n  resolver: (expression: ExpressionType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}\n\nexport interface ExpressionVariable<T> extends IExpression<T> {\n  expressionKey: 'Variable'\n  name: string\n}\n\nexport interface ParameterizedVariable<ValueType, ParameterType extends Array<Signable>> {\n  apply(...parameters: ParameterType): ExpressionVariable<ValueType>\n}\n\nexport type ExpressionContext = {\n  variables: UnknownRecord\n}\n"],"mappings":";AAAA,YAAY,wBAAwB;AACpC,YAAY,uBAAuB;AACnC,YAAY,sBAAsB;AAClC,YAAY,iBAAiB;","names":[]}

package/dist/function.d.ts

@@ -0,0 +1,2 @@
+export declare const isFunction: (value: any) => value is (...args: any[]) => any;
+//# sourceMappingURL=function.d.ts.map

package/dist/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,4BAC87rB,GAAG,mBADn7rB,CAAA"}

package/dist/function.js

@@ -0,0 +1,7 @@
+// src/function.ts
+import { isFunction as _isFunction } from "lodash-es";
+var isFunction = _isFunction;
+export {
+  isFunction
+};
+//# sourceMappingURL=function.js.map

package/dist/function.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/function.ts"],"sourcesContent":["import { isFunction as _isFunction } from 'lodash-es'\n\nexport const isFunction = _isFunction\n"],"mappings":";AAAA,SAAS,cAAc,mBAAmB;AAEnC,IAAM,aAAa;","names":[]}

package/dist/glob.d.ts

@@ -0,0 +1,8 @@
+import { NominalType } from '@bessemer/cornerstone/types';
+import { ZodType } from 'zod';
+export type GlobPattern = NominalType<string, 'GlobPattern'>;
+export declare const GlobPatternSchema: ZodType<GlobPattern>;
+export declare const schema: () => ZodType<GlobPattern>;
+export declare const match: (str: string, pattern: GlobPattern) => boolean;
+export declare const anyMatch: (str: string, patterns: Array<GlobPattern>) => boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAG7B,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAC5D,eAAO,MAAM,iBAAiB,EAAE,OAAO,CAAC,WAAW,CAAY,CAAA;AAE/D,eAAO,MAAM,MAAM,QAAO,OAAO,CAAC,WAAW,CAE5C,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,KAAK,MAAM,EAAE,SAAS,WAAW,KAAG,OAEzD,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,UAAU,KAAK,CAAC,WAAW,CAAC,KAAG,OAEpE,CAAA"}

package/dist/glob.js

@@ -0,0 +1,20 @@
+// src/glob.ts
+import { minimatch } from "minimatch";
+import { string } from "@bessemer/cornerstone/zod";
+var GlobPatternSchema = string();
+var schema = () => {
+  return string();
+};
+var match = (str, pattern) => {
+  return minimatch(str, pattern);
+};
+var anyMatch = (str, patterns) => {
+  return patterns.some((it) => match(str, it));
+};
+export {
+  GlobPatternSchema,
+  anyMatch,
+  match,
+  schema
+};
+//# sourceMappingURL=glob.js.map

package/dist/glob.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/glob.ts"],"sourcesContent":["import { minimatch } from 'minimatch'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { ZodType } from 'zod'\nimport { string } from '@bessemer/cornerstone/zod'\n\nexport type GlobPattern = NominalType<string, 'GlobPattern'>\nexport const GlobPatternSchema: ZodType<GlobPattern> = string()\n\nexport const schema = (): ZodType<GlobPattern> => {\n  return string()\n}\n\nexport const match = (str: string, pattern: GlobPattern): boolean => {\n  return minimatch(str, pattern)\n}\n\nexport const anyMatch = (str: string, patterns: Array<GlobPattern>): boolean => {\n  return patterns.some((it) => match(str, it))\n}\n"],"mappings":";AAAA,SAAS,iBAAiB;AAG1B,SAAS,cAAc;AAGhB,IAAM,oBAA0C,OAAO;AAEvD,IAAM,SAAS,MAA4B;AAChD,SAAO,OAAO;AAChB;AAEO,IAAM,QAAQ,CAAC,KAAa,YAAkC;AACnE,SAAO,UAAU,KAAK,OAAO;AAC/B;AAEO,IAAM,WAAW,CAAC,KAAa,aAA0C;AAC9E,SAAO,SAAS,KAAK,CAAC,OAAO,MAAM,KAAK,EAAE,CAAC;AAC7C;","names":[]}

package/dist/global-variable.d.ts

@@ -0,0 +1,7 @@
+import { LazyValue } from '@bessemer/cornerstone/lazy';
+export type GlobalVariable<T> = {
+    getValue: () => T;
+    setValue: (value: T) => void;
+};
+export declare const createGlobalVariable: <T>(key: string, defaultValue: LazyValue<T>) => GlobalVariable<T>;
+//# sourceMappingURL=global-variable.d.ts.map

package/dist/global-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-variable.d.ts","sourceRoot":"","sources":["../src/global-variable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAIhE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,QAAQ,EAAE,MAAM,CAAC,CAAA;IACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;CAC7B,CAAA;AAeD,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,KAAK,MAAM,EAAE,cAAc,SAAS,CAAC,CAAC,CAAC,KAAG,cAAc,CAAC,CAAC,CAiBjG,CAAA"}

package/dist/global-variable.js

@@ -0,0 +1,34 @@
+// src/global-variable.ts
+import { evaluate } from "@bessemer/cornerstone/lazy";
+import { isUndefined } from "@bessemer/cornerstone/object";
+var Global;
+if (typeof window !== "undefined") {
+  Global = window;
+} else if (typeof global !== "undefined") {
+  Global = global;
+} else {
+  Global = globalThis;
+}
+if (isUndefined(Global.BessemerGlobalVariables)) {
+  Global.BessemerGlobalVariables = {};
+}
+var createGlobalVariable = (key, defaultValue) => {
+  return {
+    getValue: () => {
+      const value = Global.BessemerGlobalVariables[key];
+      if (isUndefined(value)) {
+        const def = evaluate(defaultValue);
+        Global.BessemerGlobalVariables[key] = def;
+        return def;
+      }
+      return value;
+    },
+    setValue: (value) => {
+      Global.BessemerGlobalVariables[key] = value;
+    }
+  };
+};
+export {
+  createGlobalVariable
+};
+//# sourceMappingURL=global-variable.js.map

package/dist/global-variable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/global-variable.ts"],"sourcesContent":["import { evaluate, LazyValue } from '@bessemer/cornerstone/lazy'\nimport { isUndefined } from '@bessemer/cornerstone/object'\nimport { UnknownRecord } from 'type-fest'\n\nexport type GlobalVariable<T> = {\n  getValue: () => T\n  setValue: (value: T) => void\n}\n\nlet Global: { BessemerGlobalVariables: UnknownRecord }\nif (typeof window !== 'undefined') {\n  Global = window as any\n} else if (typeof global !== 'undefined') {\n  Global = global as any\n} else {\n  Global = globalThis as any\n}\n\nif (isUndefined(Global.BessemerGlobalVariables)) {\n  Global.BessemerGlobalVariables = {}\n}\n\nexport const createGlobalVariable = <T>(key: string, defaultValue: LazyValue<T>): GlobalVariable<T> => {\n  return {\n    getValue: () => {\n      const value = Global.BessemerGlobalVariables[key] as T | undefined\n\n      if (isUndefined(value)) {\n        const def = evaluate(defaultValue)\n        Global.BessemerGlobalVariables[key] = def\n        return def\n      }\n\n      return value\n    },\n    setValue: (value: T) => {\n      Global.BessemerGlobalVariables[key] = value\n    },\n  }\n}\n"],"mappings":";AAAA,SAAS,gBAA2B;AACpC,SAAS,mBAAmB;AAQ5B,IAAI;AACJ,IAAI,OAAO,WAAW,aAAa;AACjC,WAAS;AACX,WAAW,OAAO,WAAW,aAAa;AACxC,WAAS;AACX,OAAO;AACL,WAAS;AACX;AAEA,IAAI,YAAY,OAAO,uBAAuB,GAAG;AAC/C,SAAO,0BAA0B,CAAC;AACpC;AAEO,IAAM,uBAAuB,CAAI,KAAa,iBAAkD;AACrG,SAAO;AAAA,IACL,UAAU,MAAM;AACd,YAAM,QAAQ,OAAO,wBAAwB,GAAG;AAEhD,UAAI,YAAY,KAAK,GAAG;AACtB,cAAM,MAAM,SAAS,YAAY;AACjC,eAAO,wBAAwB,GAAG,IAAI;AACtC,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,UAAa;AACtB,aAAO,wBAAwB,GAAG,IAAI;AAAA,IACxC;AAAA,EACF;AACF;","names":[]}

package/dist/hash.d.ts

@@ -0,0 +1,11 @@
+import { TaggedType } from '@bessemer/cornerstone/types';
+export type Hash = TaggedType<string, 'Hash'>;
+export declare enum HashAlgorithm {
+    SHA1 = "SHA-1",
+    SHA256 = "SHA-256"
+}
+export declare const asString: (value: Hash) => string;
+export declare const insecureHash: (message: string) => Promise<Hash>;
+export declare const secureHash: (message: string) => Promise<Hash>;
+export declare const hash: (message: string, algorithm: HashAlgorithm) => Promise<Hash>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAExD,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7C,oBAAY,aAAa;IACvB,IAAI,UAAU;IACd,MAAM,YAAY;CACnB;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,IAAI,KAAG,MAEtC,CAAA;AAED,eAAO,MAAM,YAAY,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAEhE,CAAA;AAED,eAAO,MAAM,UAAU,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAE9D,CAAA;AAED,eAAO,MAAM,IAAI,GAAU,SAAS,MAAM,EAAE,WAAW,aAAa,KAAG,OAAO,CAAC,IAAI,CAMlF,CAAA"}

package/dist/hash.js

@@ -0,0 +1,30 @@
+// src/hash.ts
+var HashAlgorithm = /* @__PURE__ */ ((HashAlgorithm2) => {
+  HashAlgorithm2["SHA1"] = "SHA-1";
+  HashAlgorithm2["SHA256"] = "SHA-256";
+  return HashAlgorithm2;
+})(HashAlgorithm || {});
+var asString = (value) => {
+  return value;
+};
+var insecureHash = async (message) => {
+  return hash(message, "SHA-1" /* SHA1 */);
+};
+var secureHash = async (message) => {
+  return hash(message, "SHA-256" /* SHA256 */);
+};
+var hash = async (message, algorithm) => {
+  const msgBuffer = new TextEncoder().encode(message);
+  const hashBuffer = await crypto.subtle.digest(algorithm, msgBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+};
+export {
+  HashAlgorithm,
+  asString,
+  hash,
+  insecureHash,
+  secureHash
+};
+//# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hash.ts"],"sourcesContent":["import { TaggedType } from '@bessemer/cornerstone/types'\n\nexport type Hash = TaggedType<string, 'Hash'>\n\nexport enum HashAlgorithm {\n  SHA1 = 'SHA-1',\n  SHA256 = 'SHA-256',\n}\n\nexport const asString = (value: Hash): string => {\n  return value\n}\n\nexport const insecureHash = async (message: string): Promise<Hash> => {\n  return hash(message, HashAlgorithm.SHA1)\n}\n\nexport const secureHash = async (message: string): Promise<Hash> => {\n  return hash(message, HashAlgorithm.SHA256)\n}\n\nexport const hash = async (message: string, algorithm: HashAlgorithm): Promise<Hash> => {\n  const msgBuffer = new TextEncoder().encode(message)\n  const hashBuffer = await crypto.subtle.digest(algorithm, msgBuffer)\n  const hashArray = Array.from(new Uint8Array(hashBuffer))\n  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')\n  return hashHex as Hash\n}\n"],"mappings":";AAIO,IAAK,gBAAL,kBAAKA,mBAAL;AACL,EAAAA,eAAA,UAAO;AACP,EAAAA,eAAA,YAAS;AAFC,SAAAA;AAAA,GAAA;AAKL,IAAM,WAAW,CAAC,UAAwB;AAC/C,SAAO;AACT;AAEO,IAAM,eAAe,OAAO,YAAmC;AACpE,SAAO,KAAK,SAAS,kBAAkB;AACzC;AAEO,IAAM,aAAa,OAAO,YAAmC;AAClE,SAAO,KAAK,SAAS,sBAAoB;AAC3C;AAEO,IAAM,OAAO,OAAO,SAAiB,cAA4C;AACtF,QAAM,YAAY,IAAI,YAAY,EAAE,OAAO,OAAO;AAClD,QAAM,aAAa,MAAM,OAAO,OAAO,OAAO,WAAW,SAAS;AAClE,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,UAAU,CAAC;AACvD,QAAM,UAAU,UAAU,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC7E,SAAO;AACT;","names":["HashAlgorithm"]}

package/dist/hex-code.d.ts

@@ -0,0 +1,5 @@
+import { NominalType } from '@bessemer/cornerstone/types';
+import { ZodType } from 'zod';
+export type HexCode = NominalType<string, 'HexCode'>;
+export declare const HexCodeSchema: ZodType<HexCode>;
+//# sourceMappingURL=hex-code.d.ts.map

package/dist/hex-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex-code.d.ts","sourceRoot":"","sources":["../src/hex-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAE7B,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AACpD,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,OAAO,CAA2F,CAAA"}

package/dist/hex-code.js

@@ -0,0 +1,7 @@
+// src/hex-code.ts
+import { Zod } from "@bessemer/cornerstone/index";
+var HexCodeSchema = Zod.string().length(7).startsWith("#").describe("A 6-digit hex code starting a # sign");
+export {
+  HexCodeSchema
+};
+//# sourceMappingURL=hex-code.js.map

package/dist/hex-code.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hex-code.ts"],"sourcesContent":["import { NominalType } from '@bessemer/cornerstone/types'\nimport { Zod } from '@bessemer/cornerstone/index'\nimport { ZodType } from 'zod'\n\nexport type HexCode = NominalType<string, 'HexCode'>\nexport const HexCodeSchema: ZodType<HexCode> = Zod.string().length(7).startsWith('#').describe('A 6-digit hex code starting a # sign')\n"],"mappings":";AACA,SAAS,WAAW;AAIb,IAAM,gBAAkC,IAAI,OAAO,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,EAAE,SAAS,sCAAsC;","names":[]}