@angular/ssr 21.2.19 → 21.2.20

package/third_party/beasties/index.js

@@ -605,6 +605,10 @@ function requireStringifier () {
 	const STYLE_TAG = /(<)(\/?style\b)/gi;
 	const COMMENT_OPEN = /(<)(!--)/g;
 
+	// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
+	// Params starting with anything else need a space to stay separate tokens.
+	const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
+
 	function escapeHTMLInCSS(str) {
 	  if (typeof str !== 'string') return str
 	  if (!str.includes('<')) return str
@@ -630,27 +634,89 @@ function requireStringifier () {
 	  return str[0].toUpperCase() + str.slice(1)
 	}
 
+	function atruleStart(str, node) {
+	  let name = '@' + node.name;
+	  let params = node.params ? str.rawValue(node, 'params') : '';
+	  let afterName = node.raws.afterName;
+
+	  if (typeof afterName === 'undefined') {
+	    afterName = params ? ' ' : '';
+	  } else if (afterName === '' && params && !AT_NAME_END.test(params[0])) {
+	    afterName = ' ';
+	  }
+
+	  return name + afterName + params
+	}
+
+	function pushBody(str, stack, node) {
+	  let nodes = node.nodes;
+	  let last = nodes.length - 1;
+	  while (last > 0) {
+	    if (nodes[last].type !== 'comment') break
+	    last -= 1;
+	  }
+
+	  let semicolon = str.raw(node, 'semicolon');
+	  let isDocument = node.type === 'document';
+	  for (let i = nodes.length - 1; i >= 0; i--) {
+	    let child = nodes[i];
+	    let childSemicolon = last !== i || semicolon;
+	    // A childless at-rule or a custom property declaration that still has
+	    // following siblings must be terminated. Without the semicolon those
+	    // trailing comments are folded into the at-rule's prelude or the custom
+	    // property's value and disappear when the output is re-parsed.
+	    if (
+	      !childSemicolon &&
+	      i < nodes.length - 1 &&
+	      ((child.type === 'atrule' && !child.nodes) ||
+	        (child.type === 'decl' && child.prop.startsWith('--')))
+	    ) {
+	      childSemicolon = true;
+	    }
+	    stack.push({
+	      document: isDocument,
+	      node: child,
+	      semicolon: childSemicolon
+	    });
+	  }
+	}
+
+	function pushBlock(str, stack, node, start) {
+	  let between = str.raw(node, 'between', 'beforeOpen');
+	  str.builder(escapeHTMLInCSS(start + between) + '{', node, 'start');
+
+	  let hasNodes = node.nodes && node.nodes.length;
+	  let close = () => {
+	    let after = hasNodes
+	      ? str.raw(node, 'after')
+	      : str.raw(node, 'after', 'emptyBody');
+	    if (after) str.builder(escapeHTMLInCSS(after));
+	    str.builder('}', node, 'end');
+	    if (node.type === 'rule' && node.raws.ownSemicolon) {
+	      str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end');
+	    }
+	  };
+
+	  if (hasNodes) {
+	    stack.push(close);
+	    pushBody(str, stack, node);
+	  } else {
+	    close();
+	  }
+	}
+
 	class Stringifier {
 	  constructor(builder) {
 	    this.builder = builder;
 	  }
 
 	  atrule(node, semicolon) {
-	    let raws = node.raws;
-	    let name = '@' + node.name;
-	    let params = node.params ? this.rawValue(node, 'params') : '';
-
-	    if (typeof raws.afterName !== 'undefined') {
-	      name += raws.afterName;
-	    } else if (params) {
-	      name += ' ';
-	    }
-
+	    let start = atruleStart(this, node);
 	    if (node.nodes) {
-	      this.block(node, name + params);
+	      this.block(node, start);
 	    } else {
-	      let end = (raws.between || '') + (semicolon ? ';' : '');
-	      this.builder(escapeHTMLInCSS(name + params + end), node);
+	      let end = (node.raws.between || '') + (semicolon ? ';' : '');
+	      this.builder(escapeHTMLInCSS(start + end), node);
 	    }
 	  }
 
@@ -684,22 +750,15 @@ function requireStringifier () {
 	  }
 
 	  block(node, start) {
-	    let raws = node.raws;
-	    let between = typeof raws.between !== 'undefined'
-	      ? raws.between
-	      : this.raw(node, 'between', 'beforeOpen');
+	    let between = this.raw(node, 'between', 'beforeOpen');
 	    this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start');
 
 	    let after;
 	    if (node.nodes && node.nodes.length) {
 	      this.body(node);
-	      after = typeof raws.after !== 'undefined'
-	        ? raws.after
-	        : this.raw(node, 'after');
+	      after = this.raw(node, 'after');
 	    } else {
-	      after = typeof raws.after !== 'undefined'
-	        ? raws.after
-	        : this.raw(node, 'after', 'emptyBody');
+	      after = this.raw(node, 'after', 'emptyBody');
 	    }
 
 	    if (after) this.builder(escapeHTMLInCSS(after));
@@ -707,47 +766,52 @@ function requireStringifier () {
 	  }
 
 	  body(node) {
-	    let nodes = node.nodes;
-	    let last = nodes.length - 1;
-	    while (last > 0) {
-	      if (nodes[last].type !== 'comment') break
-	      last -= 1;
-	    }
+	    // Rules and at-rules are expanded into an explicit stack instead of
+	    // recursive `stringify()` calls to survive deeply nested trees.
+	    // If a subclass changes the traversal methods, its children go
+	    // through `stringify()` to keep the override in charge.
+	    let proto = Stringifier.prototype;
+	    let expandable = ['atrule', 'block', 'body', 'rule', 'stringify'].every(
+	      method => this[method] === proto[method]
+	    );
 
-	    let semicolon = this.raw(node, 'semicolon');
-	    let isDocument = node.type === 'document';
-	    for (let i = 0; i < nodes.length; i++) {
-	      let child = nodes[i];
-	      let before = child.raws.before;
-	      if (typeof before === 'undefined') {
-	        before = this.raw(child, 'before');
+	    let stack = [];
+	    pushBody(this, stack, node);
+
+	    while (stack.length > 0) {
+	      let entry = stack.pop();
+	      if (typeof entry === 'function') {
+	        entry();
+	        continue
+	      }
+
+	      let child = entry.node;
+	      let before = this.raw(child, 'before');
+	      if (before) {
+	        this.builder(entry.document ? before : escapeHTMLInCSS(before));
+	      }
+
+	      if (expandable && child.type === 'rule') {
+	        pushBlock(this, stack, child, this.rawValue(child, 'selector'));
+	      } else if (expandable && child.type === 'atrule' && child.nodes) {
+	        pushBlock(this, stack, child, atruleStart(this, child));
+	      } else {
+	        this.stringify(child, entry.semicolon);
 	      }
-	      if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before));
-	      this.stringify(child, last !== i || semicolon);
 	    }
 	  }
 
 	  comment(node) {
-	    let raws = node.raws;
-	    let left = typeof raws.left !== 'undefined'
-	      ? raws.left
-	      : this.raw(node, 'left', 'commentLeft');
-	    let right = typeof raws.right !== 'undefined'
-	      ? raws.right
-	      : this.raw(node, 'right', 'commentRight');
+	    let left = this.raw(node, 'left', 'commentLeft');
+	    let right = this.raw(node, 'right', 'commentRight');
 	    this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node);
 	  }
 
 	  decl(node, semicolon) {
 	    let raws = node.raws;
-	    let between = typeof raws.between !== 'undefined'
-	      ? raws.between
-	      : this.raw(node, 'between', 'colon');
+	    let between = this.raw(node, 'between', 'colon');
 
-	    let rawVal = raws.value;
-	    let value = rawVal && rawVal.value === node.value ? rawVal.raw : node.value;
-
-	    let string = node.prop + between + value;
+	    let string = node.prop + between + this.rawValue(node, 'value');
 
 	    if (node.important) {
 	      string += raws.important || ' !important';
@@ -1041,25 +1105,41 @@ function requireNode$1 () {
 
 	function cloneNode(obj, parent) {
 	  let cloned = new obj.constructor();
-
-	  for (let i in obj) {
-	    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
-	      /* c8 ignore next 2 */
-	      continue
-	    }
-	    if (i === 'proxyCache') continue
-	    let value = obj[i];
-	    let type = typeof value;
-
-	    if (i === 'parent' && type === 'object') {
-	      if (parent) cloned[i] = parent;
-	    } else if (i === 'source') {
-	      cloned[i] = value;
-	    } else if (Array.isArray(value)) {
-	      cloned[i] = value.map(j => cloneNode(j, cloned));
-	    } else {
-	      if (type === 'object' && value !== null) value = cloneNode(value);
-	      cloned[i] = value;
+	  // An explicit stack instead of recursive calls to survive deeply
+	  // nested trees. Each entry is [source, its clone, clone's parent].
+	  let stack = [[obj, cloned, parent]];
+
+	  while (stack.length > 0) {
+	    let [source, target, targetParent] = stack.pop();
+	    for (let i in source) {
+	      if (!Object.prototype.hasOwnProperty.call(source, i)) {
+	        /* c8 ignore next 2 */
+	        continue
+	      }
+	      if (i === 'proxyCache') continue
+	      let value = source[i];
+	      let type = typeof value;
+
+	      if (i === 'parent' && type === 'object') {
+	        if (targetParent) target[i] = targetParent;
+	      } else if (i === 'source') {
+	        target[i] = value;
+	      } else if (Array.isArray(value)) {
+	        let children = [];
+	        target[i] = children;
+	        for (let j of value) {
+	          let childClone = new j.constructor();
+	          children.push(childClone);
+	          stack.push([j, childClone, target]);
+	        }
+	      } else {
+	        if (type === 'object' && value !== null) {
+	          let valueClone = new value.constructor();
+	          stack.push([value, valueClone, undefined]);
+	          value = valueClone;
+	        }
+	        target[i] = value;
+	      }
 	    }
 	  }
 
@@ -1103,11 +1183,15 @@ function requireNode$1 () {
 	    this[isClean] = false;
 	    this[my] = true;
 
-	    for (let name in defaults) {
+	    for (let name of Object.keys(defaults)) {
+	      if (name === '__proto__') continue
 	      if (name === 'nodes') {
 	        this.nodes = [];
 	        for (let node of defaults[name]) {
-	          if (typeof node.clone === 'function') {
+	          // Clone only nodes that already belong to another tree, so passing a
+	          // freshly created (parent-less) node adopts that instance instead of
+	          // a copy and keeps the caller's reference usable. See #1987.
+	          if (typeof node.clone === 'function' && node.parent) {
 	            this.append(node.clone());
 	          } else {
 	            this.append(node);
@@ -1240,14 +1324,18 @@ function requireNode$1 () {
 	  }
 
 	  positionBy(opts = {}) {
-	    let pos = this.source.start;
+	    let inputString =
+	      'document' in this.source.input
+	        ? this.source.input.document
+	        : this.source.input.css;
+	    let pos = {
+	      column: this.source.start.column,
+	      line: this.source.start.line,
+	      offset: sourceOffset(inputString, this.source.start)
+	    };
 	    if (opts.index) {
 	      pos = this.positionInside(opts.index);
 	    } else if (opts.word) {
-	      let inputString =
-	        'document' in this.source.input
-	          ? this.source.input.document
-	          : this.source.input.css;
 	      let stringRepresentation = inputString.slice(
 	        sourceOffset(inputString, this.source.start),
 	        sourceOffset(inputString, this.source.end)
@@ -1332,7 +1420,7 @@ function requireNode$1 () {
 	          line: opts.start.line,
 	          offset: sourceOffset(inputString, opts.start)
 	        };
-	      } else if (opts.index) {
+	      } else if (typeof opts.index === 'number') {
 	        start = this.positionInside(opts.index);
 	      }
 
@@ -1344,7 +1432,7 @@ function requireNode$1 () {
 	        };
 	      } else if (typeof opts.endIndex === 'number') {
 	        end = this.positionInside(opts.endIndex);
-	      } else if (opts.index) {
+	      } else if (typeof opts.index === 'number') {
 	        end = this.positionInside(opts.index + 1);
 	      }
 	    }
@@ -1408,47 +1496,68 @@ function requireNode$1 () {
 	  }
 
 	  toJSON(_, inputs) {
-	    let fixed = {};
 	    let emitInputs = inputs == null;
 	    inputs = inputs || new Map();
-	    let inputsNextIndex = 0;
 
-	    for (let name in this) {
-	      if (!Object.prototype.hasOwnProperty.call(this, name)) {
-	        /* c8 ignore next 2 */
-	        continue
-	      }
-	      if (name === 'parent' || name === 'proxyCache') continue
-	      let value = this[name];
+	    // A worklist instead of recursive `toJSON()` calls to survive deeply
+	    // nested trees. Each entry converts one node and writes the result
+	    // into the already converted parent by [holder, key].
+	    let holderOfRoot = [];
+	    let queue = [[this, holderOfRoot, 0]];
+
+	    for (let step = 0; step < queue.length; step++) {
+	      let [node, holder, key] = queue[step];
+	      let fixed = {};
+	      holder[key] = fixed;
 
-	      if (Array.isArray(value)) {
-	        fixed[name] = value.map(i => {
-	          if (typeof i === 'object' && i.toJSON) {
-	            return i.toJSON(null, inputs)
+	      for (let name in node) {
+	        if (!Object.prototype.hasOwnProperty.call(node, name)) {
+	          /* c8 ignore next 2 */
+	          continue
+	        }
+	        if (name === 'parent' || name === 'proxyCache') continue
+	        let value = node[name];
+
+	        if (Array.isArray(value)) {
+	          let fixedArray = [];
+	          fixed[name] = fixedArray;
+	          for (let i = 0; i < value.length; i++) {
+	            let item = value[i];
+	            if (typeof item === 'object' && item.toJSON) {
+	              if (item.toJSON === Node.prototype.toJSON) {
+	                queue.push([item, fixedArray, i]);
+	              } else {
+	                fixedArray[i] = item.toJSON(null, inputs);
+	              }
+	            } else {
+	              fixedArray[i] = item;
+	            }
+	          }
+	        } else if (typeof value === 'object' && value.toJSON) {
+	          if (value.toJSON === Node.prototype.toJSON) {
+	            queue.push([value, fixed, name]);
 	          } else {
-	            return i
+	            fixed[name] = value.toJSON(null, inputs);
 	          }
-	        });
-	      } else if (typeof value === 'object' && value.toJSON) {
-	        fixed[name] = value.toJSON(null, inputs);
-	      } else if (name === 'source') {
-	        if (value == null) continue
-	        let inputId = inputs.get(value.input);
-	        if (inputId == null) {
-	          inputId = inputsNextIndex;
-	          inputs.set(value.input, inputsNextIndex);
-	          inputsNextIndex++;
+	        } else if (name === 'source') {
+	          if (value == null) continue
+	          let inputId = inputs.get(value.input);
+	          if (inputId == null) {
+	            inputId = inputs.size;
+	            inputs.set(value.input, inputId);
+	          }
+	          fixed[name] = {
+	            end: value.end,
+	            inputId,
+	            start: value.start
+	          };
+	        } else {
+	          fixed[name] = value;
 	        }
-	        fixed[name] = {
-	          end: value.end,
-	          inputId,
-	          start: value.start
-	        };
-	      } else {
-	        fixed[name] = value;
 	      }
 	    }
 
+	    let fixed = holderOfRoot[0];
 	    if (emitInputs) {
 	      fixed.inputs = [...inputs.keys()].map(input => input.toJSON());
 	    }
@@ -1552,18 +1661,25 @@ function requireContainer$1 () {
 	let AtRule, parse, Root, Rule;
 
 	function cleanSource(nodes) {
-	  return nodes.map(i => {
-	    if (i.nodes) i.nodes = cleanSource(i.nodes);
-	    delete i.source;
-	    return i
-	  })
+	  let stack = nodes.slice();
+	  while (stack.length > 0) {
+	    let node = stack.pop();
+	    delete node.source;
+	    if (node.nodes) {
+	      node.nodes = node.nodes.slice();
+	      for (let i of node.nodes) stack.push(i);
+	    }
+	  }
+	  return nodes.slice()
 	}
 
 	function markTreeDirty(node) {
-	  node[isClean] = false;
-	  if (node.proxyOf.nodes) {
-	    for (let i of node.proxyOf.nodes) {
-	      markTreeDirty(i);
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    next[isClean] = false;
+	    if (next.proxyOf.nodes) {
+	      for (let i of next.proxyOf.nodes) stack.push(i);
 	    }
 	  }
 	}
@@ -1591,9 +1707,18 @@ function requireContainer$1 () {
 	  }
 
 	  cleanRaws(keepBetween) {
-	    super.cleanRaws(keepBetween);
-	    if (this.nodes) {
-	      for (let node of this.nodes) node.cleanRaws(keepBetween);
+	    let stack = [this];
+	    while (stack.length > 0) {
+	      let node = stack.pop();
+	      if (node !== this && node.cleanRaws !== Container.prototype.cleanRaws) {
+	        // Subclass with own logic; let it handle its subtree
+	        node.cleanRaws(keepBetween);
+	        continue
+	      }
+	      Node.prototype.cleanRaws.call(node, keepBetween);
+	      if (node.nodes) {
+	        for (let child of node.nodes) stack.push(child);
+	      }
 	    }
 	  }
 
@@ -1853,19 +1978,48 @@ function requireContainer$1 () {
 	  }
 
 	  walk(callback) {
-	    return this.each((child, i) => {
+	    if (!this.proxyOf.nodes) return undefined
+
+	    // An explicit stack instead of recursive `each()` calls to survive
+	    // deeply nested trees. Each frame keeps a live `indexes` slot, so
+	    // insertion and removal during the walk behave like `each()`: the
+	    // slot stays at the current child until its subtree is finished.
+	    let stack = [{ iterator: this.getIterator(), node: this.proxyOf }];
+
+	    while (stack.length > 0) {
+	      let { iterator, node } = stack[stack.length - 1];
+	      let index = node.indexes[iterator];
+
+	      if (index >= node.proxyOf.nodes.length) {
+	        delete node.indexes[iterator];
+	        stack.pop();
+	        let parent = stack[stack.length - 1];
+	        // Finish the parent’s step for the child subtree we just left
+	        if (parent) parent.node.indexes[parent.iterator] += 1;
+	        continue
+	      }
+
+	      let child = node.proxyOf.nodes[index];
 	      let result;
 	      try {
-	        result = callback(child, i);
+	        result = callback(child, index);
 	      } catch (e) {
 	        throw child.addToError(e)
 	      }
-	      if (result !== false && child.walk) {
-	        result = child.walk(callback);
+	      if (result === false) {
+	        for (let opened of stack) {
+	          delete opened.node.indexes[opened.iterator];
+	        }
+	        return false
+	      }
+	      if (child.walk && child.proxyOf.nodes) {
+	        stack.push({ iterator: child.getIterator(), node: child });
+	      } else {
+	        node.indexes[iterator] += 1;
 	      }
+	    }
 
-	      return result
-	    })
+	    return undefined
 	  }
 
 	  walkAtRules(name, callback) {
@@ -1968,24 +2122,26 @@ function requireContainer$1 () {
 
 	/* c8 ignore start */
 	Container.rebuild = node => {
-	  if (node.type === 'atrule') {
-	    Object.setPrototypeOf(node, AtRule.prototype);
-	  } else if (node.type === 'rule') {
-	    Object.setPrototypeOf(node, Rule.prototype);
-	  } else if (node.type === 'decl') {
-	    Object.setPrototypeOf(node, Declaration.prototype);
-	  } else if (node.type === 'comment') {
-	    Object.setPrototypeOf(node, Comment.prototype);
-	  } else if (node.type === 'root') {
-	    Object.setPrototypeOf(node, Root.prototype);
-	  }
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    if (next.type === 'atrule') {
+	      Object.setPrototypeOf(next, AtRule.prototype);
+	    } else if (next.type === 'rule') {
+	      Object.setPrototypeOf(next, Rule.prototype);
+	    } else if (next.type === 'decl') {
+	      Object.setPrototypeOf(next, Declaration.prototype);
+	    } else if (next.type === 'comment') {
+	      Object.setPrototypeOf(next, Comment.prototype);
+	    } else if (next.type === 'root') {
+	      Object.setPrototypeOf(next, Root.prototype);
+	    }
 
-	  node[my] = true;
+	    next[my] = true;
 
-	  if (node.nodes) {
-	    node.nodes.forEach(child => {
-	      Container.rebuild(child);
-	    });
+	    if (next.nodes) {
+	      for (let child of next.nodes) stack.push(child);
+	    }
 	  }
 	};
 	/* c8 ignore stop */
@@ -2072,22 +2228,14 @@ var hasRequiredNonSecure;
 function requireNonSecure () {
 	if (hasRequiredNonSecure) return nonSecure;
 	hasRequiredNonSecure = 1;
-	// This alphabet uses `A-Za-z0-9_-` symbols.
-	// The order of characters is optimized for better gzip and brotli compression.
-	// References to the same file (works both for gzip and brotli):
-	// `'use`, `andom`, and `rict'`
-	// References to the brotli default dictionary:
-	// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
 	let urlAlphabet =
 	  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
 
 	let customAlphabet = (alphabet, defaultSize = 21) => {
 	  return (size = defaultSize) => {
 	    let id = '';
-	    // A compact alternative for `for (var i = 0; i < step; i++)`.
 	    let i = size | 0;
-	    while (i--) {
-	      // `| 0` is more compact and faster than `Math.floor()`.
+	    while (i-- > 0) {
 	      id += alphabet[(Math.random() * alphabet.length) | 0];
 	    }
 	    return id
@@ -2096,10 +2244,8 @@ function requireNonSecure () {
 
 	let nanoid = (size = 21) => {
 	  let id = '';
-	  // A compact alternative for `for (var i = 0; i < step; i++)`.
 	  let i = size | 0;
-	  while (i--) {
-	    // `| 0` is more compact and faster than `Math.floor()`.
+	  while (i-- > 0) {
 	    id += urlAlphabet[(Math.random() * 64) | 0];
 	  }
 	  return id
@@ -2117,7 +2263,7 @@ function requirePreviousMap () {
 	hasRequiredPreviousMap = 1;
 
 	let { existsSync, readFileSync } = require$$2;
-	let { dirname, join } = require$$2;
+	let { dirname, isAbsolute, join, relative, sep } = require$$2;
 	let { SourceMapConsumer, SourceMapGenerator } = require$$2;
 
 	function fromBase64(str) {
@@ -2201,9 +2347,12 @@ function requirePreviousMap () {
 	  }
 
 	  loadFile(path, cssFile, trusted) {
-	    /* c8 ignore next 5 */
 	    if (!trusted && !this.unsafeMap) {
-	      if (!/\.map$/i.test(path)) {
+	      if (!/\.map$/i.test(path)) return undefined
+	      if (!cssFile) return undefined
+
+	      let rel = relative(dirname(cssFile), path);
+	      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
 	        return undefined
 	      }
 	    }
@@ -2491,12 +2640,21 @@ function requireInput () {
 	    if (!this.map) return false
 	    let consumer = this.map.consumer();
 
-	    let from = consumer.originalPositionFor({ column, line });
+	    let from = consumer.originalPositionFor({ column: column - 1, line });
 	    if (!from.source) return false
 
 	    let to;
 	    if (typeof endLine === 'number') {
-	      to = consumer.originalPositionFor({ column: endColumn, line: endLine });
+	      let toPosition = consumer.originalPositionFor({
+	        column: endColumn - 1,
+	        line: endLine
+	      });
+	      // The source map may not have a mapping that covers the end position
+	      // (`originalPositionFor()` then returns `null` for `line`/`column`
+	      // instead of omitting them). Treat that the same as not requesting
+	      // an end position at all, so `endLine`/`endColumn` stay a consistent
+	      // `undefined` pair instead of a mix of `null` and a bogus number.
+	      if (toPosition.source) to = toPosition;
 	    }
 
 	    let fromUrl;
@@ -2511,8 +2669,8 @@ function requireInput () {
 	    }
 
 	    let result = {
-	      column: from.column,
-	      endColumn: to && to.column,
+	      column: from.column + 1,
+	      endColumn: to && to.column + 1,
 	      endLine: to && to.line,
 	      line: from.line,
 	      url: fromUrl.toString()
@@ -2578,6 +2736,19 @@ function requireRoot () {
 	  }
 
 	  normalize(child, sample, type) {
+	    let keepBefore = new Set();
+	    for (let node of Array.isArray(child) ? child : [child]) {
+	      if (
+	        node &&
+	        typeof node === 'object' &&
+	        !node.parent &&
+	        node.raws &&
+	        typeof node.raws.before !== 'undefined'
+	      ) {
+	        keepBefore.add(node.raws);
+	      }
+	    }
+
 	    let nodes = super.normalize(child);
 
 	    if (sample) {
@@ -2589,7 +2760,9 @@ function requireRoot () {
 	        }
 	      } else if (this.first !== sample) {
 	        for (let node of nodes) {
-	          node.raws.before = sample.raws.before;
+	          if (!keepBefore.has(node.raws)) {
+	            node.raws.before = sample.raws.before;
+	          }
 	        }
 	      }
 	    }
@@ -2744,26 +2917,24 @@ function requireFromJSON () {
 	let Root = requireRoot();
 	let Rule = requireRule();
 
-	function fromJSON(json, inputs) {
-	  if (Array.isArray(json)) return json.map(n => fromJSON(n))
-
-	  let { inputs: ownInputs, ...defaults } = json;
-	  if (ownInputs) {
-	    inputs = [];
-	    for (let input of ownInputs) {
-	      let inputHydrated = { ...input, __proto__: Input.prototype };
-	      if (inputHydrated.map) {
-	        inputHydrated.map = {
-	          ...inputHydrated.map,
-	          __proto__: PreviousMap.prototype
-	        };
-	      }
-	      inputs.push(inputHydrated);
+	function hydrateInputs(json, inputs) {
+	  if (!json.inputs) return inputs
+	  return json.inputs.map(input => {
+	    let inputHydrated = { ...input, __proto__: Input.prototype };
+	    if (inputHydrated.map) {
+	      inputHydrated.map = {
+	        ...inputHydrated.map,
+	        __proto__: PreviousMap.prototype
+	      };
 	    }
-	  }
-	  if (defaults.nodes) {
-	    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs));
-	  }
+	    return inputHydrated
+	  })
+	}
+
+	function constructNode(json, inputs, children) {
+	  let defaults = { ...json };
+	  delete defaults.inputs;
+	  delete defaults.nodes;
 	  if (defaults.source) {
 	    let { inputId, ...source } = defaults.source;
 	    defaults.source = source;
@@ -2771,19 +2942,74 @@ function requireFromJSON () {
 	      defaults.source.input = inputs[inputId];
 	    }
 	  }
+
+	  let node;
 	  if (defaults.type === 'root') {
-	    return new Root(defaults)
+	    node = new Root(defaults);
 	  } else if (defaults.type === 'decl') {
-	    return new Declaration(defaults)
+	    node = new Declaration(defaults);
 	  } else if (defaults.type === 'rule') {
-	    return new Rule(defaults)
+	    node = new Rule(defaults);
 	  } else if (defaults.type === 'comment') {
-	    return new Comment(defaults)
+	    node = new Comment(defaults);
 	  } else if (defaults.type === 'atrule') {
-	    return new AtRule(defaults)
+	    node = new AtRule(defaults);
 	  } else {
 	    throw new Error('Unknown node type: ' + json.type)
 	  }
+
+	  // Rehydrated children are attached after construction. Passing them
+	  // through the container constructor would re-run insertion spacing
+	  // normalization and overwrite each child's own `raws.before`.
+	  if (children) {
+	    node.nodes = children;
+	    for (let child of children) child.parent = node;
+	  }
+
+	  return node
+	}
+
+	function fromJSON(json, inputs) {
+	  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+	  // An explicit stack instead of recursive calls to survive deeply
+	  // nested trees. Children are rehydrated before their parent node
+	  // is constructed.
+	  let result;
+	  let stack = [
+	    { childIndex: 0, children: [], inputs: hydrateInputs(json, inputs), json }
+	  ];
+
+	  while (stack.length > 0) {
+	    let frame = stack[stack.length - 1];
+	    let jsonNodes = frame.json.nodes;
+
+	    if (jsonNodes && frame.childIndex < jsonNodes.length) {
+	      let childJson = jsonNodes[frame.childIndex];
+	      frame.childIndex += 1;
+	      stack.push({
+	        childIndex: 0,
+	        children: [],
+	        inputs: hydrateInputs(childJson, frame.inputs),
+	        json: childJson
+	      });
+	      continue
+	    }
+
+	    stack.pop();
+	    let node = constructNode(
+	      frame.json,
+	      frame.inputs,
+	      jsonNodes ? frame.children : undefined
+	    );
+	    if (stack.length > 0) {
+	      stack[stack.length - 1].children.push(node);
+	    } else {
+	      result = node;
+	    }
+	  }
+
+	  return result
 	}
 
 	fromJSON_1 = fromJSON;
@@ -3480,6 +3706,12 @@ function requireParser () {
 	  }
 	}
 
+	function tokensToString(tokens, from, to) {
+	  let result = '';
+	  for (let i = from; i < to; i++) result += tokens[i][1];
+	  return result
+	}
+
 	class Parser {
 	  constructor(input) {
 	    this.input = input;
@@ -3592,9 +3824,10 @@ function requireParser () {
 	        if (founded === 2) break
 	      }
 	    }
-	    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
-	    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
-	    // And because we need it after that one we do +1 to get the next one.
+	    // If the token is a word, e.g. `!important`, `red` or any other valid
+	    // property's value. Then we need to return the colon after that word
+	    // token. [3] is the "end" colon of that word. And because we need it
+	    // after that one we do +1 to get the next one.
 	    throw this.input.error(
 	      'Missed semicolon',
 	      token[0] === 'word' ? token[3] + 1 : token[2]
@@ -3667,50 +3900,50 @@ function requireParser () {
 	    );
 	    node.source.end.offset++;
 
-	    while (tokens[0][0] !== 'word') {
-	      if (tokens.length === 1) this.unknownWord(tokens);
-	      node.raws.before += tokens.shift()[1];
+	    let start = 0;
+	    while (tokens[start][0] !== 'word') {
+	      if (start === tokens.length - 1) this.unknownWord([tokens[start]]);
+	      start++;
 	    }
-	    node.source.start = this.getPosition(tokens[0][2]);
+	    node.raws.before += tokensToString(tokens, 0, start);
+	    node.source.start = this.getPosition(tokens[start][2]);
 
-	    node.prop = '';
-	    while (tokens.length) {
-	      let type = tokens[0][0];
+	    let propStart = start;
+	    while (start < tokens.length) {
+	      let type = tokens[start][0];
 	      if (type === ':' || type === 'space' || type === 'comment') {
 	        break
 	      }
-	      node.prop += tokens.shift()[1];
+	      start++;
 	    }
+	    node.prop = tokensToString(tokens, propStart, start);
 
-	    node.raws.between = '';
-
+	    let betweenStart = start;
 	    let token;
-	    while (tokens.length) {
-	      token = tokens.shift();
-
-	      if (token[0] === ':') {
-	        node.raws.between += token[1];
-	        break
-	      } else {
-	        if (token[0] === 'word' && /\w/.test(token[1])) {
-	          this.unknownWord([token]);
-	        }
-	        node.raws.between += token[1];
+	    while (start < tokens.length) {
+	      token = tokens[start];
+	      start++;
+	      if (token[0] === ':') break
+	      if (token[0] === 'word' && /\w/.test(token[1])) {
+	        this.unknownWord([token]);
 	      }
 	    }
+	    node.raws.between = tokensToString(tokens, betweenStart, start);
 
 	    if (node.prop[0] === '_' || node.prop[0] === '*') {
 	      node.raws.before += node.prop[0];
 	      node.prop = node.prop.slice(1);
 	    }
 
-	    let firstSpaces = [];
-	    let next;
-	    while (tokens.length) {
-	      next = tokens[0][0];
+	    let firstSpacesStart = start;
+	    while (start < tokens.length) {
+	      let next = tokens[start][0];
 	      if (next !== 'space' && next !== 'comment') break
-	      firstSpaces.push(tokens.shift());
+	      start++;
 	    }
+	    let firstSpaces = tokens.slice(firstSpacesStart, start);
+
+	    tokens = tokens.slice(start);
 
 	    this.precheckMissedSemicolon(tokens);
 
@@ -4129,12 +4362,22 @@ function requireWarning () {
 	if (hasRequiredWarning) return warning;
 	hasRequiredWarning = 1;
 
+	let Container = requireContainer$1();
+	let { my } = requireSymbols();
+
 	class Warning {
 	  constructor(text, opts = {}) {
 	    this.type = 'warning';
 	    this.text = text;
 
 	    if (opts.node && opts.node.source) {
+	      if (!opts.node[my]) {
+	        // The node comes from another PostCSS copy in node_modules, so it does
+	        // not have this copy’s methods. Container#normalize() rebuilds such
+	        // nodes on insert, but a node passed straight to Result#warn() never
+	        // goes through it.
+	        Container.rebuild(opts.node);
+	      }
 	      let range = opts.node.rangeBy(opts);
 	      this.line = range.start.line;
 	      this.column = range.start.column;
@@ -4343,8 +4586,14 @@ function requireLazyResult () {
 	}
 
 	function cleanMarks(node) {
-	  node[isClean] = false;
-	  if (node.nodes) node.nodes.forEach(i => cleanMarks(i));
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    next[isClean] = false;
+	    if (next.nodes) {
+	      for (let i of next.nodes) stack.push(i);
+	    }
+	  }
 	  return node
 	}
 
@@ -4625,7 +4874,10 @@ function requireLazyResult () {
 	    if (str.stringify) str = str.stringify;
 
 	    let rootSource = this.result.root.source;
-	    if (opts.map === undefined && !(rootSource && rootSource.input && rootSource.input.map)) {
+	    if (
+	      opts.map === undefined &&
+	      !(rootSource && rootSource.input && rootSource.input.map)
+	    ) {
 	      let result = '';
 	      str(this.result.root, i => {
 	        result += i;
@@ -4772,21 +5024,57 @@ function requireLazyResult () {
 	  }
 
 	  walkSync(node) {
+	    // An explicit stack like in async `visitTick()` to survive deeply
+	    // nested trees. Unlike `visitTick()`, nodes are marked clean only
+	    // on entering, so a node dirtied by its own visitors is revisited
+	    // on the next pass.
 	    node[isClean] = true;
-	    let events = getEvents(node);
-	    for (let event of events) {
-	      if (event === CHILDREN) {
-	        if (node.nodes) {
-	          node.each(child => {
-	            if (!child[isClean]) this.walkSync(child);
-	          });
+	    let stack = [{ eventIndex: 0, events: getEvents(node), iterator: 0, node }];
+
+	    while (stack.length > 0) {
+	      let visit = stack[stack.length - 1];
+	      let visitNode = visit.node;
+
+	      if (visit.iterator !== 0) {
+	        let iterator = visit.iterator;
+	        let child;
+	        let descended = false;
+	        while ((child = visitNode.nodes[visitNode.indexes[iterator]])) {
+	          visitNode.indexes[iterator] += 1;
+	          if (!child[isClean]) {
+	            child[isClean] = true;
+	            stack.push({
+	              eventIndex: 0,
+	              events: getEvents(child),
+	              iterator: 0,
+	              node: child
+	            });
+	            descended = true;
+	            break
+	          }
 	        }
-	      } else {
-	        let visitors = this.listeners[event];
-	        if (visitors) {
-	          if (this.visitSync(visitors, node.toProxy())) return
+	        if (descended) continue
+	        visit.iterator = 0;
+	        delete visitNode.indexes[iterator];
+	      }
+
+	      if (visit.eventIndex < visit.events.length) {
+	        let event = visit.events[visit.eventIndex];
+	        visit.eventIndex += 1;
+	        if (event === CHILDREN) {
+	          if (visitNode.nodes && visitNode.nodes.length) {
+	            visit.iterator = visitNode.getIterator();
+	          }
+	        } else {
+	          let visitors = this.listeners[event];
+	          if (visitors) {
+	            if (this.visitSync(visitors, visitNode.toProxy())) stack.pop();
+	          }
 	        }
+	        continue
 	      }
+
+	      stack.pop();
 	    }
 	  }
 
@@ -4966,7 +5254,7 @@ function requireProcessor () {
 
 	class Processor {
 	  constructor(plugins = []) {
-	    this.version = '8.5.12';
+	    this.version = '8.5.23';
 	    this.plugins = this.normalize(plugins);
 	  }