@ape-egg/codie 0.1.0

package/highlight.js

@@ -0,0 +1,423 @@
+// Codie syntax highlighting engine
+import { CLASS, JS_KEYWORDS, JS_IMPORT_KEYWORDS, JS_BRACKETS } from './constants.js';
+
+// HTML entity escaping
+const escapeHTML = (str) =>
+  str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+// Wrap in span with class
+const span = (cls, content) => `<span class="${cls}">${content}</span>`;
+
+// Highlight @[expression] - vibe brackets + variable names
+const highlightBindings = (text) =>
+  text.replace(/@\[([^\]]+)\]/g, (_, expr) => {
+    const highlighted = expr.replace(
+      /(&quot;[^&]*(?:&(?!quot;)[^&]*)*&quot;)|('[^']*')|("[^"]*")|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)/g,
+      (m, escaped, single, double, ident) => {
+        if (escaped || single || double) return m;
+        return span(CLASS.VIBE_VARIABLE, ident);
+      },
+    );
+    return `${span(CLASS.VIBE_COLOR, '@[')}${highlighted}${span(CLASS.VIBE_COLOR, ']')}`;
+  });
+
+// Highlight $.variable - vibe state access
+const highlightStateAccess = (text) =>
+  text.replace(
+    /\$\.([a-zA-Z_][a-zA-Z0-9_]*)/g,
+    `${span(CLASS.VIBE_COLOR, '$.')}${span(CLASS.VIBE_VARIABLE, '$1')}`,
+  );
+
+// Highlight variable names in Vibe comments
+const highlightCommentVariables = (content) => {
+  let result = content.replace(
+    /^(\s*(?:if|each)\s+)([a-zA-Z_][a-zA-Z0-9_.]*)/,
+    (_, prefix, varName) => `${prefix}${span(CLASS.VIBE_VARIABLE, varName)}`,
+  );
+  return result.replace(
+    /(\s+as\s+)([a-zA-Z_][a-zA-Z0-9_]*)/,
+    (_, as, alias) => `${as}${span(CLASS.VIBE_VARIABLE, alias)}`,
+  );
+};
+
+// JavaScript highlighter for escaped HTML content
+export const highlightJS = (code, options = {}) => {
+  const tokens = [];
+  const tokenRegex =
+    /(@\[([^\]]+)\])|(&quot;(?:[^&]|&(?!quot;))*?&quot;)|('(?:[^'\\]|\\.)*')|(`(?:[^`\\]|\\.)*`)|(\/\/[^\n]*)|(\/\*[\s\S]*?\*\/)|(\$\.([a-zA-Z_][a-zA-Z0-9_]*))|(\b\d+\.?\d*\b)|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)|([^\s])/g;
+  let match,
+    lastIndex = 0;
+
+  while ((match = tokenRegex.exec(code)) !== null) {
+    if (match.index > lastIndex) tokens.push(code.slice(lastIndex, match.index));
+
+    const [
+      full,
+      vibeBinding,
+      vibeExpr,
+      dblStr,
+      sglStr,
+      tmplStr,
+      lineComment,
+      blockComment,
+      stateAccess,
+      stateVar,
+      number,
+      word,
+      punct,
+    ] = match;
+
+    if (vibeBinding) {
+      const highlighted = vibeExpr.replace(
+        /('[^']*')|("[^"]*")|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)/g,
+        (m, s1, s2, ident) => (s1 || s2 ? m : span(CLASS.VIBE_VARIABLE, ident)),
+      );
+      tokens.push(`${span(CLASS.VIBE_COLOR, '@[')}${highlighted}${span(CLASS.VIBE_COLOR, ']')}`);
+    } else if (dblStr || sglStr || tmplStr) {
+      const str = dblStr || sglStr || tmplStr;
+      const highlighted = str.replace(/@\[([^\]]+)\]/g, (_, expr) => {
+        const h = expr.replace(
+          /('[^']*')|("[^"]*")|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)/g,
+          (m, s1, s2, ident) => (s1 || s2 ? m : span(CLASS.VIBE_VARIABLE, ident)),
+        );
+        return `${span(CLASS.VIBE_COLOR, '@[')}${h}${span(CLASS.VIBE_COLOR, ']')}`;
+      });
+      tokens.push(span(CLASS.JS_STRING, highlighted));
+    } else if (lineComment || blockComment) {
+      tokens.push(span(CLASS.COMMENT, full));
+    } else if (stateAccess) {
+      tokens.push(`${span(CLASS.VIBE_COLOR, '$.')}${span(CLASS.VIBE_VARIABLE, stateVar)}`);
+    } else if (number) {
+      tokens.push(span(CLASS.JS_NUMBER, full));
+    } else if (word) {
+      if (JS_IMPORT_KEYWORDS.has(word)) tokens.push(span(CLASS.JS_IMPORT, full));
+      else if (JS_KEYWORDS.has(word)) tokens.push(span(CLASS.JS_KEYWORD, full));
+      else if (code.slice(tokenRegex.lastIndex).match(/^\s*\(/))
+        tokens.push(span(CLASS.JS_FUNCTION, full));
+      else tokens.push(span(CLASS.JS_IDENT, full));
+    } else if (punct) {
+      tokens.push(
+        JS_BRACKETS.has(punct) ? span(CLASS.JS_IMPORT, full) : span(CLASS.PUNCTUATION, full),
+      );
+    } else {
+      tokens.push(full);
+    }
+    lastIndex = tokenRegex.lastIndex;
+  }
+
+  if (lastIndex < code.length) tokens.push(code.slice(lastIndex));
+  return tokens.join('');
+};
+
+// JavaScript highlighter for raw (unescaped) content
+export const highlightJSRaw = (code) => {
+  const tokens = [];
+  const tokenRegex =
+    /(<\/?[a-zA-Z][a-zA-Z0-9-]*(?:\s+[^>]*)?>)|("(?:[^"\\]|\\.)*")|('(?:[^'\\]|\\.)*')|(`(?:[^`\\]|\\.)*`)|(\/\/[^\n]*)|(\/\*[\s\S]*?\*\/)|(\$\.([a-zA-Z_][a-zA-Z0-9_]*))|(\b\d+\.?\d*\b)|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)|([^\s])/g;
+  let match,
+    lastIndex = 0;
+
+  while ((match = tokenRegex.exec(code)) !== null) {
+    if (match.index > lastIndex) tokens.push(escapeHTML(code.slice(lastIndex, match.index)));
+
+    const [
+      full,
+      htmlTag,
+      dblStr,
+      sglStr,
+      tmplStr,
+      lineComment,
+      blockComment,
+      stateAccess,
+      stateVar,
+      number,
+      word,
+      punct,
+    ] = match;
+    const escaped = escapeHTML(full);
+
+    if (htmlTag) {
+      const tagMatch = full.match(/^(<\/?)([a-zA-Z][a-zA-Z0-9-]*)([\s\S]*?)(>)$/);
+      if (tagMatch) {
+        const [, open, tagName, attrs, close] = tagMatch;
+        let result =
+          span(CLASS.PUNCTUATION, escapeHTML(open)) + span(CLASS.TAG, escapeHTML(tagName));
+        if (attrs) {
+          result += attrs.replace(
+            /([a-zA-Z][a-zA-Z0-9-:]*)(=)?(["'])?([^"']*)?(\3)?/g,
+            (m, name, eq, q1, val, q2) => {
+              if (!name) return escapeHTML(m);
+              let r = span(CLASS.ATTR_NAME, escapeHTML(name));
+              if (eq) {
+                r += span(CLASS.PUNCTUATION, '=');
+                if (q1) r += span(CLASS.PUNCTUATION, escapeHTML(q1));
+                if (val) r += span(CLASS.ATTR_VALUE, escapeHTML(val));
+                if (q2) r += span(CLASS.PUNCTUATION, escapeHTML(q2));
+              }
+              return r;
+            },
+          );
+        }
+        result += span(CLASS.PUNCTUATION, escapeHTML(close));
+        tokens.push(result);
+      } else {
+        tokens.push(escaped);
+      }
+    } else if (dblStr || sglStr || tmplStr) {
+      tokens.push(span(CLASS.JS_STRING, escaped));
+    } else if (lineComment || blockComment) {
+      tokens.push(span(CLASS.COMMENT, escaped));
+    } else if (stateAccess) {
+      tokens.push(
+        `${span(CLASS.VIBE_COLOR, '$.')}${span(CLASS.VIBE_VARIABLE, escapeHTML(stateVar))}`,
+      );
+    } else if (number) {
+      tokens.push(span(CLASS.JS_NUMBER, escaped));
+    } else if (word) {
+      if (JS_IMPORT_KEYWORDS.has(word)) tokens.push(span(CLASS.JS_IMPORT, escaped));
+      else if (JS_KEYWORDS.has(word)) tokens.push(span(CLASS.JS_KEYWORD, escaped));
+      else if (code.slice(tokenRegex.lastIndex).match(/^\s*\(/))
+        tokens.push(span(CLASS.JS_FUNCTION, escaped));
+      else tokens.push(span(CLASS.JS_IDENT, escaped));
+    } else if (punct) {
+      tokens.push(
+        JS_BRACKETS.has(punct) ? span(CLASS.JS_IMPORT, escaped) : span(CLASS.PUNCTUATION, escaped),
+      );
+    } else {
+      tokens.push(escaped);
+    }
+    lastIndex = tokenRegex.lastIndex;
+  }
+
+  if (lastIndex < code.length) tokens.push(escapeHTML(code.slice(lastIndex)));
+  return tokens.join('');
+};
+
+// CSS highlighter
+export const highlightCSS = (code, options = {}) => {
+  let result = '';
+  const ruleRegex = /(\/\*[\s\S]*?\*\/)|([^{}]+)(\{)([^}]*)(\})/g;
+  let match,
+    lastIndex = 0;
+
+  while ((match = ruleRegex.exec(code)) !== null) {
+    if (match.index > lastIndex) result += code.slice(lastIndex, match.index);
+
+    const [, comment, selector, open, props, close] = match;
+
+    if (comment) {
+      result += span(CLASS.COMMENT, comment);
+    } else {
+      const ws = selector.match(/^(\s*)/)[1];
+      result +=
+        ws + span(CLASS.CSS_SELECTOR, selector.trim()) + ' ' + span(CLASS.PUNCTUATION, open);
+
+      const propRegex = /([\w-]+)(\s*:\s*)([^;]+)(;?)/g;
+      let propMatch,
+        propLast = 0,
+        propsResult = '';
+
+      while ((propMatch = propRegex.exec(props)) !== null) {
+        if (propMatch.index > propLast) propsResult += props.slice(propLast, propMatch.index);
+        const [, prop, colon, value, semi] = propMatch;
+        propsResult += span(CLASS.CSS_PROPERTY, prop) + span(CLASS.PUNCTUATION, colon);
+        const highlighted = value.replace(/@\[([^\]]+)\]/g, (_, expr) => {
+          const h = expr.replace(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g, (v) =>
+            span(CLASS.VIBE_VARIABLE, v),
+          );
+          return `${span(CLASS.VIBE_COLOR, '@[')}${h}${span(CLASS.VIBE_COLOR, ']')}`;
+        });
+        propsResult += span(CLASS.CSS_VALUE, highlighted);
+        if (semi) propsResult += span(CLASS.PUNCTUATION, semi);
+        propLast = propRegex.lastIndex;
+      }
+      if (propLast < props.length) propsResult += props.slice(propLast);
+
+      result += propsResult + span(CLASS.PUNCTUATION, close);
+    }
+    lastIndex = ruleRegex.lastIndex;
+  }
+
+  if (lastIndex < code.length) result += code.slice(lastIndex);
+  return result;
+};
+
+// JSON highlighter (receives HTML-escaped code)
+export const highlightJSON = (code) => {
+  const tokens = [];
+  // Match HTML-escaped strings: &quot;...&quot; instead of "..."
+  const tokenRegex =
+    /(\/\/[^\n]*)|(\/\*[\s\S]*?\*\/)|(&quot;(?:(?!&quot;)[^\\]|\\.)*?&quot;)(\s*:)|(&quot;(?:(?!&quot;)[^\\]|\\.)*?&quot;)|(true|false|null)\b|(-?\d+\.?\d*(?:[eE][+-]?\d+)?)|([{}[\],:])/g;
+  let match,
+    lastIndex = 0;
+
+  while ((match = tokenRegex.exec(code)) !== null) {
+    if (match.index > lastIndex) tokens.push(code.slice(lastIndex, match.index));
+
+    const [full, lineComment, blockComment, keyString, colon, valueString, literal, number, punct] =
+      match;
+
+    if (lineComment || blockComment) {
+      tokens.push(span(CLASS.COMMENT, full));
+    } else if (keyString) {
+      // Property name (key before colon)
+      tokens.push(span(CLASS.JSON_KEY, keyString));
+      if (colon) tokens.push(span(CLASS.PUNCTUATION, colon.trim()));
+    } else if (valueString) {
+      // String value
+      tokens.push(span(CLASS.JSON_STRING, valueString));
+    } else if (literal) {
+      // true, false, null
+      if (literal === 'null') {
+        tokens.push(span(CLASS.JSON_NULL, literal));
+      } else {
+        tokens.push(span(CLASS.JSON_BOOLEAN, literal));
+      }
+    } else if (number) {
+      tokens.push(span(CLASS.JSON_NUMBER, number));
+    } else if (punct) {
+      tokens.push(span(CLASS.PUNCTUATION, punct));
+    } else {
+      tokens.push(full);
+    }
+    lastIndex = tokenRegex.lastIndex;
+  }
+
+  if (lastIndex < code.length) tokens.push(code.slice(lastIndex));
+  return tokens.join('');
+};
+
+// CSS-only highlighter - only highlights content inside <style> tags
+export const highlightCSSOnly = (html, options = {}) => {
+  // Find and highlight only <style> tag contents
+  return html.replace(
+    /(&lt;style[^&]*&gt;)([\s\S]*?)(&lt;\/style&gt;)/gi,
+    (_, open, content, close) => open + highlightCSS(content) + close,
+  );
+};
+
+// JS-only highlighter - only highlights content inside <script> tags
+export const highlightJSOnly = (html, options = {}) => {
+  // Find and highlight only <script> tag contents
+  return html.replace(
+    /(&lt;script[^&]*&gt;)([\s\S]*?)(&lt;\/script&gt;)/gi,
+    (_, open, content, close) => open + highlightJS(content) + close,
+  );
+};
+
+// HTML highlighter - main entry point
+export const highlightHTML = (
+  html,
+  { preserveWhitespace = false, highlightJS: doJS = true, highlightCSS: doCSS = true } = {},
+) => {
+  let highlighted = html;
+
+  // Format Vibe comments if not preserving whitespace
+  if (!preserveWhitespace) {
+    highlighted = highlighted
+      .replace(/([^\s])[ \t]*(&lt;!--\s*(?:if|else|\/if|each|\/each)\b)/g, '$1\n  $2')
+      .replace(/(&lt;!--\s*(?:if|else|each)\b[^-]*--&gt;)[ \t]*(\S)/g, '$1\n    $2');
+  }
+
+  // HTML comments
+  highlighted = highlighted.replace(/&lt;!--([\s\S]*?)--&gt;/g, (_, content) =>
+    span(CLASS.COMMENT, `&lt;!--${highlightCommentVariables(content)}--&gt;`),
+  );
+
+  // HTML tags with attributes
+  highlighted = highlighted.replace(
+    /(&lt;\/?)([a-zA-Z0-9\-]+)((?:\s+[a-zA-Z0-9\-:]+(?:=(?:&quot;(?:(?!&quot;).)*?&quot;|'[^']*'|[^\s&gt;]+))?)*\s*)(\/?\s*&gt;)/gs,
+    (fullMatch, open, tag, attrs, close) => {
+      let result = span(CLASS.PUNCTUATION, open) + span(CLASS.TAG, tag);
+
+      if (attrs) {
+        if (attrs.trim()) {
+          const attrRegex =
+            /([a-zA-Z0-9\-:]+)(=(?:&quot;((?:(?!&quot;).)*?)&quot;|'([^']*)'|([^\s&gt;]+)))?/gs;
+          let attrMatch,
+            last = 0;
+
+          while ((attrMatch = attrRegex.exec(attrs)) !== null) {
+            result += attrs.substring(last, attrMatch.index) + span(CLASS.ATTR_NAME, attrMatch[1]);
+
+            if (attrMatch[2]) {
+              result += span(CLASS.PUNCTUATION, '=');
+              const name = attrMatch[1].toLowerCase();
+              const value = attrMatch[3] ?? attrMatch[4] ?? attrMatch[5] ?? '';
+              const quote = attrMatch[3] !== undefined ? '&quot;' : attrMatch[4] ? "'" : '';
+
+              if (quote) result += span(CLASS.PUNCTUATION, quote);
+              if (name.startsWith('on')) {
+                result += span(CLASS.VIBE_COLOR, highlightStateAccess(value));
+              } else {
+                result += span(CLASS.ATTR_VALUE, highlightBindings(value));
+              }
+              if (quote) result += span(CLASS.PUNCTUATION, quote);
+            }
+            last = attrRegex.lastIndex;
+          }
+          const remaining = attrs.substring(last);
+          if (remaining) result += remaining;
+        } else {
+          result += attrs;
+        }
+      }
+
+      return result + span(CLASS.PUNCTUATION, close.trim());
+    },
+  );
+
+  // JavaScript in <script> tags (if enabled)
+  if (doJS) {
+    highlighted = highlighted.replace(
+      new RegExp(
+        `(<span class="${CLASS.PUNCTUATION}">&lt;<\\/span><span class="${CLASS.TAG}">script<\\/span>[\\s\\S]*?<span class="${CLASS.PUNCTUATION}">&gt;<\\/span>)([\\s\\S]*?)(<span class="${CLASS.PUNCTUATION}">&lt;\\/<\\/span><span class="${CLASS.TAG}">script<\\/span>)`,
+        'gi',
+      ),
+      (match, open, content, close) =>
+        content.includes(`class="${CLASS.JS_KEYWORD}"`)
+          ? match
+          : open + highlightJS(content) + close,
+    );
+
+    // JavaScript in <code lang="js">
+    highlighted = highlighted.replace(
+      new RegExp(
+        `(<span class="${CLASS.PUNCTUATION}">&lt;<\\/span><span class="${CLASS.TAG}">code<\\/span>\\s*<span class="${CLASS.ATTR_NAME}">lang<\\/span><span class="${CLASS.PUNCTUATION}">=<\\/span><span class="${CLASS.PUNCTUATION}">&quot;<\\/span><span class="${CLASS.ATTR_VALUE}">js<\\/span><span class="${CLASS.PUNCTUATION}">&quot;<\\/span><span class="${CLASS.PUNCTUATION}">&gt;<\\/span>)([\\s\\S]*?)(<span class="${CLASS.PUNCTUATION}">&lt;\\/<\\/span><span class="${CLASS.TAG}">code<\\/span>)`,
+        'gi',
+      ),
+      (match, open, content, close) =>
+        content.includes(`class="${CLASS.JS_KEYWORD}"`)
+          ? match
+          : open + highlightJS(content) + close,
+    );
+  }
+
+  // CSS in <style> tags (if enabled)
+  if (doCSS) {
+    highlighted = highlighted.replace(
+      new RegExp(
+        `(<span class="${CLASS.PUNCTUATION}">&lt;<\\/span><span class="${CLASS.TAG}">style<\\/span>[\\s\\S]*?<span class="${CLASS.PUNCTUATION}">&gt;<\\/span>)([\\s\\S]*?)(<span class="${CLASS.PUNCTUATION}">&lt;\\/<\\/span><span class="${CLASS.TAG}">style<\\/span>)`,
+        'gi',
+      ),
+      (match, open, content, close) =>
+        content.includes(`class="${CLASS.CSS_SELECTOR}"`)
+          ? match
+          : open + highlightCSS(content) + close,
+    );
+  }
+
+  // Remaining @[...] patterns
+  highlighted = highlighted.replace(
+    new RegExp(`(?<!${CLASS.VIBE_COLOR}">)(?<!${CLASS.JS_STRING}">)@\\[([^\\]]+)\\]`, 'g'),
+    (_, expr) => {
+      const h = expr.replace(
+        /(&quot;[^&]*(?:&(?!quot;)[^&]*)*&quot;)|('[^']*')|("[^"]*")|(\b[a-zA-Z_][a-zA-Z0-9_]*\b)/g,
+        (m, e, s1, s2, ident) => (e || s1 || s2 ? m : span(CLASS.VIBE_VARIABLE, ident)),
+      );
+      return `${span(CLASS.VIBE_COLOR, '@[')}${h}${span(CLASS.VIBE_COLOR, ']')}`;
+    },
+  );
+
+  return highlighted;
+};

package/keyboard.js

@@ -0,0 +1,61 @@
+/**
+ * keyboard.js - Key command handler for Codie editor
+ *
+ * Simple API for registering keyboard shortcuts.
+ * Normalizes platform differences (Cmd on Mac, Ctrl elsewhere).
+ */
+
+/**
+ * Normalize key combinations to a consistent string format
+ * @param {KeyboardEvent} e - The keyboard event
+ * @returns {string} - Normalized key combo like "Cmd+s" or "Cmd+Shift+f"
+ */
+function normalizeKeyCombo(e) {
+  const parts = []
+
+  // Use "Cmd" for both Command (Mac) and Control (Windows/Linux) for consistency
+  if (e.metaKey || e.ctrlKey) parts.push('Cmd')
+  if (e.altKey) parts.push('Alt')
+  if (e.shiftKey) parts.push('Shift')
+
+  // Add the actual key (lowercase for consistency)
+  const key = e.key.toLowerCase()
+  if (key !== 'meta' && key !== 'control' && key !== 'alt' && key !== 'shift') {
+    parts.push(key)
+  }
+
+  return parts.join('+')
+}
+
+/**
+ * Attach keyboard shortcuts to a textarea
+ * @param {HTMLTextAreaElement} textarea - The textarea element to attach to
+ * @param {Object} commands - Map of key combos to handler functions
+ * @returns {Function} - Cleanup function to remove the listener
+ *
+ * @example
+ * keyboard(textarea, {
+ *   'Cmd+s': (e, textarea) => {
+ *     e.preventDefault()
+ *     formatCode(textarea)
+ *   },
+ *   'Cmd+/': (e, textarea) => {
+ *     toggleComment(textarea)
+ *   }
+ * })
+ */
+export default function keyboard(textarea, commands) {
+  const handler = (e) => {
+    const combo = normalizeKeyCombo(e)
+    const command = commands[combo]
+
+    if (command) {
+      command(e, textarea)
+    }
+  }
+
+  textarea.addEventListener('keydown', handler)
+
+  // Return cleanup function
+  return () => textarea.removeEventListener('keydown', handler)
+}

package/numberRows.js

@@ -0,0 +1,51 @@
+// Codie line numbers
+import { CLASS } from './constants.js'
+
+// Count lines in code
+const countLines = code => code.split('\n').length
+
+// Generate line numbers HTML
+const generateNumbers = count => {
+  let html = ''
+  for (let i = 1; i <= count; i++) {
+    html += `<span class="${CLASS.LINE}">${i}</span>\n`
+  }
+  return html.trimEnd()
+}
+
+// Initialize line numbers for an element
+export const initNumberRows = (el, code) => {
+  const lineCount = countLines(code)
+  const container = document.createElement('div')
+  container.className = CLASS.LINE_NUMBERS
+  container.innerHTML = generateNumbers(lineCount)
+
+  // Insert at beginning
+  el.insertBefore(container, el.firstChild)
+
+  return container
+}
+
+// Update line numbers when code changes
+export const updateNumberRows = (container, code) => {
+  const newCount = countLines(code)
+  const currentCount = container.children.length
+
+  if (newCount === currentCount) return
+
+  container.innerHTML = generateNumbers(newCount)
+}
+
+// Highlight active line number
+export const highlightLineNumber = (container, lineIndex) => {
+  // Clear previous highlight
+  container.querySelectorAll(`.${CLASS.LINE_HIGHLIGHT}`).forEach(el => {
+    el.classList.remove(CLASS.LINE_HIGHLIGHT)
+  })
+
+  // Add highlight to target line
+  const lines = container.querySelectorAll(`.${CLASS.LINE}`)
+  if (lines[lineIndex]) {
+    lines[lineIndex].classList.add(CLASS.LINE_HIGHLIGHT)
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ape-egg/codie",
+  "version": "0.1.0",
+  "description": "Modular code display and editing package",
+  "type": "module",
+  "main": "codie.js",
+  "exports": {
+    ".": "./codie.js",
+    "./codie.css": "./codie.css",
+    "./highlight": "./highlight.js",
+    "./format": "./format.js",
+    "./constants": "./constants.js"
+  },
+  "files": [
+    "*.js",
+    "*.css"
+  ],
+  "keywords": [
+    "code",
+    "editor",
+    "syntax-highlighting",
+    "code-display"
+  ],
+  "author": "Kim Korte",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  }
+}