@mzebley/mark-down 1.2.1 → 1.2.2

package/dist/angular/index.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+import { f as SnippetClient, e as SnippetClientOptions, a as Snippet, S as SnippetMeta } from '../snippet-client-CiQX2Zcn.js';
+
+declare const SNIPPET_CLIENT: InjectionToken<SnippetClient>;
+declare const SNIPPET_CLIENT_OPTIONS: InjectionToken<SnippetClientOptions>;
+declare function provideSnippetClient(options: SnippetClientOptions): Provider[];
+declare class MarkdownSnippetService {
+    private readonly client;
+    constructor(client: SnippetClient);
+    get(slug: string): Observable<Snippet>;
+    listAll(): Observable<SnippetMeta[]>;
+    listByGroup(group: string): Observable<SnippetMeta[]>;
+    listByType(type: string): Observable<SnippetMeta[]>;
+    html(slug: string): Observable<string>;
+}
+
+export { MarkdownSnippetService, SNIPPET_CLIENT, SNIPPET_CLIENT_OPTIONS, Snippet, SnippetClientOptions, SnippetMeta, provideSnippetClient };

package/dist/angular/index.js

@@ -0,0 +1,58 @@
+import {
+  SnippetClient
+} from "../chunk-35YHML5Z.js";
+import "../chunk-GWLMADTU.js";
+import "../chunk-MWZFQXNW.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "../chunk-BRKEJJFQ.js";
+
+// src/angular/index.ts
+import { Inject, Injectable, InjectionToken } from "@angular/core";
+import { from, map, shareReplay } from "rxjs";
+var SNIPPET_CLIENT = new InjectionToken("@mzebley/mark-down/SNIPPET_CLIENT");
+var SNIPPET_CLIENT_OPTIONS = new InjectionToken(
+  "@mzebley/mark-down/SNIPPET_CLIENT_OPTIONS"
+);
+function provideSnippetClient(options) {
+  return [
+    { provide: SNIPPET_CLIENT_OPTIONS, useValue: options },
+    {
+      provide: SNIPPET_CLIENT,
+      useFactory: (opts) => new SnippetClient(opts),
+      deps: [SNIPPET_CLIENT_OPTIONS]
+    }
+  ];
+}
+var MarkdownSnippetService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get(slug) {
+    return from(this.client.get(slug)).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+  }
+  listAll() {
+    return from(this.client.listAll()).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+  }
+  listByGroup(group) {
+    return from(this.client.listByGroup(group)).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+  }
+  listByType(type) {
+    return from(this.client.listByType(type)).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+  }
+  html(slug) {
+    return this.get(slug).pipe(map((snippet) => snippet.html));
+  }
+};
+MarkdownSnippetService = __decorateClass([
+  Injectable({ providedIn: "root" }),
+  __decorateParam(0, Inject(SNIPPET_CLIENT))
+], MarkdownSnippetService);
+export {
+  MarkdownSnippetService,
+  SNIPPET_CLIENT,
+  SNIPPET_CLIENT_OPTIONS,
+  provideSnippetClient
+};
+//# sourceMappingURL=index.js.map

package/dist/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/angular/index.ts"],"sourcesContent":["import { Inject, Injectable, InjectionToken, Provider } from \"@angular/core\";\nimport { from, map, Observable, shareReplay } from \"rxjs\";\nimport { SnippetClient } from \"../snippet-client\";\nimport type { Snippet, SnippetClientOptions, SnippetMeta } from \"../types\";\n\nexport const SNIPPET_CLIENT = new InjectionToken<SnippetClient>(\"@mzebley/mark-down/SNIPPET_CLIENT\");\nexport const SNIPPET_CLIENT_OPTIONS = new InjectionToken<SnippetClientOptions>(\n  \"@mzebley/mark-down/SNIPPET_CLIENT_OPTIONS\"\n);\n\nexport function provideSnippetClient(options: SnippetClientOptions): Provider[] {\n  return [\n    { provide: SNIPPET_CLIENT_OPTIONS, useValue: options },\n    {\n      provide: SNIPPET_CLIENT,\n      useFactory: (opts: SnippetClientOptions) => new SnippetClient(opts),\n      deps: [SNIPPET_CLIENT_OPTIONS]\n    }\n  ];\n}\n\n@Injectable({ providedIn: \"root\" })\nexport class MarkdownSnippetService {\n  constructor(@Inject(SNIPPET_CLIENT) private readonly client: SnippetClient) {}\n\n  get(slug: string): Observable<Snippet> {\n    return from(this.client.get(slug)).pipe(shareReplay({ bufferSize: 1, refCount: true }));\n  }\n\n  listAll(): Observable<SnippetMeta[]> {\n    return from(this.client.listAll()).pipe(shareReplay({ bufferSize: 1, refCount: true }));\n  }\n\n  listByGroup(group: string): Observable<SnippetMeta[]> {\n    return from(this.client.listByGroup(group)).pipe(shareReplay({ bufferSize: 1, refCount: true }));\n  }\n\n  listByType(type: string): Observable<SnippetMeta[]> {\n    return from(this.client.listByType(type)).pipe(shareReplay({ bufferSize: 1, refCount: true }));\n  }\n\n  html(slug: string): Observable<string> {\n    return this.get(slug).pipe(map((snippet) => snippet.html));\n  }\n}\n\nexport type { Snippet, SnippetClientOptions, SnippetMeta } from \"../types\";\n"],"mappings":";;;;;;;;;;;AAAA,SAAS,QAAQ,YAAY,sBAAgC;AAC7D,SAAS,MAAM,KAAiB,mBAAmB;AAI5C,IAAM,iBAAiB,IAAI,eAA8B,mCAAmC;AAC5F,IAAM,yBAAyB,IAAI;AAAA,EACxC;AACF;AAEO,SAAS,qBAAqB,SAA2C;AAC9E,SAAO;AAAA,IACL,EAAE,SAAS,wBAAwB,UAAU,QAAQ;AAAA,IACrD;AAAA,MACE,SAAS;AAAA,MACT,YAAY,CAAC,SAA+B,IAAI,cAAc,IAAI;AAAA,MAClE,MAAM,CAAC,sBAAsB;AAAA,IAC/B;AAAA,EACF;AACF;AAGO,IAAM,yBAAN,MAA6B;AAAA,EAClC,YAAqD,QAAuB;AAAvB;AAAA,EAAwB;AAAA,EAE7E,IAAI,MAAmC;AACrC,WAAO,KAAK,KAAK,OAAO,IAAI,IAAI,CAAC,EAAE,KAAK,YAAY,EAAE,YAAY,GAAG,UAAU,KAAK,CAAC,CAAC;AAAA,EACxF;AAAA,EAEA,UAAqC;AACnC,WAAO,KAAK,KAAK,OAAO,QAAQ,CAAC,EAAE,KAAK,YAAY,EAAE,YAAY,GAAG,UAAU,KAAK,CAAC,CAAC;AAAA,EACxF;AAAA,EAEA,YAAY,OAA0C;AACpD,WAAO,KAAK,KAAK,OAAO,YAAY,KAAK,CAAC,EAAE,KAAK,YAAY,EAAE,YAAY,GAAG,UAAU,KAAK,CAAC,CAAC;AAAA,EACjG;AAAA,EAEA,WAAW,MAAyC;AAClD,WAAO,KAAK,KAAK,OAAO,WAAW,IAAI,CAAC,EAAE,KAAK,YAAY,EAAE,YAAY,GAAG,UAAU,KAAK,CAAC,CAAC;AAAA,EAC/F;AAAA,EAEA,KAAK,MAAkC;AACrC,WAAO,KAAK,IAAI,IAAI,EAAE,KAAK,IAAI,CAAC,YAAY,QAAQ,IAAI,CAAC;AAAA,EAC3D;AACF;AAtBa,yBAAN;AAAA,EADN,WAAW,EAAE,YAAY,OAAO,CAAC;AAAA,EAEnB,0BAAO,cAAc;AAAA,GADvB;","names":[]}

package/dist/browser.js

@@ -0,0 +1,580 @@
+// src/slug.ts
+var NON_ALPHANUMERIC = /[^a-z0-9]+/gi;
+var LEADING_TRAILING_DASH = /^-+|-+$/g;
+function normalizeSlug(input) {
+  const value = input?.trim();
+  if (!value) {
+    throw new Error("Cannot normalize an empty slug");
+  }
+  const normalized = value.toLowerCase().replace(NON_ALPHANUMERIC, "-").replace(/-{2,}/g, "-").replace(LEADING_TRAILING_DASH, "");
+  if (!normalized) {
+    throw new Error(`Slug '${input}' does not contain any alphanumeric characters`);
+  }
+  return normalized;
+}
+
+// src/front-matter.ts
+import { parse as parseYaml } from "yaml";
+
+// src/errors.ts
+var SnippetNotFoundError = class extends Error {
+  constructor(slug) {
+    super(`Snippet with slug '${slug}' was not found in the manifest.`);
+    this.name = "SnippetNotFoundError";
+    this.slug = slug;
+  }
+};
+var ManifestLoadError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "ManifestLoadError";
+    this.cause = cause instanceof Error ? cause : cause ? new Error(String(cause)) : void 0;
+  }
+};
+
+// src/front-matter.ts
+var FRONT_MATTER_PATTERN = /^(?:\uFEFF)?[ \t\r\n]*---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
+function parseFrontMatter(raw) {
+  const match = FRONT_MATTER_PATTERN.exec(raw);
+  if (!match) {
+    return { content: raw, meta: {}, extra: {}, hasFrontMatter: false };
+  }
+  const yamlSection = match[1];
+  let data;
+  try {
+    data = parseYaml(yamlSection) ?? {};
+  } catch (error) {
+    throw new ManifestLoadError("Failed to parse snippet front-matter.", error);
+  }
+  if (!isRecord(data)) {
+    return { content: raw.slice(match[0].length), meta: {}, extra: {}, hasFrontMatter: true };
+  }
+  const { known, extra } = splitFrontMatter(data);
+  return {
+    content: raw.slice(match[0].length),
+    meta: known.meta,
+    extra,
+    slug: known.slug,
+    hasFrontMatter: true
+  };
+}
+function splitFrontMatter(data) {
+  const meta = {};
+  const extra = {};
+  let slug;
+  for (const [key, value] of Object.entries(data)) {
+    switch (key) {
+      case "slug":
+        slug = typeof value === "string" ? value : void 0;
+        break;
+      case "title":
+        if (typeof value === "string") {
+          meta.title = value;
+        }
+        break;
+      case "type":
+        if (typeof value === "string") {
+          meta.type = value;
+        }
+        break;
+      case "order":
+        if (typeof value === "number") {
+          meta.order = value;
+        }
+        break;
+      case "tags":
+        meta.tags = normalizeTags(value);
+        break;
+      case "group":
+        if (typeof value === "string" || value === null) {
+          meta.group = value;
+        }
+        break;
+      case "draft":
+        if (typeof value === "boolean") {
+          meta.draft = value;
+        }
+        break;
+      default:
+        extra[key] = value;
+        break;
+    }
+  }
+  return { known: { meta, slug }, extra };
+}
+function normalizeTags(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((tag) => tag.trim()).filter(Boolean);
+  }
+  return void 0;
+}
+function isRecord(candidate) {
+  return Boolean(candidate) && typeof candidate === "object" && !Array.isArray(candidate);
+}
+
+// src/markdown.ts
+import { marked } from "marked";
+function renderMarkdown(markdown) {
+  const html = marked.parse(markdown);
+  if (typeof html === "string") {
+    return html;
+  }
+  throw new Error("renderMarkdown unexpectedly returned a Promise");
+}
+
+// src/snippet-client.ts
+var HTTP_PATTERN = /^https?:\/\//i;
+var SnippetClient = class {
+  constructor(options) {
+    this.snippetCache = /* @__PURE__ */ new Map();
+    if (!options || !options.manifest) {
+      throw new ManifestLoadError("A manifest source must be provided to SnippetClient.");
+    }
+    this.manifestUrl = typeof options.manifest === "string" ? options.manifest : void 0;
+    this.inferredBase = this.manifestUrl ? deriveBaseFromManifest(this.manifestUrl) : void 0;
+    const fetcher = options.fetch ?? defaultFetch;
+    const renderOption = options.render;
+    const renderer = renderOption ? async (markdown) => Promise.resolve(renderOption(markdown)) : async (markdown) => Promise.resolve(renderMarkdown(markdown));
+    this.options = {
+      manifest: options.manifest,
+      base: options.base,
+      fetch: async (url) => {
+        const response = await fetcher(url);
+        if (typeof response === "string") {
+          return response;
+        }
+        return resolveResponseText(response, url);
+      },
+      frontMatter: options.frontMatter !== false,
+      cache: options.cache !== false,
+      verbose: options.verbose === true,
+      render: renderer
+    };
+  }
+  async get(slug) {
+    const manifest = await this.loadManifest();
+    const entry = manifest.find((item) => item.slug === slug);
+    if (!entry) {
+      throw new SnippetNotFoundError(slug);
+    }
+    return this.loadSnippet(entry);
+  }
+  async listAll() {
+    const manifest = await this.loadManifest();
+    return manifest.map(cloneMeta);
+  }
+  async listByGroup(group) {
+    const manifest = await this.loadManifest();
+    return manifest.filter((item) => (item.group ?? null) === group).map(cloneMeta);
+  }
+  async listByType(type) {
+    const manifest = await this.loadManifest();
+    return manifest.filter((item) => item.type === type).map(cloneMeta);
+  }
+  async search(filter) {
+    const manifest = await this.loadManifest();
+    const tags = filter.tags ?? [];
+    const mode = filter.tagsMode ?? "any";
+    return manifest.filter((item) => {
+      if (filter.type && item.type !== filter.type) {
+        return false;
+      }
+      if (filter.group && (item.group ?? void 0) !== filter.group) {
+        return false;
+      }
+      if (!tags.length) {
+        return true;
+      }
+      const metaTags = item.tags ?? [];
+      if (!metaTags.length) {
+        return false;
+      }
+      if (mode === "all") {
+        return tags.every((tag) => metaTags.includes(tag));
+      }
+      return tags.some((tag) => metaTags.includes(tag));
+    }).map(cloneMeta);
+  }
+  async getHtml(slug) {
+    const snippet = await this.get(slug);
+    return snippet.html;
+  }
+  invalidate() {
+    this.manifestPromise = void 0;
+    this.snippetCache.clear();
+  }
+  invalidateSlug(slug) {
+    this.snippetCache.delete(slug);
+  }
+  async loadManifest() {
+    if (this.options.cache && this.manifestPromise) {
+      return this.manifestPromise;
+    }
+    const promise = this.resolveManifest();
+    if (this.options.cache) {
+      this.manifestPromise = promise;
+    }
+    return promise;
+  }
+  async resolveManifest() {
+    const source = this.options.manifest;
+    let entries;
+    try {
+      if (Array.isArray(source)) {
+        entries = source.map(normalizeManifestEntry);
+      } else if (typeof source === "function") {
+        const result = await source();
+        if (!Array.isArray(result)) {
+          throw new ManifestLoadError("Manifest loader must resolve to an array of snippet metadata.");
+        }
+        entries = result.map(normalizeManifestEntry);
+      } else {
+        const raw = await this.options.fetch(source);
+        entries = parseManifest(raw, source).map(normalizeManifestEntry);
+      }
+    } catch (error) {
+      if (error instanceof ManifestLoadError) {
+        throw error;
+      }
+      throw new ManifestLoadError("Failed to load snippet manifest.", error);
+    }
+    return entries.map(cloneMeta);
+  }
+  loadSnippet(meta) {
+    const cached = this.options.cache ? this.snippetCache.get(meta.slug) : void 0;
+    if (cached) {
+      return cached;
+    }
+    const promise = this.fetchSnippet(meta);
+    if (this.options.cache) {
+      this.snippetCache.set(meta.slug, promise);
+    }
+    return promise;
+  }
+  async fetchSnippet(meta) {
+    const url = this.resolveSnippetPath(meta.path);
+    let raw;
+    try {
+      raw = await this.options.fetch(url);
+    } catch (error) {
+      throw new ManifestLoadError(`Failed to fetch snippet at '${url}'.`, error);
+    }
+    const frontMatter = this.options.frontMatter ? parseFrontMatter(raw) : void 0;
+    const body = frontMatter?.content ?? raw;
+    const html = await this.options.render(body);
+    const merged = {
+      ...meta,
+      ...pickMeta(frontMatter?.meta),
+      extra: mergeExtra(meta.extra, frontMatter?.extra)
+    };
+    if (frontMatter?.slug) {
+      try {
+        const normalizedFrontSlug = normalizeSlug(frontMatter.slug);
+        if (normalizedFrontSlug !== meta.slug && this.options.verbose) {
+          console.warn(
+            `Front-matter slug '${frontMatter.slug}' (normalized: '${normalizedFrontSlug}') differs from manifest slug '${meta.slug}'.`
+          );
+        }
+      } catch (error) {
+        if (this.options.verbose) {
+          console.warn(`Failed to normalize front-matter slug '${frontMatter.slug}':`, error);
+        }
+      }
+    }
+    const snippet = { ...merged, html, raw: body, markdown: body };
+    if (merged.tags) {
+      snippet.tags = [...merged.tags];
+    }
+    return snippet;
+  }
+  resolveSnippetPath(path) {
+    if (HTTP_PATTERN.test(path)) {
+      return normalizeForwardSlashes(path);
+    }
+    const base = this.options.base ?? this.inferredBase ?? "";
+    if (path.startsWith("/")) {
+      if (base) {
+        return joinPaths(base, path);
+      }
+      return normalizeForwardSlashes(path);
+    }
+    if (base) {
+      return joinPaths(base, path);
+    }
+    return normalizeForwardSlashes(path);
+  }
+};
+function parseManifest(raw, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ManifestLoadError(`Manifest at '${source}' is not valid JSON.`, error);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new ManifestLoadError(`Manifest at '${source}' must be a JSON array.`);
+  }
+  return parsed;
+}
+function normalizeManifestEntry(entry) {
+  if (!entry.slug) {
+    throw new ManifestLoadError("Manifest entry is missing required 'slug' property.");
+  }
+  if (!entry.path) {
+    throw new ManifestLoadError(`Manifest entry for '${entry.slug}' is missing required 'path'.`);
+  }
+  const normalized = {
+    slug: entry.slug,
+    title: entry.title,
+    type: entry.type,
+    order: entry.order,
+    tags: entry.tags ? [...entry.tags] : void 0,
+    path: normalizeForwardSlashes(entry.path),
+    group: entry.group ?? null,
+    draft: entry.draft,
+    extra: cloneRecord(entry.extra)
+  };
+  return normalized;
+}
+function deriveBaseFromManifest(manifest) {
+  if (HTTP_PATTERN.test(manifest)) {
+    try {
+      const url = new URL(manifest);
+      url.hash = "";
+      url.search = "";
+      const path = url.pathname;
+      url.pathname = path.replace(/[^/]*$/, "");
+      return url.toString();
+    } catch (error) {
+      console.warn(`Unable to derive base from manifest '${manifest}':`, error);
+      return void 0;
+    }
+  }
+  const sanitized = manifest.replace(/[?#].*$/, "");
+  const index = sanitized.lastIndexOf("/");
+  if (index === -1) {
+    return void 0;
+  }
+  return sanitized.slice(0, index + 1);
+}
+function joinPaths(base, relative) {
+  if (HTTP_PATTERN.test(base)) {
+    return new URL(relative, base).toString();
+  }
+  const leading = base.endsWith("/") ? base : `${base}/`;
+  const trimmed = relative.startsWith("/") ? relative.slice(1) : relative;
+  return normalizeForwardSlashes(`${leading}${trimmed}`);
+}
+function normalizeForwardSlashes(value) {
+  if (HTTP_PATTERN.test(value)) {
+    try {
+      const url = new URL(value);
+      url.pathname = url.pathname.replace(/\/{2,}/g, "/");
+      return url.toString();
+    } catch {
+    }
+  }
+  if (value.startsWith("//")) {
+    return `//${value.slice(2).replace(/\/{2,}/g, "/")}`;
+  }
+  if (value.startsWith("/")) {
+    return `/${value.slice(1).replace(/\/{2,}/g, "/")}`;
+  }
+  return value.replace(/\/{2,}/g, "/");
+}
+function mergeExtra(base, overrides) {
+  if (!base && !overrides) {
+    return void 0;
+  }
+  return { ...base ?? {}, ...overrides ?? {} };
+}
+function cloneRecord(value) {
+  if (!value) {
+    return value;
+  }
+  return { ...value };
+}
+function cloneMeta(meta) {
+  return {
+    ...meta,
+    tags: meta.tags ? [...meta.tags] : void 0,
+    extra: cloneRecord(meta.extra)
+  };
+}
+async function defaultFetch(url) {
+  const runtimeFetch = globalThis.fetch;
+  if (!runtimeFetch) {
+    throw new ManifestLoadError("No global fetch implementation is available. Provide a custom fetch function.");
+  }
+  return runtimeFetch(url);
+}
+async function resolveResponseText(response, url) {
+  if (!response.ok) {
+    throw new ManifestLoadError(`Request to '${url}' failed with status ${response.status}.`);
+  }
+  return response.text();
+}
+function pickMeta(meta) {
+  if (!meta) {
+    return {};
+  }
+  const result = {};
+  if (meta.title !== void 0) {
+    result.title = meta.title;
+  }
+  if (meta.type !== void 0) {
+    result.type = meta.type;
+  }
+  if (meta.order !== void 0) {
+    result.order = meta.order;
+  }
+  if (meta.tags !== void 0) {
+    result.tags = [...meta.tags];
+  }
+  if (meta.group !== void 0) {
+    result.group = meta.group;
+  }
+  if (meta.draft !== void 0) {
+    result.draft = meta.draft;
+  }
+  if (meta.path !== void 0) {
+    result.path = meta.path;
+  }
+  return result;
+}
+
+// src/browser.ts
+installBufferShim();
+function installBufferShim() {
+  const globalRef = globalThis;
+  if (typeof globalRef.Buffer !== "undefined") {
+    return;
+  }
+  const textEncoder = new TextEncoder();
+  const textDecoder = new TextDecoder();
+  class BrowserBuffer extends Uint8Array {
+    constructor(value) {
+      if (typeof value === "number") {
+        super(value);
+        return;
+      }
+      if (isArrayBufferLike(value)) {
+        super(new Uint8Array(value));
+        return;
+      }
+      if (ArrayBuffer.isView(value)) {
+        super(
+          new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength))
+        );
+        return;
+      }
+      super(Array.from(value));
+    }
+    toString(encoding = "utf-8") {
+      if (encoding !== "utf-8" && encoding !== "utf8") {
+        throw new Error(`Unsupported encoding '${encoding}' in browser Buffer shim`);
+      }
+      return textDecoder.decode(this);
+    }
+  }
+  const from = (value, encoding = "utf-8") => {
+    if (typeof value === "string") {
+      if (encoding !== "utf-8" && encoding !== "utf8") {
+        throw new Error(`Unsupported encoding '${encoding}' in browser Buffer shim`);
+      }
+      return new BrowserBuffer(textEncoder.encode(value));
+    }
+    if (isArrayBufferLike(value)) {
+      return new BrowserBuffer(new Uint8Array(value));
+    }
+    if (ArrayBuffer.isView(value)) {
+      return new BrowserBuffer(value);
+    }
+    if (typeof value.length === "number") {
+      return new BrowserBuffer(Array.from(value));
+    }
+    throw new TypeError("Unsupported input passed to Buffer.from in browser shim");
+  };
+  const alloc = (size, fill) => {
+    if (size < 0) {
+      throw new RangeError("Invalid Buffer size");
+    }
+    const buffer = new BrowserBuffer(size);
+    if (typeof fill === "number") {
+      buffer.fill(fill);
+    } else if (typeof fill === "string") {
+      if (!fill.length) {
+        buffer.fill(0);
+      } else {
+        const pattern = textEncoder.encode(fill);
+        for (let i = 0; i < buffer.length; i++) {
+          buffer[i] = pattern[i % pattern.length];
+        }
+      }
+    } else {
+      buffer.fill(0);
+    }
+    return buffer;
+  };
+  const concat = (buffers, totalLength) => {
+    const sanitized = Array.from(
+      buffers,
+      (buffer) => buffer instanceof BrowserBuffer ? buffer : new BrowserBuffer(buffer)
+    );
+    const length = totalLength ?? sanitized.reduce((acc, current) => acc + current.length, 0);
+    const result = new BrowserBuffer(length);
+    let offset = 0;
+    for (const buffer of sanitized) {
+      result.set(buffer, offset);
+      offset += buffer.length;
+    }
+    return result;
+  };
+  const byteLength = (value) => {
+    if (typeof value === "string") {
+      return textEncoder.encode(value).length;
+    }
+    if (value instanceof ArrayBuffer) {
+      return value.byteLength;
+    }
+    if (ArrayBuffer.isView(value)) {
+      return value.byteLength;
+    }
+    throw new TypeError("Unable to determine byte length for provided value");
+  };
+  Object.defineProperties(BrowserBuffer, {
+    from: { value: from },
+    isBuffer: { value: (candidate) => candidate instanceof BrowserBuffer },
+    alloc: { value: alloc },
+    concat: { value: concat },
+    byteLength: { value: byteLength }
+  });
+  BrowserBuffer.prototype.valueOf = function valueOf() {
+    return this;
+  };
+  globalRef.Buffer = BrowserBuffer;
+  if (typeof window !== "undefined" && typeof window.Buffer === "undefined") {
+    window.Buffer = globalRef.Buffer;
+  }
+}
+function isArrayBufferLike(value) {
+  if (value instanceof ArrayBuffer) {
+    return true;
+  }
+  return typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+}
+export {
+  ManifestLoadError,
+  SnippetClient,
+  SnippetNotFoundError,
+  normalizeSlug,
+  parseFrontMatter,
+  renderMarkdown
+};
+//# sourceMappingURL=browser.js.map