create-acrylblends 0.0.0-stage → 0.1.0

package/docs/framework/middleware/builtin/request-id.md

@@ -0,0 +1,94 @@
+# Request ID Middleware
+
+Request ID Middleware generates a unique ID for each request, which you can use in your handlers.
+
+> **Note.** **Node.js**: This middleware uses `crypto.randomUUID()` to generate IDs. The global `crypto` was introduced in Node.js version 20 or later. Therefore, errors may occur in versions earlier than that. In that case, please specify `generator`. However, if you are using the Node.js adapter, it automatically sets `crypto` globally, so this is not necessary.
+
+## Import
+
+```ts
+import { Acryl } from 'acrylblends'
+import { requestId } from 'acrylblends/request-id'
+```
+
+## Usage
+
+You can access the Request ID through the `requestId` variable in the handlers and middleware to which the Request ID Middleware is applied.
+
+```ts
+const app = new Acryl()
+
+app.use('*', requestId())
+
+app.get('/', (c) => {
+  return c.text(`Your request id is ${c.get('requestId')}`)
+})
+```
+
+If you want to explicitly specify the type, import `RequestIdVariables` and pass it in the generics of `new Acryl()`.
+
+```ts
+import type { RequestIdVariables } from 'acrylblends/request-id'
+
+const app = new Acryl<{
+  Variables: RequestIdVariables
+}>()
+```
+
+### Set Request ID
+
+You set a custom request ID in the header (default: `X-Request-Id`), the middleware will use that value instead of generating a new one:
+
+```ts
+const app = new Acryl()
+
+app.use('*', requestId())
+
+app.get('/', (c) => {
+  return c.text(`${c.get('requestId')}`)
+})
+
+const res = await app.request('/', {
+  headers: {
+    'X-Request-Id': 'your-custom-id',
+  },
+})
+console.log(await res.text()) // your-custom-id
+```
+
+If you want to disable this feature, set [`headerName` option](#headername-string) to an empty string.
+
+## Options
+
+### *(optional)* limitLength: `number`
+
+The maximum length of the request ID. The default is `255`.
+
+### *(optional)* headerName: `string`
+
+The header name used for the request ID. The default is `X-Request-Id`.
+
+### *(optional)* generator: `(c: Context) => string`
+
+The request ID generation function. By default, it uses `crypto.randomUUID()`.
+
+## Platform specific Request IDs
+
+Some platform (such as AWS Lambda) already generate their own Request IDs per request.
+Without any additional configuration, this middleware is unaware of these specific Request IDs
+and generates a new Request ID. This can lead to confusion when looking at your application logs.
+
+To unify these IDs, use the `generator` function to capture the platform specific Request ID and to use it in this middleware.
+
+### Platform specific links
+
+- AWS Lambda
+  - [AWS documentation: Context object](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-context.html)
+  - Acryl: Access AWS Lambda Object
+- Cloudflare
+  - [Cloudflare Ray ID
+    ](https://developers.cloudflare.com/fundamentals/reference/cloudflare-ray-id/)
+- Deno
+  - [Request ID on the Deno Blog](https://deno.com/blog/zero-config-debugging-deno-opentelemetry#:~:text=s%20automatically%20have-,unique%20request%20IDs,-associated%20with%20them)
+- Fastly
+  - [Fastly documentation: req.xid](https://www.fastly.com/documentation/reference/vcl/variables/client-request/req-xid/)

package/docs/framework/middleware/builtin/secure-headers.md

@@ -0,0 +1,247 @@
+# Secure Headers Middleware
+
+Secure Headers Middleware simplifies the setup of security headers. Inspired in part by the capabilities of Helmet, it allows you to control the activation and deactivation of specific security headers.
+
+## Import
+
+```ts
+import { Acryl } from 'acrylblends'
+import { secureHeaders } from 'acrylblends/secure-headers'
+```
+
+## Usage
+
+You can use the optimal settings by default.
+
+```ts
+const app = new Acryl()
+app.use(secureHeaders())
+```
+
+You can suppress unnecessary headers by setting them to false.
+
+```ts
+const app = new Acryl()
+app.use(
+  '*',
+  secureHeaders({
+    xFrameOptions: false,
+    xXssProtection: false,
+  })
+)
+```
+
+You can override default header values using a string.
+
+```ts
+const app = new Acryl()
+app.use(
+  '*',
+  secureHeaders({
+    strictTransportSecurity:
+      'max-age=63072000; includeSubDomains; preload',
+    xFrameOptions: 'DENY',
+    xXssProtection: '1',
+  })
+)
+```
+
+## Supported Options
+
+Each option corresponds to the following Header Key-Value pairs.
+
+| Option                          | Header                                                                                                                                         | Value                                                                      | Default    |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ---------- |
+| -                               | X-Powered-By                                                                                                                                   | (Delete Header)                                                            | True       |
+| contentSecurityPolicy           | [Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)                                                               | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| contentSecurityPolicyReportOnly | [Content-Security-Policy-Report-Only](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy-Report-Only)           | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| trustedTypes                    | [Trusted Types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/trusted-types)                               | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| requireTrustedTypesFor          | [Require Trusted Types For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for)       | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| crossOriginEmbedderPolicy       | [Cross-Origin-Embedder-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Embedder-Policy)                         | require-corp                                                               | **False**  |
+| crossOriginResourcePolicy       | [Cross-Origin-Resource-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Resource-Policy)                         | same-origin                                                                | True       |
+| crossOriginOpenerPolicy         | [Cross-Origin-Opener-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy)                             | same-origin                                                                | True       |
+| originAgentCluster              | [Origin-Agent-Cluster](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin-Agent-Cluster)                                         | ?1                                                                         | True       |
+| referrerPolicy                  | [Referrer-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy)                                                   | no-referrer                                                                | True       |
+| reportingEndpoints              | [Reporting-Endpoints](https://www.w3.org/TR/reporting-1/#header)                                                                               | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| reportTo                        | [Report-To](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/report-to)                                       | Usage: [Setting Content-Security-Policy](#setting-content-security-policy) | No Setting |
+| strictTransportSecurity         | [Strict-Transport-Security](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security)                               | max-age=15552000; includeSubDomains                                        | True       |
+| xContentTypeOptions             | [X-Content-Type-Options](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options)                                     | nosniff                                                                    | True       |
+| xDnsPrefetchControl             | [X-DNS-Prefetch-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-DNS-Prefetch-Control)                                     | off                                                                        | True       |
+| xDownloadOptions                | [X-Download-Options](https://learn.microsoft.com/en-us/archive/blogs/ie/ie8-security-part-v-comprehensive-protection#mime-handling-force-save) | noopen                                                                     | True       |
+| xFrameOptions                   | [X-Frame-Options](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options)                                                   | SAMEORIGIN                                                                 | True       |
+| xPermittedCrossDomainPolicies   | [X-Permitted-Cross-Domain-Policies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Permitted-Cross-Domain-Policies)               | none                                                                       | True       |
+| xXssProtection                  | [X-XSS-Protection](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-XSS-Protection)                                                 | 0                                                                          | True       |
+| permissionPolicy                | [Permissions-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy)                                             | Usage: [Setting Permission-Policy](#setting-permission-policy)             | No Setting |
+
+## Middleware Conflict
+
+Please be cautious about the order of specification when dealing with middleware that manipulates the same header.
+
+In this case, Secure-headers operates and the `x-powered-by` is removed:
+
+```ts
+const app = new Acryl()
+app.use(secureHeaders())
+app.use(poweredBy())
+```
+
+In this case, Powered-By operates and the `x-powered-by` is added:
+
+```ts
+const app = new Acryl()
+app.use(poweredBy())
+app.use(secureHeaders())
+```
+
+## Setting Content-Security-Policy
+
+```ts
+const app = new Acryl()
+app.use(
+  '/test',
+  secureHeaders({
+    reportingEndpoints: [
+      {
+        name: 'endpoint-1',
+        url: 'https://example.com/reports',
+      },
+    ],
+    // -- or alternatively
+    // reportTo: [
+    //   {
+    //     group: 'endpoint-1',
+    //     max_age: 10886400,
+    //     endpoints: [{ url: 'https://example.com/reports' }],
+    //   },
+    // ],
+    contentSecurityPolicy: {
+      defaultSrc: ["'self'"],
+      baseUri: ["'self'"],
+      childSrc: ["'self'"],
+      connectSrc: ["'self'"],
+      fontSrc: ["'self'", 'https:', 'data:'],
+      formAction: ["'self'"],
+      frameAncestors: ["'self'"],
+      frameSrc: ["'self'"],
+      imgSrc: ["'self'", 'data:'],
+      manifestSrc: ["'self'"],
+      mediaSrc: ["'self'"],
+      objectSrc: ["'none'"],
+      reportTo: 'endpoint-1',
+      reportUri: '/csp-report',
+      sandbox: ['allow-same-origin', 'allow-scripts'],
+      scriptSrc: ["'self'"],
+      scriptSrcAttr: ["'none'"],
+      scriptSrcElem: ["'self'"],
+      styleSrc: ["'self'", 'https:', "'unsafe-inline'"],
+      styleSrcAttr: ['none'],
+      styleSrcElem: ["'self'", 'https:', "'unsafe-inline'"],
+      upgradeInsecureRequests: [],
+      workerSrc: ["'self'"],
+    },
+  })
+)
+```
+
+### `nonce` attribute
+
+You can add a [`nonce` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce) to a `script` or `style` element by adding the `NONCE` imported from `acrylblends/secure-headers` to a `scriptSrc` or `styleSrc`:
+
+```tsx
+import { secureHeaders, NONCE } from 'acrylblends/secure-headers'
+import type { SecureHeadersVariables } from 'acrylblends/secure-headers'
+
+// Specify the variable types to infer the `c.get('secureHeadersNonce')`:
+type Variables = SecureHeadersVariables
+
+const app = new Acryl<{ Variables: Variables }>()
+
+// Set the pre-defined nonce value to `scriptSrc`:
+app.get(
+  '*',
+  secureHeaders({
+    contentSecurityPolicy: {
+      scriptSrc: [NONCE, 'https://allowed1.example.com'],
+    },
+  })
+)
+
+// Get the value from `c.get('secureHeadersNonce')`:
+app.get('/', (c) => {
+  return c.html(
+    <html>
+      <body>
+        {/** contents */}
+        <script
+          src='/js/client.js'
+          nonce={c.get('secureHeadersNonce')}
+        />
+      </body>
+    </html>
+  )
+})
+```
+
+If you want to generate the nonce value yourself, you can also specify a function as the following:
+
+```tsx
+const app = new Acryl<{
+  Variables: { myNonce: string }
+}>()
+
+const myNonceGenerator: ContentSecurityPolicyOptionHandler = (c) => {
+  // This function is called on every request.
+  const nonce = Math.random().toString(36).slice(2)
+  c.set('myNonce', nonce)
+  return `'nonce-${nonce}'`
+}
+
+app.get(
+  '*',
+  secureHeaders({
+    contentSecurityPolicy: {
+      scriptSrc: [myNonceGenerator, 'https://allowed1.example.com'],
+    },
+  })
+)
+
+app.get('/', (c) => {
+  return c.html(
+    <html>
+      <body>
+        {/** contents */}
+        <script src='/js/client.js' nonce={c.get('myNonce')} />
+      </body>
+    </html>
+  )
+})
+```
+
+## Setting Permission-Policy
+
+The Permission-Policy header allows you to control which features and APIs can be used in the browser. Here's an example of how to set it:
+
+```ts
+const app = new Acryl()
+app.use(
+  '*',
+  secureHeaders({
+    permissionsPolicy: {
+      fullscreen: ['self'], // fullscreen=(self)
+      bluetooth: ['none'], // bluetooth=(none)
+      payment: ['self', 'https://example.com'], // payment=(self "https://example.com")
+      syncXhr: [], // sync-xhr=()
+      camera: false, // camera=none
+      microphone: true, // microphone=*
+      geolocation: ['*'], // geolocation=*
+      usb: ['self', 'https://a.example.com', 'https://b.example.com'], // usb=(self "https://a.example.com" "https://b.example.com")
+      accelerometer: ['https://*.example.com'], // accelerometer=("https://*.example.com")
+      gyroscope: ['src'], // gyroscope=(src)
+      magnetometer: [
+        'https://a.example.com',
+        'https://b.example.com',
+      ], // magnetometer=("https://a.example.com" "https://b.example.com")
+    },
+  })
+)
+```

package/docs/framework/middleware/builtin/timeout.md

@@ -0,0 +1,98 @@
+# Timeout Middleware
+
+The Timeout Middleware enables you to easily manage request timeouts in your application. It allows you to set a maximum duration for requests and optionally define custom error responses if the specified timeout is exceeded.
+
+## Import
+
+```ts
+import { Acryl } from 'acrylblends'
+import { timeout } from 'acrylblends/timeout'
+```
+
+## Usage
+
+Here's how to use the Timeout Middleware with both default and custom settings:
+
+Default Settings:
+
+```ts
+const app = new Acryl()
+
+// Applying a 5-second timeout
+app.use('/api', timeout(5000))
+
+// Handling a route
+app.get('/api/data', async (c) => {
+  // Your route handler logic
+  return c.json({ data: 'Your data here' })
+})
+```
+
+Custom settings:
+
+```ts
+import { HTTPException } from 'acrylblends/http-exception'
+
+// Custom exception factory function
+const customTimeoutException = (context) =>
+  new HTTPException(408, {
+    message: `Request timeout after waiting ${context.req.headers.get(
+      'Duration'
+    )} seconds. Please try again later.`,
+  })
+
+// for Static Exception Message
+// const customTimeoutException = new HTTPException(408, {
+//   message: 'Operation timed out. Please try again later.'
+// });
+
+// Applying a 1-minute timeout with a custom exception
+app.use('/api/long-process', timeout(60000, customTimeoutException))
+
+app.get('/api/long-process', async (c) => {
+  // Simulate a long process
+  await new Promise((resolve) => setTimeout(resolve, 61000))
+  return c.json({ data: 'This usually takes longer' })
+})
+```
+
+## Notes
+
+- The duration for the timeout can be specified in milliseconds. The middleware will automatically reject the promise and potentially throw an error if the specified duration is exceeded.
+
+- The timeout middleware cannot be used with stream Thus, use `stream.close` and `setTimeout` together.
+
+```ts
+app.get('/sse', async (c) => {
+  let id = 0
+  let running = true
+  let timer: number | undefined
+
+  return streamSSE(c, async (stream) => {
+    timer = setTimeout(() => {
+      console.log('Stream timeout reached, closing stream')
+      stream.close()
+    }, 3000) as unknown as number
+
+    stream.onAbort(async () => {
+      console.log('Client closed connection')
+      running = false
+      clearTimeout(timer)
+    })
+
+    while (running) {
+      const message = `It is ${new Date().toISOString()}`
+      await stream.writeSSE({
+        data: message,
+        event: 'time-update',
+        id: String(id++),
+      })
+      await stream.sleep(1000)
+    }
+  })
+})
+```
+
+## Middleware Conflicts
+
+Be cautious about the order of middleware, especially when using error-handling or other timing-related middleware, as it might affect the behavior of this timeout middleware.

package/docs/framework/middleware/builtin/timing.md

@@ -0,0 +1,101 @@
+# Server-Timing Middleware
+
+The [Server-Timing](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing) Middleware provides
+performance metrics in the response headers.
+
+> **Note.** On Cloudflare Workers, the timer metrics may not be accurate,
+> since [timers only show the time of last I/O](https://developers.cloudflare.com/workers/learning/security-model/#step-1-disallow-timers-and-multi-threading).
+
+## Import
+
+**npm**
+
+```ts
+import { Acryl } from 'acrylblends'
+import {
+  timing,
+  setMetric,
+  startTime,
+  endTime,
+  wrapTime,
+} from 'acrylblends/timing'
+import type { TimingVariables } from 'acrylblends/timing'
+```
+
+## Usage
+
+```js
+// Specify the variable types to infer the `c.get('metric')`:
+type Variables = TimingVariables
+
+const app = new Acryl<{ Variables: Variables }>()
+
+// add the middleware to your router
+app.use(timing());
+
+app.get('/', async (c) => {
+
+  // add custom metrics
+  setMetric(c, 'region', 'europe-west3')
+
+  // add custom metrics with timing, must be in milliseconds
+  setMetric(c, 'custom', 23.8, 'My custom Metric')
+
+  // start a new timer
+  startTime(c, 'db');
+  const data = await db.findMany(...);
+
+  // end the timer
+  endTime(c, 'db');
+
+  // ...or you can also just wrap a Promise using this function:
+  const data = await wrapTime(c, 'db', db.findMany(...));
+
+  return c.json({ response: data });
+});
+```
+
+### Conditionally enabled
+
+```ts
+const app = new Acryl()
+
+app.use(
+  '*',
+  timing({
+    // c: Context of the request
+    enabled: (c) => c.req.method === 'POST',
+  })
+)
+```
+
+## Result
+
+## Options
+
+### *(optional)* total: `boolean`
+
+Show the total response time. The default is `true`.
+
+### *(optional)* enabled: `boolean` | `(c: Context) => boolean`
+
+Whether timings should be added to the headers or not. The default is `true`.
+
+### *(optional)* totalDescription: `string`
+
+Description for the total response time. The default is `Total Response Time`.
+
+### *(optional)* autoEnd: `boolean`
+
+If `startTime()` should end automatically at the end of the request.
+If disabled, not manually ended timers will not be shown.
+
+### *(optional)* crossOrigin: `boolean` | `string` | `(c: Context) => boolean | string`
+
+The origin this timings header should be readable.
+
+- If false, only from current origin.
+- If true, from all origin.
+- If string, from this domain(s). Multiple domains must be separated with a comma.
+
+The default is `false`. See more [docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Timing-Allow-Origin).

package/docs/framework/middleware/builtin/trailing-slash.md

@@ -0,0 +1,74 @@
+# Trailing Slash Middleware
+
+This middleware handles Trailing Slash in the URL on a GET request.
+
+`appendTrailingSlash` redirects the URL to which it added the Trailing Slash if the content was not found. Also, `trimTrailingSlash` will remove the Trailing Slash.
+
+## Import
+
+```ts
+import { Acryl } from 'acrylblends'
+import {
+  appendTrailingSlash,
+  trimTrailingSlash,
+} from 'acrylblends/trailing-slash'
+```
+
+## Usage
+
+Example of redirecting a GET request of `/about/me` to `/about/me/`.
+
+```ts
+import { Acryl } from 'acrylblends'
+import { appendTrailingSlash } from 'acrylblends/trailing-slash'
+
+const app = new Acryl({ strict: true })
+
+app.use(appendTrailingSlash())
+app.get('/about/me/', (c) => c.text('With Trailing Slash'))
+```
+
+Example of redirecting a GET request of `/about/me/` to `/about/me`.
+
+```ts
+import { Acryl } from 'acrylblends'
+import { trimTrailingSlash } from 'acrylblends/trailing-slash'
+
+const app = new Acryl({ strict: true })
+
+app.use(trimTrailingSlash())
+app.get('/about/me', (c) => c.text('Without Trailing Slash'))
+```
+
+## Options
+
+### *(optional)* alwaysRedirect: `boolean`
+
+By default, trailing slash middleware only redirects when the response status is `404`. When `alwaysRedirect` is set to `true`, the middleware redirects before executing handlers. This is useful for wildcard routes (`*`) where the default behavior doesn't work.
+
+```ts
+const app = new Acryl()
+
+app.use(trimTrailingSlash({ alwaysRedirect: true }))
+app.get('/my-path/*', (c) => c.text('Wildcard route'))
+```
+
+This option is available for both `trimTrailingSlash` and `appendTrailingSlash`.
+
+### *(optional)* skip: `(path: string) => boolean`
+
+A function that determines whether the redirect should be skipped based on the request path. If the function returns `true`, the redirect will be skipped. This is useful when you want to exclude certain paths, such as those with file extensions, from being redirected.
+
+```ts
+app.use(
+  appendTrailingSlash({
+    skip: (path) => /\.\w+$/.test(path),
+  })
+)
+```
+
+This option is available for both `trimTrailingSlash` and `appendTrailingSlash`.
+
+## Note
+
+It will be enabled when the request method is `GET` and the response status is `404`.

package/docs/framework/middleware/third-party.md

@@ -0,0 +1,4 @@
+# Third-party Middleware
+
+> **Not yet available.** There is no registry of third-party middleware for Acryl yet. Middleware is an ordinary function `(c, next) => Promise<void>`, so any function that has
+> that shape works; see [Middleware](../concepts/middleware.md) and [Writing middleware](../guides/middleware.md).

package/docs/framework/upstream.json

@@ -0,0 +1,9 @@
+{
+  "source": {
+    "repo": "acryldev/acryl",
+    "path": "docs/framework",
+    "commit": "f5151e7f0c4de3b81bddb5cc686b5ef329e48e1c"
+  },
+  "files": 87,
+  "digest": "sha256:fcaa5ddb5ba4b3912151959e2031c8463d1a61ce543057ca328ebdd6e2e63d4a"
+}

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "create-acrylblends",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Create an Acryl app: npm create acrylblends@latest",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "create-acrylblends": "./bin/create-acrylblends.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates",
+    "docs"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acrylblends/acrylblends.git",
+    "directory": "packages/create"
+  },
+  "homepage": "https://acrylblends.github.io",
+  "keywords": [
+    "acryl",
+    "create",
+    "scaffold"
+  ],
+  "dependencies": {
+    "acrylblends": "^0.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "test": "vitest run"
+  }
 }

package/templates/bun/gitignore

@@ -0,0 +1 @@
+node_modules/