svelte-preprocess-org 0.2.4 → 0.3.0

package/dist/index.d.ts

@@ -1,8 +1,139 @@
-/// <reference types="svelte" />
-import type { PreprocessorGroup } from "svelte/compiler";
-import { type OxSvelteOptions } from "./emacs.js";
-export interface OrgPreprocessorOptions extends OxSvelteOptions {
-    extensions?: string[];
-}
-export declare function orgPreprocess(options?: OrgPreprocessorOptions): PreprocessorGroup;
-export default orgPreprocess;
+import { PreprocessorGroup } from "svelte/compiler";
+
+//#region src/emacs.d.ts
+/**
+ * An S-expression.
+ */
+type Sexp = Value | Cell;
+/**
+ * A value in an S-expression.
+ */
+type Value = Atom | Keyword | Quote | string | number | boolean | null;
+/**
+ * A cons cell.
+ */
+type Cell = {
+  car: Sexp;
+  cdr: Sexp;
+};
+/**
+ * An atom in an S-expression.
+ */
+type Atom = {
+  atom: string;
+};
+/**
+ * A keyword in an S-expression.
+ */
+type Keyword = {
+  keyword: string;
+};
+/**
+ * A quoted S-expression.
+ */
+type Quote = {
+  quote: Sexp;
+};
+/**
+ * Check if a value is a cons cell.
+ */
+//#endregion
+//#region src/org-export.d.ts
+/**
+ * Customization options for Org export engine.
+ *
+ * See the documentation for `ox` for more details.
+ */
+type OrgExportCustomization = Partial<{
+  withSmartQuotes: boolean;
+  withEmphasize: boolean;
+  withSpecialStrings: boolean;
+  withFixedWidth: boolean;
+  withTimestamps: boolean;
+  preserveBreaks: boolean;
+  withSubSuperscripts: boolean | Atom;
+  withArchivedTrees: boolean | Atom;
+  expandLinks: boolean;
+  withBrokenLinks: boolean | Atom;
+  withClocks: boolean;
+  withCreator: boolean;
+  withDrawers: boolean;
+  withDate: boolean;
+  withEntities: boolean;
+  withEmail: boolean;
+  withFootnotes: boolean;
+  headlineLevels: number;
+  withInlinetasks: boolean;
+  withSectionNumbers: boolean | number;
+  withPlanning: boolean;
+  withPriority: boolean;
+  withProperties: boolean | Atom[];
+  withStatisticsCookies: boolean;
+  withTags: boolean | Atom;
+  withTasks: boolean | Atom;
+  withLatex: boolean | Atom;
+  timestampFile: boolean;
+  withTitle: boolean;
+  withToc: boolean;
+  todoKeywords: boolean;
+  withTables: boolean;
+}>;
+/**
+ * Generate Emacs Lisp code to customize the Org export engine.
+ */
+//#endregion
+//#region src/org-svelte.d.ts
+/**
+ * Customization options for exporting Org documents as Svelte components.
+ *
+ * See the documentation for `ox-svelte` for more details.
+ */
+type OrgSvelteCustomization = Partial<{
+  anchorFormat: `${string}%s${string}%s${string}`;
+  brokenLinkFormat: string;
+  componentImportAlist: Record<string, string | string[] | null>;
+  metadataExportList: string[];
+  imageFormat: `${string}%s${string}%s${string}`;
+  latexEnviromnetFormat: `${string}%s${string}`;
+  latexDisplayFragmentFormat: `${string}%s${string}`;
+  latexInlineFragmentFormat: `${string}%s${string}`;
+  linkOrgFileAsSvelte: boolean;
+  rawScriptContent: string;
+  srcBlockFormat: `${string}%s${string}%s${string}`;
+  textMarkupAlist: Record<"bold" | "code" | "italic" | "strike-through" | "underline" | "verbatim", `${string}%s${string}`>;
+  verbose: boolean;
+}>;
+/**
+ * Generate Emacs Lisp code to customize the Org to Svelte export engine.
+ */
+//#endregion
+//#region src/index.d.ts
+/**
+ * Options for preprocessing Org documents to Svelte components.
+ *
+ * See the documentation for `ox` and `ox-svelte` for more details.
+ */
+type OrgPreprocessOptions = Partial<{
+  /**
+   * List of file extensions to process as Org documents.
+   */
+  extensions: string[];
+  /**
+   * List of glob patterns to locate Org files for updating ID locations.
+   */
+  idLocations: string[];
+  /**
+   * Directory to use as Emacs `user-emacs-directory`.
+   */
+  initDirectory: string;
+  /**
+   * List of extra S-expressions to evaluate during initialization.
+   */
+  initSexps: Sexp[];
+}> & OrgExportCustomization & OrgSvelteCustomization;
+/**
+ * Preprocess Org documents to Svelte components.
+ */
+declare function orgPreprocess(options?: OrgPreprocessOptions): PreprocessorGroup;
+//#endregion
+export { OrgPreprocessOptions, orgPreprocess as default, orgPreprocess };

package/dist/index.js

@@ -1 +1,328 @@
-import{execSync as n}from"node:child_process";import{join as r}from"node:path";class e{name;constructor(n){this.name=n}}class t{sexp;constructor(n){this.sexp=n}}function o(n){return n instanceof Object&&"car"in n&&"cdr"in n}function c(n){return null===n}function i(n,r){return{car:n,cdr:r}}function a(...n){if(0===n.length)return null;const[r,...e]=n;return i(r,a(...e))}function s(n){if(o(n))return`(${u(n)})`;if(c(n))return"nil";if("string"==typeof n)return`"${n}"`;if(function(n){return"number"==typeof n}(n))return n.toString();if(function(n){return"boolean"==typeof n}(n))return n?"t":"nil";if(n instanceof e)return n.name;if(n instanceof t)return`'${s(n.sexp)}`;throw new TypeError("Unknown type of S-expression: "+typeof n)}function u(n){let r="";if(o(n.car)?r+=`(${u(n.car)})`:r+=s(n.car),o(n.cdr))r+=` ${u(n.cdr)}`;else{if(c(n.cdr))return r;r+=` . ${s(n.cdr)}`}return r}function f(o){const{extensions:c=[".org"],...u}=o||{};return{markup({content:o,filename:f}){if(f&&!c.some((n=>f.endsWith(n))))return{code:o};const l=function(o,c){const{latexEnvironmentFormat:u,latexFragmentFormat:f,srcBlockFormat:l,imports:m}=c||{};let p=`/usr/bin/env emacs --script ${r(import.meta.dirname,"lisp","convert.el")}`;u&&(p+=` --latex-environment-format '${u.replaceAll("'","'\\''")}'`),f&&(p+=` --latex-fragment-format '${f.replaceAll("'","'\\''")}'`),l&&(p+=` --src-block-format '${l.replaceAll("'","'\\''")}'`),m&&(p+=` --preface '${s(a(new e("setq"),new e("org-svelte-component-import-alist"),new t(a(...Object.entries(m).map((([n,r])=>i(n,r))))))).replaceAll("'","'\\''")}'`);return n(p,{input:o}).toString()}(o,u);return{code:l}}}}export{f as default,f as orgPreprocess};
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fullpath from "ox-svelte";
+import { globSync } from "tinyglobby";
+import { spawnSync } from "node:child_process";
+
+//#region src/emacs.ts
+/**
+* Check if a value is a cons cell.
+*/
+function isCell(x) {
+	return x instanceof Object && "car" in x && "cdr" in x;
+}
+/**
+* Check if a value is an atom.
+*/
+function isAtom(x) {
+	return x instanceof Object && "atom" in x;
+}
+/**
+* Check if a value is a keyword.
+*/
+function isKeyword(x) {
+	return x instanceof Object && "keyword" in x;
+}
+/**
+* Check if a value is a quoted S-expression.
+*/
+function isQuote(x) {
+	return x instanceof Object && "quote" in x;
+}
+/**
+* Check if a value is a nil value
+*/
+function isNil(x) {
+	return x === null;
+}
+/**
+* Check if a value is a string.
+*/
+function isString(x) {
+	return typeof x === "string";
+}
+/**
+* Check if a value is a number.
+*/
+function isNumber(x) {
+	return typeof x === "number";
+}
+/**
+* Check if a value is a boolean.
+*/
+function isBoolean(x) {
+	return typeof x === "boolean";
+}
+/**
+* Create a cons cell.
+*/
+function cons(car, cdr) {
+	return {
+		car,
+		cdr
+	};
+}
+/**
+* Create a quoted S-expression.
+*/
+function quote(sexp) {
+	if (isKeyword(sexp)) return k`${sexp.keyword}`;
+	else return { quote: sexp };
+}
+/**
+* Create a list from a sequence of S-expressions.
+*/
+function list(...args) {
+	if (args.length === 0) return null;
+	const [car, ...rest] = args;
+	return cons(car, list(...rest));
+}
+/**
+* Create an atom from a tagged template string.
+*/
+function a(raw, ...substitutions) {
+	return { atom: String.raw({ raw }, ...substitutions) };
+}
+/**
+* Create a keyword from a tagged template string.
+*/
+function k(raw, ...substitutions) {
+	return { keyword: String.raw({ raw }, ...substitutions) };
+}
+/**
+* Convert an S-expression to a string.
+*/
+function stringify(sexp) {
+	switch (true) {
+		case isCell(sexp): return `(${stringifyList(sexp)})`;
+		case isNil(sexp): return "nil";
+		case isString(sexp): return `"${sexp}"`;
+		case isNumber(sexp): return sexp.toString();
+		case isBoolean(sexp): return sexp ? "t" : "nil";
+		case isAtom(sexp): return sexp.atom;
+		case isKeyword(sexp): return `:${sexp.keyword}`;
+		case isQuote(sexp): return `'${stringify(sexp.quote)}`;
+		default: throw new TypeError(`Unknown type of S-expression: ${typeof sexp}`);
+	}
+}
+/**
+* Convert a list to a string.
+*/
+function stringifyList(list$1) {
+	let result = "";
+	if (isCell(list$1.car)) result += `(${stringifyList(list$1.car)})`;
+	else result += stringify(list$1.car);
+	if (isCell(list$1.cdr)) result += ` ${stringifyList(list$1.cdr)}`;
+	else if (isNil(list$1.cdr)) return result;
+	else result += ` . ${stringify(list$1.cdr)}`;
+	return result;
+}
+/**
+* An Emacs instance for evaluating S-expressions.
+*
+* Since each Emacs instance constructetd from this class is assigned their own
+* temporary directory as their init directory, any persistent state that needs
+* to be preserved between evaluations can be stored in that directory (e.g. in
+* the .eld files).
+*/
+var Emacs = class {
+	/**
+	* S-expression to evaluate when `run` method is called.
+	*/
+	sexps = [];
+	/**
+	* String value to be piped into the standard input.
+	*/
+	stdin;
+	/**
+	* Initialize a new Emacs instance.
+	*
+	* Internally, this will request a temporary directory to be created, which
+	* will be used as the Emacs init directory when `Emacs.run` is called.
+	*
+	* @param initDirectory - Directory that will be used as the `user-emacs-directory`.
+	*/
+	constructor(initDirectory) {
+		this.initDirectory = initDirectory;
+		this.stdin = "";
+	}
+	/**
+	* Register the features/packages to require.
+	*
+	* This function will append to the previous value.
+	* The `run` call will not reset this value.
+	*/
+	require(feature, filename) {
+		this.sexps.push(filename ? list(a`require`, quote(a`${feature}`), filename) : list(a`require`, quote(a`${feature}`)));
+		return this;
+	}
+	/**
+	* Register S-expressions to evaluate.
+	*
+	* This function will append to the previous value.
+	* The `run` call will reset this value.
+	*/
+	progn(...sexps) {
+		this.sexps.push(...sexps);
+		return this;
+	}
+	/**
+	* Register the string to be fed into the standard input.
+	*
+	* This function will replace the previous value.
+	* The `run` call will reset this value.
+	*/
+	minibuffer(content) {
+		this.stdin = content;
+		return this;
+	}
+	/**
+	* Run the registered S-expressions in Emacs.
+	*
+	* @rehturns The standard output of the Emacs process.
+	*/
+	run() {
+		const { stdout, stderr, error } = spawnSync("emacs", [
+			`--init-directory=${this.initDirectory}`,
+			"--batch",
+			"--eval",
+			stringify(list(a`progn`, ...this.sexps))
+		], { input: this.stdin });
+		if (error) throw new Error(`Error running Emacs: ${stderr}`, { cause: error });
+		this.sexps = [];
+		this.stdin = "";
+		return stdout.toString();
+	}
+};
+
+//#endregion
+//#region src/utilities.ts
+/**
+* Convert a lowerCamelCase string to kebab case.
+*
+* @param s The string to convert.
+* @returns The kebab-cased string.
+*/
+function toKebabCase(s) {
+	return s.replace(/[A-Z]+(?!a-z)|[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+
+//#endregion
+//#region src/org-export.ts
+/**
+* Generate Emacs Lisp code to customize the Org export engine.
+*/
+function customize(options = {}) {
+	const transformed = Object.entries(options).flatMap(([key, val]) => {
+		switch (key) {
+			case "withProperties": return [a`org-export-with-properties`, Array.isArray(val) ? quote(list(...val)) : val];
+			case "withSmartQuotes":
+			case "withEmphasize":
+			case "withSpecialStrings":
+			case "withFixedWidth":
+			case "withTimestamps":
+			case "preserveBreaks":
+			case "withSubSuperscripts":
+			case "withArchivedTrees":
+			case "expandLinks":
+			case "withBrokenLinks":
+			case "withClocks":
+			case "withCreator":
+			case "withDrawers":
+			case "withDate":
+			case "withEntities":
+			case "withEmail":
+			case "withFootnotes":
+			case "headlineLevels":
+			case "withInlinetasks":
+			case "withSectionNumbers":
+			case "withPlanning":
+			case "withPriority":
+			case "withStatisticsCookies":
+			case "withTags":
+			case "withTasks":
+			case "withLatex":
+			case "timestampFile":
+			case "withTitle":
+			case "withToc":
+			case "todoKeywords":
+			case "withTables": return [a`org-export-${toKebabCase(key)}`, val];
+			default: return [];
+		}
+	});
+	return list(a`setq`, ...transformed);
+}
+
+//#endregion
+//#region src/org-svelte.ts
+/**
+* Generate Emacs Lisp code to customize the Org to Svelte export engine.
+*/
+function customize$1(options = {}) {
+	const transformed = Object.entries(options).flatMap(([key, val]) => {
+		switch (key) {
+			case "componentImportAlist": {
+				const cia = val;
+				return [a`org-svelte-component-import-alist`, quote(list(...Object.entries(cia).map(([k$1, v]) => {
+					if (Array.isArray(v)) return cons(k$1, list(...v));
+					else return cons(k$1, v);
+				})))];
+			}
+			case "metadataExportList": {
+				const mel = val;
+				return [a`org-svelte-metadata-export-list`, quote(list(...mel.map((v) => k`${v}`)))];
+			}
+			case "textMarkupAlist": {
+				const tma = val;
+				return [a`org-svelte-text-markup-alist`, quote(list(...Object.entries(tma).map(([key$1, val$1]) => cons(key$1, val$1))))];
+			}
+			case "anchorFormat":
+			case "brokenLinkFormat":
+			case "imageFormat":
+			case "latexEnviromnetFormat":
+			case "latexDisplayFragmentFormat":
+			case "latexInlineFragmentFormat":
+			case "linkOrgFileAsSvelte":
+			case "rawScriptContent":
+			case "srcBlockFormat":
+			case "verbose": return [a`org-svelte-${toKebabCase(key)}`, val];
+			default: return [];
+		}
+	});
+	return list(a`setq`, ...transformed);
+}
+/**
+* Export an Org document as Svelte code.
+*
+* Note: This function expects the content of the Org document to be provided
+* via minibuffer input (i.e., stdin).
+*
+* @param options Customization options for the export.
+* @returns The generated Svelte component as a string.
+*/
+const exportMinibufferAsSvelte = list(a`let`, list(list(a`content`, ``)), list(a`while`, list(a`setq`, a`line`, list(a`ignore-errors`, list(a`read-string`, ``))), list(a`setq`, a`content`, list(a`concat`, a`content`, `\\n`, a`line`))), list(a`with-temp-buffer`, list(a`org-mode`), list(a`insert`, a`content`), list(a`org-svelte-export-as-svelte`), list(a`princ`, list(a`buffer-string`))));
+
+//#endregion
+//#region src/index.ts
+/**
+* Preprocess Org documents to Svelte components.
+*/
+function orgPreprocess(options) {
+	const { extensions = [".org"], idLocations = [], initDirectory = mkdtempSync(join(tmpdir(), "svelte-preprocess-org-")), initSexps = [],...rest } = options || {};
+	const emacs = new Emacs(initDirectory);
+	if (initSexps.length > 0) emacs.progn(...initSexps).run();
+	if (idLocations.length > 0) {
+		const files = globSync(idLocations);
+		if (files.length > 0) emacs.require("org").progn(list(a`org-id-update-id-locations`, quote(list(...files)))).run();
+	}
+	return { markup({ content, filename }) {
+		if (filename && !extensions.some((ext) => filename.endsWith(ext))) return { code: content };
+		const code = emacs.require("ox-svelte", fullpath).progn(customize(rest)).progn(customize$1(rest)).progn(exportMinibufferAsSvelte).minibuffer(content).run();
+		return { code };
+	} };
+}
+var src_default = orgPreprocess;
+
+//#endregion
+export { src_default as default, orgPreprocess };

package/package.json

@@ -1,45 +1,37 @@
 {
   "name": "svelte-preprocess-org",
-  "type": "module",
-  "version": "0.2.4",
-  "description": "Svelte preprocessor for Org-mode",
+  "version": "0.3.0",
+  "description": "Svelte preprocessor for Org-mode documents",
   "author": "RangHo Lee <hello@rangho.me>",
   "homepage": "https://github.com/RangHo/svelte-preprocess-org",
   "license": "GPL-3.0-or-later",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": "dist/*",
-  "engines": {
-    "node": ">=20.11.0 || >=21.2.0"
-  },
+  "files": [
+    "dist/*"
+  ],
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "@tsconfig/node-lts": "^20.1.1",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.11.19",
-    "eslint": "^8.56.0",
-    "jest": "^29.7.0",
-    "ox-svelte": "^0.1.0",
-    "prettier": "^3.1.1",
-    "rollup": "^4.12.0",
-    "rollup-plugin-copy": "^3.5.0",
-    "svelte": "^4.2.12",
-    "ts-jest": "^29.1.2",
-    "tslib": "^2.6.2",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^7.2.0"
+    "@tsconfig/node-lts": "^22.0.2",
+    "@types/node": "^22.17.0",
+    "ox-svelte": "0.4.4",
+    "svelte": "^5.2.11"
   },
   "peerDependencies": {
-    "ox-svelte": "^0.1.0",
-    "svelte": "^4.2.12"
+    "ox-svelte": "0.4.4",
+    "svelte": "^5.2.11"
+  },
+  "dependencies": {
+    "tinyglobby": "^0.2.14"
   },
   "scripts": {
-    "build": "rollup -c",
-    "test": "NODE_OPTIONS='--experimental-vm-modules' jest",
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
     "format": "prettier --write .",
-    "lint": "eslint ."
+    "format:check": "prettier --check .",
+    "lint": "eslint . --fix",
+    "lint:check": "eslint ."
   }
 }

package/.editorconfig

@@ -1,15 +0,0 @@
-# This is the top-level editorconfig
-root = true
-
-# General file conventions
-charset = utf-8
-trim_trailing_whitespace = true
-end_of_line = lf
-insert_final_newline = true
-max_line_length = 120
-
-# JavaScript and TypeScript files
-[*.{js,cjs,mjs,ts,cts,mts}]
-indent_style = space
-indent_size = 2
-

package/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "src/lisp/ox-svelte"]
-	path = src/lisp/ox-svelte
-	url = https://github.com/RangHo/ox-svelte

package/README.md

@@ -1,11 +0,0 @@
-# Svelte Preprocessor for Org-mode Documents
-
-[Svelte](https://svelte.dev/) preprocessor to import [Org mode](https://orgmode.org)
-documents as a component, powered by [ox-svelte](https://github.com/RangHo/ox-svelte).
-
-## Prerequisites
-
-This package deliberately refrains from parsing Org mode documents.
-These processes are delegated to an actual instance of Emacs.
-
-Therefore, you need **Emacs 29** or newer installed on your system.

package/dist/emacs.d.ts

@@ -1,7 +0,0 @@
-export interface OxSvelteOptions {
-    latexEnvironmentFormat?: string;
-    latexFragmentFormat?: string;
-    srcBlockFormat?: string;
-    imports?: Record<string, string>;
-}
-export declare function convert(content: string, options?: OxSvelteOptions): string;

package/dist/lisp/convert.el

@@ -1,86 +0,0 @@
-;;; convert.el --- Read Org-mode files from stdin and write Svelte components to stdout.
-
-;; Author: RangHo Lee <hello@rangho.me>
-
-;;; Commentary:
-
-;; This script accepts the content of an Org-mode file from stdin, converts it
-;; to a Svelte component, and writes the result to stdout.  This is an Emacs
-;; Lisp script; that is, it needs to be run with Emacs in batch mode.
-;;
-;; It uses `ox-svelte' to perform the conversion.  Make sure that `ox-svelte'
-;; repository is checked out in the same directory, preferably as a git
-;; submodule.
-;;
-;; This script accepts the following command line arguments:
-;;     --preface <elisp-code>
-;;         Evaluate the given Elisp code before processing.
-;;     --latex-environment-format <format>
-;;         Set the format of LaTeX environment to <format>.  The format string
-;;         should contain a single `%s' with which the LaTeX environment content
-;;         will be replaced as a JavaScript raw string.
-;;     --latex-fragment-format <format>
-;;         Set the format of LaTeX fragment to <format>.  The format string
-;;         should contain a single `%s' with which the LaTeX fragment content
-;;         will be replaced as a JavaScript raw string.
-;;     --src-block-format <format>
-;;         Set the format of source block to <format>.  The format string should
-;;         contain two `%s' with which the language and the content of the src
-;;         block will be replaced as a JavaScript raw string.
-;;
-;; To allow more smooth preprocessor chaning, this script sets some arbitrary
-;; options to Org-mode exporter engine.  You can customize the behavior of the
-;; exporter by setting command line arguments, or by providing preface S-exps.
-
-;;; Code:
-
-(require 'ox-svelte
-         (expand-file-name "ox-svelte/ox-svelte.el"
-                           (file-name-directory load-file-name)))
-
-;; Set default settings
-(setq org-export-with-section-numbers nil)
-
-;; Process command line arguments
-(let ((i 0))
-  (while (elt argv i)
-    (cond
-     ;; Evaluate the preface S-exp if provided
-     ((string= (elt argv i) "--preface")
-      (eval (car (read-from-string (elt argv (1+ i)))))
-      (setq i (1+ i)))
-
-     ;; Set the LaTeX environment format
-     ((string= (elt argv i) "--latex-environment-format")
-      (setq org-svelte-latex-environment-format (elt argv (1+ i)))
-      (setq i (1+ i)))
-
-     ;; Set the LaTeX fragment format
-     ((string= (elt argv i) "--latex-fragment-format")
-      (setq org-svelte-latex-fragment-format (elt argv (1+ i)))
-      (setq i (1+ i)))
-
-     ;; Set the source block format
-     ((string= (elt argv i) "--src-block-format")
-      (setq org-svelte-src-block-format (elt argv (1+ i)))
-      (setq i (1+ i)))
-
-     ;; No match found, warn the user and do nothing
-     (t
-      (warn (format "Unsupported argument: %s" (elt argv i)))))
-
-    (setq i (1+ i))))
-
-;; Read the content of the Org-mode file from stdin and convert
-(with-temp-buffer
-  (while (condition-case err
-      (setq line (read-from-minibuffer ""))
-      (error nil))
-    (insert line "\n"))
-  (org-svelte-export-as-svelte)
-  (princ (buffer-string)))
-
-;; Exit Emacs after conversion to prevent unnecessary errors
-(kill-emacs 0)
-
-;;; convert.el ends here