@voidhash/mimic 0.0.2 → 0.0.4

package/dist/EffectSchema.mjs

@@ -0,0 +1,176 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { Schema } from "effect";
+
+//#region src/EffectSchema.ts
+/**
+* Effect.Schema utilities for converting Mimic primitives to Effect.Schema schemas.
+* 
+* @since 0.0.1
+*/
+var EffectSchema_exports = /* @__PURE__ */ __export({
+	TreeNodeStateSchema: () => TreeNodeStateSchema,
+	toSetSchema: () => toSetSchema,
+	toUpdateSchema: () => toUpdateSchema
+});
+/**
+* Schema for a tree node state (flat storage format).
+*/
+const TreeNodeStateSchema = Schema.Struct({
+	id: Schema.String,
+	type: Schema.String,
+	parentId: Schema.NullOr(Schema.String),
+	pos: Schema.String,
+	data: Schema.Unknown
+});
+/**
+* Check if a field is required for set operations.
+* A field is required if: TRequired is true AND THasDefault is false.
+* 
+* We determine this by checking the primitive's schema properties.
+*/
+function isRequiredForSet(primitive) {
+	const schema = primitive._schema;
+	if (!schema) return false;
+	return schema.required === true && schema.defaultValue === void 0;
+}
+/**
+* Get the base Effect.Schema for a primitive type (without optional wrapper).
+*/
+function getBaseSchema(primitive) {
+	switch (primitive._tag) {
+		case "StringPrimitive": return Schema.String;
+		case "NumberPrimitive": return Schema.Number;
+		case "BooleanPrimitive": return Schema.Boolean;
+		case "LiteralPrimitive": {
+			var _schema$literal, _schema;
+			const literalPrimitive = primitive;
+			const literalValue = (_schema$literal = (_schema = literalPrimitive._schema) === null || _schema === void 0 ? void 0 : _schema.literal) !== null && _schema$literal !== void 0 ? _schema$literal : literalPrimitive.literal;
+			return Schema.Literal(literalValue);
+		}
+		case "StructPrimitive": return buildStructSetSchema(primitive);
+		case "ArrayPrimitive": {
+			const elementSchema = buildElementSetSchema(primitive.element);
+			return Schema.Array(elementSchema);
+		}
+		case "UnionPrimitive": return buildUnionSetSchema(primitive);
+		case "EitherPrimitive": return buildEitherSchema(primitive);
+		case "LazyPrimitive": {
+			var _resolve, _resolve2;
+			const lazyPrimitive = primitive;
+			return getBaseSchema((_resolve = (_resolve2 = lazyPrimitive._resolve) === null || _resolve2 === void 0 ? void 0 : _resolve2.call(lazyPrimitive)) !== null && _resolve !== void 0 ? _resolve : lazyPrimitive._thunk());
+		}
+		case "TreeNodePrimitive": return buildStructSetSchema(primitive.data);
+		case "TreePrimitive": return Schema.Array(TreeNodeStateSchema);
+		default: return Schema.Unknown;
+	}
+}
+/**
+* Build the set schema for a struct primitive.
+* Required fields (required=true, no default) are non-optional.
+* Other fields are wrapped with Schema.optional.
+*/
+function buildStructSetSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		const baseSchema = getBaseSchema(fieldPrimitive);
+		if (isRequiredForSet(fieldPrimitive)) schemaFields[key] = baseSchema;
+		else schemaFields[key] = Schema.optional(baseSchema);
+	}
+	return Schema.Struct(schemaFields);
+}
+/**
+* Build the update schema for a struct primitive.
+* All fields are optional for partial updates.
+*/
+function buildStructUpdateSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		let fieldSchema;
+		if (fieldPrimitive._tag === "StructPrimitive") fieldSchema = buildStructUpdateSchema(fieldPrimitive);
+		else fieldSchema = getBaseSchema(fieldPrimitive);
+		schemaFields[key] = Schema.optional(fieldSchema);
+	}
+	return Schema.Struct(schemaFields);
+}
+/**
+* Build the set schema for an array element.
+* For struct elements, uses the struct's set input schema.
+*/
+function buildElementSetSchema(elementPrimitive) {
+	if (elementPrimitive._tag === "StructPrimitive") return buildStructSetSchema(elementPrimitive);
+	return getBaseSchema(elementPrimitive);
+}
+/**
+* Build the set schema for a union primitive.
+* Creates a Schema.Union of all variant schemas.
+*/
+function buildUnionSetSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructSetSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Build the schema for an either primitive.
+* Creates a Schema.Union of all scalar variant types.
+*/
+function buildEitherSchema(eitherPrimitive) {
+	const variants = eitherPrimitive.variants;
+	const variantSchemas = [];
+	for (const variant of variants) variantSchemas.push(getBaseSchema(variant));
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Build the update schema for a union primitive.
+* Creates a Schema.Union of all variant update schemas.
+*/
+function buildUnionUpdateSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructUpdateSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return Schema.Union(...variantSchemas);
+}
+/**
+* Get the update schema for a primitive.
+* For structs, all fields are optional (partial updates).
+* For simple primitives, same as set schema.
+*/
+function getUpdateSchema(primitive) {
+	switch (primitive._tag) {
+		case "StructPrimitive": return buildStructUpdateSchema(primitive);
+		case "UnionPrimitive": return buildUnionUpdateSchema(primitive);
+		case "TreeNodePrimitive": return buildStructUpdateSchema(primitive.data);
+		case "LazyPrimitive": {
+			var _resolve3, _resolve4;
+			const lazyPrimitive = primitive;
+			return getUpdateSchema((_resolve3 = (_resolve4 = lazyPrimitive._resolve) === null || _resolve4 === void 0 ? void 0 : _resolve4.call(lazyPrimitive)) !== null && _resolve3 !== void 0 ? _resolve3 : lazyPrimitive._thunk());
+		}
+		default: return getBaseSchema(primitive);
+	}
+}
+function toSetSchema(primitive) {
+	return getBaseSchema(primitive);
+}
+function toUpdateSchema(primitive) {
+	return getUpdateSchema(primitive);
+}
+
+//#endregion
+export { EffectSchema_exports };
+//# sourceMappingURL=EffectSchema.mjs.map

package/dist/EffectSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectSchema.mjs","names":["schemaFields: Record<string, any>","fieldSchema: Schema.Schema<any>","variantSchemas: Schema.Schema<any>[]"],"sources":["../src/EffectSchema.ts"],"sourcesContent":["/**\n * Effect.Schema utilities for converting Mimic primitives to Effect.Schema schemas.\n * \n * @since 0.0.1\n */\nimport { Schema } from \"effect\";\nimport type { AnyPrimitive, InferSetInput, InferUpdateInput } from \"./primitives/shared\";\nimport type { LiteralPrimitive, LiteralValue } from \"./primitives/Literal\";\nimport type { StructPrimitive } from \"./primitives/Struct\";\nimport type { ArrayPrimitive } from \"./primitives/Array\";\nimport type { UnionPrimitive, UnionVariants } from \"./primitives/Union\";\nimport type { EitherPrimitive, ScalarPrimitive } from \"./primitives/Either\";\nimport type { LazyPrimitive } from \"./primitives/Lazy\";\nimport type { TreeNodePrimitive, AnyTreeNodePrimitive } from \"./primitives/TreeNode\";\n\n// =============================================================================\n// Type-level Schema Inference\n// =============================================================================\n\n/**\n * Infer the Effect.Schema type for a primitive's set input.\n */\nexport type ToSetSchema<T extends AnyPrimitive> = Schema.Schema<InferSetInput<T>>;\n\n/**\n * Infer the Effect.Schema type for a primitive's update input.\n */\nexport type ToUpdateSchema<T extends AnyPrimitive> = Schema.Schema<InferUpdateInput<T>>;\n\n/**\n * Type for TreeNode set schema - uses the node's data set input type\n */\nexport type ToTreeNodeSetSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferSetInput<T[\"data\"]>>;\n\n/**\n * Type for TreeNode update schema - uses the node's data update input type\n */\nexport type ToTreeNodeUpdateSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferUpdateInput<T[\"data\"]>>;\n\n// =============================================================================\n// Schema for TreeNodeState\n// =============================================================================\n\n/**\n * Schema for a tree node state (flat storage format).\n */\nexport const TreeNodeStateSchema = Schema.Struct({\n  id: Schema.String,\n  type: Schema.String,\n  parentId: Schema.NullOr(Schema.String),\n  pos: Schema.String,\n  data: Schema.Unknown,\n});\n\n// =============================================================================\n// Internal type for primitives (including those that don't implement full Primitive interface)\n// =============================================================================\n\n/**\n * Internal type for anything that can be converted to a schema.\n * This includes both AnyPrimitive and AnyTreeNodePrimitive.\n */\ntype ConvertiblePrimitive = { _tag: string };\n\n// =============================================================================\n// Runtime Conversion Functions\n// =============================================================================\n\n/**\n * Check if a field is required for set operations.\n * A field is required if: TRequired is true AND THasDefault is false.\n * \n * We determine this by checking the primitive's schema properties.\n */\nfunction isRequiredForSet(primitive: ConvertiblePrimitive): boolean {\n  // Access the private schema to check required and default status\n  const schema = (primitive as any)._schema;\n  if (!schema) return false;\n  \n  return schema.required === true && schema.defaultValue === undefined;\n}\n\n/**\n * Get the base Effect.Schema for a primitive type (without optional wrapper).\n */\nfunction getBaseSchema(primitive: ConvertiblePrimitive): Schema.Schema<any> {\n  switch (primitive._tag) {\n    case \"StringPrimitive\":\n      return Schema.String;\n    \n    case \"NumberPrimitive\":\n      return Schema.Number;\n    \n    case \"BooleanPrimitive\":\n      return Schema.Boolean;\n    \n    case \"LiteralPrimitive\": {\n      const literalPrimitive = primitive as unknown as LiteralPrimitive<LiteralValue, any, any>;\n      const literalValue = (literalPrimitive as any)._schema?.literal ?? (literalPrimitive as any).literal;\n      return Schema.Literal(literalValue);\n    }\n    \n    case \"StructPrimitive\": {\n      const structPrimitive = primitive as unknown as StructPrimitive<Record<string, AnyPrimitive>, any, any>;\n      return buildStructSetSchema(structPrimitive);\n    }\n    \n    case \"ArrayPrimitive\": {\n      const arrayPrimitive = primitive as unknown as ArrayPrimitive<AnyPrimitive, any, any>;\n      const elementSchema = buildElementSetSchema(arrayPrimitive.element);\n      return Schema.Array(elementSchema);\n    }\n    \n    case \"UnionPrimitive\": {\n      const unionPrimitive = primitive as unknown as UnionPrimitive<UnionVariants, any, any, any>;\n      return buildUnionSetSchema(unionPrimitive);\n    }\n    \n    case \"EitherPrimitive\": {\n      const eitherPrimitive = primitive as unknown as EitherPrimitive<readonly ScalarPrimitive[], any, any>;\n      return buildEitherSchema(eitherPrimitive);\n    }\n    \n    case \"LazyPrimitive\": {\n      const lazyPrimitive = primitive as unknown as LazyPrimitive<() => AnyPrimitive>;\n      // Resolve the lazy primitive and get its schema\n      const resolved = (lazyPrimitive as any)._resolve?.() ?? (lazyPrimitive as any)._thunk();\n      return getBaseSchema(resolved);\n    }\n    \n    case \"TreeNodePrimitive\": {\n      const treeNodePrimitive = primitive as unknown as TreeNodePrimitive<string, StructPrimitive<any>, any>;\n      // TreeNode delegates to its data struct\n      return buildStructSetSchema(treeNodePrimitive.data);\n    }\n    \n    case \"TreePrimitive\": {\n      // Tree returns an array of TreeNodeState\n      return Schema.Array(TreeNodeStateSchema);\n    }\n    \n    default:\n      return Schema.Unknown;\n  }\n}\n\n/**\n * Build the set schema for a struct primitive.\n * Required fields (required=true, no default) are non-optional.\n * Other fields are wrapped with Schema.optional.\n */\nfunction buildStructSetSchema(structPrimitive: StructPrimitive<Record<string, AnyPrimitive>, any, any>): Schema.Schema<any> {\n  const fields = structPrimitive.fields;\n  // Use any to avoid complex Schema type constraints\n  const schemaFields: Record<string, any> = {};\n  \n  for (const key in fields) {\n    const fieldPrimitive = fields[key]!;\n    const baseSchema = getBaseSchema(fieldPrimitive);\n    \n    if (isRequiredForSet(fieldPrimitive)) {\n      // Required field - use base schema directly\n      schemaFields[key] = baseSchema;\n    } else {\n      // Optional field - wrap with Schema.optional\n      schemaFields[key] = Schema.optional(baseSchema);\n    }\n  }\n  \n  return Schema.Struct(schemaFields) as any;\n}\n\n/**\n * Build the update schema for a struct primitive.\n * All fields are optional for partial updates.\n */\nfunction buildStructUpdateSchema(structPrimitive: StructPrimitive<Record<string, AnyPrimitive>, any, any>): Schema.Schema<any> {\n  const fields = structPrimitive.fields;\n  // Use any to avoid complex Schema type constraints\n  const schemaFields: Record<string, any> = {};\n  \n  for (const key in fields) {\n    const fieldPrimitive = fields[key]!;\n    // For update, use the update schema for nested structs, otherwise base schema\n    let fieldSchema: Schema.Schema<any>;\n    \n    if (fieldPrimitive._tag === \"StructPrimitive\") {\n      fieldSchema = buildStructUpdateSchema(fieldPrimitive as StructPrimitive<Record<string, AnyPrimitive>, any, any>);\n    } else {\n      fieldSchema = getBaseSchema(fieldPrimitive);\n    }\n    \n    // All fields are optional in update\n    schemaFields[key] = Schema.optional(fieldSchema);\n  }\n  \n  return Schema.Struct(schemaFields) as any;\n}\n\n/**\n * Build the set schema for an array element.\n * For struct elements, uses the struct's set input schema.\n */\nfunction buildElementSetSchema(elementPrimitive: AnyPrimitive): Schema.Schema<any> {\n  if (elementPrimitive._tag === \"StructPrimitive\") {\n    return buildStructSetSchema(elementPrimitive as StructPrimitive<Record<string, AnyPrimitive>, any, any>);\n  }\n  return getBaseSchema(elementPrimitive);\n}\n\n/**\n * Build the set schema for a union primitive.\n * Creates a Schema.Union of all variant schemas.\n */\nfunction buildUnionSetSchema(unionPrimitive: UnionPrimitive<UnionVariants, any, any, any>): Schema.Schema<any> {\n  const variants = unionPrimitive.variants;\n  const variantSchemas: Schema.Schema<any>[] = [];\n  \n  for (const key in variants) {\n    const variantPrimitive = variants[key]!;\n    variantSchemas.push(buildStructSetSchema(variantPrimitive));\n  }\n  \n  if (variantSchemas.length === 0) {\n    return Schema.Unknown;\n  }\n  \n  if (variantSchemas.length === 1) {\n    return variantSchemas[0]!;\n  }\n  \n  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);\n}\n\n/**\n * Build the schema for an either primitive.\n * Creates a Schema.Union of all scalar variant types.\n */\nfunction buildEitherSchema(eitherPrimitive: EitherPrimitive<readonly ScalarPrimitive[], any, any>): Schema.Schema<any> {\n  const variants = eitherPrimitive.variants;\n  const variantSchemas: Schema.Schema<any>[] = [];\n  \n  for (const variant of variants) {\n    variantSchemas.push(getBaseSchema(variant as unknown as ConvertiblePrimitive));\n  }\n  \n  if (variantSchemas.length === 0) {\n    return Schema.Unknown;\n  }\n  \n  if (variantSchemas.length === 1) {\n    return variantSchemas[0]!;\n  }\n  \n  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);\n}\n\n/**\n * Build the update schema for a union primitive.\n * Creates a Schema.Union of all variant update schemas.\n */\nfunction buildUnionUpdateSchema(unionPrimitive: UnionPrimitive<UnionVariants, any, any, any>): Schema.Schema<any> {\n  const variants = unionPrimitive.variants;\n  const variantSchemas: Schema.Schema<any>[] = [];\n  \n  for (const key in variants) {\n    const variantPrimitive = variants[key]!;\n    variantSchemas.push(buildStructUpdateSchema(variantPrimitive));\n  }\n  \n  if (variantSchemas.length === 0) {\n    return Schema.Unknown;\n  }\n  \n  if (variantSchemas.length === 1) {\n    return variantSchemas[0]!;\n  }\n  \n  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);\n}\n\n/**\n * Get the update schema for a primitive.\n * For structs, all fields are optional (partial updates).\n * For simple primitives, same as set schema.\n */\nfunction getUpdateSchema(primitive: ConvertiblePrimitive): Schema.Schema<any> {\n  switch (primitive._tag) {\n    case \"StructPrimitive\": {\n      const structPrimitive = primitive as unknown as StructPrimitive<Record<string, AnyPrimitive>, any, any>;\n      return buildStructUpdateSchema(structPrimitive);\n    }\n    \n    case \"UnionPrimitive\": {\n      const unionPrimitive = primitive as unknown as UnionPrimitive<UnionVariants, any, any, any>;\n      return buildUnionUpdateSchema(unionPrimitive);\n    }\n    \n    case \"TreeNodePrimitive\": {\n      const treeNodePrimitive = primitive as unknown as TreeNodePrimitive<string, StructPrimitive<any>, any>;\n      // TreeNode update delegates to data struct's update schema (all fields optional)\n      return buildStructUpdateSchema(treeNodePrimitive.data);\n    }\n    \n    case \"LazyPrimitive\": {\n      const lazyPrimitive = primitive as unknown as LazyPrimitive<() => AnyPrimitive>;\n      const resolved = (lazyPrimitive as any)._resolve?.() ?? (lazyPrimitive as any)._thunk();\n      return getUpdateSchema(resolved);\n    }\n    \n    default:\n      // For simple primitives, update schema is same as set schema\n      return getBaseSchema(primitive);\n  }\n}\n\n// =============================================================================\n// Public API\n// =============================================================================\n\n/**\n * Convert a Mimic primitive to an Effect.Schema for set operations.\n * \n * The resulting schema:\n * - For structs: required fields (required=true, no default) are non-optional, others are optional\n * - For arrays: uses the element's set schema\n * - For unions: creates a Schema.Union of variant schemas\n * - For TreeNode: delegates to the node's data struct schema\n * - For Tree: returns Schema.Array of TreeNodeState\n * \n * @example\n * ```typescript\n * const UserSchema = Primitive.Struct({\n *   name: Primitive.String().required(),\n *   age: Primitive.Number().default(0),\n *   email: Primitive.String(),\n * });\n * \n * const SetSchema = toSetSchema(UserSchema);\n * // { name: string, age?: number, email?: string }\n * ```\n */\nexport function toSetSchema<T extends AnyPrimitive>(primitive: T): ToSetSchema<T>;\nexport function toSetSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeSetSchema<T>;\nexport function toSetSchema(primitive: ConvertiblePrimitive): Schema.Schema<any> {\n  return getBaseSchema(primitive);\n}\n\n/**\n * Convert a Mimic primitive to an Effect.Schema for update operations.\n * \n * The resulting schema:\n * - For structs: all fields are optional (partial updates)\n * - For unions: all variant fields are optional\n * - For TreeNode: delegates to the node's data struct update schema\n * - For simple primitives: same as set schema\n * \n * @example\n * ```typescript\n * const UserSchema = Primitive.Struct({\n *   name: Primitive.String().required(),\n *   age: Primitive.Number().default(0),\n *   email: Primitive.String(),\n * });\n * \n * const UpdateSchema = toUpdateSchema(UserSchema);\n * // { name?: string, age?: string, email?: string }\n * ```\n */\nexport function toUpdateSchema<T extends AnyPrimitive>(primitive: T): ToUpdateSchema<T>;\nexport function toUpdateSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeUpdateSchema<T>;\nexport function toUpdateSchema(primitive: ConvertiblePrimitive): Schema.Schema<any> {\n  return getUpdateSchema(primitive);\n}\n"],"mappings":"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"}

package/dist/FractionalIndex.cjs

@@ -0,0 +1,365 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let effect = require("effect");
+
+//#region src/FractionalIndex.ts
+function createCharSetDicts(charSet) {
+	const byCode = {};
+	const byChar = {};
+	const length = charSet.length;
+	for (let i = 0; i < length; i++) {
+		const char = charSet[i];
+		if (char === void 0) throw new Error("invalid charSet: missing character at index " + i);
+		byCode[i] = char;
+		byChar[char] = i;
+	}
+	return {
+		byCode,
+		byChar,
+		length
+	};
+}
+function integerLimits(dicts, firstPositive, mostPositive, mostNegative) {
+	return effect.Effect.gen(function* () {
+		const firstPositiveIndex = firstPositive ? dicts.byChar[firstPositive] : Math.ceil(dicts.length / 2);
+		const mostPositiveIndex = mostPositive ? dicts.byChar[mostPositive] : dicts.length - 1;
+		const mostNegativeIndex = mostNegative ? dicts.byChar[mostNegative] : 0;
+		if (firstPositiveIndex === void 0 || mostPositiveIndex === void 0 || mostNegativeIndex === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		if (mostPositiveIndex - firstPositiveIndex < 3) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("mostPositive must be at least 3 characters away from neutral"));
+		if (firstPositiveIndex - mostNegativeIndex < 3) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("mostNegative must be at least 3 characters away from neutral"));
+		const firstPositiveChar = dicts.byCode[firstPositiveIndex];
+		const mostPositiveChar = dicts.byCode[mostPositiveIndex];
+		const firstNegativeChar = dicts.byCode[firstPositiveIndex - 1];
+		const mostNegativeChar = dicts.byCode[mostNegativeIndex];
+		if (firstPositiveChar === void 0 || mostPositiveChar === void 0 || firstNegativeChar === void 0 || mostNegativeChar === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		return {
+			firstPositive: firstPositiveChar,
+			mostPositive: mostPositiveChar,
+			firstNegative: firstNegativeChar,
+			mostNegative: mostNegativeChar
+		};
+	});
+}
+function paddingDict(jitterRange, charSetLength) {
+	const paddingDict$1 = {};
+	for (let i = 0; i < 100; i++) {
+		const value = Math.pow(charSetLength, i);
+		paddingDict$1[i] = value;
+		if (value > jitterRange) break;
+	}
+	return paddingDict$1;
+}
+function validateChars(characters) {
+	if (characters.length < 7) return effect.Effect.fail(/* @__PURE__ */ new Error("charSet must be at least 7 characters long"));
+	if (!(characters.split("").sort().join("") === characters)) return effect.Effect.fail(/* @__PURE__ */ new Error("charSet must be sorted"));
+	return effect.Effect.void;
+}
+function indexCharacterSet(options) {
+	return effect.Effect.gen(function* () {
+		var _options$jitterRange;
+		yield* validateChars(options.chars);
+		const dicts = createCharSetDicts(options.chars);
+		const limits = yield* integerLimits(dicts, options.firstPositive, options.mostPositive, options.mostNegative);
+		const jitterRange = (_options$jitterRange = options.jitterRange) !== null && _options$jitterRange !== void 0 ? _options$jitterRange : Math.floor(Math.pow(dicts.length, 3) / 5);
+		const paddingRange = paddingDict(jitterRange, dicts.length);
+		const first = dicts.byCode[0];
+		const last = dicts.byCode[dicts.length - 1];
+		if (first === void 0 || last === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet"));
+		return {
+			chars: options.chars,
+			byChar: dicts.byChar,
+			byCode: dicts.byCode,
+			length: dicts.length,
+			first,
+			last,
+			firstPositive: limits.firstPositive,
+			mostPositive: limits.mostPositive,
+			firstNegative: limits.firstNegative,
+			mostNegative: limits.mostNegative,
+			jitterRange,
+			paddingDict: paddingRange
+		};
+	});
+}
+let _base62CharSet = null;
+function base62CharSet() {
+	if (_base62CharSet) return _base62CharSet;
+	_base62CharSet = effect.Effect.runSync(indexCharacterSet({
+		chars: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+		firstPositive: "a",
+		mostPositive: "z",
+		mostNegative: "A"
+	}));
+	return _base62CharSet;
+}
+function makeSameLength(a, b, pad, fillChar, forceLength) {
+	const max = forceLength !== null && forceLength !== void 0 ? forceLength : Math.max(a.length, b.length);
+	if (pad === "start") return [a.padStart(max, fillChar), b.padStart(max, fillChar)];
+	return [a.padEnd(max, fillChar), b.padEnd(max, fillChar)];
+}
+function distanceBetween(a, b, charSet) {
+	const indexA = charSet.byChar[a];
+	const indexB = charSet.byChar[b];
+	if (indexA === void 0 || indexB === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character in distance calculation"));
+	return effect.Effect.succeed(Math.abs(indexA - indexB));
+}
+function integerLengthFromSecondLevel(key, direction, charSet) {
+	if (key.length === 0) return effect.Effect.succeed(0);
+	const firstChar = key[0];
+	if (!firstChar || firstChar > charSet.mostPositive || firstChar < charSet.mostNegative) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid firstChar on key"));
+	if (firstChar === charSet.mostPositive && direction === "positive") return effect.Effect.gen(function* () {
+		const totalPositiveRoom = yield* distanceBetween(firstChar, charSet.mostNegative, charSet);
+		const rest = yield* integerLengthFromSecondLevel(key.slice(1), direction, charSet);
+		return totalPositiveRoom + 1 + rest;
+	});
+	if (firstChar === charSet.mostNegative && direction === "negative") return effect.Effect.gen(function* () {
+		const totalNegativeRoom = yield* distanceBetween(firstChar, charSet.mostPositive, charSet);
+		const rest = yield* integerLengthFromSecondLevel(key.slice(1), direction, charSet);
+		return totalNegativeRoom + 1 + rest;
+	});
+	if (direction === "positive") return effect.Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.mostNegative, charSet)) + 2;
+	});
+	else return effect.Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.mostPositive, charSet)) + 2;
+	});
+}
+function integerLength(head, charSet) {
+	if (head.length === 0) return effect.Effect.fail(/* @__PURE__ */ new Error("head cannot be empty"));
+	const firstChar = head[0];
+	if (!firstChar || firstChar > charSet.mostPositive || firstChar < charSet.mostNegative) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid firstChar on key"));
+	if (firstChar === charSet.mostPositive) return effect.Effect.gen(function* () {
+		const firstLevel = yield* distanceBetween(firstChar, charSet.firstPositive, charSet);
+		const rest = yield* integerLengthFromSecondLevel(head.slice(1), "positive", charSet);
+		return firstLevel + 1 + rest;
+	});
+	if (firstChar === charSet.mostNegative) return effect.Effect.gen(function* () {
+		const firstLevel = yield* distanceBetween(firstChar, charSet.firstNegative, charSet);
+		const rest = yield* integerLengthFromSecondLevel(head.slice(1), "negative", charSet);
+		return firstLevel + 1 + rest;
+	});
+	if (firstChar >= charSet.firstPositive) return effect.Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.firstPositive, charSet)) + 2;
+	});
+	else return effect.Effect.gen(function* () {
+		return (yield* distanceBetween(firstChar, charSet.firstNegative, charSet)) + 2;
+	});
+}
+function encodeToCharSet(int, charSet) {
+	if (int === 0) {
+		const zero = charSet.byCode[0];
+		if (zero === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 0"));
+		return effect.Effect.succeed(zero);
+	}
+	let res = "";
+	const max = charSet.length;
+	while (int > 0) {
+		const code = charSet.byCode[int % max];
+		if (code === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character code in encodeToCharSet"));
+		res = code + res;
+		int = Math.floor(int / max);
+	}
+	return effect.Effect.succeed(res);
+}
+function decodeCharSetToNumber(key, charSet) {
+	let res = 0;
+	const length = key.length;
+	const max = charSet.length;
+	for (let i = 0; i < length; i++) {
+		const char = key[i];
+		if (char === void 0) continue;
+		const charIndex = charSet.byChar[char];
+		if (charIndex === void 0) continue;
+		res += charIndex * Math.pow(max, length - i - 1);
+	}
+	return res;
+}
+function addCharSetKeys(a, b, charSet) {
+	const base = charSet.length;
+	const [paddedA, paddedB] = makeSameLength(a, b, "start", charSet.first);
+	const result = [];
+	let carry = 0;
+	for (let i = paddedA.length - 1; i >= 0; i--) {
+		const charA = paddedA[i];
+		const charB = paddedB[i];
+		if (!charA || !charB) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character in addCharSetKeys"));
+		const digitA = charSet.byChar[charA];
+		const digitB = charSet.byChar[charB];
+		if (digitA === void 0 || digitB === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character in addCharSetKeys"));
+		const sum = digitA + digitB + carry;
+		carry = Math.floor(sum / base);
+		const remainder = sum % base;
+		const codeChar = charSet.byCode[remainder];
+		if (codeChar === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character code in addCharSetKeys"));
+		result.unshift(codeChar);
+	}
+	if (carry > 0) {
+		const carryChar = charSet.byCode[carry];
+		if (carryChar === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid carry character code"));
+		result.unshift(carryChar);
+	}
+	return effect.Effect.succeed(result.join(""));
+}
+function subtractCharSetKeys(a, b, charSet, stripLeadingZeros = true) {
+	const base = charSet.length;
+	const [paddedA, paddedB] = makeSameLength(a, b, "start", charSet.first);
+	const result = [];
+	let borrow = 0;
+	for (let i = paddedA.length - 1; i >= 0; i--) {
+		const charA = paddedA[i];
+		const charB = paddedB[i];
+		if (!charA || !charB) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character in subtractCharSetKeys"));
+		let digitA = charSet.byChar[charA];
+		const digitBValue = charSet.byChar[charB];
+		if (digitA === void 0 || digitBValue === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character in subtractCharSetKeys"));
+		const digitB = digitBValue + borrow;
+		if (digitA < digitB) {
+			borrow = 1;
+			digitA += base;
+		} else borrow = 0;
+		const difference = digitA - digitB;
+		const codeChar = charSet.byCode[difference];
+		if (codeChar === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid character code in subtractCharSetKeys"));
+		result.unshift(codeChar);
+	}
+	if (borrow > 0) return effect.Effect.fail(/* @__PURE__ */ new Error("Subtraction result is negative. Ensure a is greater than or equal to b."));
+	while (stripLeadingZeros && result.length > 1 && result[0] === charSet.first) result.shift();
+	return effect.Effect.succeed(result.join(""));
+}
+function incrementKey(key, charSet) {
+	const one = charSet.byCode[1];
+	if (one === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 1"));
+	return addCharSetKeys(key, one, charSet);
+}
+function decrementKey(key, charSet) {
+	const one = charSet.byCode[1];
+	if (one === void 0) return effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing code 1"));
+	return subtractCharSetKeys(key, one, charSet, false);
+}
+function lexicalDistance(a, b, charSet) {
+	const [lower, upper] = makeSameLength(a, b, "end", charSet.first).sort();
+	return effect.Effect.gen(function* () {
+		return decodeCharSetToNumber(yield* subtractCharSetKeys(upper, lower, charSet), charSet);
+	});
+}
+function midPoint(lower, upper, charSet) {
+	return effect.Effect.gen(function* () {
+		let [paddedLower, paddedUpper] = makeSameLength(lower, upper, "end", charSet.first);
+		let distance = yield* lexicalDistance(paddedLower, paddedUpper, charSet);
+		if (distance === 1) {
+			paddedLower = paddedLower.padEnd(paddedLower.length + 1, charSet.first);
+			distance = charSet.length;
+		}
+		const mid = yield* encodeToCharSet(Math.floor(distance / 2), charSet);
+		return yield* addCharSetKeys(paddedLower, mid, charSet);
+	});
+}
+function startKey(charSet) {
+	return charSet.firstPositive + charSet.byCode[0];
+}
+function validInteger(integer, charSet) {
+	return effect.Effect.gen(function* () {
+		return (yield* integerLength(integer, charSet)) === integer.length;
+	});
+}
+function validateOrderKey(orderKey, charSet) {
+	return effect.Effect.gen(function* () {
+		yield* getIntegerPart(orderKey, charSet);
+	});
+}
+function getIntegerPart(orderKey, charSet) {
+	return effect.Effect.gen(function* () {
+		const integerPartLength = yield* integerLength(integerHead(orderKey, charSet), charSet);
+		if (integerPartLength > orderKey.length) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid order key length: " + orderKey));
+		return orderKey.slice(0, integerPartLength);
+	});
+}
+function validateInteger(integer, charSet) {
+	return effect.Effect.gen(function* () {
+		if (!(yield* validInteger(integer, charSet))) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid integer length: " + integer));
+	});
+}
+function integerHead(integer, charSet) {
+	let i = 0;
+	if (integer[0] === charSet.mostPositive) while (integer[i] === charSet.mostPositive) i = i + 1;
+	if (integer[0] === charSet.mostNegative) while (integer[i] === charSet.mostNegative) i = i + 1;
+	return integer.slice(0, i + 1);
+}
+function splitInteger(integer, charSet) {
+	return effect.Effect.gen(function* () {
+		const head = integerHead(integer, {
+			firstPositive: charSet.firstPositive,
+			mostPositive: charSet.mostPositive,
+			firstNegative: charSet.firstNegative,
+			mostNegative: charSet.mostNegative
+		});
+		return [head, integer.slice(head.length)];
+	});
+}
+function incrementIntegerHead(head, charSet) {
+	return effect.Effect.gen(function* () {
+		const inPositiveRange = head >= charSet.firstPositive;
+		const nextHead = yield* incrementKey(head, charSet);
+		const headIsLimitMax = head[head.length - 1] === charSet.mostPositive;
+		const nextHeadIsLimitMax = nextHead[nextHead.length - 1] === charSet.mostPositive;
+		if (inPositiveRange && nextHeadIsLimitMax) return nextHead + charSet.mostNegative;
+		if (!inPositiveRange && headIsLimitMax) return head.slice(0, head.length - 1);
+		return nextHead;
+	});
+}
+function decrementIntegerHead(head, charSet) {
+	return effect.Effect.gen(function* () {
+		const inPositiveRange = head >= charSet.firstPositive;
+		const headIsLimitMin = head[head.length - 1] === charSet.mostNegative;
+		if (inPositiveRange && headIsLimitMin) return yield* decrementKey(head.slice(0, head.length - 1), charSet);
+		if (!inPositiveRange && headIsLimitMin) return head + charSet.mostPositive;
+		return yield* decrementKey(head, charSet);
+	});
+}
+function startOnNewHead(head, limit, charSet) {
+	return effect.Effect.gen(function* () {
+		const newLength = yield* integerLength(head, charSet);
+		const fillCharCode = limit === "upper" ? charSet.length - 1 : 0;
+		const fillChar = charSet.byCode[fillCharCode];
+		if (fillChar === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid fill character code"));
+		return head + fillChar.repeat(newLength - head.length);
+	});
+}
+function incrementInteger(integer, charSet) {
+	return effect.Effect.gen(function* () {
+		yield* validateInteger(integer, charSet);
+		const [head, digs] = yield* splitInteger(integer, charSet);
+		const maxChar = charSet.byCode[charSet.length - 1];
+		if (maxChar === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing max character"));
+		if (digs.split("").some((d) => d !== maxChar)) return head + (yield* incrementKey(digs, charSet));
+		return yield* startOnNewHead(yield* incrementIntegerHead(head, charSet), "lower", charSet);
+	});
+}
+function decrementInteger(integer, charSet) {
+	return effect.Effect.gen(function* () {
+		yield* validateInteger(integer, charSet);
+		const [head, digs] = yield* splitInteger(integer, charSet);
+		const minChar = charSet.byCode[0];
+		if (minChar === void 0) return yield* effect.Effect.fail(/* @__PURE__ */ new Error("invalid charSet: missing min character"));
+		if (digs.split("").some((d) => d !== minChar)) return head + (yield* decrementKey(digs, charSet));
+		return yield* startOnNewHead(yield* decrementIntegerHead(head, charSet), "upper", charSet);
+	});
+}
+/**
+* Generate a key between two other keys.
+* If either lower or upper is null, the key will be generated at the start or end of the list.
+*/
+function generateKeyBetween(lower, upper, charSet = base62CharSet()) {
+	return effect.Effect.gen(function* () {
+		if (lower !== null) yield* validateOrderKey(lower, charSet);
+		if (upper !== null) yield* validateOrderKey(upper, charSet);
+		if (lower === null && upper === null) return startKey(charSet);
+		if (lower === null) return yield* decrementInteger(yield* getIntegerPart(upper, charSet), charSet);
+		if (upper === null) return yield* incrementInteger(yield* getIntegerPart(lower, charSet), charSet);
+		if (lower >= upper) return yield* effect.Effect.fail(/* @__PURE__ */ new Error(lower + " >= " + upper));
+		return yield* midPoint(lower, upper, charSet);
+	});
+}
+
+//#endregion
+exports.base62CharSet = base62CharSet;
+exports.generateKeyBetween = generateKeyBetween;