cvdl-ts 1.0.12 → 1.0.13

package/dist/AnyLayout.js

@@ -79,38 +79,22 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         let end_time = Date.now();
         console.info(`Font loading time: ${end_time - start_time}ms for section ${section.section_name}`);
         // 2. Find the data schema for the section
-        const _data_schema = data_schemas.find(s => s.schema_name === section.data_schema);
-        if (_data_schema === undefined) {
+        const data_schema = data_schemas.find(s => s.schema_name === section.data_schema);
+        if (data_schema === undefined) {
             throw new Error(`Could not find data schema ${section.data_schema}`);
         }
         start_time = Date.now();
         // 3. Render the header
-        const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data), column_width, font_dict), font_dict);
+        const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema), column_width, font_dict), font_dict);
         console.error("Header is computed");
         layouts.push(layout);
         end_time = Date.now();
         console.info(`Header rendering time: ${end_time - start_time}ms for section ${section.section_name}`);
         start_time = Date.now();
         // Render Section Items
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        // @ts-nocheck
-        for (const [index, item] of section.items.entries()) {
-            console.log("Computing item");
-            console.error("Item:", item);
-            // 1. Find the layout schema for the section
-            const layout_schema = layout_schemas
-                .find((s) => s.schema_name == section.layout_schema);
-            if (layout_schema == undefined) {
-                throw new Error(`Could not find layout schema ${section.layout_schema}`);
-            }
-            await font_dict.load_fonts_from_schema(layout_schema, storage);
-            console.log("Fonts are loaded");
-            // 2. Find the data schema for the section
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _data_schema = data_schemas
-                .find((s) => s.schema_name == section.data_schema);
+        for (const [, item] of section.items.entries()) {
             // 3. Render the item
-            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields), column_width, font_dict), font_dict);
+            const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields, data_schema.item_schema), column_width, font_dict), font_dict);
             layouts.push(layout);
         }
         end_time = Date.now();

package/dist/DataSchema.d.ts

@@ -1,32 +1,44 @@
-export type DocumentDataType = {
-    tag: "Date";
-} | {
-    tag: "String";
-} | {
-    tag: "MarkdownString";
-} | {
-    tag: "Type";
-    value: string;
-} | {
-    tag: "List";
-    value: DocumentDataType;
-} | {
-    tag: "Types";
-    value: DocumentDataType[];
-};
-export type Field = {
-    name: string;
-    data_type: DocumentDataType;
-};
+export declare namespace DocumentDataType {
+    type t = {
+        tag: "Date";
+    } | {
+        tag: "String";
+    } | {
+        tag: "MarkdownString";
+    } | {
+        tag: "Number";
+    } | {
+        tag: "Type";
+        value: string;
+    } | {
+        tag: "List";
+        value: t;
+    } | {
+        tag: "Types";
+        value: t[];
+    };
+    type DocumentDataType = t;
+    function parse(s: string): DocumentDataType;
+    function print(d: DocumentDataType): string;
+}
+export declare namespace Field {
+    type t = {
+        name: string;
+        type: DocumentDataType.t;
+    };
+    type Field = t;
+    function fromJson(json: unknown): Field;
+    function toJson(f: Field): unknown;
+}
 export declare class DataSchema {
     schema_name: string;
-    header_schema: Field[];
-    item_schema: Field[];
-    constructor(schema_name: string, header_schema: Field[], item_schema: Field[]);
+    header_schema: Field.t[];
+    item_schema: Field.t[];
+    constructor(schema_name: string, header_schema: Field.t[], item_schema: Field.t[]);
     static fromJson(json: unknown): DataSchema;
     toJson(): {
         schema_name: string;
-        header_schema: Field[];
-        item_schema: Field[];
+        header_schema: unknown[];
+        item_schema: unknown[];
     };
 }

package/dist/DataSchema.js

@@ -1,6 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSchema = void 0;
+exports.DataSchema = exports.Field = exports.DocumentDataType = void 0;
+var DocumentDataType;
+(function (DocumentDataType) {
+    function parse(s) {
+        if (s === "Date") {
+            return { tag: "Date" };
+        }
+        else if (s === "String") {
+            return { tag: "String" };
+        }
+        else if (s === "MarkdownString") {
+            return { tag: "MarkdownString" };
+        }
+        else if (s === "Number") {
+            return { tag: "Number" };
+        }
+        else if (s.startsWith("List")) {
+            return { tag: "List", value: parse(s.slice(5, -1).trim()) };
+        }
+        else if (s.includes("|")) {
+            return { tag: "Types", value: s.split("|").map((s) => s.trim()).map(parse) };
+        }
+        else {
+            throw new Error("Invalid DocumentDataType: " + s);
+        }
+    }
+    DocumentDataType.parse = parse;
+    function print(d) {
+        switch (d.tag) {
+            case "Date":
+                return "Date";
+            case "String":
+                return "String";
+            case "MarkdownString":
+                return "MarkdownString";
+            case "Number":
+                return "Number";
+            case "Type":
+                return d.value;
+            case "List":
+                return "List<" + print(d.value) + ">";
+            case "Types":
+                return d.value.map(print).join(" | ");
+        }
+    }
+    DocumentDataType.print = print;
+})(DocumentDataType || (exports.DocumentDataType = DocumentDataType = {}));
+var Field;
+(function (Field) {
+    function fromJson(json) {
+        if (typeof json !== "object" || json === null) {
+            throw new Error("Field must be an object");
+        }
+        if (!("name" in json) || !("type" in json)) {
+            throw new Error("Field must have a name and type");
+        }
+        if (typeof json.name !== "string") {
+            throw new Error("Field name must be a string");
+        }
+        if (typeof json.type !== "string") {
+            throw new Error("Field type must be a string");
+        }
+        return {
+            name: json.name,
+            type: DocumentDataType.parse(json.type),
+        };
+    }
+    Field.fromJson = fromJson;
+    function toJson(f) {
+        return {
+            name: f.name,
+            type: DocumentDataType.print(f.type),
+        };
+    }
+    Field.toJson = toJson;
+})(Field || (exports.Field = Field = {}));
 class DataSchema {
     constructor(schema_name, header_schema, item_schema) {
         this.schema_name = schema_name;
@@ -14,13 +89,13 @@ class DataSchema {
         if (!("schema_name" in json) || !("header_schema" in json) || !("item_schema" in json)) {
             throw new Error("DataSchema must have a schema_name, header_schema, and item_schema");
         }
-        return new DataSchema(json.schema_name, json.header_schema, json.item_schema);
+        return new DataSchema(json.schema_name, json.header_schema.map(Field.fromJson), json.item_schema.map(Field.fromJson));
     }
     toJson() {
         return {
             schema_name: this.schema_name,
-            header_schema: this.header_schema,
-            item_schema: this.item_schema,
+            header_schema: this.header_schema.map(Field.toJson),
+            item_schema: this.item_schema.map(Field.toJson),
         };
     }
 }

package/dist/Elem.d.ts

@@ -4,12 +4,28 @@ import { Color } from "./Layout";
 import { FontDict } from "./AnyLayout";
 import * as Row from "./Row";
 import { ItemContent } from "./Resume";
+import { Field } from "./DataSchema";
+import { Optional } from "./Utils";
+import { Box } from "./Box";
+type Span = {
+    is_italic: boolean;
+    is_bold: boolean;
+    is_code: boolean;
+    text: string;
+    link: string | null;
+    font?: Font.t;
+    width?: number;
+    line?: number;
+    bbox?: Box;
+};
 export type t = {
     tag: "Elem";
     item: string;
+    spans?: Span[];
     url: string | null;
     is_ref: boolean;
     is_fill: boolean;
+    is_markdown: boolean;
     text_width: Width.t;
     font: Font.t;
     margin: Margin.t;
@@ -18,13 +34,15 @@ export type t = {
     background_color: Color;
 };
 type Elem = t;
-export declare function elem(item: string, url: string | null, is_ref: boolean, is_fill: boolean, text_width: Width.t, font: Font.t, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color): Elem;
+export declare function elem(item: string, url: string | null, is_ref: boolean, is_fill: boolean, is_markdown: boolean, text_width: Width.t, font: Font.t, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color): Elem;
 export declare function copy(e: Elem): {
     tag: "Elem";
     item: string;
+    spans?: Span[];
     url: string;
     is_ref: boolean;
     is_fill: boolean;
+    is_markdown: boolean;
     text_width: Width.t;
     font: Font.t;
     margin: Margin.t;
@@ -33,10 +51,6 @@ export declare function copy(e: Elem): {
     background_color: Layout.Color;
 };
 export declare function default_(): Elem;
-export type Optional<T> = {
-    [P in keyof T]?: T[P];
-};
-export declare function with_(e: Elem, w: Optional<Elem>): Elem;
 export declare function from(w: Optional<Elem>): Elem;
 export declare function withItem(e: Elem, item: string): Elem;
 export declare function withUrl(e: Elem, url: string | null): Elem;
@@ -50,9 +64,10 @@ export declare function withAlignment(e: Elem, alignment: Alignment.t): Elem;
 export declare function withWidth(e: Elem, width: Width.t): Elem;
 export declare function withBackgroundColor(e: Elem, background_color: Color): Elem;
 export declare function scaleWidth(e: Elem, scale: number): Elem;
+export declare function parseMarkdownItem(item: string): Span[];
 export declare function fillFonts(e: Elem, fonts: FontDict): Elem;
 export declare function justifiedLines(e: Elem, lines: Elem[], font_dict: FontDict): Row.t[];
 export declare function break_lines(e: Elem, font_dict: FontDict): Layout.t[];
 export declare function boundWidth(e: Elem, width: number): Elem;
-export declare function instantiate(e: Elem, section: Map<string, ItemContent>): Elem;
+export declare function instantiate(e: Elem, section: Map<string, ItemContent>, fields: Field.t[]): Elem;
 export {};

package/dist/Elem.js

@@ -23,18 +23,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.instantiate = exports.boundWidth = exports.break_lines = exports.justifiedLines = exports.fillFonts = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.with_ = exports.default_ = exports.copy = exports.elem = void 0;
+exports.instantiate = exports.boundWidth = exports.break_lines = exports.justifiedLines = exports.fillFonts = exports.parseMarkdownItem = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.default_ = exports.copy = exports.elem = void 0;
 const Font = __importStar(require("./Font"));
 const _1 = require(".");
 const Row_1 = require("./Row");
 const Resume_1 = require("./Resume");
-function elem(item, url, is_ref, is_fill, text_width, font, margin, alignment, width, background_color) {
+const marked = __importStar(require("marked"));
+const ts_pattern_1 = require("ts-pattern");
+const Utils_1 = require("./Utils");
+function defaultSpanProps() {
+    return {
+        is_italic: false,
+        is_bold: false,
+        is_code: false,
+        is_link: false,
+    };
+}
+function elem(item, url, is_ref, is_fill, is_markdown, text_width, font, margin, alignment, width, background_color) {
     return {
         tag: "Elem",
         item,
         url,
         is_ref,
         is_fill,
+        is_markdown,
         text_width,
         font,
         margin,
@@ -55,6 +67,7 @@ function default_() {
         url: null,
         is_ref: false,
         is_fill: false,
+        is_markdown: false,
         text_width: _1.Width.default_(),
         font: Font.default_(),
         margin: _1.Margin.default_(),
@@ -64,10 +77,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -120,13 +129,91 @@ function scaleWidth(e, scale) {
     return withWidth(e, _1.Width.scale(e.width, scale));
 }
 exports.scaleWidth = scaleWidth;
+function flatten(ts, sp) {
+    const spans = [];
+    for (const t of ts) {
+        spans.push(...flattenToken(t, sp));
+    }
+    return spans;
+}
+function flattenToken(t, sp) {
+    return (0, ts_pattern_1.match)(t)
+        .returnType()
+        .with({ type: "paragraph", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[paragraph]", tokens);
+        return flatten(tokens, sp);
+    })
+        .with({ type: "strong", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[strong]", tokens);
+        return flatten(tokens, { ...sp, is_bold: true });
+    })
+        .with({ type: "em", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[em]", tokens);
+        return flatten(tokens, { ...sp, is_italic: true });
+    })
+        .with({ type: "codespan", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        // console.log("[codespan]", text);
+        return [{ ...sp, is_code: true, text, link: null }];
+    })
+        .with({ type: "text", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, sp);
+    })
+        .with({ type: "text", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        const result = [];
+        if (text.startsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        result.push({ ...sp, text: text.trim(), link: null });
+        if (text.endsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        else if (text.endsWith("\n")) {
+            result.push({ ...sp, text: "\n", link: null });
+        }
+        return result;
+    })
+        .otherwise((e) => {
+        // console.log(`Unknown token type: ${JSON.stringify(e)}`);
+        return [{ ...defaultSpanProps(), text: e.raw, link: null }];
+    });
+}
+function parseMarkdownItem(item) {
+    const spans = [];
+    for (const token of marked.lexer(item)) {
+        spans.push(...flatten([token], defaultSpanProps()));
+    }
+    return spans;
+}
+exports.parseMarkdownItem = parseMarkdownItem;
 function fillFonts(e, fonts) {
-    const text_width_with_font = Font.get_width(e.font, e.item, fonts);
+    const simpleSpans = e.is_markdown ? parseMarkdownItem(e.item) : [{ ...defaultSpanProps(), text: e.item, font: e.font, link: null }];
+    const spans = [];
+    for (const span of simpleSpans) {
+        const font = e.is_markdown ? (0, Utils_1.with_)(e.font, ({
+            // style: span.is_italic ? "Italic" : "Normal",
+            weight: span.is_bold ? "Bold" : "Medium",
+        })) : e.font;
+        if (span.text === " " || span.text === "\n") {
+            const width = Font.get_width(font, span.text, fonts);
+            spans.push({ ...span, font, width });
+            continue;
+        }
+        span.text.split(/\s+/).forEach(word => {
+            const width = Font.get_width(font, word, fonts);
+            spans.push({ ...span, text: word, font, width });
+            spans.push({ ...span, text: " ", font, width: Font.get_width(font, " ", fonts) });
+        });
+    }
+    const text_width = spans.reduce((acc, span) => acc + span.width, 0);
     if (e.is_fill) {
-        return withTextWidth(withWidth(e, _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width_with_font))), _1.Width.absolute(text_width_with_font));
+        return (0, Utils_1.with_)(e, {
+            width: _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width)),
+            text_width: _1.Width.absolute(text_width),
+            spans
+        });
     }
     else {
-        return withTextWidth(e, _1.Width.absolute(text_width_with_font));
+        return (0, Utils_1.with_)(e, { text_width: _1.Width.absolute(text_width), spans });
     }
 }
 exports.fillFonts = fillFonts;
@@ -137,7 +224,7 @@ function justifiedLines(e, lines, font_dict) {
         const r = (0, Row_1.row)([], line.margin, line.alignment, line.width, false, false);
         words.forEach(word => {
             const word_width = Font.get_width(e.font, word, font_dict);
-            r.elements.push(elem(word, null, false, false, _1.Width.absolute(word_width), this.font, _1.Margin.default_(), _1.Alignment.default_(), _1.Width.absolute(word_width), this.background_color));
+            r.elements.push(elem(word, null, false, false, false, _1.Width.absolute(word_width), this.font, _1.Margin.default_(), _1.Alignment.default_(), _1.Width.absolute(word_width), this.background_color));
         });
         rowLines.push(Row_1.row);
     }
@@ -189,10 +276,16 @@ function boundWidth(e, width) {
     }
 }
 exports.boundWidth = boundWidth;
-function instantiate(e, section) {
+function instantiate(e, section, fields) {
     if (!e.is_ref) {
         return e;
     }
+    const itemType = fields.find(f => f.name === e.item);
+    console.log(`Found item type: ${JSON.stringify(itemType)}`);
+    if (itemType.type.tag === "MarkdownString") {
+        console.log(`Found markdown string: ${e.item}`);
+        e.is_markdown = true;
+    }
     const text = section.get(e.item);
     if (text === undefined) {
         return withIsRef(withItem(e, ""), false);

package/dist/Layout.d.ts

@@ -9,6 +9,7 @@ import { Point } from "./Point";
 import * as Stack from "./Stack";
 import * as Row from "./Row";
 import * as Elem from "./Elem";
+import { Field } from "./DataSchema";
 export type Container = Stack.t | Row.t;
 export type t = Stack.t | Row.t | Elem.t;
 type Layout = t;
@@ -39,7 +40,7 @@ export declare function withAlignment(l: Layout, alignment: Alignment.t): Layout
 export declare function withWidth(l: Layout, width: Width.t): Layout;
 export declare function totalElementsWidth(l: Layout): number;
 export declare function isInstantiated(l: Layout): boolean;
-export declare function instantiate(l: Layout, section: Map<string, ItemContent>): Layout;
+export declare function instantiate(l: Layout, section: Map<string, ItemContent>, fields: Field.t[]): Layout;
 export declare function boundWidth(l: Layout, width: number): Layout;
 export declare function scaleWidth(l: Layout, document_width: number): Layout;
 export declare function normalize(l: Layout, width: number, font_dict: FontDict): Layout;

package/dist/Layout.js

@@ -209,14 +209,14 @@ function isInstantiated(l) {
     }
 }
 exports.isInstantiated = isInstantiated;
-function instantiate(l, section) {
+function instantiate(l, section, fields) {
     switch (l.tag) {
         case "Stack":
-            return Stack.instantiate(l, section);
+            return Stack.withElements(l, l.elements.map(e => instantiate(e, section, fields)));
         case "Row":
-            return Row.instantiate(l, section);
+            return Row.withElements(l, l.elements.map(e => instantiate(e, section, fields)));
         case "Elem":
-            return Elem.instantiate(l, section);
+            return Elem.instantiate(l, section, fields);
     }
 }
 exports.instantiate = instantiate;
@@ -266,9 +266,10 @@ function normalize(l, width, font_dict) {
     console.debug("Widths are bounded. Filling fonts...");
     const font_filled_layout = fillFonts(bounded_layout, font_dict);
     console.debug("Fonts filled. Breaking lines...");
-    const broken_layout = breakLines(font_filled_layout, font_dict);
+    // const broken_layout = breakLines(font_filled_layout, font_dict);
     console.debug("Lines broken.");
-    return broken_layout;
+    // return broken_layout;
+    return font_filled_layout;
 }
 exports.normalize = normalize;
 function fillFonts(l, font_dict) {
@@ -354,7 +355,11 @@ function computeTextboxPositions(l, top_left, font_dict) {
                 top_left = top_left.move_y_to(depth);
                 renderedElements.push(result.renderedLayout);
             }
-            return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(originalTopLeft, top_left.move_x_by(Width.get_fixed_unchecked(stack.width))), elements: renderedElements } };
+            return {
+                depth, renderedLayout: {
+                    ...l, bounding_box: new Box_1.Box(originalTopLeft, top_left.move_x_by(Width.get_fixed_unchecked(stack.width))), elements: renderedElements
+                }
+            };
         }
         case "Row": {
             const row = l;
@@ -380,19 +385,31 @@ function computeTextboxPositions(l, top_left, font_dict) {
                     top_left.move_x_by(Width.get_fixed_unchecked(element.width) + per_elem_space);
                 renderedElements.push(result.renderedLayout);
             }
-            return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(originalTopLeft, originalTopLeft.move_y_by(depth).move_x_by(Width.get_fixed_unchecked(row.width))), elements: renderedElements } };
+            return {
+                depth, renderedLayout: {
+                    ...l, bounding_box: new Box_1.Box(originalTopLeft, originalTopLeft.move_y_by(depth).move_x_by(Width.get_fixed_unchecked(row.width))), elements: renderedElements
+                }
+            };
         }
         case "Elem": {
             const elem = l;
             if (elem.is_ref) {
                 throw new Error("Cannot compute textbox positions of uninstantiated layout");
             }
-            if (elem.item === "") {
-                return { depth, renderedLayout: { ...l, bounding_box: new Box_1.Box(top_left, top_left) } };
-            }
             const height = Font.get_height(elem.font, font_dict);
             const width = Width.get_fixed_unchecked(elem.text_width);
             top_left = top_left.move_y_by(elem.margin.top).move_x_by(elem.margin.left);
+            let line = 1;
+            let cursor = top_left.x;
+            elem.spans.forEach(span => {
+                if (cursor + span.width > Width.get_fixed_unchecked(elem.width) - elem.margin.right) {
+                    cursor = top_left.x;
+                    line += 1;
+                }
+                span.bbox = new Box_1.Box(new Point_1.Point(cursor, (line - 1) * height), new Point_1.Point(cursor + span.width, line * height));
+                cursor += span.width;
+                console.log(span);
+            });
             switch (elem.alignment) {
                 case "Center":
                     top_left = top_left.move_x_by((Width.get_fixed_unchecked(elem.width) - width) / 2.0);

package/dist/PdfLayout.js

@@ -121,10 +121,29 @@ const renderSectionLayout = (layout, resume_layout, current_height, doc) => {
         }
         case "Elem": {
             const elem = layout;
-            doc.
-                font(_1.Font.full_name(elem.font)).
-                fontSize(elem.font.size).
-                text(elem.item, layout.bounding_box.top_left.x + resume_layout.margin.left, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height, { lineBreak: false });
+            elem.spans.forEach((span) => {
+                console.log(span);
+                if (span.text === "") {
+                    return;
+                }
+                doc.
+                    font(_1.Font.full_name(span.font)).
+                    fontSize(span.font.size).
+                    text(span.text, layout.bounding_box.top_left.x + resume_layout.margin.left + span.bbox.top_left.x, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height + span.bbox.top_left.y, { lineBreak: false });
+                if (span.is_code) {
+                    // Add a rounded rectangle around the code
+                    doc.roundedRect(layout.bounding_box.top_left.x + resume_layout.margin.left + span.bbox.top_left.x - span.font.size / 3, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height + span.bbox.top_left.y, span.bbox.width() + span.font.size / 3 * 2, span.bbox.height(), 5).stroke();
+                    // Add a background color to the code
+                    doc.fillColor("black");
+                    doc.fillOpacity(0.05);
+                    doc.rect(layout.bounding_box.top_left.x + resume_layout.margin.left + span.bbox.top_left.x - span.font.size / 3, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height + span.bbox.top_left.y, span.bbox.width() + span.font.size / 3 * 2, span.bbox.height()).fill();
+                    doc.fillOpacity(1);
+                }
+            });
+            // doc.
+            //     font(Font.full_name(elem.font)).
+            //     fontSize(elem.font.size).
+            //     text(elem.item, layout.bounding_box.top_left.x + resume_layout.margin.left, layout.bounding_box.top_left.y + resume_layout.margin.top + current_height, { lineBreak: false });
             break;
         }
     }

package/dist/Row.d.ts

@@ -1,8 +1,7 @@
 import { Alignment, Margin, Width } from ".";
 import { FontDict } from "./AnyLayout";
-import { Optional } from "./Elem";
+import { Optional } from "./Utils";
 import * as Layout from "./Layout";
-import { ItemContent } from "./Resume";
 export type t = {
     tag: "Row";
     elements: Layout.t[];
@@ -13,12 +12,10 @@ export type t = {
     is_fill: boolean;
 };
 type Row = t;
-export declare function with_(e: Row, w: Optional<Row>): Row;
 export declare function from(w: Optional<Row>): Row;
 export declare function row(elements: Layout.t[], margin: Margin.t, alignment: Alignment.t, width: Width.t, is_frozen: boolean, is_fill: boolean): Row;
 export declare function copy(r: Row): Row;
 export declare function default_(): Row;
-export declare function instantiate(r: Row, section: Map<string, ItemContent>): Row;
 export declare function withElements(r: Row, elements: Layout.t[]): Row;
 export declare function withMargin(r: Row, margin: Margin.t): Row;
 export declare function withAlignment(r: Row, alignment: Alignment.t): Row;

package/dist/Row.js

@@ -23,13 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.breakLines = exports.scaleWidth = exports.boundWidth = exports.elementsWidth = exports.withFill = exports.withFrozen = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.instantiate = exports.default_ = exports.copy = exports.row = exports.from = exports.with_ = void 0;
+exports.breakLines = exports.scaleWidth = exports.boundWidth = exports.elementsWidth = exports.withFill = exports.withFrozen = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.default_ = exports.copy = exports.row = exports.from = void 0;
 const _1 = require(".");
 const Layout = __importStar(require("./Layout"));
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -64,10 +60,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function instantiate(r, section) {
-    return withElements(r, r.elements.map(e => Layout.instantiate(e, section)));
-}
-exports.instantiate = instantiate;
 function withElements(r, elements) {
     return {
         ...r,

package/dist/Stack.d.ts

@@ -1,6 +1,5 @@
 import { Alignment, Layout, Margin, Width } from ".";
-import { Optional } from "./Elem";
-import { ItemContent } from "./Resume";
+import { Optional } from "./Utils";
 export type t = {
     tag: "Stack";
     elements: Layout.t[];
@@ -10,12 +9,10 @@ export type t = {
     is_fill: boolean;
 };
 type Stack = t;
-export declare function with_(e: Stack, w: Optional<Stack>): Stack;
 export declare function from(w: Optional<Stack>): Stack;
 export declare function stack(elements: Layout.t[], margin: Margin.t, alignment: Alignment.t, width: Width.t, is_fill: boolean): Stack;
 export declare function copy(s: Stack): Stack;
 export declare function default_(): Stack;
-export declare function instantiate(s: Stack, section: Map<string, ItemContent>): Stack;
 export declare function withElements(s: Stack, elements: Layout.t[]): Stack;
 export declare function withMargin(s: Stack, margin: Margin.t): Stack;
 export declare function withAlignment(s: Stack, alignment: Alignment.t): Stack;

package/dist/Stack.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaleWidth = exports.boundWidth = exports.withIsFill = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.instantiate = exports.default_ = exports.copy = exports.stack = exports.from = exports.with_ = void 0;
+exports.scaleWidth = exports.boundWidth = exports.withIsFill = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withElements = exports.default_ = exports.copy = exports.stack = exports.from = void 0;
 const _1 = require(".");
-function with_(e, w) {
-    return { ...e, ...w };
-}
-exports.with_ = with_;
 function from(w) {
     return { ...default_(), ...w };
 }
@@ -38,10 +34,6 @@ function default_() {
     };
 }
 exports.default_ = default_;
-function instantiate(s, section) {
-    return withElements(s, s.elements.map(e => _1.Layout.instantiate(e, section)));
-}
-exports.instantiate = instantiate;
 function withElements(s, elements) {
     return {
         ...s,

package/dist/Utils.d.ts

@@ -0,0 +1,4 @@
+export type Optional<T> = {
+    [P in keyof T]?: T[P];
+};
+export declare function with_<T>(e: T, w: Optional<T>): T;

package/dist/Utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.with_ = void 0;
+function with_(e, w) {
+    return { ...e, ...w };
+}
+exports.with_ = with_;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cvdl-ts",
-    "version": "1.0.12",
+    "version": "1.0.13",
     "description": "Typescript Implementation of CVDL Compiler",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -13,13 +13,19 @@
         "@types/pdfkit": "^0.13.1",
         "blob-stream": "^0.1.3",
         "fontkit": "^2.0.2",
-        "pdfkit": "^0.13.0"
+        "marked": "^13.0.2",
+        "pdfkit": "^0.13.0",
+        "ts-pattern": "^5.2.0"
     },
     "devDependencies": {
+        "@eslint/compat": "^1.1.1",
+        "@eslint/js": "^9.7.0",
         "@types/node": "^20.8.7",
         "@typescript-eslint/eslint-plugin": "^6.8.0",
         "@typescript-eslint/parser": "^6.8.0",
-        "eslint": "^8.52.0"
+        "eslint-plugin-react": "^7.34.4",
+        "globals": "^15.8.0",
+        "typescript-eslint": "^7.16.1"
     },
     "scripts": {
         "lint": "eslint . --ext .ts",