puglite 1.0.0

package/lib/prepublish.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var fs = require('fs');
+var uglify = require('uglify-js');
+var runtime = require('./');
+
+try {
+  fs.mkdirSync(__dirname + '/lib');
+} catch (ex) {
+  if (ex.code !== 'EEXIST') throw ex;
+}
+var source = fs.readFileSync(__dirname + '/index.js', 'utf8');
+var ast = uglify.parse(source);
+
+var dependencies = {};
+var internals = {dependencies: true, internals: true};
+var sources = {};
+ast.body.forEach(function(node) {
+  var name;
+  switch (node.TYPE) {
+    case 'Defun':
+      name = node.name.name;
+      break;
+    case 'Var':
+      name = node.definitions[0].name.name;
+      break;
+  }
+  if (!name || !/^pug\_/.test(name)) return;
+  name = name.replace(/^pug\_/, '');
+
+  var src = uglify.minify(source.substring(node.start.pos, node.end.endpos), {
+    fromString: true,
+  }).code;
+  sources[name] = src;
+
+  dependencies[name] = [];
+  if (node.TYPE === 'Defun') {
+    var ast = uglify.parse(src);
+    ast.figure_out_scope();
+    var globals = ast.globals.map(function(val, key) {
+      return key;
+    });
+    dependencies[name] = globals
+      .filter(function(key) {
+        return /^pug\_/.test(key);
+      })
+      .map(function(key) {
+        return key.replace(/^pug\_/, '');
+      });
+  }
+
+  if (!runtime[name]) internals[name] = true;
+});
+
+Object.keys(dependencies).forEach(function(fn) {
+  dependencies[fn] = dependencies[fn].sort();
+});
+
+fs.writeFileSync(
+  __dirname + '/lib/dependencies.js',
+  'module.exports = ' + JSON.stringify(dependencies, null, 2) + '\n'
+);
+fs.writeFileSync(
+  __dirname + '/lib/internals.js',
+  'module.exports = ' + JSON.stringify(internals, null, 2) + '\n'
+);
+fs.writeFileSync(
+  __dirname + '/lib/sources.js',
+  'module.exports = ' + JSON.stringify(sources, null, 2) + '\n'
+);

package/lib/runtime-build.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var fs = require('fs');
+var dependencies = require('./runtime-lib/dependencies.js');
+var internals = require('./runtime-lib/internals.js');
+var sources = require('./runtime-lib/sources.js');
+
+module.exports = build;
+
+function build(functions) {
+  var fns = [];
+  functions = functions.filter(function(fn) {
+    return !internals[fn];
+  });
+  for (var i = 0; i < functions.length; i++) {
+    if (fns.indexOf(functions[i]) === -1) {
+      fns.push(functions[i]);
+      functions.push.apply(functions, dependencies[functions[i]]);
+    }
+  }
+  return fns
+    .sort()
+    .map(function(name) {
+      return sources[name];
+    })
+    .join('\n');
+}

package/lib/runtime-lib/dependencies.js

@@ -0,0 +1,34 @@
+module.exports = {
+  "has_own_property": [],
+  "merge": [
+    "style"
+  ],
+  "classes_array": [
+    "classes",
+    "escape"
+  ],
+  "classes_object": [
+    "has_own_property"
+  ],
+  "classes": [
+    "classes_array",
+    "classes_object"
+  ],
+  "style": [
+    "has_own_property"
+  ],
+  "attr": [
+    "escape"
+  ],
+  "attrs": [
+    "attr",
+    "classes",
+    "has_own_property",
+    "style"
+  ],
+  "match_html": [],
+  "escape": [
+    "match_html"
+  ],
+  "rethrow": []
+}

package/lib/runtime-lib/internals.js

@@ -0,0 +1,8 @@
+module.exports = {
+  "dependencies": true,
+  "internals": true,
+  "has_own_property": true,
+  "classes_array": true,
+  "classes_object": true,
+  "match_html": true
+}

package/lib/runtime-lib/sources.js

@@ -0,0 +1,13 @@
+module.exports = {
+  "has_own_property": "var pug_has_own_property=Object.prototype.hasOwnProperty;",
+  "merge": "function pug_merge(e,r){if(1===arguments.length){for(var t=e[0],g=1;g<e.length;g++)t=pug_merge(t,e[g]);return t}for(var l in r)if(\"class\"===l){var n=e[l]||[];e[l]=(Array.isArray(n)?n:[n]).concat(r[l]||[])}else if(\"style\"===l){var n=pug_style(e[l]);n=n&&\";\"!==n[n.length-1]?n+\";\":n;var a=pug_style(r[l]);a=a&&\";\"!==a[a.length-1]?a+\";\":a,e[l]=n+a}else e[l]=r[l];return e}",
+  "classes_array": "function pug_classes_array(r,a){for(var s,e=\"\",u=\"\",c=Array.isArray(a),g=0;g<r.length;g++)s=pug_classes(r[g]),s&&(c&&a[g]&&(s=pug_escape(s)),e=e+u+s,u=\" \");return e}",
+  "classes_object": "function pug_classes_object(r){var a=\"\",n=\"\";for(var o in r)o&&r[o]&&pug_has_own_property.call(r,o)&&(a=a+n+o,n=\" \");return a}",
+  "classes": "function pug_classes(s,r){return Array.isArray(s)?pug_classes_array(s,r):s&&\"object\"==typeof s?pug_classes_object(s):s||\"\"}",
+  "style": "function pug_style(r){if(!r)return\"\";if(\"object\"==typeof r){var t=\"\";for(var e in r)pug_has_own_property.call(r,e)&&(t=t+e+\":\"+r[e]+\";\");return t}return r+\"\"}",
+  "attr": "function pug_attr(t,e,n,r){if(e===!1||null==e||!e&&(\"class\"===t||\"style\"===t))return\"\";if(e===!0)return\" \"+(r?t:t+'=\"'+t+'\"');var f=typeof e;return\"object\"!==f&&\"function\"!==f||\"function\"!=typeof e.toJSON||(e=e.toJSON()),\"string\"==typeof e||(e=JSON.stringify(e),n||e.indexOf('\"')===-1)?(n&&(e=pug_escape(e)),\" \"+t+'=\"'+e+'\"'):\" \"+t+\"='\"+e.replace(/'/g,\"&#39;\")+\"'\"}",
+  "attrs": "function pug_attrs(t,r){var a=\"\";for(var s in t)if(pug_has_own_property.call(t,s)){var u=t[s];if(\"class\"===s){u=pug_classes(u),a=pug_attr(s,u,!1,r)+a;continue}\"style\"===s&&(u=pug_style(u)),a+=pug_attr(s,u,!1,r)}return a}",
+  "match_html": "var pug_match_html=/[\"&<>]/;",
+  "escape": "function pug_escape(e){var a=\"\"+e,t=pug_match_html.exec(a);if(!t)return e;var r,c,n,s=\"\";for(r=t.index,c=0;r<a.length;r++){switch(a.charCodeAt(r)){case 34:n=\"&quot;\";break;case 38:n=\"&amp;\";break;case 60:n=\"&lt;\";break;case 62:n=\"&gt;\";break;default:continue}c!==r&&(s+=a.substring(c,r)),c=r+1,s+=n}return c!==r?s+a.substring(c,r):s}",
+  "rethrow": "function pug_rethrow(e,n,r,t){if(!(e instanceof Error))throw e;if(!(\"undefined\"==typeof window&&n||t))throw e.message+=\" on line \"+r,e;var o,a,i,s;try{t=t||require(\"fs\").readFileSync(n,{encoding:\"utf8\"}),o=3,a=t.split(\"\\n\"),i=Math.max(r-o,0),s=Math.min(a.length,r+o)}catch(t){return e.message+=\" - could not read from \"+n+\" (\"+t.message+\")\",void pug_rethrow(e,null,r)}o=a.slice(i,s).map(function(e,n){var t=n+i+1;return(t==r?\"  > \":\"    \")+t+\"| \"+e}).join(\"\\n\"),e.path=n;try{e.message=(n||\"Pug\")+\":\"+r+\"\\n\"+o+\"\\n\\n\"+e.message}catch(e){}throw e}"
+}

package/lib/runtime-wrap.js

@@ -0,0 +1,10 @@
+var runtime = require('./runtime');
+
+module.exports = wrap;
+function wrap(template, templateName) {
+  templateName = templateName || 'template';
+  return Function(
+    'pug',
+    template + '\n' + 'return ' + templateName + ';'
+  )(runtime);
+}

package/lib/runtime.js

@@ -0,0 +1,287 @@
+'use strict';
+
+var pug_has_own_property = Object.prototype.hasOwnProperty;
+
+/**
+ * Merge two attribute objects giving precedence
+ * to values in object `b`. Classes are special-cased
+ * allowing for arrays and merging/joining appropriately
+ * resulting in a string.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ * @api private
+ */
+
+exports.merge = pug_merge;
+function pug_merge(a, b) {
+  if (arguments.length === 1) {
+    var attrs = a[0];
+    for (var i = 1; i < a.length; i++) {
+      attrs = pug_merge(attrs, a[i]);
+    }
+    return attrs;
+  }
+
+  for (var key in b) {
+    if (key === 'class') {
+      var valA = a[key] || [];
+      a[key] = (Array.isArray(valA) ? valA : [valA]).concat(b[key] || []);
+    } else if (key === 'style') {
+      var valA = pug_style(a[key]);
+      valA = valA && valA[valA.length - 1] !== ';' ? valA + ';' : valA;
+      var valB = pug_style(b[key]);
+      valB = valB && valB[valB.length - 1] !== ';' ? valB + ';' : valB;
+      a[key] = valA + valB;
+    } else {
+      a[key] = b[key];
+    }
+  }
+
+  return a;
+}
+
+/**
+ * Process array, object, or string as a string of classes delimited by a space.
+ *
+ * If `val` is an array, all members of it and its subarrays are counted as
+ * classes. If `escaping` is an array, then whether or not the item in `val` is
+ * escaped depends on the corresponding item in `escaping`. If `escaping` is
+ * not an array, no escaping is done.
+ *
+ * If `val` is an object, all the keys whose value is truthy are counted as
+ * classes. No escaping is done.
+ *
+ * If `val` is a string, it is counted as a class. No escaping is done.
+ *
+ * @param {(Array.<string>|Object.<string, boolean>|string)} val
+ * @param {?Array.<string>} escaping
+ * @return {String}
+ */
+exports.classes = pug_classes;
+function pug_classes_array(val, escaping) {
+  var classString = '',
+    className,
+    padding = '',
+    escapeEnabled = Array.isArray(escaping);
+  for (var i = 0; i < val.length; i++) {
+    className = pug_classes(val[i]);
+    if (!className) continue;
+    escapeEnabled && escaping[i] && (className = pug_escape(className));
+    classString = classString + padding + className;
+    padding = ' ';
+  }
+  return classString;
+}
+function pug_classes_object(val) {
+  var classString = '',
+    padding = '';
+  for (var key in val) {
+    if (key && val[key] && pug_has_own_property.call(val, key)) {
+      classString = classString + padding + key;
+      padding = ' ';
+    }
+  }
+  return classString;
+}
+function pug_classes(val, escaping) {
+  if (Array.isArray(val)) {
+    return pug_classes_array(val, escaping);
+  } else if (val && typeof val === 'object') {
+    return pug_classes_object(val);
+  } else {
+    return val || '';
+  }
+}
+
+/**
+ * Convert object or string to a string of CSS styles delimited by a semicolon.
+ *
+ * @param {(Object.<string, string>|string)} val
+ * @return {String}
+ */
+
+exports.style = pug_style;
+function pug_style(val) {
+  if (!val) return '';
+  if (typeof val === 'object') {
+    var out = '';
+    for (var style in val) {
+      /* istanbul ignore else */
+      if (pug_has_own_property.call(val, style)) {
+        out = out + style + ':' + val[style] + ';';
+      }
+    }
+    return out;
+  } else {
+    return val + '';
+  }
+}
+
+/**
+ * Render the given attribute.
+ *
+ * @param {String} key
+ * @param {String} val
+ * @param {Boolean} escaped
+ * @param {Boolean} terse
+ * @return {String}
+ */
+exports.attr = pug_attr;
+function pug_attr(key, val, escaped, terse) {
+  if (
+    val === false ||
+    val == null ||
+    (!val && (key === 'class' || key === 'style'))
+  ) {
+    return '';
+  }
+  if (val === true) {
+    var useTerse = terse || key.charAt(0) === '#';
+    return ' ' + (useTerse ? key : key + '="' + key + '"');
+  }
+  var type = typeof val;
+  if (
+    (type === 'object' || type === 'function') &&
+    typeof val.toJSON === 'function'
+  ) {
+    val = val.toJSON();
+  }
+  if (typeof val !== 'string') {
+    val = JSON.stringify(val);
+    if (!escaped && val.indexOf('"') !== -1) {
+      return ' ' + key + "='" + val.replace(/'/g, '&#39;') + "'";
+    }
+  }
+  if (escaped) val = pug_escape(val);
+  return ' ' + key + '="' + val + '"';
+}
+
+/**
+ * Render the given attributes object.
+ *
+ * @param {Object} obj
+ * @param {Object} terse whether to use HTML5 terse boolean attributes
+ * @return {String}
+ */
+exports.attrs = pug_attrs;
+function pug_attrs(obj, terse) {
+  var attrs = '';
+
+  for (var key in obj) {
+    if (pug_has_own_property.call(obj, key)) {
+      var val = obj[key];
+
+      if ('class' === key) {
+        val = pug_classes(val);
+        attrs = pug_attr(key, val, false, terse) + attrs;
+        continue;
+      }
+      if ('style' === key) {
+        val = pug_style(val);
+      }
+      attrs += pug_attr(key, val, false, terse);
+    }
+  }
+
+  return attrs;
+}
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @api private
+ */
+
+var pug_match_html = /["&<>]/;
+exports.escape = pug_escape;
+function pug_escape(_html) {
+  var html = '' + _html;
+  var regexResult = pug_match_html.exec(html);
+  if (!regexResult) return _html;
+
+  var result = '';
+  var i, lastIndex, escape;
+  for (i = regexResult.index, lastIndex = 0; i < html.length; i++) {
+    switch (html.charCodeAt(i)) {
+      case 34:
+        escape = '&quot;';
+        break;
+      case 38:
+        escape = '&amp;';
+        break;
+      case 60:
+        escape = '&lt;';
+        break;
+      case 62:
+        escape = '&gt;';
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== i) result += html.substring(lastIndex, i);
+    lastIndex = i + 1;
+    result += escape;
+  }
+  if (lastIndex !== i) return result + html.substring(lastIndex, i);
+  else return result;
+}
+
+/**
+ * Re-throw the given `err` in context to the
+ * the pug in `filename` at the given `lineno`.
+ *
+ * @param {Error} err
+ * @param {String} filename
+ * @param {String} lineno
+ * @param {String} str original source
+ * @api private
+ */
+
+exports.rethrow = pug_rethrow;
+function pug_rethrow(err, filename, lineno, str) {
+  if (!(err instanceof Error)) throw err;
+  if ((typeof window != 'undefined' || !filename) && !str) {
+    err.message += ' on line ' + lineno;
+    throw err;
+  }
+  var context, lines, start, end;
+  try {
+    str = str || require('fs').readFileSync(filename, {encoding: 'utf8'});
+    context = 3;
+    lines = str.split('\n');
+    start = Math.max(lineno - context, 0);
+    end = Math.min(lines.length, lineno + context);
+  } catch (ex) {
+    err.message +=
+      ' - could not read from ' + filename + ' (' + ex.message + ')';
+    pug_rethrow(err, null, lineno);
+    return;
+  }
+
+  // Error context
+  context = lines
+    .slice(start, end)
+    .map(function(line, i) {
+      var curr = i + start + 1;
+      return (curr == lineno ? '  > ' : '    ') + curr + '| ' + line;
+    })
+    .join('\n');
+
+  // Alter exception message
+  err.path = filename;
+  try {
+    err.message =
+      (filename || 'Pug') +
+      ':' +
+      lineno +
+      '\n' +
+      context +
+      '\n\n' +
+      err.message;
+  } catch (e) {}
+  throw err;
+}

package/lib/strip-comments.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var error = require('./error');
+
+module.exports = stripComments;
+
+function unexpectedToken(type, occasion, filename, line) {
+  var msg = '`' + type + '` encountered when ' + occasion;
+  throw error('UNEXPECTED_TOKEN', msg, {filename: filename, line: line});
+}
+
+function stripComments(input, options) {
+  options = options || {};
+
+  // Default: strip unbuffered comments and leave buffered ones alone
+  var stripUnbuffered = options.stripUnbuffered !== false;
+  var stripBuffered = options.stripBuffered === true;
+  var filename = options.filename;
+
+  var out = [];
+  // If we have encountered a comment token and are not sure if we have gotten
+  // out of the comment or not
+  var inComment = false;
+  // If we are sure that we are in a block comment and all tokens except
+  // `end-pipeless-text` should be ignored
+  var inPipelessText = false;
+
+  return input.filter(function(tok) {
+    switch (tok.type) {
+      case 'comment':
+        if (inComment) {
+          unexpectedToken(
+            'comment',
+            'already in a comment',
+            filename,
+            tok.line
+          );
+        } else {
+          inComment = tok.buffer ? stripBuffered : stripUnbuffered;
+          return !inComment;
+        }
+      case 'start-pipeless-text':
+        if (!inComment) return true;
+        if (inPipelessText) {
+          unexpectedToken(
+            'start-pipeless-text',
+            'already in pipeless text mode',
+            filename,
+            tok.line
+          );
+        }
+        inPipelessText = true;
+        return false;
+      case 'end-pipeless-text':
+        if (!inComment) return true;
+        if (!inPipelessText) {
+          unexpectedToken(
+            'end-pipeless-text',
+            'not in pipeless text mode',
+            filename,
+            tok.line
+          );
+        }
+        inPipelessText = false;
+        inComment = false;
+        return false;
+      // There might be a `text` right after `comment` but before
+      // `start-pipeless-text`. Treat it accordingly.
+      case 'text':
+        return !inComment;
+      default:
+        if (inPipelessText) return false;
+        inComment = false;
+        return true;
+    }
+  });
+}

package/lib/wrap.js

@@ -0,0 +1,10 @@
+var runtime = require('./');
+
+module.exports = wrap;
+function wrap(template, templateName) {
+  templateName = templateName || 'template';
+  return Function(
+    'pug',
+    template + '\n' + 'return ' + templateName + ';'
+  )(runtime);
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "puglite",
+  "version": "1.0.0",
+  "description": "A clean, whitespace-sensitive template language for writing HTML",
+  "keywords": [
+    "html",
+    "jade",
+    "pug",
+    "template"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/raykin/puglite"
+  },
+  "main": "lib",
+  "builders": "builders.json",
+  "exports": {
+    ".": "./lib/index.js",
+    "./angular-webpack": "./angular-webpack/index.js",
+    "./builders/browser": "./builders/browser/index.js",
+    "./builders/dev-server": "./builders/dev-server/index.js",
+    "./builders/karma": "./builders/karma/index.js",
+    "./builders/vitest": "./builders/vitest/index.js",
+    "./builders.json": "./builders.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/",
+    "angular-webpack/",
+    "builders.json",
+    "builders/"
+  ],
+  "scripts": {
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "watch": "jest --watch"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/*.test.js"
+    ]
+  },
+  "dependencies": {
+    "character-parser": "^4.0.0",
+    "constantinople": "^4.0.1",
+    "doctypes": "^1.1.0",
+    "is-expression": "^4.0.0",
+    "js-stringify": "^1.0.2",
+    "token-stream": "^1.0.0",
+    "void-elements": "^3.1.0",
+    "with": "^7.0.2"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0",
+    "uglify-js": "^3.19.3"
+  },
+  "peerDependencies": {
+    "@angular-builders/custom-webpack": ">=18.0.0",
+    "@angular-devkit/architect": ">=0.1800.0",
+    "@angular-devkit/build-angular": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular-builders/custom-webpack": {
+      "optional": true
+    }
+  },
+  "browser": {
+    "fs": false
+  }
+}