@samva/markup 0.4.0 → 0.6.0

package/dist/interpolate.js

@@ -1,22 +1,4 @@
-import { Schema } from "effect";
 //#region src/interpolate.ts
-const limitedString = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength));
-const DocumentVariableTypeSchema = Schema.Literals([
-	"string",
-	"number",
-	"boolean",
-	"date",
-	"array",
-	"object"
-]);
-/** One entry of a template's declared variable schema. */
-const DocumentVariableSchema = Schema.Struct({
-	name: limitedString(128),
-	type: DocumentVariableTypeSchema,
-	required: Schema.Boolean,
-	default: Schema.optional(Schema.Unknown),
-	description: Schema.optional(limitedString(512))
-});
 const variableReferencePattern = /\$\{\s*\/?([\w.]+)\s*\}|\{\{\s*([\w.]+)\s*\}\}/g;
 const getVariableValue = (variables, variableSchema, name) => {
 	const schema = variableSchema.find((item) => item.name === name);
@@ -56,6 +38,6 @@ const addVariableReferences = (target, text) => {
 	variableReferences(text).forEach((name) => target.add(name));
 };
 //#endregion
-export { DocumentVariableSchema, DocumentVariableTypeSchema, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
+export { addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
 
 //# sourceMappingURL=interpolate.js.map

package/dist/jsx-dev-runtime.d.ts

@@ -1,5 +1,5 @@
-import { r as JsxSource } from "./source-locations-BCJQnIfU.js";
-import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-C5k_Zq0A.js";
+import { r as JsxSource } from "./source-locations-DrCM82Ym.js";
+import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-I-1nCtl2.js";
 //#region src/jsx-dev-runtime.d.ts
 interface JsxDevProps {
   readonly children?: unknown;

package/dist/{jsx-runtime-C5k_Zq0A.d.ts → jsx-runtime-I-1nCtl2.d.ts}

@@ -1,5 +1,5 @@
-import { E as SmlNode, m as ElementNode, n as Attribute } from "./ast-63I-VLQx.js";
-import { s as VariableRef } from "./variables-if1VrV34.js";
+import { f as ElementNode, n as Attribute, x as SmlNode } from "./ast-BrDtApwS.js";
+import { s as VariableRef } from "./variables-J_L3qxRa.js";
 //#region src/jsx-runtime.d.ts
 /** A component is a plain function of its props that returns a draft node. */
 type Component<P> = (props: P) => SmlNode;
@@ -54,4 +54,4 @@ declare namespace JSX {
 }
 //#endregion
 export { JsxResult as a, elementDraft as c, normalizeChildren as d, JSX as i, jsx as l, Fragment as n, SmlChild as o, FragmentDraft as r, SmlChildren as s, Component as t, jsxs as u };
-//# sourceMappingURL=jsx-runtime-C5k_Zq0A.d.ts.map
+//# sourceMappingURL=jsx-runtime-I-1nCtl2.d.ts.map

package/dist/jsx-runtime.d.ts

@@ -1,2 +1,2 @@
-import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-C5k_Zq0A.js";
+import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-I-1nCtl2.js";
 export { Component, Fragment, FragmentDraft, JSX, JsxResult, SmlChild, SmlChildren, elementDraft, jsx, jsxs, normalizeChildren };

package/dist/jsx-runtime.js

@@ -1,14 +1,14 @@
+import { t as hasProperty } from "./guards-eV1qLbf2.js";
 import { JSX_SOURCE_LOCATION_PROP, attachJsxSourceLocation, completeJsxSourceLocation } from "./source-locations.js";
 import { VARIABLE_REF, isVariableRef } from "./variables.js";
-import { Predicate } from "effect";
 //#region src/jsx-runtime.ts
 const PLACEHOLDER_SPAN = {
 	start: 0,
 	end: 0
 };
-const isFragmentDraft = (value) => Predicate.hasProperty(value, "kind") && value.kind === "fragment";
+const isFragmentDraft = (value) => hasProperty(value, "kind") && value.kind === "fragment";
 const isSmlNode = (value) => {
-	if (!Predicate.hasProperty(value, "kind")) return false;
+	if (!hasProperty(value, "kind")) return false;
 	const kind = value.kind;
 	return kind === "element" || kind === "text" || kind === "interpolation";
 };

package/dist/lexer.js

@@ -21,6 +21,7 @@ const CHAR_UNDERSCORE = 95;
 const CHAR_0 = 48;
 const CHAR_9 = 57;
 const CHAR_UPPER_A = 65;
+const CHAR_UPPER_X = 88;
 const CHAR_UPPER_Z = 90;
 const CHAR_LOWER_A = 97;
 const CHAR_LOWER_X = 120;
@@ -60,6 +61,10 @@ const NAMED_ENTITIES = {
 	apos: "'",
 	nbsp: "\xA0"
 };
+const numericEntityCodePoint = (digits, radix) => {
+	const codePoint = Number.parseInt(digits, radix);
+	return Number.isFinite(codePoint) && codePoint <= 1114111 ? codePoint : void 0;
+};
 /**
 * Validates the entity starting at `offset` (which points at `&`).
 * Returns the end offset (past `;`) or -1 when malformed.
@@ -68,7 +73,8 @@ const scanEntity = (source, offset) => {
 	let index = offset + 1;
 	if (source.charCodeAt(index) === CHAR_HASH) {
 		index++;
-		const hex = source.charCodeAt(index) === CHAR_LOWER_X;
+		const marker = source.charCodeAt(index);
+		const hex = marker === CHAR_LOWER_X || marker === CHAR_UPPER_X;
 		if (hex) index++;
 		const digitsStart = index;
 		while (index < source.length) {
@@ -77,11 +83,13 @@ const scanEntity = (source, offset) => {
 			index++;
 		}
 		if (index === digitsStart) return -1;
+		if (numericEntityCodePoint(source.slice(digitsStart, index), hex ? 16 : 10) === void 0) return -1;
 		return source.charCodeAt(index) === CHAR_SEMICOLON ? index + 1 : -1;
 	}
 	const nameStart = index;
 	while (index < source.length && isLetter(source.charCodeAt(index))) index++;
-	if (!(source.slice(nameStart, index) in NAMED_ENTITIES)) return -1;
+	const name = source.slice(nameStart, index);
+	if (!Object.hasOwn(NAMED_ENTITIES, name)) return -1;
 	return source.charCodeAt(index) === CHAR_SEMICOLON ? index + 1 : -1;
 };
 /** Decodes entities in text that already passed `scanEntity` validation. */
@@ -102,9 +110,13 @@ const decodeEntities = (raw) => {
 			break;
 		}
 		const body = raw.slice(ampersand + 1, semicolon);
-		if (body.startsWith("#x") || body.startsWith("#X")) result += String.fromCodePoint(Number.parseInt(body.slice(2), 16));
-		else if (body.startsWith("#")) result += String.fromCodePoint(Number.parseInt(body.slice(1), 10));
-		else result += NAMED_ENTITIES[body];
+		if (body.startsWith("#x") || body.startsWith("#X")) {
+			const codePoint = numericEntityCodePoint(body.slice(2), 16);
+			result += codePoint === void 0 ? raw.slice(ampersand, semicolon + 1) : String.fromCodePoint(codePoint);
+		} else if (body.startsWith("#")) {
+			const codePoint = numericEntityCodePoint(body.slice(1), 10);
+			result += codePoint === void 0 ? raw.slice(ampersand, semicolon + 1) : String.fromCodePoint(codePoint);
+		} else result += Object.hasOwn(NAMED_ENTITIES, body) ? NAMED_ENTITIES[body] : raw.slice(ampersand, semicolon + 1);
 		index = semicolon + 1;
 	}
 	return result;

package/dist/model.d.ts

@@ -1,39 +1,24 @@
-import { O as SmlTag, w as SmlDocument } from "./ast-63I-VLQx.js";
-import { Result, Schema } from "effect";
+import { S as SmlTag, b as SmlDocument } from "./ast-BrDtApwS.js";
+import { Result } from "better-result";
 //#region src/model.d.ts
-declare const SmlNodeKeyAttrsSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-declare const SmlNodeIndexEntrySchema: Schema.Struct<{
-  readonly id: Schema.String;
-  readonly tag: Schema.String;
-  readonly order: Schema.Finite;
-  readonly parentId: Schema.NullOr<Schema.String>;
-  readonly childIndex: Schema.Finite;
-  readonly depth: Schema.Finite;
-  readonly path: Schema.String;
-  readonly textPreview: Schema.String;
-  readonly attrs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-}>;
-type SmlNodeIndexEntry = typeof SmlNodeIndexEntrySchema.Type & {
+/** The subset of an element's attributes the navigator and agent tools read. */
+type SmlNodeKeyAttrs = Readonly<Record<string, string | number>>;
+interface SmlNodeIndexEntry {
+  readonly id: string;
   readonly tag: SmlTag;
-};
-declare const SmlNodeIndexSchema: Schema.Struct<{
-  readonly nodes: Schema.$Array<Schema.Struct<{
-    readonly id: Schema.String;
-    readonly tag: Schema.String;
-    readonly order: Schema.Finite;
-    readonly parentId: Schema.NullOr<Schema.String>;
-    readonly childIndex: Schema.Finite;
-    readonly depth: Schema.Finite;
-    readonly path: Schema.String;
-    readonly textPreview: Schema.String;
-    readonly attrs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-  }>>;
-}>;
-type SmlNodeIndex = typeof SmlNodeIndexSchema.Type & {
+  readonly order: number;
+  readonly parentId: string | null;
+  readonly childIndex: number;
+  readonly depth: number;
+  readonly path: string;
+  readonly textPreview: string;
+  readonly attrs: SmlNodeKeyAttrs;
+}
+interface SmlNodeIndex {
   readonly nodes: readonly SmlNodeIndexEntry[];
-};
+}
 declare const deriveNodeIndexFromDocument: (document: SmlDocument) => SmlNodeIndex;
-declare const deriveNodeIndex: (source: string) => Result.Result<SmlNodeIndex, string>;
+declare const deriveNodeIndex: (source: string) => Result<SmlNodeIndex, string>;
 //#endregion
-export { SmlNodeIndex, SmlNodeIndexEntry, SmlNodeIndexEntrySchema, SmlNodeIndexSchema, SmlNodeKeyAttrsSchema, deriveNodeIndex, deriveNodeIndexFromDocument };
+export { SmlNodeIndex, SmlNodeIndexEntry, SmlNodeKeyAttrs, deriveNodeIndex, deriveNodeIndexFromDocument };
 //# sourceMappingURL=model.d.ts.map

package/dist/model.js

@@ -1,19 +1,6 @@
 import { parseSml } from "./parser.js";
-import { Result, Schema } from "effect";
+import { Result } from "better-result";
 //#region src/model.ts
-const SmlNodeKeyAttrsSchema = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Finite]));
-const SmlNodeIndexEntrySchema = Schema.Struct({
-	id: Schema.String,
-	tag: Schema.String,
-	order: Schema.Finite,
-	parentId: Schema.NullOr(Schema.String),
-	childIndex: Schema.Finite,
-	depth: Schema.Finite,
-	path: Schema.String,
-	textPreview: Schema.String,
-	attrs: SmlNodeKeyAttrsSchema
-});
-const SmlNodeIndexSchema = Schema.Struct({ nodes: Schema.Array(SmlNodeIndexEntrySchema) });
 const KEY_ATTRS = /* @__PURE__ */ new Set([
 	"alt",
 	"class",
@@ -81,10 +68,10 @@ const deriveNodeIndexFromDocument = (document) => {
 };
 const deriveNodeIndex = (source) => {
 	const parsed = parseSml(source);
-	if (Result.isFailure(parsed)) return Result.fail(parsed.failure.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-	return Result.succeed(deriveNodeIndexFromDocument(parsed.success));
+	if (Result.isError(parsed)) return Result.err(parsed.error.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+	return Result.ok(deriveNodeIndexFromDocument(parsed.value));
 };
 //#endregion
-export { SmlNodeIndexEntrySchema, SmlNodeIndexSchema, SmlNodeKeyAttrsSchema, deriveNodeIndex, deriveNodeIndexFromDocument };
+export { deriveNodeIndex, deriveNodeIndexFromDocument };
 
 //# sourceMappingURL=model.js.map