@forsakringskassan/docs-generator 2.35.4 → 2.35.5

package/dist/index.mjs

@@ -4,8 +4,8 @@ const require = $createRequire(import.meta.url);
 
 import fs from 'node:fs/promises';
 import path from 'node:path/posix';
-import { g as globSync, m as minimatch, M as MarkdownIt, d as dedent, b as closest, e as distance, f as fm, i as isCI, h as glob, j as moduleImporter, k as cliProgress, t as tinylr, w as watch, l as createInstance, n as fse, o as inter } from './vendor-Dd3EDAs1.mjs';
-import { g as generateId, p as parseInfostring, i as isDocumentPage, n as normalizePath, a as getFingerprint, h as hasTag, f as findTag, b as getOutputFilePath, d as htmlencode, e as exampleWorkerUrl, c as createMarkdownRenderer, j as generateExample } from './create-markdown-renderer-C3-r8Xp9.mjs';
+import { g as globSync, m as minimatch, M as MarkdownIt, d as dedent, b as closest, e as distance, f as fm, i as isCI, h as glob, j as moduleImporter, k as cliProgress, t as tinylr, w as watch, l as createInstance, n as fse, o as inter } from './vendor-Q6b0E6UP.mjs';
+import { g as generateId, p as parseInfostring, i as isDocumentPage, n as normalizePath, a as getFingerprint, h as hasTag, f as findTag, b as getOutputFilePath, d as htmlencode, e as exampleWorkerUrl, c as createMarkdownRenderer, j as generateExample } from './create-markdown-renderer-Bx9oXbtZ.mjs';
 import sp__default from 'node:path';
 import require$$1 from 'crypto';
 import 'node:crypto';

package/dist/markdown.mjs

@@ -2,8 +2,8 @@ import { createRequire as $createRequire } from "node:module";
 
 const require = $createRequire(import.meta.url);
 
-export { S as SoftError, c as createMarkdownRenderer } from './create-markdown-renderer-C3-r8Xp9.mjs';
-import './vendor-Dd3EDAs1.mjs';
+export { S as SoftError, c as createMarkdownRenderer } from './create-markdown-renderer-Bx9oXbtZ.mjs';
+import './vendor-Q6b0E6UP.mjs';
 import 'node:url';
 import 'node:path';
 import 'fs';

package/dist/{vendor-Dd3EDAs1.mjs → vendor-Q6b0E6UP.mjs}

@@ -25091,9 +25091,6 @@ class PluralResolver {
     this.logger = baseLogger.create('pluralResolver');
     this.pluralRulesCache = {};
   }
-  addRule(lng, obj) {
-    this.rules[lng] = obj;
-  }
   clearCache() {
     this.pluralRulesCache = {};
   }
@@ -26249,7 +26246,19 @@ class I18n extends EventEmitter {
       clone.store = new ResourceStore(clonedData, mergedOptions);
       clone.services.resourceStore = clone.store;
     }
-    if (options.interpolation) clone.services.interpolator = new Interpolator(mergedOptions);
+    if (options.interpolation) {
+      const defOpts = get$1();
+      const mergedInterpolation = {
+        ...defOpts.interpolation,
+        ...this.options.interpolation,
+        ...options.interpolation
+      };
+      const mergedForInterpolator = {
+        ...mergedOptions,
+        interpolation: mergedInterpolation
+      };
+      clone.services.interpolator = new Interpolator(mergedForInterpolator);
+    }
     clone.translator = new Translator(clone.services, mergedOptions);
     clone.translator.on('*', (event, ...args) => {
       clone.emit(event, ...args);
@@ -29001,6 +29010,11 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     return canonicalizedObj;
 }
 
+const INCLUDE_HEADERS = {
+    includeIndex: true,
+    includeUnderline: true,
+    includeFileHeaders: true
+};
 function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
     let optionsObj;
     if (!options) {
@@ -29130,17 +29144,29 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
  * creates a unified diff patch.
  * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)
  */
-function formatPatch(patch) {
+function formatPatch(patch, headerOptions) {
+    if (!headerOptions) {
+        headerOptions = INCLUDE_HEADERS;
+    }
     if (Array.isArray(patch)) {
-        return patch.map(formatPatch).join('\n');
+        if (patch.length > 1 && !headerOptions.includeFileHeaders) {
+            throw new Error('Cannot omit file headers on a multi-file patch. '
+                + '(The result would be unparseable; how would a tool trying to apply '
+                + 'the patch know which changes are to which file?)');
+        }
+        return patch.map(p => formatPatch(p, headerOptions)).join('\n');
     }
     const ret = [];
-    if (patch.oldFileName == patch.newFileName) {
+    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
         ret.push('Index: ' + patch.oldFileName);
     }
-    ret.push('===================================================================');
-    ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\t' + patch.oldHeader));
-    ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\t' + patch.newHeader));
+    if (headerOptions.includeUnderline) {
+        ret.push('===================================================================');
+    }
+    if (headerOptions.includeFileHeaders) {
+        ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\t' + patch.oldHeader));
+        ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\t' + patch.newHeader));
+    }
     for (let i = 0; i < patch.hunks.length; i++) {
         const hunk = patch.hunks[i];
         // Unified Diff Format quirk: If the chunk size is 0,
@@ -29170,7 +29196,7 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
         if (!patchObj) {
             return;
         }
-        return formatPatch(patchObj);
+        return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
     }
     else {
         const { callback } = options;
@@ -29179,7 +29205,7 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
                     callback(undefined);
                 }
                 else {
-                    callback(formatPatch(patchObj));
+                    callback(formatPatch(patchObj, options.headerOptions));
                 }
             } }));
     }
@@ -54893,10 +54919,32 @@ function requireUtils () {
 	hasRequiredUtils = 1;
 
 	var formats = requireFormats();
+	var getSideChannel = requireSideChannel();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
 
+	// Track objects created from arrayLimit overflow using side-channel
+	// Stores the current max numeric index for O(1) lookup
+	var overflowChannel = getSideChannel();
+
+	var markOverflow = function markOverflow(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	    return obj;
+	};
+
+	var isOverflow = function isOverflow(obj) {
+	    return overflowChannel.has(obj);
+	};
+
+	var getMaxIndex = function getMaxIndex(obj) {
+	    return overflowChannel.get(obj);
+	};
+
+	var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	};
+
 	var hexTable = (function () {
 	    var array = [];
 	    for (var i = 0; i < 256; ++i) {
@@ -54946,7 +54994,12 @@ function requireUtils () {
 	        if (isArray(target)) {
 	            target.push(source);
 	        } else if (target && typeof target === 'object') {
-	            if (
+	            if (isOverflow(target)) {
+	                // Add at next numeric index for overflow objects
+	                var newIndex = getMaxIndex(target) + 1;
+	                target[newIndex] = source;
+	                setMaxIndex(target, newIndex);
+	            } else if (
 	                (options && (options.plainObjects || options.allowPrototypes))
 	                || !has.call(Object.prototype, source)
 	            ) {
@@ -54960,6 +55013,18 @@ function requireUtils () {
 	    }
 
 	    if (!target || typeof target !== 'object') {
+	        if (isOverflow(source)) {
+	            // Create new object with target at 0, source values shifted by 1
+	            var sourceKeys = Object.keys(source);
+	            var result = options && options.plainObjects
+	                ? { __proto__: null, 0: target }
+	                : { 0: target };
+	            for (var m = 0; m < sourceKeys.length; m++) {
+	                var oldKey = parseInt(sourceKeys[m], 10);
+	                result[oldKey + 1] = source[sourceKeys[m]];
+	            }
+	            return markOverflow(result, getMaxIndex(source) + 1);
+	        }
 	        return [target].concat(source);
 	    }
 
@@ -55131,8 +55196,20 @@ function requireUtils () {
 	    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
 	};
 
-	var combine = function combine(a, b) {
-	    return [].concat(a, b);
+	var combine = function combine(a, b, arrayLimit, plainObjects) {
+	    // If 'a' is already an overflow object, add to it
+	    if (isOverflow(a)) {
+	        var newIndex = getMaxIndex(a) + 1;
+	        a[newIndex] = b;
+	        setMaxIndex(a, newIndex);
+	        return a;
+	    }
+
+	    var result = [].concat(a, b);
+	    if (result.length > arrayLimit) {
+	        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
+	    }
+	    return result;
 	};
 
 	var maybeMap = function maybeMap(val, fn) {
@@ -55154,6 +55231,7 @@ function requireUtils () {
 	    decode: decode,
 	    encode: encode,
 	    isBuffer: isBuffer,
+	    isOverflow: isOverflow,
 	    isRegExp: isRegExp,
 	    maybeMap: maybeMap,
 	    merge: merge
@@ -55640,16 +55718,18 @@ function requireParse () {
 	        } else {
 	            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
 
-	            val = utils.maybeMap(
-	                parseArrayValue(
-	                    part.slice(pos + 1),
-	                    options,
-	                    isArray(obj[key]) ? obj[key].length : 0
-	                ),
-	                function (encodedVal) {
-	                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');
-	                }
-	            );
+	            if (key !== null) {
+	                val = utils.maybeMap(
+	                    parseArrayValue(
+	                        part.slice(pos + 1),
+	                        options,
+	                        isArray(obj[key]) ? obj[key].length : 0
+	                    ),
+	                    function (encodedVal) {
+	                        return options.decoder(encodedVal, defaults.decoder, charset, 'value');
+	                    }
+	                );
+	            }
 	        }
 
 	        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
@@ -55660,11 +55740,18 @@ function requireParse () {
 	            val = isArray(val) ? [val] : val;
 	        }
 
-	        var existing = has.call(obj, key);
-	        if (existing && options.duplicates === 'combine') {
-	            obj[key] = utils.combine(obj[key], val);
-	        } else if (!existing || options.duplicates === 'last') {
-	            obj[key] = val;
+	        if (key !== null) {
+	            var existing = has.call(obj, key);
+	            if (existing && options.duplicates === 'combine') {
+	                obj[key] = utils.combine(
+	                    obj[key],
+	                    val,
+	                    options.arrayLimit,
+	                    options.plainObjects
+	                );
+	            } else if (!existing || options.duplicates === 'last') {
+	                obj[key] = val;
+	            }
 	        }
 	    }
 
@@ -55685,9 +55772,19 @@ function requireParse () {
 	        var root = chain[i];
 
 	        if (root === '[]' && options.parseArrays) {
-	            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
-	                ? []
-	                : utils.combine([], leaf);
+	            if (utils.isOverflow(leaf)) {
+	                // leaf is already an overflow object, preserve it
+	                obj = leaf;
+	            } else {
+	                obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
+	                    ? []
+	                    : utils.combine(
+	                        [],
+	                        leaf,
+	                        options.arrayLimit,
+	                        options.plainObjects
+	                    );
+	            }
 	        } else {
 	            obj = options.plainObjects ? { __proto__: null } : {};
 	            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
@@ -55715,29 +55812,28 @@ function requireParse () {
 	    return leaf;
 	};
 
-	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
-	    if (!givenKey) {
-	        return;
-	    }
-
-	    // Transform dot notation to bracket notation
+	var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
 	    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
 
-	    // The regex chunks
+	    if (options.depth <= 0) {
+	        if (!options.plainObjects && has.call(Object.prototype, key)) {
+	            if (!options.allowPrototypes) {
+	                return;
+	            }
+	        }
+
+	        return [key];
+	    }
 
 	    var brackets = /(\[[^[\]]*])/;
 	    var child = /(\[[^[\]]*])/g;
 
-	    // Get the parent
-
-	    var segment = options.depth > 0 && brackets.exec(key);
+	    var segment = brackets.exec(key);
 	    var parent = segment ? key.slice(0, segment.index) : key;
 
-	    // Stash the parent if it exists
-
 	    var keys = [];
+
 	    if (parent) {
-	        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
 	        if (!options.plainObjects && has.call(Object.prototype, parent)) {
 	            if (!options.allowPrototypes) {
 	                return;
@@ -55747,28 +55843,42 @@ function requireParse () {
 	        keys.push(parent);
 	    }
 
-	    // Loop through children appending to the array until we hit depth
-
 	    var i = 0;
-	    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
+	    while ((segment = child.exec(key)) !== null && i < options.depth) {
 	        i += 1;
-	        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+
+	        var segmentContent = segment[1].slice(1, -1);
+	        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
 	            if (!options.allowPrototypes) {
 	                return;
 	            }
 	        }
+
 	        keys.push(segment[1]);
 	    }
 
-	    // If there's a remainder, check strictDepth option for throw, else just add whatever is left
-
 	    if (segment) {
 	        if (options.strictDepth === true) {
 	            throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
 	        }
+
 	        keys.push('[' + key.slice(segment.index) + ']');
 	    }
 
+	    return keys;
+	};
+
+	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+	    if (!givenKey) {
+	        return;
+	    }
+
+	    var keys = splitKeyIntoSegments(givenKey, options);
+
+	    if (!keys) {
+	        return;
+	    }
+
 	    return parseObject(keys, val, options, valuesParsed);
 	};
 
@@ -56359,4 +56469,4 @@ var srcExports = requireSrc();
 var tinylr = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 
 export { HighlightJS as H, MarkdownIt as M, deflist_plugin as a, closest as b, createTwoFilesPatch as c, dedent as d, distance as e, fm as f, globSync as g, glob as h, isCI as i, moduleImporter as j, cliProgress as k, createInstance as l, minimatch as m, fse as n, inter as o, tinylr as t, watch$1 as w };
-//# sourceMappingURL=vendor-Dd3EDAs1.mjs.map
+//# sourceMappingURL=vendor-Q6b0E6UP.mjs.map