fencen 0.0.1 → 0.1.0

package/README.md

@@ -0,0 +1,85 @@
+# fencen
+
+Safe and simple utilities for wrapping code in Markdown-style fences.
+
+## Usage
+
+```ts
+import fencen, {blockFences, inlineFences, pickFence} from 'fencen'
+
+fencen('hello')
+// ```
+// hello
+// ```
+
+const fence = pickFence('hello')
+fence.opener() // '```\n'
+fence.closer() // '\n```'
+
+fencen('hello ` world', {inline: true})
+// `` hello ` world ``
+
+fencen('const value = 1', {inline: true, language: 'ts'})
+// <code language="ts">const value = 1</code>
+```
+
+`pickFence` returns a `Fence` with `opener()` and `closer()` renderers. Block Markdown fences render `language` after the opener. Inline output with a language uses the XML `<code language="…">` fence because Markdown inline-code fences have no language syntax. XML attribute values are escaped.
+
+## Trimming
+
+`trim` accepts a boolean or object:
+
+```ts
+fencen(input, {
+  trim: {
+    vertical: true,
+    lines: true,
+    indentation: true,
+  },
+})
+```
+
+`trim: true` is equivalent to:
+
+```ts
+{
+  vertical: true,
+  lines: false,
+  indentation: false,
+}
+```
+
+`vertical` removes surrounding blank lines, `lines` trims trailing whitespace from each line and `indentation` removes shared leading indentation. `trim` defaults to `true`.
+
+## Fence candidates
+
+`blockFences` and `inlineFences` are static arrays. `pickFence` checks them in order and throws a `RangeError` if none is safe.
+
+Block candidates are:
+
+```text
+```
+````
+`````
+``````
+~~~
+~~~~
+~~~~~
+~~~~~~
+```````
+~~~~~~~
+````````
+<code>
+```
+
+Inline candidates are:
+
+```text
+`
+``
+```
+````
+<code>
+```
+
+Multi-backtick inline fences include a trailing space in the opener and a leading space in the closer. The single-backtick fence and `<code>` fallback are unspaced.

package/lib.d.ts

@@ -0,0 +1,31 @@
+declare const fencen: {
+	(input: string, options?: Options): string;
+	inline(input: string, options?: Exclude<Options, "inline">): string;
+	block(input: string, options?: Exclude<Options, "inline">): string;
+};
+export declare const blockFences: Fence[];
+export declare const inlineFences: Fence[];
+export declare const pickFence: (input: string, inline?: boolean, language?: string) => Fence;
+type Fence = {
+	closer: () => string;
+	opener: (payload?: FencePayload) => string;
+};
+type FencePayload = {
+	language?: string;
+};
+type Options = {
+	inline?: "auto" | boolean;
+	language?: string;
+	trim?: TrimOptions;
+};
+type TrimOptions = {
+	indentation?: boolean;
+	lines?: boolean;
+	vertical?: boolean;
+} | boolean;
+
+export {
+	fencen as default,
+};
+
+export {};

package/lib.js

@@ -0,0 +1,23 @@
+var e=(e,n)=>{let t=e.repeat(n)
+return{opener:e=>e?.language?`${t}${e.language}\n`:`${t}\n`,closer:()=>`\n${t}`}},n=[e("`",3),e("`",4),e("`",5),e("`",6),e("~",3),e("~",4),e("~",5),e("~",6),e("`",7),e("~",7),e("`",8),{opener:()=>"<code>\n",closer:()=>"\n</code>"}],t=e=>{let n="`".repeat(e)
+return 1===e?{opener:()=>n,closer:()=>n}:{opener:()=>`${n} `,closer:()=>` ${n}`}},l=[t(1),t(2),t(3),t(4),{opener:e=>e?.language?`<code language="${(e=>e.replaceAll("&","&amp;").replaceAll('"',"&quot;").replaceAll("<","&lt;").replaceAll(">","&gt;"))(e.language)}">`:"<code>",closer:()=>"</code>"}],r=/\r\n|[\n\r\u2028\u2029]/u,i=e=>e.opener().trimEnd(),o=e=>"<code>"===i(e),a=e=>!e.includes("<code>")&&!e.includes("</code>"),c=(e,n)=>{if(o(n))return a(e)
+let t=i(n)
+for(let n of e.split(r))if(n.replace(/^ {0,3}/u,"").startsWith(t))return!1
+return!0},u=(e,n)=>o(n)?a(e):!e.includes(i(n)),s=(e,t=!1,r)=>{let i=n
+t&&(i=r?l.slice(-1):l)
+for(let n of i)if(t?u(e,n):c(e,n))return n
+throw RangeError("No safe fence is available.")},g=/\r\n|[\n\r\u2028\u2029]/gu,f=/\r\n|[\n\r\u2028\u2029]/u,p=/^\s*$/u,d=(e,n={})=>{let t=((e,n=!0)=>{let t=((e=!0)=>"boolean"==typeof e?{vertical:e,lines:!1,indentation:!1}:{vertical:e.vertical??!1,lines:e.lines??!1,indentation:e.indentation??!1})(n)
+if(!t.vertical&&!t.lines&&!t.indentation)return e
+let l=(e=>{let n=[],t=0
+for(let l of e.matchAll(g)){let r=l.index
+n.push({content:e.slice(t,r),lineBreak:l[0]}),t=r+l[0].length}return n.push({content:e.slice(t),lineBreak:""}),n})(e)
+if(t.lines)for(let e of l)e.content=e.content.trimEnd()
+if(t.vertical){for(;l.length>0&&p.test(l[0].content);)l.shift()
+for(;l.length>0&&p.test(l.at(-1).content);)l.pop()
+l.length>0&&(l.at(-1).lineBreak="")}if(t.indentation){let e=(e=>{let n=e.filter(e=>!p.test(e.content))
+return 0===n.length?0:Math.min(...n.map(e=>/^\s*/u.exec(e.content)[0].length))})(l)
+if(e>0)for(let n of l)n.content=n.content.slice(e)}return l.map(e=>e.content+e.lineBreak).join("")})(e,n.trim),l=((e,n,t)=>!t&&("auto"===n?!f.test(e):n??!1))(t,n.inline,n.language),r=s(t,l,n.language)
+return`${r.opener({language:n.language})}${t}${r.closer()}`}
+d.inline=(e,n={})=>d(e,{...n,inline:!0}),d.block=(e,n={})=>d(e,{...n,inline:!1})
+var h=d
+export{n as blockFences,h as default,l as inlineFences,s as pickFence}

package/package.json

@@ -1 +1 @@
-{"name":"fencen","description":"returns `'fencen'`","version":"0.0.1","type":"module","exports":{".":{"types":"./index.d.ts","import":"./index.js","default":"./index.js"}},"author":"Jaid <6216144+Jaid@users.noreply.github.com> (https://github.com/Jaid)","license":"MIT","repository":"github:Jaid/fencen"}
+{"bugs":{"url":"https://github.com/Jaid/fencen/issues"},"description":"safe and simple utilities for wrapping code in Markdown-style fences","homepage":"https://github.com/Jaid/fencen#readme","license":"MIT","name":"fencen","repository":"github:Jaid/fencen","version":"0.1.0","type":"module","exports":{".":{"types":"./lib.d.ts","import":"./lib.js","default":"./lib.js"}},"types":"./lib.d.ts"}

package/index.d.ts

@@ -1,6 +0,0 @@
-declare module 'fencen' {
-  /**
-   * returns `'fencen'`
-   */
-  export default () => string
-}

package/index.js

@@ -1 +0,0 @@
-export default () => 'fencen'

package/readme.md

@@ -1 +0,0 @@
-# fencen