hwp-convert 1.0.0

package/dist/lib/hwp/mdReader.js

@@ -0,0 +1,485 @@
+/**
+ * Markdown → HwpDocument IR.
+ *
+ * `marked` 의 lexer 로 토큰 트리를 만들고 IR 로 변환.
+ *   - heading → 굵은 paragraph (charShape 별도 정의: 큰 사이즈 + bold)
+ *   - paragraph → text + bold/italic run 분할
+ *   - list (ordered/unordered) → "1. " / "- " prefix 가 포함된 paragraph (간단 표현)
+ *   - blockquote → 인용 paragraph (회색 배경)
+ *   - code (block / inline) → 모노스페이스 charShape
+ *   - table → HwpTableControl (셀 paragraph 재귀)
+ *   - image → HwpPictureControl + binData 등록 (data: URI 만 지원)
+ *   - link → 텍스트 그대로 (링크 자체는 보존하지 않음 — HWP 필드 컨트롤은 별도 작업)
+ */
+import { marked } from "marked";
+/** Markdown 텍스트를 HwpDocument 로 변환. */
+export function markdownToHwpDocument(md, options) {
+    const tokens = marked.lexer(md);
+    const ctx = {
+        charShapeIds: new Map(),
+        binData: new Map(),
+        nextBinDataId: 1,
+        imageResolver: options?.imageResolver,
+    };
+    // 기본 charShapes / paraShapes / styles / fontFaces 등록
+    // ID 0: 기본 (10pt, 함초롬바탕)
+    // 추가 ID 는 paragraph 처리 중에 동적으로 발급
+    const charShapes = [defaultCharShape()];
+    ctx.charShapeIds.set("default", 0);
+    const paraShapes = [defaultParaShape()];
+    const styles = [{ name: "바탕글", engName: "Normal", paraShapeId: 0, charShapeId: 0 }];
+    const fontFaces = [
+        [{ name: "함초롬바탕" }, { name: "맑은 고딕" }, { name: "Courier New" }],
+        [{ name: "Times New Roman" }],
+        [],
+        [],
+        [],
+        [],
+        [],
+    ];
+    // bold/italic charShape 사전 등록
+    const idBold = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true });
+    const idItalic = registerCharShape(charShapes, ctx, { ...defaultCharShape(), italic: true });
+    const idBoldItalic = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true, italic: true });
+    // 헤딩(굵게 + 큰 사이즈) — h1=1800, h2=1600, h3=1400, h4-6=1200
+    const idH1 = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true, baseSize: 1800 });
+    const idH2 = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true, baseSize: 1600 });
+    const idH3 = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true, baseSize: 1400 });
+    const idHmin = registerCharShape(charShapes, ctx, { ...defaultCharShape(), bold: true, baseSize: 1200 });
+    // 모노스페이스
+    const idMono = registerCharShape(charShapes, ctx, {
+        ...defaultCharShape(),
+        faceNameIds: { hangul: 2, latin: 2, hanja: 2, japanese: 2, other: 2, symbol: 2, user: 2 },
+    });
+    const headingShapeId = (depth) => (depth === 1 ? idH1 : depth === 2 ? idH2 : depth === 3 ? idH3 : idHmin);
+    const paragraphs = [];
+    const visitTokens = (tks) => {
+        for (const tk of tks) {
+            paragraphs.push(...renderToken(tk, { idBold, idItalic, idBoldItalic, headingShapeId, idMono }, ctx, charShapes));
+        }
+    };
+    visitTokens(tokens);
+    return {
+        header: defaultFileHeader(),
+        docInfo: {
+            fontFaces,
+            charShapes,
+            paraShapes,
+            styles,
+            binData: [],
+            borderFills: [],
+            numberings: [],
+            bullets: [],
+            tabDefs: [],
+        },
+        sections: [{ paragraphs }],
+        binData: ctx.binData,
+    };
+}
+function renderToken(tk, ids, ctx, charShapes) {
+    switch (tk.type) {
+        case "heading": {
+            const t = tk;
+            const csId = ids.headingShapeId(t.depth);
+            const runs = inlineToRuns(t.tokens ?? [], ids, csId);
+            return [
+                {
+                    paraShapeId: 0,
+                    styleId: 0,
+                    text: runsToText(runs),
+                    runs,
+                    controls: [],
+                },
+            ];
+        }
+        case "paragraph": {
+            const t = tk;
+            const runs = inlineToRuns(t.tokens ?? [], ids, 0);
+            const controls = [];
+            // image 토큰은 별도 컨트롤로
+            const imageControls = collectImagesFromInline(t.tokens ?? [], ctx);
+            controls.push(...imageControls);
+            return [
+                {
+                    paraShapeId: 0,
+                    styleId: 0,
+                    text: runsToText(runs),
+                    runs,
+                    controls,
+                },
+            ];
+        }
+        case "blockquote": {
+            const t = tk;
+            const inner = (t.tokens ?? []).flatMap((sub) => renderToken(sub, ids, ctx, charShapes));
+            // "> " prefix 로 시각적 표시
+            return inner.map((p) => ({
+                ...p,
+                text: `> ${p.text}`,
+                runs: p.runs.length > 0 ? [{ charShapeId: p.runs[0].charShapeId, text: `> ${runsToText(p.runs)}` }] : [],
+            }));
+        }
+        case "list": {
+            const t = tk;
+            const out = [];
+            let idx = t.start === "" ? 1 : Number(t.start) || 1;
+            for (const item of t.items) {
+                const prefix = t.ordered ? `${idx}. ` : "- ";
+                const inner = (item.tokens ?? []).flatMap((sub) => renderToken(sub, ids, ctx, charShapes));
+                if (inner.length === 0) {
+                    out.push({
+                        paraShapeId: 0,
+                        styleId: 0,
+                        text: prefix,
+                        runs: [{ charShapeId: 0, text: prefix }],
+                        controls: [],
+                    });
+                }
+                else {
+                    // 첫 paragraph 에 prefix 추가
+                    const first = inner[0];
+                    const newText = prefix + first.text;
+                    const newRuns = [
+                        { charShapeId: 0, text: prefix },
+                        ...first.runs,
+                    ];
+                    out.push({ ...first, text: newText, runs: newRuns });
+                    for (let i = 1; i < inner.length; i++)
+                        out.push(inner[i]);
+                }
+                idx++;
+            }
+            return out;
+        }
+        case "code": {
+            const t = tk;
+            // 코드 블록 — 모노스페이스 paragraph 들로 분할
+            const lines = t.text.split("\n");
+            return lines.map((line) => ({
+                paraShapeId: 0,
+                styleId: 0,
+                text: line,
+                runs: line.length > 0 ? [{ charShapeId: ids.idMono, text: line }] : [],
+                controls: [],
+            }));
+        }
+        case "table": {
+            const t = tk;
+            const rowCount = 1 + t.rows.length;
+            const colCount = t.header.length;
+            const cells = [];
+            // 헤더 행
+            for (let c = 0; c < t.header.length; c++) {
+                const cellTokens = t.header[c].tokens ?? [];
+                const runs = inlineToRuns(cellTokens, ids, ids.idBold);
+                cells.push({
+                    col: c,
+                    row: 0,
+                    colSpan: 1,
+                    rowSpan: 1,
+                    paragraphs: [
+                        {
+                            paraShapeId: 0,
+                            styleId: 0,
+                            text: runsToText(runs),
+                            runs,
+                            controls: [],
+                        },
+                    ],
+                });
+            }
+            // 본 행
+            for (let r = 0; r < t.rows.length; r++) {
+                for (let c = 0; c < t.rows[r].length; c++) {
+                    const cellTokens = t.rows[r][c].tokens ?? [];
+                    const runs = inlineToRuns(cellTokens, ids, 0);
+                    cells.push({
+                        col: c,
+                        row: r + 1,
+                        colSpan: 1,
+                        rowSpan: 1,
+                        paragraphs: [
+                            {
+                                paraShapeId: 0,
+                                styleId: 0,
+                                text: runsToText(runs),
+                                runs,
+                                controls: [],
+                            },
+                        ],
+                    });
+                }
+            }
+            return [
+                {
+                    paraShapeId: 0,
+                    styleId: 0,
+                    text: "",
+                    runs: [],
+                    controls: [{ kind: "table", rowCount, colCount, cells }],
+                },
+            ];
+        }
+        case "hr":
+            return [
+                {
+                    paraShapeId: 0,
+                    styleId: 0,
+                    text: "─────",
+                    runs: [{ charShapeId: 0, text: "─────" }],
+                    controls: [],
+                },
+            ];
+        case "space":
+            return [];
+        case "text": {
+            // 블록 레벨 text 토큰 — list item 안 등에서 등장 (tight list).
+            const t = tk;
+            const inlineTokens = t.tokens ??
+                [{ type: "text", text: t.text, raw: t.text }];
+            const runs = inlineToRuns(inlineTokens, ids, 0);
+            return [
+                {
+                    paraShapeId: 0,
+                    styleId: 0,
+                    text: runsToText(runs),
+                    runs,
+                    controls: [],
+                },
+            ];
+        }
+        default:
+            return [];
+    }
+}
+/** 인라인 토큰 (text / strong / em / codespan / link / br / image) → HwpRun[] */
+function inlineToRuns(tokens, ids, baseCharShapeId) {
+    const runs = [];
+    for (const t of tokens) {
+        walkInline(t, baseCharShapeId, ids, runs, false, false);
+    }
+    // 인접 동일 charShape 합치기
+    return mergeRuns(runs);
+}
+function walkInline(tk, baseId, ids, runs, bold, italic) {
+    switch (tk.type) {
+        case "text": {
+            const t = tk;
+            const text = t.text;
+            // 자식 토큰이 있으면 재귀, 없으면 그대로
+            if (t.tokens) {
+                for (const sub of t.tokens) {
+                    walkInline(sub, baseId, ids, runs, bold, italic);
+                }
+            }
+            else if (text.length > 0) {
+                runs.push({ charShapeId: pickShapeId(baseId, ids, bold, italic), text: decodeEntities(text) });
+            }
+            break;
+        }
+        case "strong": {
+            const t = tk;
+            for (const sub of t.tokens ?? [])
+                walkInline(sub, baseId, ids, runs, true, italic);
+            break;
+        }
+        case "em": {
+            const t = tk;
+            for (const sub of t.tokens ?? [])
+                walkInline(sub, baseId, ids, runs, bold, true);
+            break;
+        }
+        case "codespan": {
+            const t = tk;
+            runs.push({ charShapeId: ids.idMono, text: decodeEntities(t.text) });
+            break;
+        }
+        case "link": {
+            const t = tk;
+            // 링크 텍스트만 보존 (URL 은 미보존 — 필드 컨트롤은 별도 작업)
+            for (const sub of t.tokens ?? [])
+                walkInline(sub, baseId, ids, runs, bold, italic);
+            break;
+        }
+        case "br":
+            runs.push({ charShapeId: pickShapeId(baseId, ids, bold, italic), text: "\n" });
+            break;
+        case "del": {
+            const t = tk;
+            for (const sub of t.tokens ?? [])
+                walkInline(sub, baseId, ids, runs, bold, italic);
+            break;
+        }
+        case "image":
+            // 이미지는 paragraph 레벨에서 별도 처리 — runs 에는 alt 만
+            runs.push({ charShapeId: baseId, text: tk.text });
+            break;
+        case "escape":
+            runs.push({ charShapeId: pickShapeId(baseId, ids, bold, italic), text: tk.text });
+            break;
+        case "html":
+            // raw HTML 은 텍스트로
+            runs.push({ charShapeId: baseId, text: tk.text });
+            break;
+        default:
+            break;
+    }
+}
+function pickShapeId(baseId, ids, bold, italic) {
+    if (bold && italic)
+        return ids.idBoldItalic;
+    if (bold)
+        return ids.idBold;
+    if (italic)
+        return ids.idItalic;
+    return baseId;
+}
+function mergeRuns(runs) {
+    const out = [];
+    for (const r of runs) {
+        const last = out[out.length - 1];
+        if (last && last.charShapeId === r.charShapeId) {
+            last.text += r.text;
+        }
+        else {
+            out.push({ ...r });
+        }
+    }
+    return out;
+}
+function runsToText(runs) {
+    return runs.map((r) => r.text).join("");
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+/**
+ * paragraph 토큰 안의 image 토큰을 추출 → HwpPictureControl 로.
+ * src 가 `data:` URI 인 경우만 binData 로 등록 (외부 URL/상대 경로는 보존 불가).
+ */
+function collectImagesFromInline(tokens, ctx) {
+    const out = [];
+    const visit = (tks) => {
+        for (const tk of tks) {
+            if (tk.type === "image") {
+                const img = tk;
+                const ctrl = imageTokenToControl(img.href, ctx);
+                if (ctrl)
+                    out.push(ctrl);
+            }
+            const subTokens = tk.tokens;
+            if (Array.isArray(subTokens))
+                visit(subTokens);
+        }
+    };
+    visit(tokens);
+    return out;
+}
+function imageTokenToControl(href, ctx) {
+    // data URI 처리
+    const match = /^data:([^;]+);base64,(.*)$/i.exec(href);
+    if (match) {
+        const mime = match[1].toLowerCase();
+        const ext = mime === "image/png"
+            ? "png"
+            : mime === "image/jpeg"
+                ? "jpg"
+                : mime === "image/gif"
+                    ? "gif"
+                    : mime === "image/bmp"
+                        ? "bmp"
+                        : mime === "image/webp"
+                            ? "webp"
+                            : "bin";
+        let bytes;
+        try {
+            if (typeof Buffer !== "undefined") {
+                bytes = new Uint8Array(Buffer.from(match[2], "base64"));
+            }
+            else {
+                const bin = globalThis.atob?.(match[2]) ?? "";
+                bytes = new Uint8Array(bin.length);
+                for (let i = 0; i < bin.length; i++)
+                    bytes[i] = bin.charCodeAt(i);
+            }
+        }
+        catch {
+            return null;
+        }
+        const id = ctx.nextBinDataId++;
+        ctx.binData.set(id, { data: bytes, extension: ext });
+        return { kind: "picture", binDataId: id };
+    }
+    // data URI 가 아니면 resolver(주입 시)로 file://·로컬 경로를 해석. 없으면 skip.
+    const resolved = ctx.imageResolver?.(href);
+    if (resolved && resolved.data.length > 0) {
+        const id = ctx.nextBinDataId++;
+        ctx.binData.set(id, { data: resolved.data, extension: resolved.extension.toLowerCase() });
+        return { kind: "picture", binDataId: id };
+    }
+    return null;
+}
+// ============================================================
+// 기본 IR 빌더
+// ============================================================
+function defaultCharShape() {
+    return {
+        faceNameIds: { hangul: 0, latin: 1, hanja: 0, japanese: 0, other: 0, symbol: 0, user: 0 },
+        baseSize: 1000, // 10pt
+        property: 0,
+        textColor: 0,
+        shadeColor: 0xffffff,
+        underlineColor: 0,
+        shadowColor: 0,
+        bold: false,
+        italic: false,
+        underline: false,
+        strikeout: false,
+    };
+}
+function defaultParaShape() {
+    return {
+        alignment: "justify",
+        property: 0,
+        leftMargin: 0,
+        rightMargin: 0,
+        indent: 0,
+        prevSpacing: 0,
+        nextSpacing: 0,
+        lineSpacing: 160,
+    };
+}
+function defaultFileHeader() {
+    return {
+        version: { major: 5, minor: 0, build: 6, revision: 0 },
+        flags: {
+            raw: 0,
+            compressed: false,
+            encrypted: false,
+            distribution: false,
+            script: false,
+            drm: false,
+            xmlTemplate: false,
+            documentHistory: false,
+            digitalSignature: false,
+            publicKeyEncrypted: false,
+            modifiedCertificate: false,
+            prepareDistribution: false,
+        },
+    };
+}
+function registerCharShape(shapes, ctx, cs) {
+    const key = JSON.stringify(cs);
+    const existing = ctx.charShapeIds.get(key);
+    if (existing !== undefined)
+        return existing;
+    const id = shapes.length;
+    shapes.push(cs);
+    ctx.charShapeIds.set(key, id);
+    return id;
+}

package/dist/lib/hwp/mdWriter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HwpDocument IR → Markdown.
+ *
+ * 보존:
+ *   - 문단 텍스트
+ *   - 글자 모양 굵게/기울임 (charShape lookup)
+ *   - 표 (markdown table; 셀 병합은 평탄화)
+ *   - 이미지 (`![](BinData/imageN.ext)` 또는 `data:` URI 인라인)
+ *   - 머리말/꼬리말/각주 (인용 블록)
+ *
+ * 의도적으로 단순화한 부분:
+ *   - 헤딩 레벨 자동 판별 안 함 (paraShape.heading 정보 부족)
+ *   - 색상/사이즈는 마크다운 표준에서 표현 못 함 → 무시
+ *   - 줄바꿈은 \n\n 으로 문단 구분
+ */
+import type { HwpDocument } from "./types.js";
+export interface MarkdownWriteOptions {
+    /** 이미지를 base64 data URI 로 인라인 (브라우저에서 즉시 렌더링) */
+    embedImages?: boolean;
+    /** 이미지 src 경로 변환 (embedImages=false 일 때) */
+    imageSrcResolver?: (binPath: string, storageId: number) => string;
+}
+export declare function hwpDocumentToMarkdown(doc: HwpDocument, options?: MarkdownWriteOptions): string;

package/dist/lib/hwp/mdWriter.js

@@ -0,0 +1,182 @@
+/**
+ * HwpDocument IR → Markdown.
+ *
+ * 보존:
+ *   - 문단 텍스트
+ *   - 글자 모양 굵게/기울임 (charShape lookup)
+ *   - 표 (markdown table; 셀 병합은 평탄화)
+ *   - 이미지 (`![](BinData/imageN.ext)` 또는 `data:` URI 인라인)
+ *   - 머리말/꼬리말/각주 (인용 블록)
+ *
+ * 의도적으로 단순화한 부분:
+ *   - 헤딩 레벨 자동 판별 안 함 (paraShape.heading 정보 부족)
+ *   - 색상/사이즈는 마크다운 표준에서 표현 못 함 → 무시
+ *   - 줄바꿈은 \n\n 으로 문단 구분
+ */
+import { detectImageMime } from "./binData.js";
+export function hwpDocumentToMarkdown(doc, options) {
+    const blocks = [];
+    for (const section of doc.sections) {
+        for (const para of section.paragraphs) {
+            const md = renderParagraph(para, doc, options);
+            if (md.length > 0)
+                blocks.push(md);
+        }
+    }
+    return blocks.join("\n\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+function renderParagraph(p, doc, options) {
+    const parts = [];
+    // 본문 runs (charShape 기반 굵게/기울임 보존)
+    if (p.runs.length > 0) {
+        parts.push(renderRuns(p.runs, doc));
+    }
+    else if (p.text.length > 0) {
+        parts.push(escapeMd(p.text));
+    }
+    // 컨트롤
+    for (const ctrl of p.controls) {
+        switch (ctrl.kind) {
+            case "table":
+                parts.push(renderTable(ctrl, doc, options));
+                break;
+            case "picture": {
+                const md = renderPicture(ctrl.binDataId, doc, options);
+                if (md)
+                    parts.push(md);
+                break;
+            }
+            case "header":
+            case "footer":
+            case "footnote": {
+                const inner = ctrl.paragraphs
+                    .map((q) => renderParagraph(q, doc, options))
+                    .filter((s) => s.length > 0)
+                    .join("\n");
+                if (inner) {
+                    // 인용 블록으로 표시
+                    parts.push(inner.split("\n").map((line) => `> ${line}`).join("\n"));
+                }
+                break;
+            }
+            case "equation":
+                if (ctrl.script.length > 0) {
+                    parts.push("```\n" + ctrl.script + "\n```");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return parts.filter((s) => s.length > 0).join("\n\n");
+}
+function renderRuns(runs, doc) {
+    const out = [];
+    for (const run of runs) {
+        if (run.text.length === 0)
+            continue;
+        const cs = doc.docInfo.charShapes[run.charShapeId];
+        out.push(applyInlineStyle(escapeMd(run.text), cs));
+    }
+    return out.join("");
+}
+function applyInlineStyle(text, cs) {
+    if (!cs)
+        return text;
+    let s = text;
+    if (cs.bold)
+        s = `**${s}**`;
+    if (cs.italic)
+        s = `*${s}*`;
+    // 밑줄/취소선: 표준 MD 부재 — 생략
+    return s;
+}
+function renderTable(t, doc, options) {
+    if (t.rowCount === 0 || t.colCount === 0)
+        return "";
+    // 셀을 행별로 그룹핑하고 col 순으로 정렬
+    const grid = Array.from({ length: t.rowCount }, () => new Array(t.colCount).fill(undefined));
+    for (const cell of t.cells) {
+        if (cell.row >= 0 && cell.row < t.rowCount && cell.col >= 0 && cell.col < t.colCount) {
+            // 병합된 셀 영역도 마크다운에서는 동일 컨텐츠로 채움 (표준 MD 표는 병합 미지원)
+            for (let r = 0; r < cell.rowSpan; r++) {
+                for (let c = 0; c < cell.colSpan; c++) {
+                    const ri = cell.row + r;
+                    const ci = cell.col + c;
+                    if (ri < t.rowCount && ci < t.colCount && !grid[ri][ci]) {
+                        grid[ri][ci] = cell;
+                    }
+                }
+            }
+        }
+    }
+    const rows = [];
+    for (const row of grid) {
+        const cellTexts = row.map((cell) => {
+            if (!cell)
+                return "";
+            const inner = cell.paragraphs
+                .map((q) => renderParagraph(q, doc, options))
+                .filter((s) => s.length > 0)
+                .join(" ")
+                .replace(/\n+/g, " ")
+                .replace(/\|/g, "\\|");
+            return inner;
+        });
+        rows.push(cellTexts);
+    }
+    if (rows.length === 0)
+        return "";
+    // 첫 행을 헤더로 (마크다운 표 규칙 — 항상 헤더 1행 + 구분선)
+    const header = rows[0];
+    const sep = header.map(() => "---");
+    const body = rows.slice(1);
+    const fmt = (cells) => `| ${cells.map((c) => c || " ").join(" | ")} |`;
+    const lines = [];
+    lines.push(fmt(header));
+    lines.push(fmt(sep));
+    for (const row of body)
+        lines.push(fmt(row));
+    return lines.join("\n");
+}
+function renderPicture(binDataId, doc, options) {
+    const entry = doc.binData.get(binDataId);
+    if (!entry)
+        return "";
+    const ext = entry.extension.toLowerCase();
+    const binPath = `BinData/image${binDataId}.${ext}`;
+    if (options?.embedImages) {
+        const mime = detectImageMime(ext);
+        const b64 = bytesToBase64(entry.data);
+        return `![](data:${mime};base64,${b64})`;
+    }
+    if (options?.imageSrcResolver) {
+        return `![](${options.imageSrcResolver(binPath, binDataId)})`;
+    }
+    return `![](${binPath})`;
+}
+function bytesToBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    // 브라우저 fallback
+    let bin = "";
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return globalThis.btoa?.(bin) ?? "";
+}
+/**
+ * 마크다운 메타문자 이스케이프.
+ * 너무 공격적으로 하면 문서가 읽기 어려워지므로 핵심만 처리.
+ *   - 백슬래시
+ *   - 인라인 강조: `*`, `_`, `` ` ``, `~`
+ *   - 줄 시작의 헤딩(#)/인용(>) 마커
+ *
+ * 줄 시작의 `1.`, `-`, `+` 는 일부러 이스케이프하지 않는다 — 일반 텍스트(특히 날짜)에 너무 자주 등장.
+ */
+function escapeMd(text) {
+    return text
+        .replace(/\\/g, "\\\\")
+        .replace(/([*_`~])/g, "\\$1")
+        .replace(/^([#>])/gm, "\\$1");
+}