@p-buddy/parkdown 0.0.0

package/.assets/api-note.md

@@ -0,0 +1,3 @@
+**_NOTE ON API USAGE:_** As you can see from the included examples, each _invocation_ of an API method looks like a less strict (more quirky) version of a typical javascript function invocation. 
+
+Please see the [full explanation](#query-parameters-with-function-like-apis) to learn more and/or if the below is confusing.

package/.assets/api.md

@@ -0,0 +1,34 @@
+## Query Parameters with Function-like APIs
+
+Some query parameters have more complex APIs, which are defined by a collection of typescript function singatures (limited to only `string`, `boolean`, and `number` arguments), like:
+
+```ts
+const definitions = [
+  "method(arg1: string, arg2: boolean, arg3?: number)",
+  "otherMethod(arg1: string, arg2?: boolean, arg3?: number)"
+]
+```
+
+These APIs are utilized when setting the query parameter with a _function-like_ invocation syntax, such as:
+
+```md
+[](<url>?example=method(hello-world,true))
+```
+
+As you can maybe tell from the example above, we're relaxing some constraints on typical function invocations (like the need to wrap string arguments in quotes), while also imposing some additional constraints (like not using spaces) to ensure the links are valid markdown and the URLs are [safe](https://support.exactonline.com/community/s/knowledge-base?language=en_GB#All-All-DNO-Content-urlcharacters).
+
+The goal is to make it as painless as possible to author links that are valid markdown, valid URLs, and easy to read and write.
+
+Please note the following:
+
+- Methods that take no arguments can be invoked without parentheses (e.g. `[](<url>?example=method)`).
+- String arguments do not need to be wrapped in quotes (e.g. `[](<url>?example=method(some-string))`), and they should **NOT** be wrapped in double quotes (see more below).
+- You cannot use spaces within a string argument or anywhere else in the query (as this would violate the markdown link syntax). For arguments that reasonably could include spaces, there should be an optional `space` argument that defaults to `-`, so that any usage of the space character will be converted to a space (e.g. `hello-world` becomes `hello world`).
+- If a method takes a string argument, and you want to include a comma within that argument, you must wrap it in one or more single quotes (`'`). 
+- String arguments wrapped in single set of single quotes will automatically have their single quotes removed when the query is parsed (e.g. the argument included in `[](<url>?example=method('hello,world'))` will parse to `hello,world`).
+- If you want single quotes preserved in the parsed output, use two single quotes in a row (e.g. `[](<url>?example=method(''single-quoted''))`). 
+- You cannot use double quotes within a string argument (as they are not a [URL safe character](https://support.exactonline.com/community/s/knowledge-base#All-All-DNO-Content-urlcharacters)). To include a double-quote in the parsed output, use three single quotes in a row (e.g. `[](<url>?example=method'''double-quoted'''))`).
+- Optional arguments can be completely ommitted (for example if a `method` took 3 optional arguments, and you only wanted to provide the third, you could do the following: `[](<url>?example=method(,,your-third-argument))`).
+- Overall, text meant to be displayed to a human will be _sanitized_ in the following manner (unless otherwise noted):
+
+[](../src/utils.ts?region=extract(sanitize))

package/.assets/authoring.md

@@ -0,0 +1,69 @@
+# Authoring
+
+You author inclusions in your markdown files using a link with no text i.e. `[](<url>)`, where `<url>` points to some local or remote text resource (e.g.`./other.md`, `https://example.com/remote.md`).
+
+These links can be rendered either [inline](#inline) or [block](#block), depending on how you author them.
+
+## Inline
+
+Inline inclusions occur when your _text-less_ link has 1 or more siblings (meaning it's **not** the only node in a [paragraph](https://www.markdownguide.org/basic-syntax/#paragraphs-1)).
+
+There are two equivalent ways to author inline inclusions, [single-line](#single-line) or [multi-line](#multi-line), and which you choose depends solely on how you want your raw markdown to look (it will **not** affect the rendered output).
+
+### Single-line
+
+What you write:
+
+[](./unpopulated/inline.single.md?wrap=code)
+
+What is rendered (**_before_** processing, same as [Option B](#option-b-multi-line)):
+
+[](./unpopulated/inline.single.md?wrap=quote&inline)
+
+What your markdown file contains (**_after_** processing):
+
+[](./populated/inline.single.md?wrap=code)
+
+What is rendered (**_after_** processing, same as [Option B](#option-b-multi-line)):
+
+[](./populated/inline.single.md?wrap=quote&inline)
+
+### Multi-line
+
+What you write:
+
+[](./unpopulated/inline.multi.md?wrap=code)
+
+What is rendered (**_before_** processing, same as [Option A](#option-a-single-line)):
+
+[](./unpopulated/inline.multi.md?wrap=quote&inline)
+
+What your markdown file contains (**_after_** processing):
+
+[](./populated/inline.multi.md?wrap=code)
+
+What is rendered (**_after_** processing, same as [Option A](#option-a-single-line)):
+
+[](./populated/inline.multi.md?wrap=quote&inline)
+
+## Block
+
+Block inclusions occur when your "empty" link is the **only** node in a [paragraph](https://www.markdownguide.org/basic-syntax/#paragraphs-1) (at least before being populated). This is likely the most common way to author inclusions.
+
+What you write:
+
+[](./unpopulated/block.md?wrap=code)
+
+What is rendered (**_before_** processing):
+
+[](./unpopulated/block.md?wrap=quote)
+
+What your markdown file contains (**_after_** processing):
+
+[](./populated/block.md?wrap=code)
+
+What is rendered (**_after_** processing):
+
+[](./populated/block.md?wrap=quote)
+
+[](./query.md?heading=-1)

package/.assets/code/depopulate.ts

@@ -0,0 +1,6 @@
+import { depopulateMarkdownInclusions } from /** p▼: pkg */ "../../src" /** p▼: pkg */;
+
+const file = "README.md";
+const writeFile = true;
+
+depopulateMarkdownInclusions(file, writeFile);

package/.assets/code/inclusions.ts

@@ -0,0 +1,6 @@
+import { populateMarkdownInclusions } from /** p▼: pkg */ "../../src" /** p▼: pkg */;
+
+const file = "README.md";
+const writeFile = true;
+
+populateMarkdownInclusions(file, writeFile);

package/.assets/depopulated.md

@@ -0,0 +1,25 @@
+# Removing populated inclusions
+
+Sometimes you may want to remove populated inclusions from your markdown file, since they can make things more difficult to read during authoring. You can do this either using the [cli](#cli-removing-populated-inclusions) or via the `removePopulatedInclusions` [export](#depopulateMarkdownIncludes-export):
+
+## CLI (removing populated inclusions)
+
+The following commands are all equivalent:
+
+```bash
+npx parkdown --file ./README.md --depopulate --no-inclusions
+npx parkdown -f README.md -d --ni # Notice the double-dash (--) on 'ni'
+npx parkdown -d --ni # defaults to processing the 'README.md' file of the current working directory
+```
+
+The following commands will lead to the same result, but since `--no-inclusions` (`--ni`) is not specified, there will be some wasted work as inclusions will be processed and then removed.
+
+```bash
+npx parkdown --file ./README.md --depopulate
+npx parkdown -f README.md -d
+npx parkdown -d # defaults to processing the 'README.md' file of the current working directory
+```
+
+## `depopulateMarkdownIncludes` export
+
+[](./code/depopulate.ts?region=replace(pkg,'''parkdown'''))

package/.assets/invocation.md

@@ -0,0 +1,16 @@
+# Invocation
+
+Invoke [parkdown's]() functionality with either the [cli](#cli-inclusions) or via the `processMarkdownIncludes` [export](#populateMarkdownIncludes-export):
+
+## CLI
+
+The following commands are all equivalent:
+```bash
+npx parkdown --file ./README.md
+npx parkdown -f README.md
+npx parkdown # defaults to processing inclusions in the 'README.md' file of the current working directory
+```
+
+## `populateMarkdownIncludes` export
+
+[](./code/inclusions.ts?region=replace(pkg,'''parkdown'''))

package/.assets/populated/block.md

@@ -0,0 +1,9 @@
+Before...
+
+[](<url>)
+<!-- p▼ Begin  -->
+...Included Content...
+...Included Content...
+<!-- p▼ End  -->
+
+...After

package/.assets/populated/inline.multi.md

@@ -0,0 +1,5 @@
+Before... 
+[](<url>) <!-- p▼ Begin -->
+...Included Content...
+...Included Content... <!-- p▼ End --> 
+...After

package/.assets/populated/inline.single.md

@@ -0,0 +1,3 @@
+Before... [](<url>) <!-- p▼ Begin -->
+...Included Content...
+...Included Content... <!-- p▼ End --> ...After

package/.assets/query.md

@@ -0,0 +1,73 @@
+# Query parameters
+
+You can pass query parameters to your inclusion links to control how their content is processed and included within your markdown.
+
+## Processing Order
+
+[](../src/include.ts?&region=extract(query))
+
+## `region`
+
+Either extract, remove, or replace content from the included file based on the provided specifier(s).
+
+Specifiers will be searched for within the file's comments, and are expected to come in pairs / bookend the desired region, like so:
+
+```ts
+/** some-specifier */
+... code to find ...
+/** some-specifier */
+```
+
+```md
+[](...?region=extract(some-specifier))
+```
+
+Below is the currently supported API for the `region` query parameter, where each defined method signature can be _invoked_ as a value for the `region` parameter (e.g. `[](<url>?region=extract(some-specifier))`, `[](<url>?region=remove(some-specifier))`, `[](<url>?region=replace(some-specifier))`).
+
+[](./api-note.md?wrap=quote)
+
+[](../src/region.ts?region=extract(definition))
+
+## `skip`
+
+Skip the default processing behavior for the given type of file. 
+
+[](../src/include.ts?wrap=dropdown(See-default-processing-behavior.)&region=extract(Default-Behavior),replace(...))
+
+```md
+[](<url>?skip)
+```
+
+## `heading` 
+
+Modify the heading depth applied to included content. By default, the headings of the included content are adjusted to be one-level below their parent heading.
+
+In the following example, the headings within the included content of `<url>` will be adjusted to one-level below the parent heading (which is an `h2` / `##`), so any `#` headings will be converted to `###` headings, and `##` headings will be converted to `####` headings, and so on.
+
+```md
+## Heading
+
+[](<url>)
+```
+
+The following would then ensure that the headings of the included content are at the same level as the parent heading.
+
+```md
+## Heading
+
+[](<url>?heading=-1)
+```
+
+A value of `-2` would result in the headings of the included content being at their original level (since the content is being included underneath an `h2` / `##` heading).
+
+## `inline` (Advanced)
+
+## `wrap`
+
+Wrap the content of the included file in a specific kind of element.
+
+Below is the currently supported API for the `wrap` query parameter, where each defined method signature can be _invoked_ as a value for the `wrap` parameter (e.g. `[](<url>?wrap=code)`, `[](<url>?wrap=dropdown(hello-world))`).
+
+[](./api-note.md?wrap=quote)
+
+[](../src/wrap.ts?region=extract(definition))

package/.assets/unpopulated/block.md

@@ -0,0 +1,5 @@
+Before...
+
+[](<url>)
+
+...After

package/.assets/unpopulated/inline.multi.md

@@ -0,0 +1,3 @@
+Before... 
+[](<url>)
+...After

package/.assets/unpopulated/inline.single.md

@@ -0,0 +1 @@
+Before... [](<url>) ...After

package/.devcontainer/Dockerfile

@@ -0,0 +1,16 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.187.0/containers/typescript-node/.devcontainer/base.Dockerfile
+
+# [Choice] Node.js version: 16, 18, 20
+ARG VARIANT="20-buster"
+FROM mcr.microsoft.com/vscode/devcontainers/typescript-node:0-${VARIANT}
+
+# [Optional] Uncomment this section to install additional OS packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>
+
+# [Optional] Uncomment if you want to install an additional version of node using nvm
+# ARG EXTRA_NODE_VERSION=10
+# RUN su node -c "source /usr/local/share/nvm/nvm.sh && nvm install ${EXTRA_NODE_VERSION}"
+
+# To install more global node packages
+RUN su node -c "npm install -g pnpm@10"

package/.devcontainer/devcontainer.json

@@ -0,0 +1,35 @@
+{
+  "name": "parkdown-dev",
+  "dockerFile": "Dockerfile",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-vscode.vscode-typescript-next",
+        "svelte.svelte-vscode",
+        "ms-azuretools.vscode-docker",
+        "bradlc.vscode-tailwindcss",
+        "YoavBls.pretty-ts-errors"
+      ]
+    }
+  },
+  "postStartCommand": [
+    "bash",
+    "-c",
+    "git config --global user.name \"${GIT_USER_NAME}\"",
+    "bash",
+    "-c",
+    "git config --global user.email \"${GIT_USER_EMAIL}\"",
+    "bash",
+    "-c",
+    "pnpm install"
+  ],
+  "mounts": [
+    "source=${localEnv:HOME}/.ssh,target=/home/node/.ssh,type=bind,readonly"
+  ],
+  "containerEnv": {
+    "NPM_TOKEN": "${localEnv:PARKDOWN_NPM_TOKEN}",
+    "HOST_WORKSPACE_PATH": "${localWorkspaceFolder}",
+    "GIT_USER_NAME": "${localEnv:GIT_USER_NAME}",
+    "GIT_USER_EMAIL": "${localEnv:GIT_USER_EMAIL}"
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Parker Malachowsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.